Added borsh

Cargo.lock

@@ -532,15 +532,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
 
 [[package]]
-name = "bincode"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
-dependencies = [
- "serde",
-]
-
-[[package]]
 name = "bitflags"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -590,6 +581,31 @@ dependencies = [
 ]
 
 [[package]]
+name = "borsh"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f58b559fd6448c6e2fd0adb5720cd98a2506594cafa4737ff98c396f3e82f667"
+dependencies = [
+ "borsh-derive",
+ "bytes 1.5.0",
+ "cfg_aliases",
+]
+
+[[package]]
+name = "borsh-derive"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aadb5b6ccbd078890f6d7003694e33816e6b784358f18e15e7e6d9f065a57cd"
+dependencies = [
+ "once_cell",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.37",
+ "syn_derive",
+]
+
+[[package]]
 name = "brotli"
 version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -665,6 +681,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
+name = "cfg_aliases"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
+
+[[package]]
 name = "chrono"
 version = "0.4.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2053,6 +2075,38 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
 [[package]]
+name = "proc-macro-crate"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d37c51ca738a55da99dc0c4a34860fd675453b8b36209178c2249bb13651284"
+dependencies = [
+ "toml_edit",
+]
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
 name = "proc-macro-hack"
 version = "0.5.20+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2843,6 +2897,18 @@ dependencies = [
 ]
 
 [[package]]
+name = "syn_derive"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1329189c02ff984e9736652b1631330da25eaa6bc639089ed4915d25446cbe7b"
+dependencies = [
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.37",
+]
+
+[[package]]
 name = "tempfile"
 version = "3.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -3022,6 +3088,23 @@ dependencies = [
 ]
 
 [[package]]
