Throw on an attempt to submit the same transaction twice

Author: mainnet-pat

packages/cashscript/src/network/MockNetworkProvider.ts

@@ -10,7 +10,7 @@ const bobAddress = 'bchtest:qz6q5gqnxdldkr07xpls5474mmzmlesd6qnux4skuc';
 const carolAddress = 'bchtest:qqsr7nqwe6rq5crj63gy5gdqchpnwmguusmr7tfmsj';
 
 export default class MockNetworkProvider implements NetworkProvider {
-  // we use lockingBytecode as the key for utxoMap to make cashaddresses and tokenaddresses interchangeable
+  // we use lockingBytecode hex as the key for utxoMap to make cash addresses and token addresses interchangeable
   private utxoMap: Record<string, Utxo[]> = {};
   private transactionMap: Record<string, string> = {};
   public network: Network = Network.MOCKNET;
@@ -45,6 +45,11 @@ export default class MockNetworkProvider implements NetworkProvider {
     const transactionBin = hexToBin(txHex);
 
     const txid = binToHex(sha256(sha256(transactionBin)).reverse());
+
+    if (this.transactionMap[txid]) {
+      throw new Error(`Transaction with txid ${txid} was already submitted: txn-mempool-conflict`);
+    }
+
     this.transactionMap[txid] = txHex;
 
     const decoded = decodeTransaction(transactionBin);
@@ -54,21 +59,23 @@ export default class MockNetworkProvider implements NetworkProvider {
 
     // remove (spend) UTXOs from the map
     for (const input of decoded.inputs) {
-      for (const address of Object.keys(this.utxoMap)) {
-        const utxos = this.utxoMap[address];
+      for (const lockingBytecodeHex of Object.keys(this.utxoMap)) {
+        const utxos = this.utxoMap[lockingBytecodeHex];
         const index = utxos.findIndex(
-          (utxo) => utxo.txid === binToHex(input.outpointTransactionHash) && utxo.vout === input.outpointIndex
+          (utxo) => utxo.txid === binToHex(input.outpointTransactionHash) && utxo.vout === input.outpointIndex,
         );
 
         if (index !== -1) {
           // Remove the UTXO from the map
           utxos.splice(index, 1);
-          this.utxoMap[address] = utxos;
+          this.utxoMap[lockingBytecodeHex] = utxos;
+
+          if (utxos.length === 0) {
+            delete this.utxoMap[lockingBytecodeHex]; // Clean up empty address entries
+          }
+
           break; // Exit loop after finding and removing the UTXO
         }
-        if (utxos.length === 0) {
-          delete this.utxoMap[address]; // Clean up empty address entries
-        }
       }
     }
 
@@ -93,7 +100,8 @@ export default class MockNetworkProvider implements NetworkProvider {
   }
 
   addUtxo(addressOrLockingBytecode: string, utxo: Utxo): void {
-    const lockingBytecode = isHex(addressOrLockingBytecode) ? addressOrLockingBytecode : binToHex(addressToLockScript(addressOrLockingBytecode));
+    const lockingBytecode = isHex(addressOrLockingBytecode) ?
+      addressOrLockingBytecode : binToHex(addressToLockScript(addressOrLockingBytecode));
     if (!this.utxoMap[lockingBytecode]) {
       this.utxoMap[lockingBytecode] = [];
     }

packages/cashscript/test/e2e/network/MockNetworkProvider.test.ts

@@ -30,9 +30,13 @@ describe('Transaction Builder', () => {
     expect(await provider.getUtxos(p2pkhInstance.address)).toHaveLength(0);
 
     // add by address
-    provider.addUtxo(aliceAddress, randomUtxo());
+    provider.addUtxo(aliceAddress, randomUtxo({
+      satoshis: 1100n,
+    }));
     // add by locking bytecode
-    provider.addUtxo(binToHex(addressToLockScript(p2pkhInstance.address)), randomUtxo());
+    provider.addUtxo(binToHex(addressToLockScript(p2pkhInstance.address)), randomUtxo({
+      satoshis: 1100n,
+    }));
 
     const aliceUtxos = await provider.getUtxos(aliceAddress);
     const p2pkhUtxos = await provider.getUtxos(p2pkhInstance.address);
@@ -43,17 +47,26 @@ describe('Transaction Builder', () => {
     const sigTemplate = new SignatureTemplate(alicePriv);
 
     // spend both utxos to bob
-    new TransactionBuilder({provider})
-      .addInput(p2pkhUtxos[0], p2pkhInstance.unlock.spend(alicePub, sigTemplate))
-      .addInput(aliceUtxos[0], sigTemplate.unlockP2PKH())
-      .addOutput({ to: bobAddress, amount: 1000n })
-      .send();
+    const builder = new TransactionBuilder({ provider })
+      .addInputs(p2pkhUtxos, p2pkhInstance.unlock.spend(alicePub, sigTemplate))
+      .addInputs(aliceUtxos, sigTemplate.unlockP2PKH())
+      .addOutput({ to: bobAddress, amount: 2000n });
+
+    const tx = builder.build();
+
+    // try to send invalid transaction
+    await expect(provider.sendRawTransaction(tx.slice(0, -2))).rejects.toThrow('Error reading transaction.');
+
+    // send valid transaction
+    await expect(provider.sendRawTransaction(tx)).resolves.not.toThrow();
 
     // utxos should be removed from the provider
     expect(await provider.getUtxos(aliceAddress)).toHaveLength(0);
     expect(await provider.getUtxos(p2pkhInstance.address)).toHaveLength(0);
 
     // utxo should be added to bob
     expect(await provider.getUtxos(bobAddress)).toHaveLength(1);
+
+    await expect(provider.sendRawTransaction(tx)).rejects.toThrow('txn-mempool-conflict');
   });
 });