Add AnyId

TODO.md

@@ -0,0 +1,7 @@
+* [ ] Add caching layer: This cache layer can built on top of the utxo::ledger,
+  because all operations can be safely cached until a new transaction
+  referencing their account is issued, by that point, all the caches related to
+  anaccount can be evicted
+* [ ] Build admin interface
+* [ ] ADd memo to changes. Build append only table with all movements as
+  inserts. Wraps the objects to all their changes

src/main.rs

@@ -4,7 +4,7 @@ use actix_web::{
     error::InternalError, get, middleware::Logger, post, web, App, HttpResponse, HttpServer,
     Responder,
 };
-use ledger_utxo::{AccountId, AssetDefinition, AssetManager, Status, TransactionId};
+use ledger_utxo::{AccountId, AnyId, AssetDefinition, AssetManager, Status, TransactionId};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 
@@ -45,16 +45,53 @@ pub struct Transaction {
     pub status: Status,
 }
 
+#[derive(Deserialize)]
+pub struct UpdateTransaction {
+    pub status: Status,
+    pub memo: String,
+}
+
+impl UpdateTransaction {
+    pub async fn to_ledger_transaction(
+        self,
+        id: &TransactionId,
+        ledger: &Ledger,
+    ) -> Result<ledger_utxo::Transaction, ledger_utxo::Error> {
+        ledger._inner.change_status(id, self.status).await
+    }
+}
+
 impl Transaction {
     pub async fn to_ledger_transaction(
         self,
         ledger: &Ledger,
     ) -> Result<ledger_utxo::Transaction, ledger_utxo::Error> {
-        todo!()
-        /*ledger
-        ._inner
-        .new_transaction(self.memo, self.status, from, to)
-        .await*/
+        let from = self
+            .debit
+            .into_iter()
+            .map(|x| {
+                ledger
+                    ._inner
+                    .parse_amount(&x.asset, &x.amount)
+                    .map(|amount| (x.account, amount))
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let to = self
+            .credit
+            .into_iter()
+            .map(|x| {
+                ledger
+                    ._inner
+                    .parse_amount(&x.asset, &x.amount)
+                    .map(|amount| (x.account, amount))
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        ledger
+            ._inner
+            .new_transaction(self.memo, self.status, from, to)
+            .await
     }
 }
 
@@ -95,21 +132,24 @@ async fn get_balance(info: web::Path<AccountId>, ledger: web::Data<Ledger>) -> i
     }
 }
 
-#[get("/tx/{id}")]
-async fn get_transaction(
-    info: web::Path<TransactionId>,
-    ledger: web::Data<Ledger>,
-) -> impl Responder {
-    // Retrieve an item by ID from a database or another data source.
-    // For this example, we'll return a hardcoded item.
-
-    let tx = ledger._inner.get_transaction(&info.0).await;
-    println!("{:?}", tx);
+#[get("/{id}")]
+async fn get_info(info: web::Path<AnyId>, ledger: web::Data<Ledger>) -> impl Responder {
+    let result = match info.0 {
+        AnyId::Account(account_id) => ledger
+            ._inner
+            .get_transactions(&account_id, None)
+            .await
+            .map(|transactions| HttpResponse::Ok().json(transactions)),
+        AnyId::Transaction(transaction_id) => ledger
+            ._inner
+            .get_transaction(&transaction_id)
+            .await
+            .map(|tx| HttpResponse::Ok().json(tx)),
+    };
 
-    if let Ok(tx) = tx {
-        HttpResponse::Ok().json(tx)
-    } else {
-        HttpResponse::BadRequest().json(json!({"error": "not found"}))
+    match result {
+        Ok(x) => x,
+        Err(err) => HttpResponse::InternalServerError().json(err),
     }
 }
 
@@ -132,12 +172,25 @@ async fn create_transaction(
     item: web::Json<Transaction>,
     ledger: web::Data<Ledger>,
 ) -> impl Responder {
-    if let Ok(tx) = item.into_inner().to_ledger_transaction(&ledger).await {
-        // Insert the item into a database or another data source.
-        // For this example, we'll just echo the received item.
-        HttpResponse::Created().json(tx)
-    } else {
-        HttpResponse::Created().json(json!({"test": "true"}))
+    match item.into_inner().to_ledger_transaction(&ledger).await {
+        Ok(tx) => HttpResponse::Accepted().json(tx),
+        Err(err) => HttpResponse::Created().json(err),
+    }
+}
+
+#[post("/{id}")]
+async fn update_status(
+    info: web::Path<TransactionId>,
+    item: web::Json<UpdateTransaction>,
+    ledger: web::Data<Ledger>,
+) -> impl Responder {
+    match item
+        .into_inner()
+        .to_ledger_transaction(&info.0, &ledger)
+        .await
+    {
+        Ok(tx) => HttpResponse::Accepted().json(tx),
+        Err(err) => HttpResponse::Created().json(err),
     }
 }
 
@@ -181,9 +234,10 @@ async fn main() -> std::io::Result<()> {
                 .into()
             }))
             .service(get_balance)
-            .service(get_transaction)
+            .service(get_info)
             .service(deposit)
             .service(create_transaction)
+            .service(update_status)
     })
     .bind("127.0.0.1:8080")?
     .run()

utxo/src/id.rs

@@ -7,6 +7,9 @@ use std::str::FromStr;
 pub enum Error {
     #[error("Invalid length for {0}: {1} (expected: {2})")]
     InvalidLength(String, usize, usize),
+
+    #[error("Unknown prefix {0}")]
+    UnknownPrefix(String),
 }
 
 macro_rules! Id {
@@ -138,6 +141,36 @@ macro_rules! Id {
 Id!(AccountId, "account");
 Id!(TransactionId, "tx");
 
+#[derive(Debug)]
+pub enum AnyId {
+    Account(AccountId),
+    Transaction(TransactionId),
+}
+
+impl FromStr for AnyId {
+    type Err = Error;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        if value.starts_with("account") {
+            Ok(Self::Account(value.parse()?))
+        } else if value.starts_with("tx") {
+            Ok(Self::Transaction(value.parse()?))
+        } else {
+            Err(Error::UnknownPrefix(value.to_owned()))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AnyId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        AnyId::from_str(&s).map_err(serde::de::Error::custom)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

utxo/src/transaction/inner.rs

@@ -62,6 +62,7 @@ impl Transaction {
     ) -> Result<Transaction, Error> {
         let created_at = Utc::now();
         let id = Self::calculate_hash(
+            &reference,
             spend.iter().map(|t| &t.id).collect::<Vec<&PaymentId>>(),
             vec![],
             created_at,
@@ -92,6 +93,7 @@ impl Transaction {
     ) -> Result<Transaction, Error> {
         let created_at = Utc::now();
         let id = Self::calculate_hash(
+            &reference,
             vec![],
             pay_to
                 .iter()
@@ -135,6 +137,7 @@ impl Transaction {
     ) -> Result<Transaction, Error> {
         let created_at = Utc::now();
         let id = Self::calculate_hash(
+            &reference,
             spend.iter().map(|t| &t.id).collect::<Vec<&PaymentId>>(),
             pay_to
                 .iter()
@@ -184,6 +187,7 @@ impl Transaction {
     }
 
     fn calculate_hash(
+        reference: &str,
         spend: Vec<&PaymentId>,
         create: Vec<(&AccountId, &Amount)>,
         created_at: DateTime<Utc>,
@@ -201,6 +205,7 @@ impl Transaction {
             hasher.update(&bincode::serialize(amount)?);
         }
         hasher.update(&created_at.timestamp_millis().to_le_bytes());
+        hasher.update(&reference);
         Ok(TransactionId::new(hasher.finalize().into()))
     }
 
@@ -254,6 +259,7 @@ impl Transaction {
 
     pub(crate) fn validate(&self) -> Result<(), Error> {
         let calculated_id = Self::calculate_hash(
+            &self.reference,
             self.spends.iter().map(|p| &p.id).collect::<Vec<_>>(),
             self.creates
                 .iter()
@@ -292,10 +298,7 @@ impl Transaction {
             return Ok(());
         }
 
-        for (i, output) in self.creates.iter().enumerate() {
-            if output.spent_by.is_some() {
-                return Err(Error::SpentPayment(i));
-            }
+        for output in self.creates.iter() {
             if let Some(value) = credit.get_mut(output.amount.asset()) {
                 *value = output
                     .amount