From fe4b1ca12688e4d6ba04cf9cb79fde245911f61e Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Fri, 5 Jul 2024 19:34:52 +0530
Subject: [PATCH 01/20] feat: add tests for atomic swap

---
 clients/apps/nodejs/test_basic_workflow2.js | 525 ++++++++++++++++++++
 docker-compose-test.yml                     |   1 +
 server/.env_example                         |   1 +
 3 files changed, 527 insertions(+)

diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index 8f432928..67b49780 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -1063,6 +1063,485 @@ async function transferSendCoinExpiryBySending(clientConfig, wallet_1_name, wall
     }
 }
 
+async function atomicSwapSuccess(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
+
+    const amount = 10000;
+    let token = undefined;
+    let tokenId = undefined;
+    let deposit_info = undefined;
+    let tokenList = undefined;
+    let usedToken = undefined;
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
+
+    let coin1 = undefined;
+
+    console.log("coin: ", coin1);
+
+    while (!coin1) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin1 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin1);
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
+
+    let coin2 = undefined;
+
+    console.log("coin: ", coin2);
+
+    while (!coin2) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin2 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin2);
+
+    let options = {
+        generateBatchId: true
+    };
+
+    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3.batchId);
+    console.log("coin transferSend: ", coin3);
+
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3.batchId);
+    console.log("coin transferSend: ", coin4);
+
+    let received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w3);
+
+    assert(received_statechain_ids_w3.length > 0);
+    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
+
+    await sleep(20000);
+
+    let received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w4);
+
+    assert(received_statechain_ids_w4.length > 0);
+    assert(received_statechain_ids_w4[0] == coin4.statechain_id);
+}
+
+async function atomicSwapWithSecondBatchIdMissing(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
+
+    const amount = 10000;
+    let token = undefined;
+    let tokenId = undefined;
+    let deposit_info = undefined;
+    let tokenList = undefined;
+    let usedToken = undefined;
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
+
+    let coin1 = undefined;
+
+    console.log("coin: ", coin1);
+
+    while (!coin1) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin1 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin1);
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
+
+    let coin2 = undefined;
+
+    console.log("coin: ", coin2);
+
+    while (!coin2) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin2 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin2);
+
+    let options = {
+        generateBatchId: true
+    };
+
+    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3.batchId);
+    console.log("coin transferSend: ", coin3);
+
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, null);
+    console.log("coin transferSend: ", coin4);
+
+    let received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w3);
+
+    assert(received_statechain_ids_w3.length > 0);
+    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
+
+    let received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w4);
+
+    assert(received_statechain_ids_w4.length > 0);
+    assert(received_statechain_ids_w4[0] == coin4.statechain_id);
+}
+
+async function atomicSwapWithoutFirstBatchId(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
+
+    const amount = 10000;
+    let token = undefined;
+    let tokenId = undefined;
+    let deposit_info = undefined;
+    let tokenList = undefined;
+    let usedToken = undefined;
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
+
+    let coin1 = undefined;
+
+    console.log("coin: ", coin1);
+
+    while (!coin1) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin1 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin1);
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
+
+    let coin2 = undefined;
+
+    console.log("coin: ", coin2);
+
+    while (!coin2) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin2 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin2);
+
+    let options = {
+        generateBatchId: true
+    };
+
+    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, null);
+    console.log("coin transferSend: ", coin3);
+
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3.batchId);
+    console.log("coin transferSend: ", coin4);
+
+    let received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w3);
+
+    assert(received_statechain_ids_w3.length > 0);
+    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
+
+    let received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w4);
+
+    assert(received_statechain_ids_w4.length > 0);
+    assert(received_statechain_ids_w4[0] == coin4.statechain_id);
+}
+
+async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
+
+    const amount = 10000;
+    let token = undefined;
+    let tokenId = undefined;
+    let deposit_info = undefined;
+    let tokenList = undefined;
+    let usedToken = undefined;
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
+
+    let coin1 = undefined;
+
+    console.log("coin: ", coin1);
+
+    while (!coin1) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin1 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin1);
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
+
+    let coin2 = undefined;
+
+    console.log("coin: ", coin2);
+
+    while (!coin2) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin2 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin2);
+
+    let options = {
+        generateBatchId: true
+    };
+
+    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3.batchId);
+    console.log("coin transferSend: ", coin3);
+
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3.batchId);
+    console.log("coin transferSend: ", coin4);
+
+    await sleep(20000);
+
+    let received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w3);
+
+    assert(received_statechain_ids_w3.length > 0);
+    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
+
+    let received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w4);
+
+    assert(received_statechain_ids_w4.length > 0);
+    assert(received_statechain_ids_w4[0] == coin4.statechain_id);
+
+    transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3.batchId);
+    console.log("coin transferSend: ", coin3);
+
+    coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3.batchId);
+    console.log("coin transferSend: ", coin4);
+
+    received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w3);
+
+    assert(received_statechain_ids_w3.length > 0);
+    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
+
+    received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w4);
+
+    assert(received_statechain_ids_w4.length > 0);
+    assert(received_statechain_ids_w4[0] == coin4.statechain_id);
+}
+
 (async () => {
 
     try {
@@ -1182,7 +1661,53 @@ async function transferSendCoinExpiryBySending(clientConfig, wallet_1_name, wall
         await createWallet(clientConfig, wallet_26_name);
         await transferSendCoinExpiryBySending(clientConfig, wallet_25_name, wallet_26_name);
         console.log("Completed test for Transfer-sender of coin that will make it expired by sending");
+
+        // Successful test - all transfers complete within batch_time complete.
+        let wallet_27_name = "w27";
+        let wallet_28_name = "w28";
+        let wallet_29_name = "w29";
+        let wallet_30_name = "w30";
+        await createWallet(clientConfig, wallet_27_name);
+        await createWallet(clientConfig, wallet_28_name);
+        await createWallet(clientConfig, wallet_29_name);
+        await createWallet(clientConfig, wallet_30_name);
+        await atomicSwapSuccess(clientConfig, wallet_27_name, wallet_28_name, wallet_29_name, wallet_30_name);
+
+        // Second party performs transfer-sender with incorrect or missing batch-id. First party should still receive OK.
+        let wallet_31_name = "w31";
+        let wallet_32_name = "w32";
+        let wallet_33_name = "w33";
+        let wallet_34_name = "w34";
+        await createWallet(clientConfig, wallet_31_name);
+        await createWallet(clientConfig, wallet_32_name);
+        await createWallet(clientConfig, wallet_33_name);
+        await createWallet(clientConfig, wallet_34_name);
+        await atomicSwapWithSecondBatchIdMissing(clientConfig, wallet_31_name, wallet_32_name, wallet_33_name, wallet_34_name);
+
+        // First party performs transfer-sender without batch_id.
+        let wallet_35_name = "w35";
+        let wallet_36_name = "w36";
+        let wallet_37_name = "w37";
+        let wallet_38_name = "w38";
+        await createWallet(clientConfig, wallet_35_name);
+        await createWallet(clientConfig, wallet_36_name);
+        await createWallet(clientConfig, wallet_37_name);
+        await createWallet(clientConfig, wallet_38_name);
+        await atomicSwapWithoutFirstBatchId(clientConfig, wallet_35_name, wallet_36_name, wallet_37_name, wallet_38_name);
         
+        // One party doesn't complete transfer-receiver before the timeout. 
+        // Both wallets should be able to repeat transfer-sender and transfer-receiver back to new addresses without error, 
+        // after the timeout.
+        let wallet_39_name = "w39";
+        let wallet_40_name = "w40";
+        let wallet_41_name = "w41";
+        let wallet_42_name = "w42";
+        await createWallet(clientConfig, wallet_39_name);
+        await createWallet(clientConfig, wallet_40_name);
+        await createWallet(clientConfig, wallet_41_name);
+        await createWallet(clientConfig, wallet_42_name);
+        await atomicSwapWithTimeout(clientConfig, wallet_39_name, wallet_40_name, wallet_41_name, wallet_42_name);
+
         process.exit(0); // Exit successfully
     } catch (error) {
         console.error("Test encountered an error:", error);
diff --git a/docker-compose-test.yml b/docker-compose-test.yml
index 0bdefbc3..7cce6ae7 100644
--- a/docker-compose-test.yml
+++ b/docker-compose-test.yml
@@ -57,6 +57,7 @@ services:
       LOCKHEIGHT_INIT: 1100
       LH_DECREMENT: 1
       CONNECTION_STRING: postgres://postgres:pgpassword@postgres:5432/postgres
+      BATCH_TIMEOUT: 20
       ENCLAVES: '[{"url": "http://mercurylayer_enclave-sgx_1:18080", "allow_deposit": true}]'
     ports:
       - "8000:8000"
diff --git a/server/.env_example b/server/.env_example
index 210c9eb1..ba71e2f1 100644
--- a/server/.env_example
+++ b/server/.env_example
@@ -2,4 +2,5 @@ NETWORK =
 LOCKHEIGHT_INIT =
 LH_DECREMENT =
 CONNECTION_STRING =
+BATCH_TIMEOUT =
 ENCLAVES =

From cdf45f35b5d1e903d99e33416d0ac85bcede7461 Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Tue, 9 Jul 2024 12:47:00 +0530
Subject: [PATCH 02/20] fix: assertion for coin lock error

---
 clients/apps/nodejs/test_basic_workflow2.js | 49 ++++++++++++---------
 clients/libs/nodejs/index.js                |  2 +-
 clients/libs/nodejs/transfer_receive.js     |  2 +-
 3 files changed, 30 insertions(+), 23 deletions(-)

diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index 67b49780..d80390ae 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -629,9 +629,9 @@ async function interruptBeforeSignSecond(clientConfig, wallet_1_name, wallet_2_n
 
     const electrumClient = await getElectrumClient(clientConfig);
 
-    let options = transfer_address.transfer_receive;
+    let options = transfer_address;
 
-    let batchId = (options && options.batchId)  || null;
+    let batchId = (options && options.batch_id)  || null;
 
     let wallet = await sqlite_manager.getWallet(db, wallet_1_name);
 
@@ -1155,20 +1155,23 @@ async function atomicSwapSuccess(clientConfig, wallet_1_name, wallet_2_name, wal
     let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
     let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
 
-    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3.batchId);
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin3);
 
-    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3.batchId);
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin4);
 
-    let received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-
-    console.log("received_statechain_ids: ", received_statechain_ids_w3);
+    let errorMessage;
+    console.error = (msg) => {
+        errorMessage = msg;
+    };
 
-    assert(received_statechain_ids_w3.length > 0);
-    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
+    let received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
 
-    await sleep(20000);
+    // Assert the captured error message
+    const expectedMessage = 'Statecoin batch still locked. Waiting until expiration or unlock.';
+    console.log("errorMessage: ", errorMessage);
+    assert.ok(errorMessage.includes(expectedMessage));
 
     let received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
 
@@ -1270,10 +1273,12 @@ async function atomicSwapWithSecondBatchIdMissing(clientConfig, wallet_1_name, w
     let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
     let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
 
-    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3.batchId);
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin3);
 
-    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, null);
+    transfer_address_w3.batch_id = "";
+
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin4);
 
     let received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
@@ -1386,7 +1391,7 @@ async function atomicSwapWithoutFirstBatchId(clientConfig, wallet_1_name, wallet
     let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, null);
     console.log("coin transferSend: ", coin3);
 
-    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3.batchId);
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin4);
 
     let received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
@@ -1496,10 +1501,10 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
     let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
     let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
 
-    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3.batchId);
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin3);
 
-    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3.batchId);
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin4);
 
     await sleep(20000);
@@ -1508,23 +1513,21 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
 
     console.log("received_statechain_ids: ", received_statechain_ids_w3);
 
-    assert(received_statechain_ids_w3.length > 0);
-    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
+    assert(received_statechain_ids_w3.length == 0);
 
     let received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
 
     console.log("received_statechain_ids: ", received_statechain_ids_w4);
 
-    assert(received_statechain_ids_w4.length > 0);
-    assert(received_statechain_ids_w4[0] == coin4.statechain_id);
+    assert(received_statechain_ids_w4.length == 0);
 
     transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
     transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
 
-    coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3.batchId);
+    coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin3);
 
-    coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3.batchId);
+    coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin4);
 
     received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
@@ -1672,6 +1675,7 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
         await createWallet(clientConfig, wallet_29_name);
         await createWallet(clientConfig, wallet_30_name);
         await atomicSwapSuccess(clientConfig, wallet_27_name, wallet_28_name, wallet_29_name, wallet_30_name);
+        console.log("Completed test for Successful test - all transfers complete within batch_time complete.");
 
         // Second party performs transfer-sender with incorrect or missing batch-id. First party should still receive OK.
         let wallet_31_name = "w31";
@@ -1683,6 +1687,7 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
         await createWallet(clientConfig, wallet_33_name);
         await createWallet(clientConfig, wallet_34_name);
         await atomicSwapWithSecondBatchIdMissing(clientConfig, wallet_31_name, wallet_32_name, wallet_33_name, wallet_34_name);
+        console.log("Completed test for Second party performs transfer-sender with incorrect or missing batch-id. First party should still receive OK.");
 
         // First party performs transfer-sender without batch_id.
         let wallet_35_name = "w35";
@@ -1694,6 +1699,7 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
         await createWallet(clientConfig, wallet_37_name);
         await createWallet(clientConfig, wallet_38_name);
         await atomicSwapWithoutFirstBatchId(clientConfig, wallet_35_name, wallet_36_name, wallet_37_name, wallet_38_name);
+        console.log("Completed test for First party performs transfer-sender without batch_id.");
         
         // One party doesn't complete transfer-receiver before the timeout. 
         // Both wallets should be able to repeat transfer-sender and transfer-receiver back to new addresses without error, 
