Exposed Replay protection to HTTPd wrapper

src/balance.rs

@@ -48,6 +48,9 @@ pub async fn handler(
     State(ctx): State<Context>,
 ) -> Result<Json<Vec<Balance>>, (StatusCode, String)> {
     Ok(Json(account.handle(&ctx).await.map_err(|err| {
-        (StatusCode::BAD_REQUEST, err.to_string())
+        (
+            StatusCode::BAD_REQUEST,
+            serde_json::to_string(&err).unwrap_or_default(),
+        )
     })?))
 }

src/deposit.rs

@@ -1,7 +1,7 @@
 use crate::{Context, Handler};
 use axum::{extract::State, http::StatusCode, Json};
 use serde::Deserialize;
-use verax::{AccountId, AnyAmount, Status, Tag};
+use verax::{AccountId, AnyAmount, ReplayProtection, Status, Tag, Transaction};
 
 #[derive(Deserialize)]
 pub struct Deposit {
@@ -11,6 +11,7 @@ pub struct Deposit {
     pub memo: String,
     pub tags: Vec<Tag>,
     pub status: Status,
+    pub replay_protection: Option<ReplayProtection>,
 }
 
 #[async_trait::async_trait]
@@ -19,14 +20,19 @@ impl Handler for Deposit {
     type Err = verax::Error;
 
     async fn handle(self, ctx: &Context) -> Result<Self::Ok, Self::Err> {
+        let new_deposit = Transaction::new_external_deposit(
+            self.memo,
+            self.status,
+            self.tags,
+            vec![(self.account.clone(), self.amount.try_into()?)],
+        )?;
+
         ctx.ledger
-            .deposit(
-                &self.account,
-                self.amount.try_into()?,
-                self.status,
-                self.tags,
-                self.memo,
-            )
+            .store(if let Some(replay_protection) = self.replay_protection {
+                new_deposit.set_replay_protection(replay_protection)?
+            } else {
+                new_deposit
+            })
             .await
     }
 }
@@ -36,6 +42,9 @@ pub async fn handler(
     Json(item): Json<Deposit>,
 ) -> Result<Json<verax::Transaction>, (StatusCode, String)> {
     Ok(Json(item.handle(&ledger).await.map_err(|err| {
-        (StatusCode::BAD_REQUEST, err.to_string())
+        (
+            StatusCode::BAD_REQUEST,
+            serde_json::to_string(&err).unwrap_or_default(),
+        )
     })?))
 }

src/get.rs

@@ -72,5 +72,10 @@ pub async fn handler(
             json_response
         })
         */
-        .map_err(|err| (StatusCode::BAD_REQUEST, err.to_string()))
+        .map_err(|err| {
+            (
+                StatusCode::BAD_REQUEST,
+                serde_json::to_string(&err).unwrap_or_default(),
+            )
+        })
 }

src/lock.rs

@@ -41,6 +41,11 @@ pub async fn handler(
 ) -> Result<Json<Response>, (StatusCode, String)> {
     item.handle(&ctx)
         .await
-        .map_err(|err| (StatusCode::BAD_REQUEST, err.to_string()))
+        .map_err(|err| {
+            (
+                StatusCode::BAD_REQUEST,
+                serde_json::to_string(&err).unwrap_or_default(),
+            )
+        })
         .map(Json)
 }

src/tx.rs

@@ -1,7 +1,7 @@
 use crate::{Context, Handler};
 use axum::{extract::State, http::StatusCode, Json};
 use serde::Deserialize;
-use verax::{AccountId, AnyAmount, Status};
+use verax::{AccountId, AnyAmount, ReplayProtection, Status};
 
 #[derive(Deserialize)]
 pub struct AccountWithAmount {
@@ -16,6 +16,7 @@ pub struct Transaction {
     pub credit: Vec<AccountWithAmount>,
     pub memo: String,
     pub status: Status,
+    pub replay_protection: Option<ReplayProtection>,
 }
 
 #[async_trait::async_trait]
@@ -38,7 +39,7 @@ impl Handler for Transaction {
 
         ledger
             .ledger
-            .new_transaction(self.memo, self.status, from, to)
+            .new_transaction(self.memo, self.status, from, to, self.replay_protection)
             .await
     }
 }