+name = "toml_datetime"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
+
+[[package]]
+name = "toml_edit"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
+dependencies = [
+ "indexmap 2.0.2",
+ "toml_datetime",
+ "winnow",
+]
+
+[[package]]
 name = "tracing"
 version = "0.1.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -3170,7 +3253,7 @@ name = "verax"
 version = "0.1.0"
 dependencies = [
  "async-trait",
- "bincode",
+ "borsh",
  "chrono",
  "futures",
  "hex",
@@ -3413,6 +3496,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
 [[package]]
+name = "winnow"
+version = "0.5.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
 name = "winreg"
 version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"

src/main.rs

@@ -4,7 +4,7 @@ use actix_web::{
 };
 use serde::{Deserialize, Serialize};
 use serde_json::json;
-use verax::{AccountId, AnyAmount, AnyId, Asset, RevisionId, Status, Type};
+use verax::{AccountId, AnyAmount, AnyId, Asset, Status, TxId, Type};
 
 #[derive(Deserialize)]
 pub struct Movement {
@@ -56,7 +56,7 @@ pub struct UpdateTransaction {
 impl UpdateTransaction {
     pub async fn to_ledger_transaction(
         self,
-        id: &RevisionId,
+        id: &TxId,
         ledger: &Ledger,
     ) -> Result<verax::Transaction, verax::Error> {
         ledger
@@ -192,7 +192,7 @@ async fn create_transaction(
 
 #[post("/{id}")]
 async fn update_status(
-    info: web::Path<RevisionId>,
+    info: web::Path<TxId>,
     item: web::Json<UpdateTransaction>,
     ledger: web::Data<Ledger>,
 ) -> impl Responder {

utxo/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 async-trait = "0.1.73"
-bincode = { version = "1.3.3", features = ["i128"] }
+borsh = { version = "1.3.1", features = ["derive", "bytes", "de_strict_order"] }
 chrono = { version = "0.4.31", features = ["serde"] }
 futures = { version = "0.3.30", optional = true }
 hex = "0.4.3"

utxo/src/amount.rs

@@ -65,7 +65,16 @@ impl TryInto<Amount> for AnyAmount {
 ///
 /// The `cents` and `Asset` must be used to store amounts in the storage
 /// layer. Float or string representations should be used to display
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    Serialize,
+    Deserialize,
+    borsh::BorshSerialize,
+    borsh::BorshDeserialize,
+)]
 pub struct Amount {
     asset: Asset,
     #[serde(

utxo/src/asset.rs

@@ -8,7 +8,7 @@ use std::{
     str::FromStr,
 };
 
-#[derive(Debug, Hash, PartialEq, Eq, Clone)]
+#[derive(Debug, Hash, PartialEq, Eq, Clone, borsh::BorshSerialize, borsh::BorshDeserialize)]
 /// An asset type
 pub struct Asset {
     /// The name of the asset

utxo/src/id/binary.rs

@@ -2,7 +2,17 @@
 /// Creates a wrapper for a hexahexadecimal identifier with a human prefix
 macro_rules! BinaryId {
     ($id:ident, $suffix:expr) => {
-        #[derive(Clone, Debug, Eq, PartialOrd, Ord, Hash, PartialEq)]
+        #[derive(
+            Clone,
+            Debug,
+            Eq,
+            PartialOrd,
+            Ord,
+            Hash,
+            PartialEq,
+            borsh::BorshSerialize,
+            borsh::BorshDeserialize,
+        )]
         /// A unique identifier for $id
         pub struct $id {
             bytes: [u8; 32],

utxo/src/id/mod.rs

@@ -2,7 +2,18 @@ use serde::{de, Deserialize, Deserializer, Serialize};
 use sha2::{Digest, Sha256};
 use std::{fmt::Display, ops::Deref, str::FromStr};
 
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialOrd, PartialEq, Serialize)]
+#[derive(
+    Clone,
+    Debug,
+    Eq,
+    Hash,
+    Ord,
+    PartialOrd,
+    PartialEq,
+    Serialize,
+    borsh::BorshDeserialize,
+    borsh::BorshSerialize,
+)]
 /// A string with a max-length checked at compiled time
 pub struct MaxLengthString<const MAX_LENGTH: usize>(String);
 

utxo/src/id/payment.rs

@@ -2,7 +2,17 @@ use crate::{id::Error, TxId};
 use serde::{de, Serialize, Serializer};
 use std::{fmt, ops::Deref, str::FromStr};
 
-#[derive(Clone, Debug, Eq, Ord, Hash, PartialOrd, PartialEq)]
+#[derive(
+    Clone,
+    Debug,
+    Eq,
+    Ord,
+    Hash,
+    PartialOrd,
+    PartialEq,
+    borsh::BorshSerialize,
+    borsh::BorshDeserialize,
+)]
 /// PaymentID
 ///
 /// This is the payment ID. The payment ID has two public members, which is

utxo/src/payment.rs

@@ -1,7 +1,16 @@
 use crate::{AccountId, Amount, PaymentId};
 use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+#[derive(
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    Deserialize,
+    Serialize,
+    borsh::BorshDeserialize,
+    borsh::BorshSerialize,
+)]
 pub struct PaymentTo {
     /// Which account can spend this new payment
     pub to: AccountId,
@@ -10,7 +19,16 @@ pub struct PaymentTo {
 }
 
 /// Payment
-#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+#[derive(
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    Deserialize,
+    Serialize,
+    borsh::BorshDeserialize,
+    borsh::BorshSerialize,
+)]
 pub struct PaymentFrom {
     /// The payment ID
     pub id: PaymentId,

utxo/src/storage/mod.rs

@@ -58,6 +58,11 @@ pub enum Error {
     /// Any error related to the storage layer, with string
     Storage(String),
 
+    #[error("I/O error: {0}")]
+    #[serde(serialize_with = "crate::serialize_error_to_string")]
+    /// Any error related to the storage layer, with std::io::Error
+    Io(#[from] std::io::Error),
+
     #[error("Invalid date format: {0}")]
     /// The date format is invalid
     InvalidDate(String),

utxo/src/storage/sqlite/batch.rs

@@ -82,8 +82,7 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
             .try_get::<Vec<u8>, usize>(1)
             .map_err(|e| Error::Storage(e.to_string()))?;
         Transaction::from_revision(
-            bincode::deserialize::<Revision>(&encoded)
-                .map_err(|e| Error::Storage(e.to_string()))?,
+            Revision::from_slice(&encoded)?,
             Some(
                 row.try_get::<String, usize>(0)
                     .map_err(|e| Error::Storage(e.to_string()))?
@@ -264,7 +263,7 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
         )
         .bind(transaction.revision_id.to_string())
         .bind(transaction.id.to_string())
-        .bind(bincode::serialize(transaction.inner()).map_err(|e| Error::Encoding(e.to_string()))?)
+        .bind(transaction.revision().to_vec()?)
         .bind(transaction.status().to_string())
         .bind(transaction.created_at())
         .execute(&mut *self.inner)

utxo/src/storage/sqlite/mod.rs

@@ -263,8 +263,7 @@ impl Storage for SQLite {
             .map_err(|e| Error::Storage(e.to_string()))?;
 
         Transaction::from_revision(
-            bincode::deserialize::<Revision>(&encoded)
-                .map_err(|e| Error::Storage(e.to_string()))?,
+            Revision::from_slice(&encoded)?,
             Some(
                 row.try_get::<String, usize>(0)
                     .map_err(|e| Error::Storage(e.to_string()))?
@@ -337,8 +336,7 @@ impl Storage for SQLite {
                     .map_err(|e| Error::Storage(e.to_string()))?;
 
                 Transaction::from_revision(
-                    bincode::deserialize::<Revision>(&encoded)
-                        .map_err(|e| Error::Storage(e.to_string()))?,
+                    Revision::from_slice(&encoded)?,
                     Some(
                         row.try_get::<String, usize>(0)
                             .map_err(|e| Error::Storage(e.to_string()))?

utxo/src/transaction/error.rs

@@ -33,9 +33,9 @@ pub enum Error {
     #[error("Storage: {0}")]
     Storage(#[from] storage::Error),
 
-    #[error("Internal error at serializing: {0}")]
+    #[error("IO error: {0}")]
     #[serde(serialize_with = "crate::serialize_error_to_string")]
-    Serde(#[from] Box<bincode::ErrorKind>),
+    Serialization(#[from] std::io::Error),
 
     #[error("No storage update when expecting")]
     /// No update was performed when expecting one

utxo/src/transaction/inner.rs

@@ -6,7 +6,7 @@ use crate::{
     transaction::*,
     AccountId, Amount, Asset, PaymentFrom, RevId, Status, TxId,
 };
-use chrono::{serde::ts_milliseconds, DateTime, Utc};
+use chrono::{serde::ts_milliseconds, DateTime, TimeZone, Utc};
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
 use std::collections::HashMap;
@@ -21,7 +21,7 @@ use std::collections::HashMap;
 ///
 /// Since the transaction ID is calculated from the transaction itself, to provide cryptographic
 /// security that its content was not altered.
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize, borsh::BorshSerialize, borsh::BorshDeserialize)]
 pub struct Revision {
     #[serde(rename = "_prev_rev")]
     /// Any previous transaction that this transaction is replacing.
@@ -37,26 +37,64 @@ pub struct Revision {
     status: Status,
     tags: Vec<String>,
     #[serde(with = "ts_milliseconds")]
+    #[borsh(
+        serialize_with = "to_ts_microseconds",
+        deserialize_with = "from_ts_microseconds"
+    )]
     created_at: DateTime<Utc>,
     #[serde(with = "ts_milliseconds")]
+    #[borsh(
+        serialize_with = "to_ts_microseconds",
+        deserialize_with = "from_ts_microseconds"
+    )]
     updated_at: DateTime<Utc>,
 }
 
+fn to_ts_microseconds<W: std::io::Write>(
+    dt: &DateTime<Utc>,
+    writer: &mut W,
+) -> std::io::Result<()> {
+    borsh::BorshSerialize::serialize(&dt.timestamp_millis(), writer)?;
+    Ok(())
+}
+
+fn from_ts_microseconds<R: borsh::io::Read>(
+    reader: &mut R,
+) -> ::core::result::Result<DateTime<Utc>, borsh::io::Error> {
+    match Utc.timestamp_millis_opt(borsh::BorshDeserialize::deserialize_reader(reader)?) {
+        chrono::LocalResult::Single(dt) => Ok(dt.with_timezone(&Utc)),
+        _ => Err(borsh::io::Error::new(
+            borsh::io::ErrorKind::InvalidData,
+            "invalid timestamp".to_owned(),
+        )),
+    }
+}
+
 impl Revision {
     /// Calculates a revision ID
     pub fn calculate_rev_id(&self) -> Result<RevId, Error> {
         let mut hasher = Sha256::new();
-        let bytes = bincode::serialize(self)?;
+        let bytes = borsh::to_vec(&self)?;
         hasher.update(bytes);
         Ok(RevId::new(hasher.finalize().into()))
     }
 
+    /// TODO
+    pub fn to_vec(&self) -> Result<Vec<u8>, crate::storage::Error> {
+        Ok(borsh::to_vec(&self)?)
+    }
+
+    /// TODO
+    pub fn from_slice(slice: &[u8]) -> Result<Self, crate::storage::Error> {
+        Ok(borsh::from_slice(slice)?)
+    }
+
     /// The transaction fingerprint is a hash of the properties that are not allowed to be updated
     /// in a transaction.
     pub fn calculate_id(&self) -> Result<TxId, Error> {
         let mut hasher = Sha256::new();
-        hasher.update(&bincode::serialize(&self.spends)?);
-        hasher.update(&bincode::serialize(&self.creates)?);
+        hasher.update(&borsh::to_vec(&self.spends)?);
+        hasher.update(&borsh::to_vec(&self.creates)?);
         hasher.update(&self.typ.to_string());
         hasher.update(&self.reference);
         hasher.update(&self.created_at.timestamp_millis().to_string());
@@ -173,7 +211,7 @@ pub struct Transaction {
 
     /// The transaction inner details
     #[serde(flatten)]
-    inner: Revision,
+    revision: Revision,
 }
 
 impl Transaction {
@@ -279,18 +317,18 @@ impl Transaction {
             id: revision.calculate_id()?,
             revision_id,
             lastest_revision,
-            inner: revision,
+            revision,
         })
     }
 
     /// Gets the inner transaction
-    pub fn inner(&self) -> &Revision {
-        &self.inner
+    pub fn revision(&self) -> &Revision {
+        &self.revision
     }
 
     /// Returns the previous revision of this transaction, if any
     pub fn previous(&self) -> Option<RevId> {
-        self.inner.previous.clone()
+        self.revision.previous.clone()
     }
 
     /// Returns a unique list of accounts involved in this transaction.
@@ -298,14 +336,14 @@ impl Transaction {
     /// Accounts are sorted and unique, and they include the accounts that spent and that receives
     pub fn accounts(&self) -> Vec<AccountId> {
         let mut accounts = self
-            .inner
+            .revision
             .creates
             .iter()
             .map(|x| x.to.clone())
             .collect::<Vec<_>>();
 
         accounts.extend(
-            self.inner
+            self.revision
                 .spends
                 .iter()
                 .map(|x| x.from.clone())
@@ -335,8 +373,8 @@ impl Transaction {
     {
         config
             .status
-            .is_valid_transition(&self.inner.status, &new_status)?;
-        let mut inner = self.inner;
+            .is_valid_transition(&self.revision.status, &new_status)?;
+        let mut inner = self.revision;
         inner.changelog = reason;
         inner.updated_at = Utc::now();
         inner.previous = Some(self.revision_id);
@@ -348,24 +386,24 @@ impl Transaction {
 
     /// Validates the transaction before storing
     pub(crate) fn validate(&self) -> Result<(), Error> {
-        let calculated_revision_id = self.inner.calculate_rev_id()?;
-        let calculated_tx_id = self.inner.calculate_id()?;
+        let calculated_revision_id = self.revision.calculate_rev_id()?;
+        let calculated_tx_id = self.revision.calculate_id()?;
 
         if self.revision_id != calculated_revision_id || self.id != calculated_tx_id {
             return Err(Error::InvalidTxId(self.id.clone(), calculated_tx_id));
         }
 
-        self.inner.validate()
+        self.revision.validate()
     }
 
     /// Returns the list of payments that were used to create this transaction
     pub fn spends(&self) -> &[PaymentFrom] {
-        &self.inner.spends
+        &self.revision.spends
     }
 
     /// Returns the list of payments that were created by this transaction
     pub fn creates(&self) -> &[PaymentTo] {
-        &self.inner.creates
+        &self.revision.creates
     }
 
     /// Returns the transaction ID
@@ -375,27 +413,27 @@ impl Transaction {
 
     /// Returns the transaction status
     pub fn status(&self) -> &Status {
-        &self.inner.status
+        &self.revision.status
     }
 
     /// Returns the transaction type
     pub fn typ(&self) -> Type {
-        self.inner.typ
+        self.revision.typ
     }
 
     /// Returns the reference of this transaction
     pub fn reference(&self) -> &str {
-        &self.inner.reference
+        &self.revision.reference
     }
 
     /// Returns the time when this transaction was created
     pub fn created_at(&self) -> DateTime<Utc> {
-        self.inner.created_at
+        self.revision.created_at
     }
 
     /// Returns the time when this transaction was last updated
     pub fn updated_at(&self) -> DateTime<Utc> {
-        self.inner.updated_at
+        self.revision.updated_at
     }
 
     /// Persists the changes done to this transaction object.
@@ -409,63 +447,63 @@ impl Transaction {
 
         let mut batch = config.storage.begin().await?;
 
-        if let Some(previous_id) = &self.inner.previous {
+        if let Some(previous_id) = &self.revision.previous {
             // Make sure this update is updating the last revision and the status is not final
             let current_transaction = batch.get_and_lock_transaction(&self.id).await?;
 
-            if config.status.is_final(&current_transaction.inner.status)
-                || self.inner.calculate_id()? != current_transaction.inner.calculate_id()?
+            if config.status.is_final(&current_transaction.revision.status)
+                || self.revision.calculate_id()? != current_transaction.revision.calculate_id()?
                 || *previous_id != current_transaction.lastest_revision
             {
                 return Err(Error::TransactionUpdatesNotAllowed);
             }
 
             // Updates all the spends to reflect the new status.
-            let (updated_created, updated_spent) = if config.status.is_reverted(&self.inner.status)
-            {
-                // Release all the previously spent payments since the whole transaction is being
-                // reverted due a failure or cancellation.
-                batch
-                    .update_transaction_payments(
-                        &self.id,
-                        storage::Status::Failed,
-                        storage::Status::Spendable,
-                    )
-                    .await?
-            } else if config.status.is_spendable(&self.inner.status) {
-                // Spend all the payments that were used to create this transaction
-                batch
-                    .update_transaction_payments(
-                        &self.id,
-                        storage::Status::Spendable,
-                        storage::Status::Spent,
-                    )
-                    .await?
-            } else {
-                // Lock both the spent transaction and the created transaction, since this
-                // transaction is still not finalized
-                batch
-                    .update_transaction_payments(
-                        &self.id,
-                        storage::Status::Locked,
-                        storage::Status::Locked,
-                    )
-                    .await?
-            };
-            if updated_created != self.inner.creates.len()
-                || updated_spent != self.inner.spends.len()
+            let (updated_created, updated_spent) =
+                if config.status.is_reverted(&self.revision.status) {
+                    // Release all the previously spent payments since the whole transaction is
+                    // being reverted due a failure or cancellation.
+                    batch
+                        .update_transaction_payments(
+                            &self.id,
+                            storage::Status::Failed,
+                            storage::Status::Spendable,
+                        )
+                        .await?
+                } else if config.status.is_spendable(&self.revision.status) {
+                    // Spend all the payments that were used to create this transaction
+                    batch
+                        .update_transaction_payments(
+                            &self.id,
+                            storage::Status::Spendable,
+                            storage::Status::Spent,
+                        )
+                        .await?
+                } else {
+                    // Lock both the spent transaction and the created transaction, since this
+                    // transaction is still not finalized
+                    batch
+                        .update_transaction_payments(
+                            &self.id,
+                            storage::Status::Locked,
+                            storage::Status::Locked,
+                        )
+                        .await?
+                };
+            if updated_created != self.revision.creates.len()
+                || updated_spent != self.revision.spends.len()
             {
                 return Err(Error::NoUpdate);
             }
         } else {
             let spends = self
-                .inner
+                .revision
                 .spends
                 .iter()
                 .map(|x| x.id.clone())
                 .collect::<Vec<_>>();
             let (spent_payment_status, creates_payment_status) =
-                if config.status.is_spendable(&self.inner.status) {
+                if config.status.is_spendable(&self.revision.status) {
                     (storage::Status::Spent, storage::Status::Spendable)
                 } else {
                     (storage::Status::Locked, storage::Status::Locked)
@@ -474,7 +512,7 @@ impl Transaction {
                 .spend_payments(&self.id, spends, spent_payment_status)
                 .await?;
             batch
-                .create_payments(&self.id, &self.inner.creates, creates_payment_status)
+                .create_payments(&self.id, &self.revision.creates, creates_payment_status)
                 .await?;
 
             for account in self.accounts() {

utxo/src/transaction/typ.rs

@@ -6,7 +6,16 @@ pub enum Error {
     InvalidStatus(u32),
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Serialize,
+    Deserialize,
+    borsh::BorshDeserialize,
+    borsh::BorshSerialize,
+)]
 #[serde(rename_all = "snake_case")]
 /// Transaction types
 pub enum Type {