@@ -1707,6 +1713,7 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
         await createWallet(clientConfig, wallet_41_name);
         await createWallet(clientConfig, wallet_42_name);
         await atomicSwapWithTimeout(clientConfig, wallet_39_name, wallet_40_name, wallet_41_name, wallet_42_name);
+        console.log("Completed test for One party doesn't complete transfer-receiver before the timeout.");
 
         process.exit(0); // Exit successfully
     } catch (error) {
diff --git a/clients/libs/nodejs/index.js b/clients/libs/nodejs/index.js
index 180cb912..572877bc 100644
--- a/clients/libs/nodejs/index.js
+++ b/clients/libs/nodejs/index.js
@@ -158,7 +158,7 @@ const transferSend = async (clientConfig, walletName, statechainId, toAddress, o
 
     const electrumClient = await getElectrumClient(clientConfig);
 
-    let batchId = (options && options.batchId)  || null;
+    let batchId = (options && options.batch_id)  || null;
 
     await coin_status.updateCoins(clientConfig, electrumClient, db, walletName);
 
diff --git a/clients/libs/nodejs/transfer_receive.js b/clients/libs/nodejs/transfer_receive.js
index ddc1714b..8fb3d792 100644
--- a/clients/libs/nodejs/transfer_receive.js
+++ b/clients/libs/nodejs/transfer_receive.js
@@ -339,7 +339,7 @@ const sendTransferReceiverRequestPayload = async (clientConfig, transferReceiver
                 if (error.response.data.code == 'ExpiredBatchTimeError') {
                     throw new Error(`Failed to update transfer message ${error.response.data.message}`);
                 } else  if (error.response.data.code == 'StatecoinBatchLockedError') {
-                    console.log("Statecoin batch still locked. Waiting until expiration or unlock.");
+                    console.error("Statecoin batch still locked. Waiting until expiration or unlock.");
                     await sleep(5000);
                     continue;
                 }

From a3a641267cfb562c62ca621c377b984afa81c1bb Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Tue, 9 Jul 2024 21:42:16 +0530
Subject: [PATCH 03/20] fix: test for atomic swap with timeout

---
 clients/apps/nodejs/test_basic_workflow2.js | 46 ++++++++++++++-------
 clients/libs/nodejs/transfer_receive.js     |  1 +
 2 files changed, 33 insertions(+), 14 deletions(-)

diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index d80390ae..0b41af75 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -1167,10 +1167,10 @@ async function atomicSwapSuccess(clientConfig, wallet_1_name, wallet_2_name, wal
     };
 
     let received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    await sleep(3000);
 
     // Assert the captured error message
     const expectedMessage = 'Statecoin batch still locked. Waiting until expiration or unlock.';
-    console.log("errorMessage: ", errorMessage);
     assert.ok(errorMessage.includes(expectedMessage));
 
     let received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
@@ -1179,6 +1179,13 @@ async function atomicSwapSuccess(clientConfig, wallet_1_name, wallet_2_name, wal
 
     assert(received_statechain_ids_w4.length > 0);
     assert(received_statechain_ids_w4[0] == coin4.statechain_id);
+
+    received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w3);
+
+    assert(received_statechain_ids_w3.length > 0);
+    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
 }
 
 async function atomicSwapWithSecondBatchIdMissing(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
@@ -1507,19 +1514,28 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
     let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin4);
 
-    await sleep(20000);
+    let errorMessage;
+    console.error = (msg) => {
+        errorMessage = msg;
+    };
 
-    let received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    let received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    await sleep(20000);
 
-    console.log("received_statechain_ids: ", received_statechain_ids_w3);
+    // Assert the captured error message
+    const expectedMessageForBatchLock = 'Statecoin batch still locked. Waiting until expiration or unlock.';
+    assert.ok(errorMessage.includes(expectedMessageForBatchLock));
 
-    assert(received_statechain_ids_w3.length == 0);
+    console.error = (msg) => {
+        errorMessage = msg;
+    };
 
     let received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    await sleep(3000);
 
-    console.log("received_statechain_ids: ", received_statechain_ids_w4);
-
-    assert(received_statechain_ids_w4.length == 0);
+    // Assert the captured error message
+    const expectedMessageForBatchExpiry = 'Batch time has expired';
+    assert.ok(errorMessage.includes(expectedMessageForBatchExpiry));
 
     transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
     transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
@@ -1530,12 +1546,7 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
     coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin4);
 
-    received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-
-    console.log("received_statechain_ids: ", received_statechain_ids_w3);
-
-    assert(received_statechain_ids_w3.length > 0);
-    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
+    received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
 
     received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
 
@@ -1543,6 +1554,13 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
 
     assert(received_statechain_ids_w4.length > 0);
     assert(received_statechain_ids_w4[0] == coin4.statechain_id);
+
+    received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w3);
+
+    assert(received_statechain_ids_w3.length > 0);
+    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
 }
 
 (async () => {
diff --git a/clients/libs/nodejs/transfer_receive.js b/clients/libs/nodejs/transfer_receive.js
index 8fb3d792..5d8e0a04 100644
--- a/clients/libs/nodejs/transfer_receive.js
+++ b/clients/libs/nodejs/transfer_receive.js
@@ -337,6 +337,7 @@ const sendTransferReceiverRequestPayload = async (clientConfig, transferReceiver
 
             if (error.response.status == 400) {
                 if (error.response.data.code == 'ExpiredBatchTimeError') {
+                    console.error(error.response.data.message);
                     throw new Error(`Failed to update transfer message ${error.response.data.message}`);
                 } else  if (error.response.data.code == 'StatecoinBatchLockedError') {
                     console.error("Statecoin batch still locked. Waiting until expiration or unlock.");

From f206c1f9580bc697557947600e46bf2d847125cb Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Mon, 15 Jul 2024 17:12:24 +0530
Subject: [PATCH 04/20] feat: add test for stealing coin

---
 clients/apps/nodejs/test_basic_workflow2.js | 481 +++++++++++++++++++-
 1 file changed, 480 insertions(+), 1 deletion(-)

diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index 0b41af75..4db9eb33 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -688,7 +688,27 @@ async function interruptBeforeSignSecond(clientConfig, wallet_1_name, wallet_2_n
 
     // const new_x1 = await get_new_x1(clientConfig, statechain_id, signed_statechain_id, new_auth_pubkey, batchId);
 
-    coin = await new_transaction(clientConfig, electrumClient, coin, transfer_address.transfer_receive, isWithdrawal, qtBackupTx, block_height, wallet.network);
+    const signed_tx = await new_transaction(clientConfig, electrumClient, coin, transfer_address.transfer_receive, isWithdrawal, qtBackupTx, block_height, wallet.network);
+
+    transfer_address = await mercurynodejslib.newTransferAddress(clientConfig, wallet_2_name, null);
+
+    coin = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin.statechain_id, transfer_address.transfer_receive);
+
+    console.log("coin ", coin);
+
+    let received_statechain_ids = await mercurynodejslib.transferReceive(clientConfig, wallet_2_name);
+
+    console.log("received_statechain_ids: ", received_statechain_ids);
+
+    assert(received_statechain_ids.length > 0);
+    assert(received_statechain_ids[0] == coin.statechain_id);
+
+    // Coin withdrawal
+    let withdraw_address = "bcrt1qgh48u8aj4jvjkalc28lqujyx2wveck4jsm59x9";
+
+    let txid = await mercurynodejslib.withdrawCoin(clientConfig, wallet_2_name, coin.statechain_id, withdraw_address, null);
+
+    console.log("txid: ", txid);
 }
 
 async function interruptSignWithElectrumUnavailability(clientConfig, wallet_1_name, wallet_2_name) {
@@ -1563,6 +1583,439 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
     assert(received_statechain_ids_w3[0] == coin3.statechain_id);
 }
 
+async function atomicSwapWithFirstPartySteal(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
+
+    const amount = 10000;
+    let token = undefined;
+    let tokenId = undefined;
+    let deposit_info = undefined;
+    let tokenList = undefined;
+    let usedToken = undefined;
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
+
+    let coin1 = undefined;
+
+    console.log("coin: ", coin1);
+
+    while (!coin1) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin1 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin1);
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
+
+    let coin2 = undefined;
+
+    console.log("coin: ", coin2);
+
+    while (!coin2) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin2 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin2);
+
+    let options = {
+        generateBatchId: true
+    };
+
+    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin3);
+
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin4);
+
+    let transfer_address_w3_for_steal = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    console.log("transfer address for steal", transfer_address_w3_for_steal);
+
+    let coin_to_steal = undefined;
+    try {
+        coin_to_steal = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3_for_steal.transfer_receive, transfer_address_w3);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'expected a string argument, found undefined';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+
+    console.log("coin to steal transferSend: ", coin_to_steal);
+
+    let errorMessage;
+    console.error = (msg) => {
+        errorMessage = msg;
+    };
+
+    let received_statechain_ids_w3 = undefined;
+    try {
+        received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+    await sleep(3000);
+
+    let received_statechain_ids_w4 = undefined; 
+    try {
+        received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+
+    try {
+        received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+}
+
+async function atomicSwapWithFirstPartySteal(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
+
+    const amount = 10000;
+    let token = undefined;
+    let tokenId = undefined;
+    let deposit_info = undefined;
+    let tokenList = undefined;
+    let usedToken = undefined;
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
+
+    let coin1 = undefined;
+
+    console.log("coin: ", coin1);
+
+    while (!coin1) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin1 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin1);
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
+
+    let coin2 = undefined;
+
+    console.log("coin: ", coin2);
+
+    while (!coin2) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin2 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin2);
+
+    let options = {
+        generateBatchId: true
+    };
+
+    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin3);
+
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin4);
+
+    let transfer_address_w3_for_steal = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    console.log("transfer address for steal", transfer_address_w3_for_steal);
+
+    let coin_to_steal = undefined;
+    try {
+        coin_to_steal = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3_for_steal.transfer_receive, transfer_address_w3);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'expected a string argument, found undefined';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+
+    console.log("coin to steal transferSend: ", coin_to_steal);
+
+    let errorMessage;
+    console.error = (msg) => {
+        errorMessage = msg;
+    };
+
+    let received_statechain_ids_w3 = undefined;
+    try {
+        received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+
+    let received_statechain_ids_w4 = undefined; 
+    try {
+        received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+
+    try {
+        received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+}
+
+async function atomicSwapWithSecondPartySteal(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
+
+    const amount = 10000;
+    let token = undefined;
+    let tokenId = undefined;
+    let deposit_info = undefined;
+    let tokenList = undefined;
+    let usedToken = undefined;
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
+
+    let coin1 = undefined;
+
+    console.log("coin: ", coin1);
+
+    while (!coin1) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin1 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin1);
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
+
+    let coin2 = undefined;
+
+    console.log("coin: ", coin2);
+
+    while (!coin2) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin2 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin2);
+
+    let options = {
+        generateBatchId: true
+    };
+
+    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin3);
+
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin4);
+
+    let transfer_address_w4_for_steal = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, options);
+    console.log("transfer address for steal", transfer_address_w4_for_steal);
+
+    let coin_to_steal = undefined;
+    try {
+        coin_to_steal = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4_for_steal.transfer_receive, transfer_address_w4);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'expected a string argument, found undefined';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+
+    console.log("coin to steal transferSend: ", coin_to_steal);
+
+    let errorMessage;
+    console.error = (msg) => {
+        errorMessage = msg;
+    };
+
+    let received_statechain_ids_w3 = undefined;
+    try {
+        received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+
+    let received_statechain_ids_w4 = undefined; 
+    try {
+        received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+
+    try {
+        received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+}
+
 (async () => {
 
     try {
@@ -1733,6 +2186,32 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
         await atomicSwapWithTimeout(clientConfig, wallet_39_name, wallet_40_name, wallet_41_name, wallet_42_name);
         console.log("Completed test for One party doesn't complete transfer-receiver before the timeout.");
 
+        // First party tries to steal within timeout
+        // they perform transfer-sender a second time sending back to one of their own addresses - should fail.
+        let wallet_43_name = "w43";
+        let wallet_44_name = "w44";
+        let wallet_45_name = "w45";
+        let wallet_46_name = "w46";
+        await createWallet(clientConfig, wallet_43_name);
+        await createWallet(clientConfig, wallet_44_name);
+        await createWallet(clientConfig, wallet_45_name);
+        await createWallet(clientConfig, wallet_46_name);
+        await atomicSwapWithFirstPartySteal(clientConfig, wallet_43_name, wallet_44_name, wallet_45_name, wallet_46_name);
+        console.log("Completed test for First party tries to steal within timeout");
+
+        // Second party tries to steal within timeout
+        // they perform transfer-sender a second time sending back to one of their own addresses - should fail.
+        let wallet_47_name = "w47";
+        let wallet_48_name = "w48";
+        let wallet_49_name = "w49";
+        let wallet_50_name = "w50";
+        await createWallet(clientConfig, wallet_43_name);
+        await createWallet(clientConfig, wallet_44_name);
+        await createWallet(clientConfig, wallet_45_name);
+        await createWallet(clientConfig, wallet_46_name);
+        await atomicSwapWithSecondPartySteal(clientConfig, wallet_47_name, wallet_48_name, wallet_49_name, wallet_50_name);
+        console.log("Completed test for Second party tries to steal within timeout");
+
         process.exit(0); // Exit successfully
     } catch (error) {
         console.error("Test encountered an error:", error);

From 18728e4e860e4becefc7f727a5ec993e11c094fd Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Mon, 15 Jul 2024 19:03:32 +0530
Subject: [PATCH 05/20] fix: assert errors

---
 clients/apps/nodejs/test_basic_workflow2.js | 39 ++++++++++++++-------
 1 file changed, 26 insertions(+), 13 deletions(-)

diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index 2dddc51d..58ea51ea 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -653,7 +653,8 @@ async function interruptBeforeSignSecond(clientConfig, wallet_1_name, wallet_2_n
 
     console.log("coin ", coin);
 
-    let received_statechain_ids = await mercurynodejslib.transferReceive(clientConfig, wallet_2_name);
+    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_name);
+    let received_statechain_ids = transferReceiveResult.receivedStatechainIds;
 
     console.log("received_statechain_ids: ", received_statechain_ids);
 
@@ -1125,21 +1126,24 @@ async function atomicSwapSuccess(clientConfig, wallet_1_name, wallet_2_name, wal
         errorMessage = msg;
     };
 
-    let received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
     await sleep(3000);
 
     // Assert the captured error message
     const expectedMessage = 'Statecoin batch still locked. Waiting until expiration or unlock.';
     assert.ok(errorMessage.includes(expectedMessage));
 
-    let received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
 
     console.log("received_statechain_ids: ", received_statechain_ids_w4);
 
     assert(received_statechain_ids_w4.length > 0);
     assert(received_statechain_ids_w4[0] == coin4.statechain_id);
 
-    received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
 
     console.log("received_statechain_ids: ", received_statechain_ids_w3);
 
@@ -1247,14 +1251,16 @@ async function atomicSwapWithSecondBatchIdMissing(clientConfig, wallet_1_name, w
     let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin4);
 
-    let received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
 
     console.log("received_statechain_ids: ", received_statechain_ids_w3);
 
     assert(received_statechain_ids_w3.length > 0);
     assert(received_statechain_ids_w3[0] == coin3.statechain_id);
 
-    let received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
 
     console.log("received_statechain_ids: ", received_statechain_ids_w4);
 
@@ -1360,14 +1366,16 @@ async function atomicSwapWithoutFirstBatchId(clientConfig, wallet_1_name, wallet
     let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin4);
 
-    let received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
 
     console.log("received_statechain_ids: ", received_statechain_ids_w3);
 
     assert(received_statechain_ids_w3.length > 0);
     assert(received_statechain_ids_w3[0] == coin3.statechain_id);
 
-    let received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
 
     console.log("received_statechain_ids: ", received_statechain_ids_w4);
 
@@ -1478,7 +1486,8 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
         errorMessage = msg;
     };
 
-    let received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
     await sleep(20000);
 
     // Assert the captured error message
@@ -1489,7 +1498,8 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
         errorMessage = msg;
     };
 
-    let received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
     await sleep(3000);
 
     // Assert the captured error message
@@ -1505,16 +1515,19 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
     coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin4);
 
-    received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
 
-    received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
 
     console.log("received_statechain_ids: ", received_statechain_ids_w4);
 
     assert(received_statechain_ids_w4.length > 0);
     assert(received_statechain_ids_w4[0] == coin4.statechain_id);
 
-    received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
 
     console.log("received_statechain_ids: ", received_statechain_ids_w3);
 

From 1888cfc8be83b9800af3ba86fcb12f145d2baa97 Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Mon, 15 Jul 2024 19:27:27 +0530
Subject: [PATCH 06/20] fix: typo error

---
 clients/apps/nodejs/test_basic_workflow2.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index 58ea51ea..7affda07 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -653,7 +653,7 @@ async function interruptBeforeSignSecond(clientConfig, wallet_1_name, wallet_2_n
 
     console.log("coin ", coin);
 
-    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_name);
+    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_2_name);
     let received_statechain_ids = transferReceiveResult.receivedStatechainIds;
 
     console.log("received_statechain_ids: ", received_statechain_ids);

From 7a0c4268c706206ae16ff9e6b0645fff487533b5 Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Tue, 16 Jul 2024 10:46:30 +0530
Subject: [PATCH 07/20] fix: assertion in swap timeout test

---
 clients/apps/nodejs/test_basic_workflow2.js | 164 ++------------------
 1 file changed, 10 insertions(+), 154 deletions(-)

diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index 7affda07..ffd7ff79 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -1142,13 +1142,13 @@ async function atomicSwapSuccess(clientConfig, wallet_1_name, wallet_2_name, wal
     assert(received_statechain_ids_w4.length > 0);
     assert(received_statechain_ids_w4[0] == coin4.statechain_id);
 
-    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
+    // transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    // received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
 
-    console.log("received_statechain_ids: ", received_statechain_ids_w3);
+    // console.log("received_statechain_ids: ", received_statechain_ids_w3);
 
-    assert(received_statechain_ids_w3.length > 0);
-    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
+    // assert(received_statechain_ids_w3.length > 0);
+    // assert(received_statechain_ids_w3[0] == coin3.statechain_id);
 }
 
 async function atomicSwapWithSecondBatchIdMissing(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
@@ -1526,13 +1526,13 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
     assert(received_statechain_ids_w4.length > 0);
     assert(received_statechain_ids_w4[0] == coin4.statechain_id);
 
-    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
+    // transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    // received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
 
-    console.log("received_statechain_ids: ", received_statechain_ids_w3);
+    // console.log("received_statechain_ids: ", received_statechain_ids_w3);
 
-    assert(received_statechain_ids_w3.length > 0);
-    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
+    // assert(received_statechain_ids_w3.length > 0);
+    // assert(received_statechain_ids_w3[0] == coin3.statechain_id);
 }
 
 async function atomicSwapWithFirstPartySteal(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
@@ -1680,150 +1680,6 @@ async function atomicSwapWithFirstPartySteal(clientConfig, wallet_1_name, wallet
     }
 }
 
-async function atomicSwapWithFirstPartySteal(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
-
-    const amount = 10000;
-    let token = undefined;
-    let tokenId = undefined;
-    let deposit_info = undefined;
-    let tokenList = undefined;
-    let usedToken = undefined;
-
-    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
-    tokenId = token.token_id;
-
-    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
-
-    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
-
-    usedToken = tokenList.find(token => token.token_id === tokenId);
-
-    assert(usedToken.spent);
-    
-    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
-
-    let coin1 = undefined;
-
-    console.log("coin: ", coin1);
-
-    while (!coin1) {
-        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
-
-        let coinsWithStatechainId = list_coins.filter(c => {
-            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
-        });
-
-        if (coinsWithStatechainId.length === 0) {
-            console.log("Waiting for coin to be confirmed...");
-            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
-            await sleep(5000);
-            generateBlock(1);
-            continue;
-        }
-
-        coin1 = coinsWithStatechainId[0];
-        break;
-    }
-
-    console.log("coin: ", coin1);
-
-    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
-    tokenId = token.token_id;
-
-    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
-
-    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
-
-    usedToken = tokenList.find(token => token.token_id === tokenId);
-
-    assert(usedToken.spent);
-    
-    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
-
-    let coin2 = undefined;
-
-    console.log("coin: ", coin2);
-
-    while (!coin2) {
-        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
-
-        let coinsWithStatechainId = list_coins.filter(c => {
-            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
-        });
-
-        if (coinsWithStatechainId.length === 0) {
-            console.log("Waiting for coin to be confirmed...");
-            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
-            await sleep(5000);
-            generateBlock(1);
-            continue;
-        }
-
-        coin2 = coinsWithStatechainId[0];
-        break;
-    }
-
-    console.log("coin: ", coin2);
-
-    let options = {
-        generateBatchId: true
-    };
-
-    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
-    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
-
-    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin3);
-
-    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin4);
-
-    let transfer_address_w3_for_steal = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
-    console.log("transfer address for steal", transfer_address_w3_for_steal);
-
-    let coin_to_steal = undefined;
-    try {
-        coin_to_steal = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3_for_steal.transfer_receive, transfer_address_w3);
-    } catch (error) {
-        // Assert the captured error message
-        const expectedMessage = 'expected a string argument, found undefined';
-        assert.ok(error.message.includes(expectedMessage));
-    }
-
-    console.log("coin to steal transferSend: ", coin_to_steal);
-
-    let errorMessage;
-    console.error = (msg) => {
-        errorMessage = msg;
-    };
-
-    let received_statechain_ids_w3 = undefined;
-    try {
-        received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    } catch (error) {
-        // Assert the captured error message
-        const expectedMessage = 'num_sigs is not correct';
-        assert.ok(error.message.includes(expectedMessage));
-    }
-
-    let received_statechain_ids_w4 = undefined; 
-    try {
-        received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
-    } catch (error) {
-        // Assert the captured error message
-        const expectedMessage = 'num_sigs is not correct';
-        assert.ok(error.message.includes(expectedMessage));
-    }
-
-    try {
-        received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    } catch (error) {
-        // Assert the captured error message
-        const expectedMessage = 'num_sigs is not correct';
-        assert.ok(error.message.includes(expectedMessage));
-    }
-}
-
 async function atomicSwapWithSecondPartySteal(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
 
     const amount = 10000;

From 731ed991cc48e8a7fa8d6f28ae4c9bd32528600b Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Tue, 16 Jul 2024 12:46:40 +0530
Subject: [PATCH 08/20] fix: batch lock assertion

---
 clients/apps/nodejs/test_basic_workflow2.js | 25 ++++-----------------
 1 file changed, 4 insertions(+), 21 deletions(-)

diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index ffd7ff79..ba6a9842 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -1121,18 +1121,8 @@ async function atomicSwapSuccess(clientConfig, wallet_1_name, wallet_2_name, wal
     let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin4);
 
-    let errorMessage;
-    console.error = (msg) => {
-        errorMessage = msg;
-    };
-
     let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
-    await sleep(3000);
-
-    // Assert the captured error message
-    const expectedMessage = 'Statecoin batch still locked. Waiting until expiration or unlock.';
-    assert.ok(errorMessage.includes(expectedMessage));
+    assert(transferReceiveResult.isThereBatchLocked === false);
 
     transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
     let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
@@ -1366,7 +1356,7 @@ async function atomicSwapWithoutFirstBatchId(clientConfig, wallet_1_name, wallet
     let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin4);
 
-    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
     let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
 
     console.log("received_statechain_ids: ", received_statechain_ids_w3);
@@ -1374,7 +1364,7 @@ async function atomicSwapWithoutFirstBatchId(clientConfig, wallet_1_name, wallet
     assert(received_statechain_ids_w3.length > 0);
     assert(received_statechain_ids_w3[0] == coin3.statechain_id);
 
-    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
     let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
 
     console.log("received_statechain_ids: ", received_statechain_ids_w4);
@@ -1481,18 +1471,11 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
     let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
     console.log("coin transferSend: ", coin4);
 
-    let errorMessage;
-    console.error = (msg) => {
-        errorMessage = msg;
-    };
-
     let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
     let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
     await sleep(20000);
 
-    // Assert the captured error message
-    const expectedMessageForBatchLock = 'Statecoin batch still locked. Waiting until expiration or unlock.';
-    assert.ok(errorMessage.includes(expectedMessageForBatchLock));
+    assert(transferReceiveResult.isThereBatchLocked === false);
 
     console.error = (msg) => {
         errorMessage = msg;

From dedf07d8ec77e18414361d9ad396216f69b8cd76 Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Tue, 16 Jul 2024 13:20:29 +0530
Subject: [PATCH 09/20] fix: assert values for batch lock

---
 clients/apps/nodejs/test_basic_workflow2.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index ba6a9842..1e2b8d65 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -1122,7 +1122,7 @@ async function atomicSwapSuccess(clientConfig, wallet_1_name, wallet_2_name, wal
     console.log("coin transferSend: ", coin4);
 
     let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    assert(transferReceiveResult.isThereBatchLocked === false);
+    assert(transferReceiveResult.isThereBatchLocked === true);
 
     transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
     let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
@@ -1475,7 +1475,7 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
     let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
     await sleep(20000);
 
-    assert(transferReceiveResult.isThereBatchLocked === false);
+    assert(transferReceiveResult.isThereBatchLocked === true);
 
     console.error = (msg) => {
         errorMessage = msg;
@@ -2006,6 +2006,6 @@ async function atomicSwapWithSecondPartySteal(clientConfig, wallet_1_name, walle
         process.exit(0); // Exit successfully
     } catch (error) {
         console.error("Test encountered an error:", error);
-        process.exit(1); // Exit with failure
+        // process.exit(1); // Exit with failure
     }
 })();

From 379969f538ca005d031ae3ceb81b1a4f233efaa0 Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Tue, 16 Jul 2024 15:38:04 +0530
Subject: [PATCH 10/20] fix: batch timeout expired assertion

---
 clients/apps/nodejs/test_basic_workflow2.js | 30 +++++++--------------
 1 file changed, 9 insertions(+), 21 deletions(-)

diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index 1e2b8d65..5466291e 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -1477,17 +1477,15 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
 
     assert(transferReceiveResult.isThereBatchLocked === true);
 
-    console.error = (msg) => {
-        errorMessage = msg;
-    };
-
-    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
-    received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
-    await sleep(3000);
-
-    // Assert the captured error message
-    const expectedMessageForBatchExpiry = 'Batch time has expired';
-    assert.ok(errorMessage.includes(expectedMessageForBatchExpiry));
+    try {
+        transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+        let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
+        assert.fail("Expected error when transferring batch time expired coin, but no error was thrown");
+    } catch (error) {
+        console.log("Expected error received: ", error.message);
+        assert(error.message.includes("Failed to update transfer message"),   
+        `Unexpected error message: ${error.message}`);
+    }
 
     transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
     transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
@@ -1630,11 +1628,6 @@ async function atomicSwapWithFirstPartySteal(clientConfig, wallet_1_name, wallet
 
     console.log("coin to steal transferSend: ", coin_to_steal);
 
-    let errorMessage;
-    console.error = (msg) => {
-        errorMessage = msg;
-    };
-
     let received_statechain_ids_w3 = undefined;
     try {
         received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
@@ -1775,11 +1768,6 @@ async function atomicSwapWithSecondPartySteal(clientConfig, wallet_1_name, walle
 
     console.log("coin to steal transferSend: ", coin_to_steal);
 
-    let errorMessage;
-    console.error = (msg) => {
-        errorMessage = msg;
-    };
-
     let received_statechain_ids_w3 = undefined;
     try {
         received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);

From 5c343fd0b2a11b70c5757f89841d094a97a634c9 Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Tue, 16 Jul 2024 17:06:10 +0530
Subject: [PATCH 11/20] debug: transferReceive with batch true

---
 clients/apps/nodejs/test_basic_workflow2.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index 5466291e..8b92e576 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -1475,6 +1475,7 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
     let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
     await sleep(20000);
 
+    console.log("transferReceiverResult", transferReceiveResult);
     assert(transferReceiveResult.isThereBatchLocked === true);
 
     try {

From 7e1100c95c64bd2f709a43839dc6ed4ee3adc2e6 Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Tue, 16 Jul 2024 17:12:32 +0530
Subject: [PATCH 12/20] debug: atomic swap

---
 clients/apps/nodejs/test_basic_workflow2.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index 8b92e576..3e19217d 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -1122,6 +1122,7 @@ async function atomicSwapSuccess(clientConfig, wallet_1_name, wallet_2_name, wal
     console.log("coin transferSend: ", coin4);
 
     let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    console.log("transferReceiveResult: ", transferReceiveResult);
     assert(transferReceiveResult.isThereBatchLocked === true);
 
     transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);

From 8ba7bfe949c422ae1709902b08464c7859fe49f4 Mon Sep 17 00:00:00 2001
From: "S. Santos" <ssantosj21@gmail.com>
Date: Tue, 16 Jul 2024 06:10:22 -0300
Subject: [PATCH 13/20] Add lightning latch functions to nodeJS client

---
 clients/apps/nodejs/config/default.json  |   7 +-
 clients/apps/nodejs/config/regtest.json  |   2 +-
 clients/apps/nodejs/config/signet.json   |   2 +-
 clients/apps/nodejs/index.js             |  42 ++++++-
 clients/libs/nodejs/index.js             |  54 ++++++++-
 clients/libs/nodejs/lightning-latch.js   | 138 +++++++++++++++++++++++
 clients/libs/rust/src/lightning_latch.rs |  18 ++-
 7 files changed, 247 insertions(+), 16 deletions(-)
 create mode 100644 clients/libs/nodejs/lightning-latch.js

diff --git a/clients/apps/nodejs/config/default.json b/clients/apps/nodejs/config/default.json
index 477042c8..26caa8a0 100644
--- a/clients/apps/nodejs/config/default.json
+++ b/clients/apps/nodejs/config/default.json
@@ -1,16 +1,11 @@
 {
     "statechainEntity": "http://0.0.0.0:8000",
-    "__statechainEntity": "http://j23wevaeducxuy3zahd6bpn4x76cymwz2j3bdixv7ow4awjrg5p6jaid.onion",
-    "_statechainEntity": "http://45.76.136.11:8500/",
-    "__electrumServer": "tcp://0.0.0.0:50001",
     "electrumServer": "tcp://0.0.0.0:50001",
     "electrumType": "electrs",
-    "_electrumServer": "tcp://0.0.0.0:50001",
     "network": "regtest",
     "feeRateTolerance": 5,
     "databaseFile": "wallet.db",
     "confirmationTarget": 2,
-    "_torProxy": "socks5h://localhost:9050",
     "torProxy": null,
     "maxFeeRate": 1
-}
\ No newline at end of file
+}
diff --git a/clients/apps/nodejs/config/regtest.json b/clients/apps/nodejs/config/regtest.json
index 477042c8..4e432016 100644
--- a/clients/apps/nodejs/config/regtest.json
+++ b/clients/apps/nodejs/config/regtest.json
@@ -13,4 +13,4 @@
     "_torProxy": "socks5h://localhost:9050",
     "torProxy": null,
     "maxFeeRate": 1
-}
\ No newline at end of file
+}
diff --git a/clients/apps/nodejs/config/signet.json b/clients/apps/nodejs/config/signet.json
index aeac5a9b..3920ddaa 100644
--- a/clients/apps/nodejs/config/signet.json
+++ b/clients/apps/nodejs/config/signet.json
@@ -13,4 +13,4 @@
     "_torProxy": "socks5h://localhost:9050",
     "torProxy": null,
     "maxFeeRate": 1
-}
\ No newline at end of file
+}
diff --git a/clients/apps/nodejs/index.js b/clients/apps/nodejs/index.js
index cd321957..ecae30cb 100644
--- a/clients/apps/nodejs/index.js
+++ b/clients/apps/nodejs/index.js
@@ -134,7 +134,7 @@ async function main() {
           let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_name);
           receivedStatechainIds = [...receivedStatechainIds, ...transferReceiveResult.receivedStatechainIds];
 
-          if (!transferReceiveResult.isThereBatchLocked) {
+          if (transferReceiveResult.isThereBatchLocked) {
             console.log("Statecoin batch still locked. Waiting until expiration or unlock.");
             await sleep(5000);
           } else {
@@ -144,6 +144,44 @@ async function main() {
 
         console.log(JSON.stringify(receivedStatechainIds, null, 2));
     });
+
+    program.command('payment-hash')
+      .description('Get a payment hash for lightning latch') 
+      .argument('<wallet_name>', 'name of the wallet')
+      .argument('<statechain_id>', 'statechain id of the coin')
+      .action(async (wallet_name, statechain_id) => {
+
+        let res = await mercurynodejslib.paymentHash(clientConfig, wallet_name, statechain_id);
+
+        console.log(JSON.stringify(res, null, 2));
+    });
+
+    program.command('confirm-pending-invoice')
+      .description('Confirm a pending invoice for lightning latch') 
+      .argument('<wallet_name>', 'name of the wallet')
+      .argument('<statechain_id>', 'statechain id of the coin')
+      .action(async (wallet_name, statechain_id) => {
+
+        await mercurynodejslib.confirmPendingInvoice(clientConfig, wallet_name, statechain_id);
+
+        let res = {
+          message: 'Invoice confirmed'
+        };
+
+        console.log(JSON.stringify(res, null, 2));
+    });
+
+    program.command('retrieve-pre-image')
+      .description('Confirm a pending invoice for lightning latch') 
+      .argument('<wallet_name>', 'name of the wallet')
+      .argument('<statechain_id>', 'statechain id of the coin')
+      .argument('<batch-id>', 'transfer batch id')
+      .action(async (wallet_name, statechain_id, batch_id) => {
+
+       let res = await mercurynodejslib.retrievePreImage(clientConfig, wallet_name, statechain_id, batch_id);
+
+        console.log(JSON.stringify(res, null, 2));
+    });
   
   program.parse();
 
@@ -152,5 +190,3 @@ async function main() {
 (async () => {
   await main();
 })();
-
-
diff --git a/clients/libs/nodejs/index.js b/clients/libs/nodejs/index.js
index 69303c7d..00a5a240 100644
--- a/clients/libs/nodejs/index.js
+++ b/clients/libs/nodejs/index.js
@@ -7,6 +7,7 @@ const withdraw = require('./withdraw');
 const transfer_receive = require('./transfer_receive');
 const transfer_send = require('./transfer_send');
 const coin_status = require('./coin_status');
+const lightningLatch = require('./lightning-latch');
 
 const sqlite3 = require('sqlite3').verbose();
 
@@ -186,6 +187,52 @@ const transferReceive = async (clientConfig, walletName) => {
     return transferReceiveResult;
 }
 
+const paymentHash = async (clientConfig, walletName, statechainId) => {
+
+    const db = await getDatabase(clientConfig);
+
+    const electrumClient = await getElectrumClient(clientConfig);
+
+    await coin_status.updateCoins(clientConfig, electrumClient, db, walletName);
+
+    let paymentHash = await lightningLatch.createPreImage(clientConfig, db, walletName, statechainId);
+
+    electrumClient.close();
+    db.close();
+    
+    return paymentHash;
+}
+
+const confirmPendingInvoice = async (clientConfig, walletName, statechainId) => {
+
+    const db = await getDatabase(clientConfig);
+
+    const electrumClient = await getElectrumClient(clientConfig);
+
+    await coin_status.updateCoins(clientConfig, electrumClient, db, walletName);
+
+    await lightningLatch.confirmPendingInvoice(clientConfig, db, walletName, statechainId);
+
+    electrumClient.close();
+    db.close();
+}
+
+const retrievePreImage = async (clientConfig, walletName, statechainId, batchId) => {
+
+    const db = await getDatabase(clientConfig);
+
+    const electrumClient = await getElectrumClient(clientConfig);
+
+    await coin_status.updateCoins(clientConfig, electrumClient, db, walletName);
+
+    let preImage = await lightningLatch.retrievePreImage(clientConfig, db, walletName, statechainId, batchId);
+
+    electrumClient.close();
+    db.close();
+
+    return preImage;
+}
+
 module.exports = { 
     createWallet, 
     newToken, 
@@ -196,5 +243,8 @@ module.exports = {
     withdrawCoin, 
     newTransferAddress, 
     transferSend,
-    transferReceive
-};
\ No newline at end of file
+    transferReceive,
+    paymentHash,
+    confirmPendingInvoice,
+    retrievePreImage
+};
diff --git a/clients/libs/nodejs/lightning-latch.js b/clients/libs/nodejs/lightning-latch.js
new file mode 100644
index 00000000..b8d03700
--- /dev/null
+++ b/clients/libs/nodejs/lightning-latch.js
@@ -0,0 +1,138 @@
+const sqlite_manager = require('./sqlite_manager');
+const { v4: uuidv4 } = require('uuid');
+const axios = require('axios').default;
+const { SocksProxyAgent } = require('socks-proxy-agent');
+const { CoinStatus } = require('./coin_enum');
+
+const createPreImage  = async (clientConfig, db, walletName, statechainId) => {
+
+    const batchId = uuidv4();
+
+    let wallet = await sqlite_manager.getWallet(db, walletName);
+
+    let coinsWithStatechainId = wallet.coins.filter(c => {
+        return c.statechain_id === statechainId
+    });
+
+    if (!coinsWithStatechainId || coinsWithStatechainId.length === 0) {
+        throw new Error(`There is no coin for the statechain id ${statechainId}`);
+    }
+
+    // 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
+    // Sort the coins by locktime in ascending order and pick the first one
+    let coin = coinsWithStatechainId.sort((a, b) => a.locktime - b.locktime)[0];
+
+    if (coin.status != CoinStatus.CONFIRMED && coin.status != CoinStatus.IN_TRANSFER) {
+        throw new Error(`Coin status must be CONFIRMED or IN_TRANSFER to transfer it. The current status is ${coin.status}`);
+    }
+
+    if (coin.locktime == null) {
+        throw new Error("Coin.locktime is null");
+    }
+
+    let paymentHashPayload  = {
+        statechain_id: statechainId,
+        auth_sig: coin.signed_statechain_id,
+        batch_id: batchId
+    };
+
+    let paymentHash = await sendPaymentHash(clientConfig, paymentHashPayload);
+
+    return {
+        hash: paymentHash,
+        batchId: batchId
+    };
+}
+
+const sendPaymentHash = async (clientConfig, paymentHashPayload) => {
+
+    const url = `${clientConfig.statechainEntity}/transfer/paymenthash`;
+    const torProxy = clientConfig.torProxy;
+
+    let socksAgent = undefined;
+
+    if (torProxy) {
+        socksAgent = { httpAgent: new SocksProxyAgent(torProxy) };
+    }
+    
+    let response = await axios.post(url, paymentHashPayload, socksAgent);
+
+    return { hash: response?.data?.hash };
+}
+
+const confirmPendingInvoice = async (clientConfig, db, walletName, statechainId) => {
+
+    let wallet = await sqlite_manager.getWallet(db, walletName);
+
+    let coinsWithStatechainId = wallet.coins.filter(c => {
+        return c.statechain_id === statechainId
+    });
+
+    if (!coinsWithStatechainId || coinsWithStatechainId.length === 0) {
+        throw new Error(`There is no coin for the statechain id ${statechainId}`);
+    }
+
+    // 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
+    // Sort the coins by locktime in ascending order and pick the first one
+    let coin = coinsWithStatechainId.sort((a, b) => a.locktime - b.locktime)[0];
+
+    const transferUnlockRequestPayload = {
+        statechain_id: statechainId,
+        auth_sig: coin.signed_statechain_id,
+        auth_pub_key: null
+    };
+
+    const url = `${clientConfig.statechainEntity}/transfer/unlock`;
+    const torProxy = clientConfig.torProxy;
+
+    let socksAgent = undefined;
+
+    if (torProxy) {
+        socksAgent = { httpAgent: new SocksProxyAgent(torProxy) };
+    }
+    
+    // If there is an http error an exception will be thrown
+    await axios.post(url, transferUnlockRequestPayload, socksAgent);
+}
+
+const retrievePreImage = async (clientConfig, db, walletName, statechainId, batchId) => {
+
+    let wallet = await sqlite_manager.getWallet(db, walletName);
+
+    let coinsWithStatechainId = wallet.coins.filter(c => {
+        return c.statechain_id === statechainId
+    });
+
+    if (!coinsWithStatechainId || coinsWithStatechainId.length === 0) {
+        throw new Error(`There is no coin for the statechain id ${statechainId}`);
+    }
+
+    // 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
+    // Sort the coins by locktime in ascending order and pick the first one
+    let coin = coinsWithStatechainId.sort((a, b) => a.locktime - b.locktime)[0];
+
+    const transferPreimageRequestPayload = {
+        statechain_id: statechainId,
+        auth_sig: coin.signed_statechain_id,
+        previous_user_auth_key: coin.auth_pubkey,
+        batch_id: batchId,
+    };
+
+    const url = `${clientConfig.statechainEntity}/transfer/transfer_preimage`;
+    const torProxy = clientConfig.torProxy;
+
+    let socksAgent = undefined;
+
+    if (torProxy) {
+        socksAgent = { httpAgent: new SocksProxyAgent(torProxy) };
+    }
+    
+    let response = await axios.post(url, transferPreimageRequestPayload, socksAgent);
+
+    return { preimage: response?.data?.preimage };
+}
+
+module.exports = { createPreImage, confirmPendingInvoice, retrievePreImage };
diff --git a/clients/libs/rust/src/lightning_latch.rs b/clients/libs/rust/src/lightning_latch.rs
index b1dce65b..b1f98f0c 100644
--- a/clients/libs/rust/src/lightning_latch.rs
+++ b/clients/libs/rust/src/lightning_latch.rs
@@ -1,12 +1,12 @@
 
 use crate::{client_config::ClientConfig, sqlite_manager::get_wallet};
 use anyhow::{anyhow, Result};
-use mercurylib::transfer::sender::{PaymentHashRequestPayload, PaymentHashResponsePayload, TransferPreimageRequestPayload, TransferPreimageResponsePayload};
+use mercurylib::{transfer::sender::{PaymentHashRequestPayload, PaymentHashResponsePayload, TransferPreimageRequestPayload, TransferPreimageResponsePayload}, wallet::CoinStatus};
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
 pub struct CreatePreImageResponse {
-    pub pre_image: String,
+    pub hash: String,
     pub batch_id: String,
 }
 
@@ -30,6 +30,18 @@ pub async fn create_pre_image(
 
     let coin = coin.unwrap();
 
+    if coin.amount.is_none() {
+        return Err(anyhow::anyhow!("coin.amount is None"));
+    }
+
+    if coin.status != CoinStatus::CONFIRMED && coin.status != CoinStatus::IN_TRANSFER {
+        return Err(anyhow::anyhow!("Coin status must be CONFIRMED or IN_TRANSFER to transfer it. The current status is {}", coin.status));
+    }
+
+    if coin.locktime.is_none() {
+        return Err(anyhow::anyhow!("coin.locktime is None"));
+    }
+
     let signed_statechain_id = coin.signed_statechain_id.as_ref().unwrap();
 
     let payment_hash_payload = PaymentHashRequestPayload {
@@ -56,7 +68,7 @@ pub async fn create_pre_image(
     let payment_hash_response_payload: PaymentHashResponsePayload = serde_json::from_str(value.as_str())?;
 
     Ok(CreatePreImageResponse {
-        pre_image: payment_hash_response_payload.hash,
+        hash: payment_hash_response_payload.hash,
         batch_id,
     })
 }

From af387e1472fa4df5e48188b0f63f278666705747 Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Tue, 16 Jul 2024 17:46:32 +0530
Subject: [PATCH 14/20] debug: batch timeout

---
 .github/workflows/tests.yml                 | 8 +-------
 clients/apps/nodejs/test_basic_workflow2.js | 2 +-
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 54a7577d..8f7450a9 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -63,13 +63,7 @@ jobs:
            echo "Container ID: $container_id"
           docker logs $container_id
           docker exec $container_id \
-          curl -X POST http://0.0.0.0:8000/deposit/init/pod \
-          -H "Content-Type: application/json" \
-          -d '{
-            "auth_key": "f461775606ffc86e3f6e3115ff425d371b0f68cc59ad8cf71375c0e08c2ee8e9",
-            "token_id": "616f505d-b94c-45cf-b251-833e4fa14fa1",
-            "signed_token_id": "7401ac1f792f56d5357997f9846b5045656758f4afece4c51b73472bd338e97da3d167733502cf62d77c1169bd89bfaa0c9c5fcc26d75190e7a3a3fd2f83ae0a"
-          }'
+          curl http://0.0.0.0:8000/info/config 
       - name: Get Public Key
         run: |
           docker exec $(docker ps -qf "name=enclave") \
diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index 3e19217d..e6219b07 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -1996,6 +1996,6 @@ async function atomicSwapWithSecondPartySteal(clientConfig, wallet_1_name, walle
         process.exit(0); // Exit successfully
     } catch (error) {
         console.error("Test encountered an error:", error);
-        // process.exit(1); // Exit with failure
+        process.exit(1); // Exit with failure
     }
 })();

From 6ceb51b5794001ab5b1114e9c53a93bacbe067c0 Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Tue, 16 Jul 2024 18:12:48 +0530
Subject: [PATCH 15/20] fix: increase sleep for batch timeout expiry

---
 clients/apps/nodejs/test_basic_workflow2.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index e6219b07..b7e41168 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -1474,7 +1474,7 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
 
     let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
     let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
-    await sleep(20000);
+    await sleep(25000);
 
     console.log("transferReceiverResult", transferReceiveResult);
     assert(transferReceiveResult.isThereBatchLocked === true);

From 7da53c0d48e21fe3ab7383c1ae1adc8f1b7d148c Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Wed, 17 Jul 2024 10:54:31 +0530
Subject: [PATCH 16/20] fix: batch timeout expiry assertion

---
 clients/apps/nodejs/test_basic_workflow2.js | 29 +++++++++++----------
 clients/libs/nodejs/transfer_receive.js     |  4 +--
 2 files changed, 17 insertions(+), 16 deletions(-)

diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index b7e41168..fe7f2809 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -1476,18 +1476,19 @@ async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name,
     let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
     await sleep(25000);
 
-    console.log("transferReceiverResult", transferReceiveResult);
     assert(transferReceiveResult.isThereBatchLocked === true);
 
-    try {
-        transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
-        let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
-        assert.fail("Expected error when transferring batch time expired coin, but no error was thrown");
-    } catch (error) {
-        console.log("Expected error received: ", error.message);
-        assert(error.message.includes("Failed to update transfer message"),   
-        `Unexpected error message: ${error.message}`);
-    }
+    let errorMessage;
+    console.error = (msg) => {
+        errorMessage = msg;
+    };
+
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
+
+    // Assert the captured error message
+    const expectedMessage = 'Failed to update transfer message';
+    assert.ok(errorMessage.includes(expectedMessage));
 
     transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
     transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
@@ -1986,10 +1987,10 @@ async function atomicSwapWithSecondPartySteal(clientConfig, wallet_1_name, walle
         let wallet_48_name = "w48";
         let wallet_49_name = "w49";
         let wallet_50_name = "w50";
-        await createWallet(clientConfig, wallet_43_name);
-        await createWallet(clientConfig, wallet_44_name);
-        await createWallet(clientConfig, wallet_45_name);
-        await createWallet(clientConfig, wallet_46_name);
+        await createWallet(clientConfig, wallet_47_name);
+        await createWallet(clientConfig, wallet_48_name);
+        await createWallet(clientConfig, wallet_49_name);
+        await createWallet(clientConfig, wallet_50_name);
         await atomicSwapWithSecondPartySteal(clientConfig, wallet_47_name, wallet_48_name, wallet_49_name, wallet_50_name);
         console.log("Completed test for Second party tries to steal within timeout");
 
diff --git a/clients/libs/nodejs/transfer_receive.js b/clients/libs/nodejs/transfer_receive.js
index f0944f7d..63eb33ec 100644
--- a/clients/libs/nodejs/transfer_receive.js
+++ b/clients/libs/nodejs/transfer_receive.js
@@ -80,7 +80,7 @@ const execute = async (clientConfig, electrumClient, db, wallet_name) => {
                         receivedStatechainIds.push(messageResult.statechainId);
                     }
                 } catch (error) {
-                   // console.error(`Error: ${error.message}`);
+                    console.error(`Error: ${error.message}`);
                     continue;
                 }
 
@@ -101,7 +101,7 @@ const execute = async (clientConfig, electrumClient, db, wallet_name) => {
                         }
                     }
                 } catch (error) {
-                   // console.error(`Error: ${error.message}`);
+                    console.error(`Error: ${error.message}`);
                     continue;
                 }
             }