@@ -49,6 +50,11 @@ pub async fn handler(
 ) -> Result<Json<verax::Transaction>, (StatusCode, String)> {
     item.handle(&ledger)
         .await
-        .map_err(|err| (StatusCode::BAD_REQUEST, err.to_string()))
+        .map_err(|err| {
+            (
+                StatusCode::BAD_REQUEST,
+                serde_json::to_string(&err).unwrap_or_default(),
+            )
+        })
         .map(Json)
 }

src/update.rs

@@ -75,6 +75,11 @@ pub async fn handler(
     update
         .handle(&ctx)
         .await
-        .map_err(|err| (StatusCode::BAD_REQUEST, err.to_string()))
+        .map_err(|err| {
+            (
+                StatusCode::BAD_REQUEST,
+                serde_json::to_string(&err).unwrap_or_default(),
+            )
+        })
         .map(Json)
 }

utxo/src/ledger.rs

@@ -7,8 +7,8 @@ use crate::{
     token::TokenPayload,
     transaction::{Error as TxError, Type},
     worker::WorkerManager,
-    AccountId, Amount, Error, Filter, PaymentFrom, PaymentId, RevId, Status, Tag, Transaction,
-    TxId,
+    AccountId, Amount, Error, Filter, PaymentFrom, PaymentId, ReplayProtection, RevId, Status, Tag,
+    Transaction, TxId,
 };
 use std::{cmp::Ordering, collections::HashMap, sync::Arc};
 use tokio::sync::mpsc::{self, Receiver, Sender};
@@ -406,13 +406,24 @@ where
         status: Status,
         from: Vec<(AccountId, Amount)>,
         to: Vec<(AccountId, Amount)>,
+        replay_protection: Option<ReplayProtection>,
     ) -> Result<Transaction, Error> {
         let (change_transaction, payments) = self.select_payments_from_accounts(from).await?;
+
+        let transaction =
+            Transaction::new(reference, status, Type::Transaction, payments, to).await?;
+
+        let transaction = if let Some(replay_protection) = replay_protection {
+            transaction.set_replay_protection(replay_protection)?
+        } else {
+            transaction
+        };
+
         if let Some(change_tx) = change_transaction {
             self.store(change_tx).await?;
         }
-        self.store(Transaction::new(reference, status, Type::Transaction, payments, to).await?)
-            .await
+
+        self.store(transaction).await
     }
 
     /// Return the balances from a given account

utxo/src/tests/negative_deposit.rs

@@ -31,6 +31,7 @@ async fn negative_deposit_prevent_spending() {
                     (dest.clone(), usd.from_human("9.5").expect("amount")),
                     (fee.clone(), usd.from_human("0.5").expect("amount")),
                 ],
+                None,
             )
             .await
             .unwrap_err()
@@ -68,6 +69,7 @@ async fn negative_deposit_prevent_spending_payback() {
                     (dest.clone(), usd.from_human("9.5").expect("amount")),
                     (fee.clone(), usd.from_human("0.5").expect("amount")),
                 ],
+                None,
             )
             .await
             .unwrap_err()
@@ -86,6 +88,7 @@ async fn negative_deposit_prevent_spending_payback() {
                 (dest.clone(), usd.from_human("9.5").expect("amount")),
                 (fee.clone(), usd.from_human("0.5").expect("amount")),
             ],
+            None,
         )
         .await
         .expect("valid tx");

utxo/src/transaction/base_tx.rs

@@ -19,6 +19,7 @@ use std::collections::HashMap;
 /// Withdrawal transaction.
 pub struct BaseTx {
     /// A unique identifier generated by the client to make sure the transaction was not created before. If provided the storage layer will make sure it is unique.
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub replay_protection: Option<ReplayProtection>,
     /// List of spend payments to create this transaction
     #[serde(skip_serializing_if = "Vec::is_empty")]