Release 0.3

clients/apps/rust/src/main.rs

@@ -58,6 +58,7 @@ enum Commands {
         force_send: Option<bool>,
         /// Batch id for atomic transfers
         batch_id: Option<String>,
+        duplicated_indexes: Option<Vec<u32>>,
     },
     /// Send a statechain coin to a transfer address
     TransferReceive { wallet_name: String },
@@ -158,12 +159,12 @@ async fn main() -> Result<()> {
 
             println!("{}", serde_json::to_string_pretty(&obj).unwrap());
         },
-        Commands::TransferSend { wallet_name, statechain_id, to_address, force_send, batch_id } => {
+        Commands::TransferSend { wallet_name, statechain_id, to_address, force_send, batch_id, duplicated_indexes } => {
             mercuryrustlib::coin_status::update_coins(&client_config, &wallet_name).await?;
 
             let force_send = force_send.unwrap_or(false);
 
-            mercuryrustlib::transfer_sender::execute(&client_config, &to_address, &wallet_name, &statechain_id, force_send, batch_id).await?;
+            mercuryrustlib::transfer_sender::execute(&client_config, &to_address, &wallet_name, &statechain_id, duplicated_indexes, force_send, batch_id).await?;
 
             let obj = json!({"Transfer": "sent"});
 

clients/libs/nodejs/coin_enum.js

@@ -9,6 +9,8 @@ const CoinStatus = {
     TRANSFERRED: "TRANSFERRED", // the coin was transferred
     WITHDRAWN: "WITHDRAWN", // the coin was withdrawn
     DUPLICATED: "DUPLICATED", // the coin was withdrawn
+    DUPLICATED: "DUPLICATED", // the coin was withdrawn
+    INVALIDATED: "INVALIDATED", // the coin was invalidated
 };
 
 module.exports = { CoinStatus };

clients/libs/rust/migrations/0001_signer_data_table.sql

@@ -4,6 +4,7 @@ CREATE TABLE IF NOT EXISTS wallet (
 );
 
 CREATE TABLE IF NOT EXISTS backup_txs (
+    wallet_name TEXT NOT NULL,
     statechain_id TEXT NOT NULL,
     txs TEXT NOT NULL
 );

clients/libs/rust/src/broadcast_backup_tx.rs

@@ -16,7 +16,7 @@ pub async fn execute(client_config: &ClientConfig, wallet_name: &str, statechain
         }
     }
 
-    let backup_txs = get_backup_txs(&client_config.pool, &statechain_id).await?;
+    let backup_txs = get_backup_txs(&client_config.pool, &wallet.name, &statechain_id).await?;
 
     // If the user sends to himself, he will have two coins with same statechain_id
     // In this case, we need to find the one with the lowest locktime

clients/libs/rust/src/coin_status.rs

@@ -59,12 +59,20 @@ async fn check_deposit(client_config: &ClientConfig, coin: &mut Coin, wallet_net
         let utxo_txid = utxo.tx_hash.to_string();
         let utxo_vout = utxo.tx_pos as u32;
 
-        let backup_tx = create_tx1(client_config, coin, wallet_netwotk, &utxo_txid, utxo_vout).await?;
+        if coin.status != CoinStatus::INITIALISED {
+            return Err(anyhow!("The coin with the public key {} is not in the INITIALISED state", coin.user_pubkey.to_string()));
+        }
+
+        coin.utxo_txid = Some(utxo_txid.to_string());
+        coin.utxo_vout = Some(utxo_vout);
+
+        coin.status = CoinStatus::IN_MEMPOOL;
+
+        let backup_tx = create_tx1(client_config, coin, wallet_netwotk, 1u32).await?;
 
         let activity_utxo = format!("{}:{}", utxo.tx_hash.to_string(), utxo.tx_pos);
 
         let activity = Some(create_activity(&activity_utxo, utxo.value as u32, "deposit"));
-        // return Ok(Some(activity));
 
         deposit_result = Some(DepositResult {
             activity: activity.unwrap(),
@@ -238,7 +246,7 @@ pub async fn update_coins(client_config: &ClientConfig, wallet_name: &str) -> Re
                 let backup_tx = deposit_result.backup_tx;
 
                 wallet.activities.push(activity);
-                insert_backup_txs(&client_config.pool, &coin.statechain_id.as_ref().unwrap(), &[backup_tx].to_vec()).await?;
+                insert_backup_txs(&client_config.pool, &wallet.name, &coin.statechain_id.as_ref().unwrap(), &[backup_tx].to_vec()).await?;
             }
         } else if coin.status == CoinStatus::IN_TRANSFER {
 
@@ -257,6 +265,21 @@ pub async fn update_coins(client_config: &ClientConfig, wallet_name: &str) -> Re
 
     wallet.coins.extend(duplicated_coins);
 
+    // invalidate duplicated coins that were not transferred
+    for i in 0..wallet.coins.len() {
+        if wallet.coins[i].status == CoinStatus::DUPLICATED {
+            let is_transferred = (0..wallet.coins.len()).any(|j| 
+                i != j && // Skip comparing with self
+                wallet.coins[j].statechain_id == wallet.coins[i].statechain_id &&
+                wallet.coins[j].locktime == wallet.coins[i].locktime &&
+                wallet.coins[j].status == CoinStatus::TRANSFERRED
+            );
+            if is_transferred {
+                wallet.coins[i].status = CoinStatus::INVALIDATED;
+            }
+        }
+    }
+
     update_wallet(&client_config.pool, &wallet).await?;
 
     Ok(())

clients/libs/rust/src/deposit.rs

@@ -1,5 +1,5 @@
 use anyhow::{anyhow, Result, Ok};
-use mercurylib::{deposit::{create_deposit_msg1, create_aggregated_address}, wallet::{Wallet, BackupTx, CoinStatus, Coin}, transaction:: get_user_backup_address, utils::get_blockheight};
+use mercurylib::{deposit::{create_deposit_msg1, create_aggregated_address}, wallet::{Wallet, BackupTx, Coin}, transaction:: get_user_backup_address, utils::get_blockheight};
 
 use crate::{client_config::ClientConfig, sqlite_manager::{get_wallet, update_wallet}, transaction::new_transaction, utils::info_config};
 
@@ -23,19 +23,8 @@ pub async fn get_deposit_bitcoin_address(client_config: &ClientConfig, wallet_na
     Ok(aggregated_public_key.aggregate_address)
 }
 
-pub async fn create_tx1(client_config: &ClientConfig, coin: &mut Coin, wallet_netwotk: &str, tx0_hash: &str, tx0_vout: u32) -> Result<BackupTx> {
-
-    if coin.status != CoinStatus::INITIALISED {
-        return Err(anyhow!("The coin with the public key {} is not in the INITIALISED state", coin.user_pubkey.to_string()));
-    }
-
-    if coin.utxo_txid.is_some() && coin.utxo_vout.is_some() {
-        return Err(anyhow!("The coin with the public key {} has already been deposited", coin.user_pubkey.to_string()));
-    }
-    coin.utxo_txid = Some(tx0_hash.to_string());
-    coin.utxo_vout = Some(tx0_vout);
-
-    coin.status = CoinStatus::IN_MEMPOOL;
+// When sending duplicated coins, the tx_n of the backup_tx must be different
+pub async fn create_tx1(client_config: &ClientConfig, coin: &mut Coin, wallet_netwotk: &str, tx_n: u32) -> Result<BackupTx> {
 
     let to_address = get_user_backup_address(&coin, wallet_netwotk.to_string())?;
 
@@ -73,7 +62,7 @@ pub async fn create_tx1(client_config: &ClientConfig, coin: &mut Coin, wallet_ne
     }
 
     let backup_tx = BackupTx {
-        tx_n: 1,
+        tx_n,
         tx: signed_tx,
         client_public_nonce: coin.public_nonce.as_ref().unwrap().to_string(),
         server_public_nonce: coin.server_public_nonce.as_ref().unwrap().to_string(),

clients/libs/rust/src/lib.rs

@@ -16,6 +16,7 @@ pub use mercurylib::wallet::CoinStatus;
 pub use mercurylib::wallet::Coin;
 pub use mercurylib::wallet::BackupTx;
 pub use mercurylib::wallet::Activity;
+pub use mercurylib::wallet::get_previous_outpoint;
 
 pub use mercurylib::transfer::sender::{TransferSenderRequestPayload, TransferSenderResponsePayload, create_transfer_signature, create_transfer_update_msg};
 pub use mercurylib::transaction::{SignFirstRequestPayload, SignFirstResponsePayload, create_and_commit_nonces};

clients/libs/rust/src/sqlite_manager.rs

@@ -53,13 +53,14 @@ pub async fn update_wallet(pool: &Pool<Sqlite>, wallet: &Wallet) -> Result<()> {
     Ok(())
 }
 
-pub async fn insert_backup_txs(pool: &Pool<Sqlite>, statechain_id: &str, backup_txs: &Vec<BackupTx>) -> Result<()> {
+pub async fn insert_backup_txs(pool: &Pool<Sqlite>, wallet_name: &str, statechain_id: &str, backup_txs: &Vec<BackupTx>) -> Result<()> {
 
     let backup_txs_json = json!(backup_txs).to_string();
 
-    let query = "INSERT INTO backup_txs (statechain_id, txs) VALUES ($1, $2)";
+    let query = "INSERT INTO backup_txs (wallet_name, statechain_id, txs) VALUES ($1, $2, $3)";
 
     let _ = sqlx::query(query)
+            .bind(wallet_name)
             .bind(statechain_id)
             .bind(backup_txs_json)
             .execute(pool)
@@ -68,27 +69,29 @@ pub async fn insert_backup_txs(pool: &Pool<Sqlite>, statechain_id: &str, backup_
     Ok(())
 }
 
-pub async fn update_backup_txs(pool: &Pool<Sqlite>, statechain_id: &str, backup_txs: &Vec<BackupTx>) -> Result<()> {
+pub async fn update_backup_txs(pool: &Pool<Sqlite>, wallet_name: &str, statechain_id: &str, backup_txs: &Vec<BackupTx>) -> Result<()> {
 
     let backup_txs_json = json!(backup_txs).to_string();
 
-    let query = "UPDATE backup_txs SET txs = $1 WHERE statechain_id = $2";
+    let query = "UPDATE backup_txs SET txs = $1 WHERE statechain_id = $2 AND wallet_name = $3";
 
     let _ = sqlx::query(query)
             .bind(backup_txs_json)
             .bind(statechain_id)
+            .bind(wallet_name)
             .execute(pool)
             .await?;
 
     Ok(())
 }
 
-pub async fn get_backup_txs(pool: &Pool<Sqlite>, statechain_id: &str,) -> Result<Vec<BackupTx>> {
+pub async fn get_backup_txs(pool: &Pool<Sqlite>, wallet_name: &str, statechain_id: &str,) -> Result<Vec<BackupTx>> {
 
-    let query = "SELECT txs FROM backup_txs WHERE statechain_id = $1";
+    let query = "SELECT txs FROM backup_txs WHERE statechain_id = $1 AND wallet_name = $2";
 
     let row = sqlx::query(query)
         .bind(statechain_id)
+        .bind(wallet_name)
         .fetch_one(pool)
         .await?;
 
@@ -103,23 +106,25 @@ pub async fn get_backup_txs(pool: &Pool<Sqlite>, statechain_id: &str,) -> Result
     Ok(backup_txs)
 }
 
-pub async fn insert_or_update_backup_txs(pool: &Pool<Sqlite>, statechain_id: &str, backup_txs: &Vec<BackupTx>) -> Result<()> {
+pub async fn insert_or_update_backup_txs(pool: &Pool<Sqlite>, wallet_name: &str, statechain_id: &str, backup_txs: &Vec<BackupTx>) -> Result<()> {
 
     let mut transaction = pool.begin().await?;
 
     let backup_txs_json = json!(backup_txs).to_string();
 
-    let query = "DELETE FROM backup_txs WHERE statechain_id = $1";
+    let query = "DELETE FROM backup_txs WHERE statechain_id = $1 AND wallet_name = $2";
 
     let _ = sqlx::query(query)
             .bind(statechain_id)
+            .bind(wallet_name)
             .execute(&mut *transaction)
             .await?;
 
-    let query = "INSERT INTO backup_txs (statechain_id, txs) VALUES ($1, $2)";
+    let query = "INSERT INTO backup_txs (statechain_id, wallet_name, txs) VALUES ($1, $2, $3)";
 
     let _ = sqlx::query(query)
             .bind(statechain_id)
+            .bind(wallet_name)
             .bind(backup_txs_json)
             .execute(&mut *transaction)
             .await?;