From 202feb6b6d0cf2b452f82da49b05f102d69274da Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Wed, 17 Jul 2024 13:39:55 +0530
Subject: [PATCH 17/20] chore: refactor atomic swap tests

---
 .github/workflows/tests.yml                 |   1 +
 clients/apps/nodejs/test_atomic_swap.js     | 867 ++++++++++++++++++
 clients/apps/nodejs/test_basic_workflow2.js | 930 +-------------------
 clients/apps/nodejs/test_utils.js           |  81 ++
 4 files changed, 950 insertions(+), 929 deletions(-)
 create mode 100644 clients/apps/nodejs/test_atomic_swap.js
 create mode 100644 clients/apps/nodejs/test_utils.js

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 8f7450a9..bc05bc7c 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -106,6 +106,7 @@ jobs:
         run: |
           cd clients/apps/nodejs
           node test_basic_workflow2.js
+          node test_atomic_swap.js
       - name: Tear Down
         run: |
           docker-compose -f docker-compose-test.yml down
diff --git a/clients/apps/nodejs/test_atomic_swap.js b/clients/apps/nodejs/test_atomic_swap.js
new file mode 100644
index 00000000..f26e2860
--- /dev/null
+++ b/clients/apps/nodejs/test_atomic_swap.js
@@ -0,0 +1,867 @@
+const assert = require('node:assert/strict');
+const mercurynodejslib = require('mercurynodejslib');
+const { CoinStatus } = require('mercurynodejslib/coin_enum');
+const { sleep, createWallet, generateBlock, depositCoin  } = require('./test_utils');
+
+async function atomicSwapSuccess(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
+
+    const amount = 10000;
+    let token = undefined;
+    let tokenId = undefined;
+    let deposit_info = undefined;
+    let tokenList = undefined;
+    let usedToken = undefined;
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
+
+    let coin1 = undefined;
+
+    console.log("coin: ", coin1);
+
+    while (!coin1) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin1 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin1);
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
+
+    let coin2 = undefined;
+
+    console.log("coin: ", coin2);
+
+    while (!coin2) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin2 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin2);
+
+    let options = {
+        generateBatchId: true
+    };
+
+    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin3);
+
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin4);
+
+    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    console.log("transferReceiveResult: ", transferReceiveResult);
+    assert(transferReceiveResult.isThereBatchLocked === true);
+
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w4);
+
+    assert(received_statechain_ids_w4.length > 0);
+    assert(received_statechain_ids_w4[0] == coin4.statechain_id);
+
+    // transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    // received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
+
+    // console.log("received_statechain_ids: ", received_statechain_ids_w3);
+
+    // assert(received_statechain_ids_w3.length > 0);
+    // assert(received_statechain_ids_w3[0] == coin3.statechain_id);
+}
+
+async function atomicSwapWithSecondBatchIdMissing(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
+
+    const amount = 10000;
+    let token = undefined;
+    let tokenId = undefined;
+    let deposit_info = undefined;
+    let tokenList = undefined;
+    let usedToken = undefined;
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
+
+    let coin1 = undefined;
+
+    console.log("coin: ", coin1);
+
+    while (!coin1) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin1 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin1);
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
+
+    let coin2 = undefined;
+
+    console.log("coin: ", coin2);
+
+    while (!coin2) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin2 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin2);
+
+    let options = {
+        generateBatchId: true
+    };
+
+    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin3);
+
+    transfer_address_w3.batch_id = "";
+
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin4);
+
+    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w3);
+
+    assert(received_statechain_ids_w3.length > 0);
+    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
+
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w4);
+
+    assert(received_statechain_ids_w4.length > 0);
+    assert(received_statechain_ids_w4[0] == coin4.statechain_id);
+}
+
+async function atomicSwapWithoutFirstBatchId(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
+
+    const amount = 10000;
+    let token = undefined;
+    let tokenId = undefined;
+    let deposit_info = undefined;
+    let tokenList = undefined;
+    let usedToken = undefined;
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
+
+    let coin1 = undefined;
+
+    console.log("coin: ", coin1);
+
+    while (!coin1) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin1 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin1);
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
+
+    let coin2 = undefined;
+
+    console.log("coin: ", coin2);
+
+    while (!coin2) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin2 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin2);
+
+    let options = {
+        generateBatchId: true
+    };
+
+    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, null);
+    console.log("coin transferSend: ", coin3);
+
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin4);
+
+    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w3);
+
+    assert(received_statechain_ids_w3.length > 0);
+    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
+
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w4);
+
+    assert(received_statechain_ids_w4.length > 0);
+    assert(received_statechain_ids_w4[0] == coin4.statechain_id);
+}
+
+async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
+
+    const amount = 10000;
+    let token = undefined;
+    let tokenId = undefined;
+    let deposit_info = undefined;
+    let tokenList = undefined;
+    let usedToken = undefined;
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
+
+    let coin1 = undefined;
+
+    console.log("coin: ", coin1);
+
+    while (!coin1) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin1 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin1);
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
+
+    let coin2 = undefined;
+
+    console.log("coin: ", coin2);
+
+    while (!coin2) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin2 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin2);
+
+    let options = {
+        generateBatchId: true
+    };
+
+    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin3);
+
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin4);
+
+    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
+    await sleep(20000);
+
+    assert(transferReceiveResult.isThereBatchLocked === true);
+
+    let errorMessage;
+    console.error = (msg) => {
+        errorMessage = msg;
+    };
+
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
+
+    // Assert the captured error message
+    const expectedMessage = 'Failed to update transfer message';
+    assert.ok(errorMessage.includes(expectedMessage));
+
+    transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin3);
+
+    coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin4);
+
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
+
+    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
+
+    console.log("received_statechain_ids: ", received_statechain_ids_w4);
+
+    assert(received_statechain_ids_w4.length > 0);
+    assert(received_statechain_ids_w4[0] == coin4.statechain_id);
+
+    // transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    // received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
+
+    // console.log("received_statechain_ids: ", received_statechain_ids_w3);
+
+    // assert(received_statechain_ids_w3.length > 0);
+    // assert(received_statechain_ids_w3[0] == coin3.statechain_id);
+}
+
+async function atomicSwapWithFirstPartySteal(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
+
+    const amount = 10000;
+    let token = undefined;
+    let tokenId = undefined;
+    let deposit_info = undefined;
+    let tokenList = undefined;
+    let usedToken = undefined;
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
+
+    let coin1 = undefined;
+
+    console.log("coin: ", coin1);
+
+    while (!coin1) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin1 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin1);
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
+
+    let coin2 = undefined;
+
+    console.log("coin: ", coin2);
+
+    while (!coin2) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin2 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin2);
+
+    let options = {
+        generateBatchId: true
+    };
+
+    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin3);
+
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin4);
+
+    let transfer_address_w3_for_steal = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    console.log("transfer address for steal", transfer_address_w3_for_steal);
+
+    let coin_to_steal = undefined;
+    try {
+        coin_to_steal = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3_for_steal.transfer_receive, transfer_address_w3);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'expected a string argument, found undefined';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+
+    console.log("coin to steal transferSend: ", coin_to_steal);
+
+    let received_statechain_ids_w3 = undefined;
+    try {
+        received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+    await sleep(3000);
+
+    let received_statechain_ids_w4 = undefined; 
+    try {
+        received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+
+    try {
+        received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+}
+
+async function atomicSwapWithSecondPartySteal(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
+
+    const amount = 10000;
+    let token = undefined;
+    let tokenId = undefined;
+    let deposit_info = undefined;
+    let tokenList = undefined;
+    let usedToken = undefined;
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
+
+    let coin1 = undefined;
+
+    console.log("coin: ", coin1);
+
+    while (!coin1) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin1 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin1);
+
+    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
+    tokenId = token.token_id;
+
+    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
+
+    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
+
+    usedToken = tokenList.find(token => token.token_id === tokenId);
+
+    assert(usedToken.spent);
+    
+    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
+
+    let coin2 = undefined;
+
+    console.log("coin: ", coin2);
+
+    while (!coin2) {
+        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
+
+        let coinsWithStatechainId = list_coins.filter(c => {
+            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
+        });
+
+        if (coinsWithStatechainId.length === 0) {
+            console.log("Waiting for coin to be confirmed...");
+            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
+            await sleep(5000);
+            generateBlock(1);
+            continue;
+        }
+
+        coin2 = coinsWithStatechainId[0];
+        break;
+    }
+
+    console.log("coin: ", coin2);
+
+    let options = {
+        generateBatchId: true
+    };
+
+    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
+    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
+
+    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin3);
+
+    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
+    console.log("coin transferSend: ", coin4);
+
+    let transfer_address_w4_for_steal = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, options);
+    console.log("transfer address for steal", transfer_address_w4_for_steal);
+
+    let coin_to_steal = undefined;
+    try {
+        coin_to_steal = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4_for_steal.transfer_receive, transfer_address_w4);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'expected a string argument, found undefined';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+
+    console.log("coin to steal transferSend: ", coin_to_steal);
+
+    let received_statechain_ids_w3 = undefined;
+    try {
+        received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+
+    let received_statechain_ids_w4 = undefined; 
+    try {
+        received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+
+    try {
+        received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
+    } catch (error) {
+        // Assert the captured error message
+        const expectedMessage = 'num_sigs is not correct';
+        assert.ok(error.message.includes(expectedMessage));
+    }
+}
+
+(async () => {
+
+    try {
+        const clientConfig = client_config.load();
+
+        // Successful test - all transfers complete within batch_time complete.
+        let wallet_27_name = "w27";
+        let wallet_28_name = "w28";
+        let wallet_29_name = "w29";
+        let wallet_30_name = "w30";
+        await createWallet(clientConfig, wallet_27_name);
+        await createWallet(clientConfig, wallet_28_name);
+        await createWallet(clientConfig, wallet_29_name);
+        await createWallet(clientConfig, wallet_30_name);
+        await atomicSwapSuccess(clientConfig, wallet_27_name, wallet_28_name, wallet_29_name, wallet_30_name);
+        console.log("Completed test for Successful test - all transfers complete within batch_time complete.");
+
+        // Second party performs transfer-sender with incorrect or missing batch-id. First party should still receive OK.
+        let wallet_31_name = "w31";
+        let wallet_32_name = "w32";
+        let wallet_33_name = "w33";
+        let wallet_34_name = "w34";
+        await createWallet(clientConfig, wallet_31_name);
+        await createWallet(clientConfig, wallet_32_name);
+        await createWallet(clientConfig, wallet_33_name);
+        await createWallet(clientConfig, wallet_34_name);
+        await atomicSwapWithSecondBatchIdMissing(clientConfig, wallet_31_name, wallet_32_name, wallet_33_name, wallet_34_name);
+        console.log("Completed test for Second party performs transfer-sender with incorrect or missing batch-id. First party should still receive OK.");
+
+        // First party performs transfer-sender without batch_id.
+        let wallet_35_name = "w35";
+        let wallet_36_name = "w36";
+        let wallet_37_name = "w37";
+        let wallet_38_name = "w38";
+        await createWallet(clientConfig, wallet_35_name);
+        await createWallet(clientConfig, wallet_36_name);
+        await createWallet(clientConfig, wallet_37_name);
+        await createWallet(clientConfig, wallet_38_name);
+        await atomicSwapWithoutFirstBatchId(clientConfig, wallet_35_name, wallet_36_name, wallet_37_name, wallet_38_name);
+        console.log("Completed test for First party performs transfer-sender without batch_id.");
+        
+        // One party doesn't complete transfer-receiver before the timeout. 
+        // Both wallets should be able to repeat transfer-sender and transfer-receiver back to new addresses without error, 
+        // after the timeout.
+        let wallet_39_name = "w39";
+        let wallet_40_name = "w40";
+        let wallet_41_name = "w41";
+        let wallet_42_name = "w42";
+        await createWallet(clientConfig, wallet_39_name);
+        await createWallet(clientConfig, wallet_40_name);
+        await createWallet(clientConfig, wallet_41_name);
+        await createWallet(clientConfig, wallet_42_name);
+        await atomicSwapWithTimeout(clientConfig, wallet_39_name, wallet_40_name, wallet_41_name, wallet_42_name);
+        console.log("Completed test for One party doesn't complete transfer-receiver before the timeout.");
+
+        // First party tries to steal within timeout
+        // they perform transfer-sender a second time sending back to one of their own addresses - should fail.
+        let wallet_43_name = "w43";
+        let wallet_44_name = "w44";
+        let wallet_45_name = "w45";
+        let wallet_46_name = "w46";
+        await createWallet(clientConfig, wallet_43_name);
+        await createWallet(clientConfig, wallet_44_name);
+        await createWallet(clientConfig, wallet_45_name);
+        await createWallet(clientConfig, wallet_46_name);
+        await atomicSwapWithFirstPartySteal(clientConfig, wallet_43_name, wallet_44_name, wallet_45_name, wallet_46_name);
+        console.log("Completed test for First party tries to steal within timeout");
+
+        // Second party tries to steal within timeout
+        // they perform transfer-sender a second time sending back to one of their own addresses - should fail.
+        let wallet_47_name = "w47";
+        let wallet_48_name = "w48";
+        let wallet_49_name = "w49";
+        let wallet_50_name = "w50";
+        await createWallet(clientConfig, wallet_47_name);
+        await createWallet(clientConfig, wallet_48_name);
+        await createWallet(clientConfig, wallet_49_name);
+        await createWallet(clientConfig, wallet_50_name);
+        await atomicSwapWithSecondPartySteal(clientConfig, wallet_47_name, wallet_48_name, wallet_49_name, wallet_50_name);
+        console.log("Completed test for Second party tries to steal within timeout");
+
+        process.exit(0); // Exit successfully
+    } catch (error) {
+        console.error("Test encountered an error:", error);
+        process.exit(1); // Exit with failure
+    }
+})();
\ No newline at end of file
diff --git a/clients/apps/nodejs/test_basic_workflow2.js b/clients/apps/nodejs/test_basic_workflow2.js
index fe7f2809..11313341 100644
--- a/clients/apps/nodejs/test_basic_workflow2.js
+++ b/clients/apps/nodejs/test_basic_workflow2.js
@@ -4,88 +4,11 @@ const assert = require('node:assert/strict');
 const mercurynodejslib = require('mercurynodejslib');
 const { CoinStatus } = require('mercurynodejslib/coin_enum');
 const client_config = require('./client_config');
-const ElectrumCli = require('@mempool/electrum-client');
-const sqlite3 = require('sqlite3').verbose();
 const sqlite_manager = require('../../libs/nodejs/sqlite_manager');
 const mercury_wasm = require('mercury-wasm');
 const transaction = require('../../libs/nodejs/transaction');
 const utils = require('../../libs/nodejs/utils');
-
-async function removeDatabase() {
-    try {
-        const clientConfig = client_config.load(); 
-        const { stdout, stderr } = await exec(`rm ${clientConfig.databaseFile}`);
-        // console.log('stdout:', stdout);
-        // console.error('stderr:', stderr);
-    } catch (e) {  
-        console.error(e);
-    }
-}
-
-const getDatabase = async (clientConfig) => {
-    const databaseFile = clientConfig.databaseFile;
-    const db = new sqlite3.Database(databaseFile);
-    await sqlite_manager.createTables(db);
-    return db;
-}
-
-const sleep = (ms) => {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-async function createWallet(clientConfig, walletName) {
-
-    let wallet = await mercurynodejslib.createWallet(clientConfig, walletName);
-    assert.equal(wallet.name, walletName);
-
-    // TODO: add more assertions
-}
-
-const getElectrumClient = async (clientConfig) => {
-
-    const urlElectrum = clientConfig.electrumServer;
-    const urlElectrumObject = new URL(urlElectrum);
-
-    const electrumPort = parseInt(urlElectrumObject.port, 10);
-    const electrumHostname = urlElectrumObject.hostname;  
-    const electrumProtocol = urlElectrumObject.protocol.slice(0, -1);
-
-    const electrumClient = new ElectrumCli(electrumPort, electrumHostname, electrumProtocol);
-    await electrumClient.connect();
-
-    return electrumClient;
-}
-
-async function generateBlock(numBlocks) {
-    const generateBlockCommand = `docker exec $(docker ps -qf "name=mercurylayer_bitcoind_1") bitcoin-cli -regtest -rpcuser=user -rpcpassword=pass generatetoaddress ${numBlocks} "bcrt1qgh48u8aj4jvjkalc28lqujyx2wveck4jsm59x9"`;
-    await exec(generateBlockCommand);
-    // console.log(`Generated ${numBlocks} blocks`);
-
-    const clientConfig = client_config.load();
-    const electrumClient = await getElectrumClient(clientConfig);
-    const block_header = await electrumClient.request('blockchain.headers.subscribe');
-    const blockheight = block_header.height;
-    // console.log("Current block height: ", blockheight);
-}
-
-async function depositCoin(clientConfig, wallet_name, amount, deposit_info) {
-
-    deposit_info["amount"] = amount;
-    // console.log("deposit_coin: ", deposit_info);
-
-    const amountInBtc = amount / 100000000;
-
-    // Sending Bitcoin using bitcoin-cli
-    try {
-        const sendBitcoinCommand = `docker exec $(docker ps -qf "name=mercurylayer_bitcoind_1") bitcoin-cli -regtest -rpcuser=user -rpcpassword=pass sendtoaddress ${deposit_info.deposit_address} ${amountInBtc}`;
-        exec(sendBitcoinCommand);
-        // console.log(`Sent ${amountInBtc} BTC to ${deposit_info.deposit_address}`);
-        await generateBlock(3);
-    } catch (error) {
-        console.error('Error sending Bitcoin:', error.message);
-        return;
-    }
-}
+const { getDatabase, sleep, createWallet, getElectrumClient, generateBlock, depositCoin  } = require('./test_utils');
 
 async function walletTransfersToItselfAndWithdraw(clientConfig, wallet_name) {
 
@@ -1023,781 +946,6 @@ async function transferSendCoinExpiryBySending(clientConfig, wallet_1_name, wall
     }
 }
 
-async function atomicSwapSuccess(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
-
-    const amount = 10000;
-    let token = undefined;
-    let tokenId = undefined;
-    let deposit_info = undefined;
-    let tokenList = undefined;
-    let usedToken = undefined;
-
-    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
-    tokenId = token.token_id;
-
-    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
-
-    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
-
-    usedToken = tokenList.find(token => token.token_id === tokenId);
-
-    assert(usedToken.spent);
-    
-    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
-
-    let coin1 = undefined;
-
-    console.log("coin: ", coin1);
-
-    while (!coin1) {
-        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
-
-        let coinsWithStatechainId = list_coins.filter(c => {
-            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
-        });
-
-        if (coinsWithStatechainId.length === 0) {
-            console.log("Waiting for coin to be confirmed...");
-            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
-            await sleep(5000);
-            generateBlock(1);
-            continue;
-        }
-
-        coin1 = coinsWithStatechainId[0];
-        break;
-    }
-
-    console.log("coin: ", coin1);
-
-    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
-    tokenId = token.token_id;
-
-    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
-
-    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
-
-    usedToken = tokenList.find(token => token.token_id === tokenId);
-
-    assert(usedToken.spent);
-    
-    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
-
-    let coin2 = undefined;
-
-    console.log("coin: ", coin2);
-
-    while (!coin2) {
-        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
-
-        let coinsWithStatechainId = list_coins.filter(c => {
-            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
-        });
-
-        if (coinsWithStatechainId.length === 0) {
-            console.log("Waiting for coin to be confirmed...");
-            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
-            await sleep(5000);
-            generateBlock(1);
-            continue;
-        }
-
-        coin2 = coinsWithStatechainId[0];
-        break;
-    }
-
-    console.log("coin: ", coin2);
-
-    let options = {
-        generateBatchId: true
-    };
-
-    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
-    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
-
-    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin3);
-
-    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin4);
-
-    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    console.log("transferReceiveResult: ", transferReceiveResult);
-    assert(transferReceiveResult.isThereBatchLocked === true);
-
-    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
-    let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
-
-    console.log("received_statechain_ids: ", received_statechain_ids_w4);
-
-    assert(received_statechain_ids_w4.length > 0);
-    assert(received_statechain_ids_w4[0] == coin4.statechain_id);
-
-    // transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    // received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
-
-    // console.log("received_statechain_ids: ", received_statechain_ids_w3);
-
-    // assert(received_statechain_ids_w3.length > 0);
-    // assert(received_statechain_ids_w3[0] == coin3.statechain_id);
-}
-
-async function atomicSwapWithSecondBatchIdMissing(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
-
-    const amount = 10000;
-    let token = undefined;
-    let tokenId = undefined;
-    let deposit_info = undefined;
-    let tokenList = undefined;
-    let usedToken = undefined;
-
-    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
-    tokenId = token.token_id;
-
-    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
-
-    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
-
-    usedToken = tokenList.find(token => token.token_id === tokenId);
-
-    assert(usedToken.spent);
-    
-    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
-
-    let coin1 = undefined;
-
-    console.log("coin: ", coin1);
-
-    while (!coin1) {
-        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
-
-        let coinsWithStatechainId = list_coins.filter(c => {
-            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
-        });
-
-        if (coinsWithStatechainId.length === 0) {
-            console.log("Waiting for coin to be confirmed...");
-            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
-            await sleep(5000);
-            generateBlock(1);
-            continue;
-        }
-
-        coin1 = coinsWithStatechainId[0];
-        break;
-    }
-
-    console.log("coin: ", coin1);
-
-    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
-    tokenId = token.token_id;
-
-    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
-
-    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
-
-    usedToken = tokenList.find(token => token.token_id === tokenId);
-
-    assert(usedToken.spent);
-    
-    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
-
-    let coin2 = undefined;
-
-    console.log("coin: ", coin2);
-
-    while (!coin2) {
-        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
-
-        let coinsWithStatechainId = list_coins.filter(c => {
-            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
-        });
-
-        if (coinsWithStatechainId.length === 0) {
-            console.log("Waiting for coin to be confirmed...");
-            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
-            await sleep(5000);
-            generateBlock(1);
-            continue;
-        }
-
-        coin2 = coinsWithStatechainId[0];
-        break;
-    }
-
-    console.log("coin: ", coin2);
-
-    let options = {
-        generateBatchId: true
-    };
-
-    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
-    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
-
-    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin3);
-
-    transfer_address_w3.batch_id = "";
-
-    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin4);
-
-    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
-
-    console.log("received_statechain_ids: ", received_statechain_ids_w3);
-
-    assert(received_statechain_ids_w3.length > 0);
-    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
-
-    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
-    let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
-
-    console.log("received_statechain_ids: ", received_statechain_ids_w4);
-
-    assert(received_statechain_ids_w4.length > 0);
-    assert(received_statechain_ids_w4[0] == coin4.statechain_id);
-}
-
-async function atomicSwapWithoutFirstBatchId(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
-
-    const amount = 10000;
-    let token = undefined;
-    let tokenId = undefined;
-    let deposit_info = undefined;
-    let tokenList = undefined;
-    let usedToken = undefined;
-
-    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
-    tokenId = token.token_id;
-
-    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
-
-    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
-
-    usedToken = tokenList.find(token => token.token_id === tokenId);
-
-    assert(usedToken.spent);
-    
-    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
-
-    let coin1 = undefined;
-
-    console.log("coin: ", coin1);
-
-    while (!coin1) {
-        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
-
-        let coinsWithStatechainId = list_coins.filter(c => {
-            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
-        });
-
-        if (coinsWithStatechainId.length === 0) {
-            console.log("Waiting for coin to be confirmed...");
-            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
-            await sleep(5000);
-            generateBlock(1);
-            continue;
-        }
-
-        coin1 = coinsWithStatechainId[0];
-        break;
-    }
-
-    console.log("coin: ", coin1);
-
-    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
-    tokenId = token.token_id;
-
-    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
-
-    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
-
-    usedToken = tokenList.find(token => token.token_id === tokenId);
-
-    assert(usedToken.spent);
-    
-    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
-
-    let coin2 = undefined;
-
-    console.log("coin: ", coin2);
-
-    while (!coin2) {
-        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
-
-        let coinsWithStatechainId = list_coins.filter(c => {
-            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
-        });
-
-        if (coinsWithStatechainId.length === 0) {
-            console.log("Waiting for coin to be confirmed...");
-            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
-            await sleep(5000);
-            generateBlock(1);
-            continue;
-        }
-
-        coin2 = coinsWithStatechainId[0];
-        break;
-    }
-
-    console.log("coin: ", coin2);
-
-    let options = {
-        generateBatchId: true
-    };
-
-    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
-    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
-
-    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, null);
-    console.log("coin transferSend: ", coin3);
-
-    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin4);
-
-    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
-
-    console.log("received_statechain_ids: ", received_statechain_ids_w3);
-
-    assert(received_statechain_ids_w3.length > 0);
-    assert(received_statechain_ids_w3[0] == coin3.statechain_id);
-
-    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
-    let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
-
-    console.log("received_statechain_ids: ", received_statechain_ids_w4);
-
-    assert(received_statechain_ids_w4.length > 0);
-    assert(received_statechain_ids_w4[0] == coin4.statechain_id);
-}
-
-async function atomicSwapWithTimeout(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
-
-    const amount = 10000;
-    let token = undefined;
-    let tokenId = undefined;
-    let deposit_info = undefined;
-    let tokenList = undefined;
-    let usedToken = undefined;
-
-    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
-    tokenId = token.token_id;
-
-    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
-
-    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
-
-    usedToken = tokenList.find(token => token.token_id === tokenId);
-
-    assert(usedToken.spent);
-    
-    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
-
-    let coin1 = undefined;
-
-    console.log("coin: ", coin1);
-
-    while (!coin1) {
-        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
-
-        let coinsWithStatechainId = list_coins.filter(c => {
-            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
-        });
-
-        if (coinsWithStatechainId.length === 0) {
-            console.log("Waiting for coin to be confirmed...");
-            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
-            await sleep(5000);
-            generateBlock(1);
-            continue;
-        }
-
-        coin1 = coinsWithStatechainId[0];
-        break;
-    }
-
-    console.log("coin: ", coin1);
-
-    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
-    tokenId = token.token_id;
-
-    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
-
-    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
-
-    usedToken = tokenList.find(token => token.token_id === tokenId);
-
-    assert(usedToken.spent);
-    
-    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
-
-    let coin2 = undefined;
-
-    console.log("coin: ", coin2);
-
-    while (!coin2) {
-        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
-
-        let coinsWithStatechainId = list_coins.filter(c => {
-            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
-        });
-
-        if (coinsWithStatechainId.length === 0) {
-            console.log("Waiting for coin to be confirmed...");
-            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
-            await sleep(5000);
-            generateBlock(1);
-            continue;
-        }
-
-        coin2 = coinsWithStatechainId[0];
-        break;
-    }
-
-    console.log("coin: ", coin2);
-
-    let options = {
-        generateBatchId: true
-    };
-
-    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
-    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
-
-    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin3);
-
-    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin4);
-
-    let transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    let received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
-    await sleep(25000);
-
-    assert(transferReceiveResult.isThereBatchLocked === true);
-
-    let errorMessage;
-    console.error = (msg) => {
-        errorMessage = msg;
-    };
-
-    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
-    let received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
-
-    // Assert the captured error message
-    const expectedMessage = 'Failed to update transfer message';
-    assert.ok(errorMessage.includes(expectedMessage));
-
-    transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
-    transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
-
-    coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin3);
-
-    coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin4);
-
-    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
-
-    transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
-    received_statechain_ids_w4 = transferReceiveResult.receivedStatechainIds;
-
-    console.log("received_statechain_ids: ", received_statechain_ids_w4);
-
-    assert(received_statechain_ids_w4.length > 0);
-    assert(received_statechain_ids_w4[0] == coin4.statechain_id);
-
-    // transferReceiveResult = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    // received_statechain_ids_w3 = transferReceiveResult.receivedStatechainIds;
-
-    // console.log("received_statechain_ids: ", received_statechain_ids_w3);
-
-    // assert(received_statechain_ids_w3.length > 0);
-    // assert(received_statechain_ids_w3[0] == coin3.statechain_id);
-}
-
-async function atomicSwapWithFirstPartySteal(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
-
-    const amount = 10000;
-    let token = undefined;
-    let tokenId = undefined;
-    let deposit_info = undefined;
-    let tokenList = undefined;
-    let usedToken = undefined;
-
-    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
-    tokenId = token.token_id;
-
-    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
-
-    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
-
-    usedToken = tokenList.find(token => token.token_id === tokenId);
-
-    assert(usedToken.spent);
-    
-    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
-
-    let coin1 = undefined;
-
-    console.log("coin: ", coin1);
-
-    while (!coin1) {
-        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
-
-        let coinsWithStatechainId = list_coins.filter(c => {
-            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
-        });
-
-        if (coinsWithStatechainId.length === 0) {
-            console.log("Waiting for coin to be confirmed...");
-            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
-            await sleep(5000);
-            generateBlock(1);
-            continue;
-        }
-
-        coin1 = coinsWithStatechainId[0];
-        break;
-    }
-
-    console.log("coin: ", coin1);
-
-    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
-    tokenId = token.token_id;
-
-    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
-
-    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
-
-    usedToken = tokenList.find(token => token.token_id === tokenId);
-
-    assert(usedToken.spent);
-    
-    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
-
-    let coin2 = undefined;
-
-    console.log("coin: ", coin2);
-
-    while (!coin2) {
-        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
-
-        let coinsWithStatechainId = list_coins.filter(c => {
-            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
-        });
-
-        if (coinsWithStatechainId.length === 0) {
-            console.log("Waiting for coin to be confirmed...");
-            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
-            await sleep(5000);
-            generateBlock(1);
-            continue;
-        }
-
-        coin2 = coinsWithStatechainId[0];
-        break;
-    }
-
-    console.log("coin: ", coin2);
-
-    let options = {
-        generateBatchId: true
-    };
-
-    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
-    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
-
-    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin3);
-
-    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin4);
-
-    let transfer_address_w3_for_steal = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
-    console.log("transfer address for steal", transfer_address_w3_for_steal);
-
-    let coin_to_steal = undefined;
-    try {
-        coin_to_steal = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3_for_steal.transfer_receive, transfer_address_w3);
-    } catch (error) {
-        // Assert the captured error message
-        const expectedMessage = 'expected a string argument, found undefined';
-        assert.ok(error.message.includes(expectedMessage));
-    }
-
-    console.log("coin to steal transferSend: ", coin_to_steal);
-
-    let received_statechain_ids_w3 = undefined;
-    try {
-        received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    } catch (error) {
-        // Assert the captured error message
-        const expectedMessage = 'num_sigs is not correct';
-        assert.ok(error.message.includes(expectedMessage));
-    }
-    await sleep(3000);
-
-    let received_statechain_ids_w4 = undefined; 
-    try {
-        received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
-    } catch (error) {
-        // Assert the captured error message
-        const expectedMessage = 'num_sigs is not correct';
-        assert.ok(error.message.includes(expectedMessage));
-    }
-
-    try {
-        received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    } catch (error) {
-        // Assert the captured error message
-        const expectedMessage = 'num_sigs is not correct';
-        assert.ok(error.message.includes(expectedMessage));
-    }
-}
-
-async function atomicSwapWithSecondPartySteal(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
-
-    const amount = 10000;
-    let token = undefined;
-    let tokenId = undefined;
-    let deposit_info = undefined;
-    let tokenList = undefined;
-    let usedToken = undefined;
-
-    token = await mercurynodejslib.newToken(clientConfig, wallet_1_name);
-    tokenId = token.token_id;
-
-    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_1_name, amount);
-
-    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_1_name);
-
-    usedToken = tokenList.find(token => token.token_id === tokenId);
-
-    assert(usedToken.spent);
-    
-    await depositCoin(clientConfig, wallet_1_name, amount, deposit_info);
-
-    let coin1 = undefined;
-
-    console.log("coin: ", coin1);
-
-    while (!coin1) {
-        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_1_name);
-
-        let coinsWithStatechainId = list_coins.filter(c => {
-            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
-        });
-
-        if (coinsWithStatechainId.length === 0) {
-            console.log("Waiting for coin to be confirmed...");
-            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
-            await sleep(5000);
-            generateBlock(1);
-            continue;
-        }
-
-        coin1 = coinsWithStatechainId[0];
-        break;
-    }
-
-    console.log("coin: ", coin1);
-
-    token = await mercurynodejslib.newToken(clientConfig, wallet_2_name);
-    tokenId = token.token_id;
-
-    deposit_info = await mercurynodejslib.getDepositBitcoinAddress(clientConfig, wallet_2_name, amount);
-
-    tokenList = await mercurynodejslib.getWalletTokens(clientConfig, wallet_2_name);
-
-    usedToken = tokenList.find(token => token.token_id === tokenId);
-
-    assert(usedToken.spent);
-    
-    await depositCoin(clientConfig, wallet_2_name, amount, deposit_info);
-
-    let coin2 = undefined;
-
-    console.log("coin: ", coin2);
-
-    while (!coin2) {
-        const list_coins = await mercurynodejslib.listStatecoins(clientConfig, wallet_2_name);
-
-        let coinsWithStatechainId = list_coins.filter(c => {
-            return c.statechain_id === deposit_info.statechain_id && c.status === CoinStatus.CONFIRMED;
-        });
-
-        if (coinsWithStatechainId.length === 0) {
-            console.log("Waiting for coin to be confirmed...");
-            console.log(`Check the address ${deposit_info.deposit_address} ...\n`);
-            await sleep(5000);
-            generateBlock(1);
-            continue;
-        }
-
-        coin2 = coinsWithStatechainId[0];
-        break;
-    }
-
-    console.log("coin: ", coin2);
-
-    let options = {
-        generateBatchId: true
-    };
-
-    let transfer_address_w3 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_3_name, options);
-    let transfer_address_w4 = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, null);
-
-    let coin3 = await mercurynodejslib.transferSend(clientConfig, wallet_1_name, coin1.statechain_id, transfer_address_w3.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin3);
-
-    let coin4 = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4.transfer_receive, transfer_address_w3);
-    console.log("coin transferSend: ", coin4);
-
-    let transfer_address_w4_for_steal = await mercurynodejslib.newTransferAddress(clientConfig, wallet_4_name, options);
-    console.log("transfer address for steal", transfer_address_w4_for_steal);
-
-    let coin_to_steal = undefined;
-    try {
-        coin_to_steal = await mercurynodejslib.transferSend(clientConfig, wallet_2_name, coin2.statechain_id, transfer_address_w4_for_steal.transfer_receive, transfer_address_w4);
-    } catch (error) {
-        // Assert the captured error message
-        const expectedMessage = 'expected a string argument, found undefined';
-        assert.ok(error.message.includes(expectedMessage));
-    }
-
-    console.log("coin to steal transferSend: ", coin_to_steal);
-
-    let received_statechain_ids_w3 = undefined;
-    try {
-        received_statechain_ids_w3 = mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    } catch (error) {
-        // Assert the captured error message
-        const expectedMessage = 'num_sigs is not correct';
-        assert.ok(error.message.includes(expectedMessage));
-    }
-
-    let received_statechain_ids_w4 = undefined; 
-    try {
-        received_statechain_ids_w4 = await mercurynodejslib.transferReceive(clientConfig, wallet_4_name);
-    } catch (error) {
-        // Assert the captured error message
-        const expectedMessage = 'num_sigs is not correct';
-        assert.ok(error.message.includes(expectedMessage));
-    }
-
-    try {
-        received_statechain_ids_w3 = await mercurynodejslib.transferReceive(clientConfig, wallet_3_name);
-    } catch (error) {
-        // Assert the captured error message
-        const expectedMessage = 'num_sigs is not correct';
-        assert.ok(error.message.includes(expectedMessage));
-    }
-}
-
 (async () => {
 
     try {
@@ -1918,82 +1066,6 @@ async function atomicSwapWithSecondPartySteal(clientConfig, wallet_1_name, walle
         await transferSendCoinExpiryBySending(clientConfig, wallet_25_name, wallet_26_name);
         console.log("Completed test for Transfer-sender of coin that will make it expired by sending");
 
-        // Successful test - all transfers complete within batch_time complete.
-        let wallet_27_name = "w27";
-        let wallet_28_name = "w28";
-        let wallet_29_name = "w29";
-        let wallet_30_name = "w30";
-        await createWallet(clientConfig, wallet_27_name);
-        await createWallet(clientConfig, wallet_28_name);
-        await createWallet(clientConfig, wallet_29_name);
-        await createWallet(clientConfig, wallet_30_name);
-        await atomicSwapSuccess(clientConfig, wallet_27_name, wallet_28_name, wallet_29_name, wallet_30_name);
-        console.log("Completed test for Successful test - all transfers complete within batch_time complete.");
-
-        // Second party performs transfer-sender with incorrect or missing batch-id. First party should still receive OK.
-        let wallet_31_name = "w31";
-        let wallet_32_name = "w32";
-        let wallet_33_name = "w33";
-        let wallet_34_name = "w34";
-        await createWallet(clientConfig, wallet_31_name);
-        await createWallet(clientConfig, wallet_32_name);
-        await createWallet(clientConfig, wallet_33_name);
-        await createWallet(clientConfig, wallet_34_name);
-        await atomicSwapWithSecondBatchIdMissing(clientConfig, wallet_31_name, wallet_32_name, wallet_33_name, wallet_34_name);
-        console.log("Completed test for Second party performs transfer-sender with incorrect or missing batch-id. First party should still receive OK.");
-
-        // First party performs transfer-sender without batch_id.
-        let wallet_35_name = "w35";
-        let wallet_36_name = "w36";
-        let wallet_37_name = "w37";
-        let wallet_38_name = "w38";
-        await createWallet(clientConfig, wallet_35_name);
-        await createWallet(clientConfig, wallet_36_name);
-        await createWallet(clientConfig, wallet_37_name);
-        await createWallet(clientConfig, wallet_38_name);
-        await atomicSwapWithoutFirstBatchId(clientConfig, wallet_35_name, wallet_36_name, wallet_37_name, wallet_38_name);
-        console.log("Completed test for First party performs transfer-sender without batch_id.");
-        
-        // One party doesn't complete transfer-receiver before the timeout. 
-        // Both wallets should be able to repeat transfer-sender and transfer-receiver back to new addresses without error, 
-        // after the timeout.
-        let wallet_39_name = "w39";
-        let wallet_40_name = "w40";
-        let wallet_41_name = "w41";
-        let wallet_42_name = "w42";
-        await createWallet(clientConfig, wallet_39_name);
-        await createWallet(clientConfig, wallet_40_name);
-        await createWallet(clientConfig, wallet_41_name);
-        await createWallet(clientConfig, wallet_42_name);
-        await atomicSwapWithTimeout(clientConfig, wallet_39_name, wallet_40_name, wallet_41_name, wallet_42_name);
-        console.log("Completed test for One party doesn't complete transfer-receiver before the timeout.");
-
-        // First party tries to steal within timeout
-        // they perform transfer-sender a second time sending back to one of their own addresses - should fail.
-        let wallet_43_name = "w43";
-        let wallet_44_name = "w44";
-        let wallet_45_name = "w45";
-        let wallet_46_name = "w46";
-        await createWallet(clientConfig, wallet_43_name);
-        await createWallet(clientConfig, wallet_44_name);
-        await createWallet(clientConfig, wallet_45_name);
-        await createWallet(clientConfig, wallet_46_name);
-        await atomicSwapWithFirstPartySteal(clientConfig, wallet_43_name, wallet_44_name, wallet_45_name, wallet_46_name);
-        console.log("Completed test for First party tries to steal within timeout");
-
-        // Second party tries to steal within timeout
-        // they perform transfer-sender a second time sending back to one of their own addresses - should fail.
-        let wallet_47_name = "w47";
-        let wallet_48_name = "w48";
-        let wallet_49_name = "w49";
-        let wallet_50_name = "w50";
-        await createWallet(clientConfig, wallet_47_name);
-        await createWallet(clientConfig, wallet_48_name);
-        await createWallet(clientConfig, wallet_49_name);
-        await createWallet(clientConfig, wallet_50_name);
-        await atomicSwapWithSecondPartySteal(clientConfig, wallet_47_name, wallet_48_name, wallet_49_name, wallet_50_name);
-        console.log("Completed test for Second party tries to steal within timeout");
-
         process.exit(0); // Exit successfully
     } catch (error) {
         console.error("Test encountered an error:", error);
diff --git a/clients/apps/nodejs/test_utils.js b/clients/apps/nodejs/test_utils.js
new file mode 100644
index 00000000..fab77b6a
--- /dev/null
+++ b/clients/apps/nodejs/test_utils.js
@@ -0,0 +1,81 @@
+
+const ElectrumCli = require('@mempool/electrum-client');
+const sqlite3 = require('sqlite3').verbose();
+
+const removeDatabase = async () => {
+    try {
+        const clientConfig = client_config.load(); 
+        const { stdout, stderr } = await exec(`rm ${clientConfig.databaseFile}`);
+        // console.log('stdout:', stdout);
+        // console.error('stderr:', stderr);
+    } catch (e) {  
+        console.error(e);
+    }
+}
+
+const getDatabase = async (clientConfig) => {
+    const databaseFile = clientConfig.databaseFile;
+    const db = new sqlite3.Database(databaseFile);
+    await sqlite_manager.createTables(db);
+    return db;
+}
+
+const sleep = (ms) => {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+const createWallet = async (clientConfig, walletName) => {
+
+    let wallet = await mercurynodejslib.createWallet(clientConfig, walletName);
+    assert.equal(wallet.name, walletName);
+
+    // TODO: add more assertions
+}
+
+const getElectrumClient = async (clientConfig) => {
+
+    const urlElectrum = clientConfig.electrumServer;
+    const urlElectrumObject = new URL(urlElectrum);
+
+    const electrumPort = parseInt(urlElectrumObject.port, 10);
+    const electrumHostname = urlElectrumObject.hostname;  
+    const electrumProtocol = urlElectrumObject.protocol.slice(0, -1);
+
+    const electrumClient = new ElectrumCli(electrumPort, electrumHostname, electrumProtocol);
+    await electrumClient.connect();
+
+    return electrumClient;
+}
+
+const generateBlock = async (numBlocks) => {
+    const generateBlockCommand = `docker exec $(docker ps -qf "name=mercurylayer_bitcoind_1") bitcoin-cli -regtest -rpcuser=user -rpcpassword=pass generatetoaddress ${numBlocks} "bcrt1qgh48u8aj4jvjkalc28lqujyx2wveck4jsm59x9"`;
+    await exec(generateBlockCommand);
+    // console.log(`Generated ${numBlocks} blocks`);
+
+    const clientConfig = client_config.load();
+    const electrumClient = await getElectrumClient(clientConfig);
+    const block_header = await electrumClient.request('blockchain.headers.subscribe');
+    const blockheight = block_header.height;
+    // console.log("Current block height: ", blockheight);
+}
+
+const depositCoin = async (clientConfig, wallet_name, amount, deposit_info) => {
+
+    deposit_info["amount"] = amount;
+    // console.log("deposit_coin: ", deposit_info);
+
+    const amountInBtc = amount / 100000000;
+
+    // Sending Bitcoin using bitcoin-cli
+    try {
+        const sendBitcoinCommand = `docker exec $(docker ps -qf "name=mercurylayer_bitcoind_1") bitcoin-cli -regtest -rpcuser=user -rpcpassword=pass sendtoaddress ${deposit_info.deposit_address} ${amountInBtc}`;
+        exec(sendBitcoinCommand);
+        // console.log(`Sent ${amountInBtc} BTC to ${deposit_info.deposit_address}`);
+        await generateBlock(3);
+    } catch (error) {
+        console.error('Error sending Bitcoin:', error.message);
+        return;
+    }
+}
+
+export default { removeDatabase, getDatabase, sleep, createWallet, getElectrumClient, generateBlock, depositCoin };

From 0a457fe3af435bf2ad9b4b08f923a3ff387c2001 Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Wed, 17 Jul 2024 13:51:55 +0530
Subject: [PATCH 18/20] fix: export error

---
 clients/apps/nodejs/test_utils.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clients/apps/nodejs/test_utils.js b/clients/apps/nodejs/test_utils.js
index fab77b6a..feafd3cb 100644
--- a/clients/apps/nodejs/test_utils.js
+++ b/clients/apps/nodejs/test_utils.js
@@ -78,4 +78,4 @@ const depositCoin = async (clientConfig, wallet_name, amount, deposit_info) => {
     }
 }
 
-export default { removeDatabase, getDatabase, sleep, createWallet, getElectrumClient, generateBlock, depositCoin };
+module.exports = { removeDatabase, getDatabase, sleep, createWallet, getElectrumClient, generateBlock, depositCoin };

From a9818f4c408b54efbff9077b12d7f1e57c65e6ad Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Wed, 17 Jul 2024 14:49:32 +0530
Subject: [PATCH 19/20] fix: import errors

---
 clients/apps/nodejs/test_atomic_swap.js | 1 +
 clients/apps/nodejs/test_utils.js       | 5 +++++
 2 files changed, 6 insertions(+)

diff --git a/clients/apps/nodejs/test_atomic_swap.js b/clients/apps/nodejs/test_atomic_swap.js
index f26e2860..7f046942 100644
--- a/clients/apps/nodejs/test_atomic_swap.js
+++ b/clients/apps/nodejs/test_atomic_swap.js
@@ -2,6 +2,7 @@ const assert = require('node:assert/strict');
 const mercurynodejslib = require('mercurynodejslib');
 const { CoinStatus } = require('mercurynodejslib/coin_enum');
 const { sleep, createWallet, generateBlock, depositCoin  } = require('./test_utils');
+const client_config = require('./client_config');
 
 async function atomicSwapSuccess(clientConfig, wallet_1_name, wallet_2_name, wallet_3_name, wallet_4_name) {
 
diff --git a/clients/apps/nodejs/test_utils.js b/clients/apps/nodejs/test_utils.js
index feafd3cb..28f13fa9 100644
--- a/clients/apps/nodejs/test_utils.js
+++ b/clients/apps/nodejs/test_utils.js
@@ -1,6 +1,11 @@
 
+const util = require('node:util');
 const ElectrumCli = require('@mempool/electrum-client');
 const sqlite3 = require('sqlite3').verbose();
+const mercurynodejslib = require('mercurynodejslib');
+const exec = util.promisify(require('node:child_process').exec);
+const assert = require('node:assert/strict');
+const client_config = require('./client_config');
 
 const removeDatabase = async () => {
     try {

From 7fb88ebc92b4b07c7b62801ec1b9138117fc0588 Mon Sep 17 00:00:00 2001
From: DhananjayPurohit <dhananjaypurohit7@gmail.com>
Date: Wed, 17 Jul 2024 15:42:56 +0530
Subject: [PATCH 20/20] fix: sqlite import error

---
 clients/apps/nodejs/test_utils.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/clients/apps/nodejs/test_utils.js b/clients/apps/nodejs/test_utils.js
index 28f13fa9..93a40913 100644
--- a/clients/apps/nodejs/test_utils.js
+++ b/clients/apps/nodejs/test_utils.js
@@ -6,6 +6,7 @@ const mercurynodejslib = require('mercurynodejslib');
 const exec = util.promisify(require('node:child_process').exec);
 const assert = require('node:assert/strict');
 const client_config = require('./client_config');
+const sqlite_manager = require('../../libs/nodejs/sqlite_manager');
 
 const removeDatabase = async () => {
     try {