Has a better idea

The whole locking mechanism will be implemented in a higher level, as the
revision layer.

The idea ise to reuse existing infrastructure/code and to leave a trail of the
locked transactions and their usage

utxo/src/storage/cache/batch.rs

@@ -2,7 +2,6 @@ use super::Storage;
 use crate::{
     payment::PaymentTo,
     storage::{AccountTransactionType, Batch, Error, ReceivedPaymentStatus},
-    token::Token,
     AccountId, BaseTx, PaymentId, RevId, Revision, Tag, TxId,
 };
 use std::{collections::HashMap, marker::PhantomData, sync::Arc};
@@ -67,13 +66,6 @@ where
         Ok(())
     }
 
-    async fn consume_update_token(
-        &mut self,
-        transaction_id: &TxId,
-    ) -> Result<Option<Token>, Error> {
-        self.inner.consume_update_token(transaction_id).await
-    }
-
     async fn relate_account_to_transaction(
         &mut self,
         account_type: AccountTransactionType,

utxo/src/storage/cache/mod.rs

@@ -2,7 +2,6 @@
 use crate::{
     amount::AmountCents,
     storage::{self, Error},
-    token::Token,
     AccountId, Amount, Asset, BaseTx, Filter, PaymentFrom, PaymentId, RevId, Revision, TxId,
 };
 use std::{collections::HashMap, sync::Arc};
@@ -78,10 +77,6 @@ where
         }
     }
 
-    async fn lock_transaction(&self, token: &Token) -> Result<(), Error> {
-        self.inner.lock_transaction(token).await
-    }
-
     async fn get_revisions(&self, transaction_id: &TxId) -> Result<Vec<RevId>, Error> {
         let cache = self.storage.revisions_by_transactions.read().await;
         if let Some(revisions) = cache.get(transaction_id) {

utxo/src/storage/mod.rs

@@ -1,7 +1,7 @@
 //! Storage layer trait
 use crate::{
-    amount::AmountCents, payment::PaymentTo, token::Token, transaction::Type, AccountId, Amount,
-    Asset, BaseTx, Filter, PaymentFrom, PaymentId, RevId, Revision, Tag, Transaction, TxId,
+    amount::AmountCents, payment::PaymentTo, transaction::Type, AccountId, Amount, Asset, BaseTx,
+    Filter, PaymentFrom, PaymentId, RevId, Revision, Tag, Transaction, TxId,
 };
 //use chrono::{DateTime, Utc};
 use serde::Serialize;
@@ -160,13 +160,6 @@ pub trait Batch<'a> {
         status: ReceivedPaymentStatus,
     ) -> Result<(), Error>;
 
-    /// Consumes the update token, if any, returning the token.
-    ///
-    /// Update tokens one time only. Expired update tokens should be discarded by the storage engine
-    /// and None should be returned instead.
-    async fn consume_update_token(&mut self, transaction_id: &TxId)
-        -> Result<Option<Token>, Error>;
-
     /// Create a new list of payments
     async fn create_payments(
         &mut self,
@@ -266,21 +259,6 @@ pub trait Storage {
     /// Returns the balances for a given account
     async fn get_balance(&self, account: &AccountId) -> Result<Vec<Amount>, Error>;
 
-    /// Locks the transaction
-    ///
-    /// Upon success, the client will have an update token, which can be used once. The locked
-    /// transactions can only be updated with their update token; without it, the storage engine
-    /// will refuse to perform any updates. By default, the update tokens have an expiration time.
-    ///
-    /// This is a straightforward and user-friendly mechanism to lock transactions for further
-    /// updates. It operates without the need for any external semaphore-like system to coordinate
-    /// updates, making it easy to understand and manage.
-    ///
-    /// The database ensures correct concurrencies with its revision design. Only one update will
-    /// succeed, and all others will be stale updates, forcing clients of failed updates to fetch
-    /// the latest revision and re-submit their updates.
-    async fn lock_transaction(&self, token: &Token) -> Result<(), Error>;
-
     /// Returns all the negative payments that are unspent by any account
     ///
     /// If any unspent negative deposit exists with the given account and asset, it must be spend in
@@ -422,7 +400,7 @@ pub mod test {
         )
         .expect("valid tx");
 
-        let deposit = ledger.store(deposit, None).await.expect("valid insert");
+        let deposit = ledger.store(deposit).await.expect("valid insert");
 
         ledger
             .change_status(

utxo/src/storage/sqlite/batch.rs

@@ -1,7 +1,6 @@
 use crate::{
     payment::PaymentTo,
     storage::{self, to_bytes, AccountTransactionType, Error, ReceivedPaymentStatus},
-    token::Token,
     AccountId, BaseTx, PaymentId, RevId, Revision, Tag, TxId, Type,
 };
 use sqlx::{Row, Sqlite, Transaction as SqlxTransaction};
@@ -35,13 +34,6 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
             .map_err(|e| Error::Storage(e.to_string()))
     }
 
-    async fn consume_update_token(
-        &mut self,
-        _transaction_id: &TxId,
-    ) -> Result<Option<Token>, Error> {
-        todo!()
-    }
-
     async fn relate_account_to_transaction(
         &mut self,
         account_type: AccountTransactionType,

utxo/src/storage/sqlite/mod.rs

@@ -3,7 +3,6 @@ use super::{AccountTransactionType, Cursor, ReceivedPaymentStatus};
 use crate::{
     amount::AmountCents,
     storage::{Error, Storage},
-    token::Token,
     transaction::Revision,
     AccountId, Amount, Asset, BaseTx, Filter, PaymentFrom, PaymentId, PrimaryFilter, RevId, TxId,
 };
@@ -401,10 +400,6 @@ impl SQLite {
         );
         CREATE UNIQUE INDEX IF NOT EXISTS "unique_account_transaction" ON "transaction_accounts" ("account_id", "transaction_id", "relationship");
         CREATE INDEX IF NOT EXISTS "sorted_account_transaction" ON "transaction_accounts" ("account_id", "id" desc);
-        CREATE TABLE IF NOT EXISTS "update_token" (
-            "token" VARCHAR(64) NOT NULL PRIMARY KEY,
-            "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP
-        );
         "#,
         )
         .await?;
@@ -450,14 +445,6 @@ impl Storage for SQLite {
             .map_err(|x| Error::Storage(x.to_string()))
     }
 
-    async fn lock_transaction(&self, token: &Token) -> Result<(), Error> {
-        format!(
-            "SELECT * FROM transactions WHERE transaction_id = '{:?}' FOR UPDATE",
-            token
-        );
-        todo!()
-    }
-
     async fn get_balance(&self, account: &AccountId) -> Result<Vec<Amount>, Error> {
         let mut conn = self
             .db