refactor: harden output script detection

Author: michael1011

lib/swap/SwapDetector.ts

@@ -25,19 +25,44 @@ type DetectedSwap<T> = {
   vout: number;
 } & (T extends Transaction ? TransactionOutput : LiquidTxOutput);
 
+const scriptForType: Record<OutputType, (input: Uint8Array) => Uint8Array> = {
+  [OutputType.Legacy]: p2shOutput,
+  [OutputType.Compatibility]: p2shP2wshOutput,
+  [OutputType.Bech32]: p2wshOutput,
+  [OutputType.Taproot]: p2trOutput,
+};
+
 /**
  * Detects a swap output with the matching redeem script or tweaked key in a transaction
+ *
+ * @param redeemScriptOrTweakedKey redeem script or tweaked key of the swap
+ * @param transaction transaction to scan for the swap output
+ * @param expectedOutput the advertised output wrapper to detect; either an
+ *   {@link OutputType} or the exact expected output script. Detection is bound to
+ *   this wrapper so a lockup can never be matched against a different one.
  */
 export const detectSwap = <T extends Transaction | LiquidTransaction>(
   redeemScriptOrTweakedKey: Uint8Array,
   transaction: T,
+  expectedOutput: OutputType | Uint8Array,
 ): DetectedSwap<T> | undefined => {
-  const scripts: [OutputType, Uint8Array][] = [
-    [OutputType.Legacy, p2shOutput(redeemScriptOrTweakedKey)],
-    [OutputType.Compatibility, p2shP2wshOutput(redeemScriptOrTweakedKey)],
-    [OutputType.Bech32, p2wshOutput(redeemScriptOrTweakedKey)],
-    [OutputType.Taproot, p2trOutput(redeemScriptOrTweakedKey)],
-  ];
+  const scripts = (
+    [
+      OutputType.Legacy,
+      OutputType.Compatibility,
+      OutputType.Bech32,
+      OutputType.Taproot,
+    ] as OutputType[]
+  )
+    .map((type): [OutputType, Uint8Array] => [
+      type,
+      scriptForType[type](redeemScriptOrTweakedKey),
+    ])
+    .filter(([type, script]) =>
+      typeof expectedOutput === 'number'
+        ? type === expectedOutput
+        : equalBytes(script, expectedOutput),
+    );
 
   const findMatch = (
     vout: number,

test/integration/Utils.ts

@@ -116,7 +116,7 @@ const sendFundsToOutput = async <
     : LiquidTransaction.fromHex(txHex);
 
   return {
-    ...detectSwap(redeemScriptOrTweakedKey, transaction)!,
+    ...detectSwap(redeemScriptOrTweakedKey, transaction, outputType)!,
     blindingPrivateKey,
     type: outputType,
     transactionId,

test/integration/fundingAddressTree/FundingAddressTreeRefund.spec.ts

@@ -39,7 +39,7 @@ const createFundingAddressOutput = async (
   const txHex = await bitcoinClient.getRawTransaction(transactionId);
   const transaction = Transaction.fromRaw(hex.decode(txHex));
 
-  const detected = detectSwap(tweakedPubKey, transaction)!;
+  const detected = detectSwap(tweakedPubKey, transaction, OutputType.Taproot)!;
 
   const utxo = {
     ...detected,

test/integration/liquid/fundingAddressTree/FundingAddressTreeRefund.spec.ts

@@ -81,7 +81,7 @@ const createFundingAddressOutput = async (
   const txHex = await elementsClient.getRawTransaction(transactionId);
   const transaction = Transaction.fromHex(txHex);
 
-  const detected = detectSwap(tweakedPubKey, transaction)!;
+  const detected = detectSwap(tweakedPubKey, transaction, OutputType.Taproot)!;
 
   const utxo = {
     ...detected,

test/integration/liquid/reverseSwapTree/ReverseSwapTreeCovenantClaim.spec.ts

@@ -105,7 +105,11 @@ describe.each`
         ),
       );
 
-      const output = detectSwap(Buffer.from(tweakedMusig.aggPubkey), tx)!;
+      const output = detectSwap(
+        Buffer.from(tweakedMusig.aggPubkey),
+        tx,
+        OutputType.Taproot,
+      )!;
 
       return {
         tree,

test/unit/liquid/swap/SwapDetector.spec.ts

@@ -53,7 +53,7 @@ describe('Liquid SwapDetector', () => {
       nonce,
     );
 
-    const output = detectSwap(redeemScript, transaction)!;
+    const output = detectSwap(redeemScript, transaction, type)!;
 
     expect(output).not.toBeUndefined();
     expect(output.vout).toEqual(1);

test/unit/swap/SwapDetector.spec.ts

@@ -48,7 +48,7 @@ describe('SwapDetector', () => {
       script: Script.encode(['RETURN']),
     });
 
-    const output = detectSwap(redeemScript, transaction)!;
+    const output = detectSwap(redeemScript, transaction, type)!;
 
     expect(output).not.toBeUndefined();
     expect(output.vout).toEqual(1);
@@ -77,7 +77,7 @@ describe('SwapDetector', () => {
       amount: 312n,
     });
 
-    const output = detectSwap(tweakedKeys, transaction)!;
+    const output = detectSwap(tweakedKeys, transaction, OutputType.Taproot)!;
 
     expect(output).not.toBeUndefined();
     expect(output.vout).toEqual(1);
@@ -86,6 +86,75 @@ describe('SwapDetector', () => {
     expect(output.script).toEqual(p2trOutput(tweakedKeys));
   });
 
+  test('should restrict detection to an expected OutputType', () => {
+    const publicKey = secp256k1.getPublicKey(secp256k1.utils.randomSecretKey());
+    const redeemScript = swapScript(sha256(publicKey), publicKey, publicKey, 1);
+
+    // A decoy output paying to the same redeem script under a different wrapper
+    const decoy = outputFunctionForType(OutputType.Bech32)!(redeemScript);
+    const advertised = outputFunctionForType(OutputType.Compatibility)!(
+      redeemScript,
+    );
+
+    const transaction = new Transaction({ allowUnknownOutputs: true });
+    transaction.addOutput({ amount: 42n, script: decoy });
+    transaction.addOutput({ amount: 21n, script: advertised });
+
+    // The decoy wrapper at vout 0 is ignored; only the advertised one is detected
+    const output = detectSwap(
+      redeemScript,
+      transaction,
+      OutputType.Compatibility,
+    )!;
+
+    expect(output.vout).toEqual(1);
+    expect(output.amount).toEqual(21n);
+    expect(output.type).toEqual(OutputType.Compatibility);
+    expect(output.script).toEqual(advertised);
+  });
+
+  test('should restrict detection to an expected output script', () => {
+    const publicKey = secp256k1.getPublicKey(secp256k1.utils.randomSecretKey());
+    const redeemScript = swapScript(sha256(publicKey), publicKey, publicKey, 1);
+
+    const decoy = outputFunctionForType(OutputType.Bech32)!(redeemScript);
+    const advertised = outputFunctionForType(OutputType.Compatibility)!(
+      redeemScript,
+    );
+
+    const transaction = new Transaction({ allowUnknownOutputs: true });
+    transaction.addOutput({ amount: 42n, script: decoy });
+    transaction.addOutput({ amount: 21n, script: advertised });
+
+    const output = detectSwap(redeemScript, transaction, advertised)!;
+
+    expect(output.vout).toEqual(1);
+    expect(output.amount).toEqual(21n);
+    expect(output.type).toEqual(OutputType.Compatibility);
+    expect(output.script).toEqual(advertised);
+  });
+
+  test('should return undefined when no output matches the expectation', () => {
+    const publicKey = secp256k1.getPublicKey(secp256k1.utils.randomSecretKey());
+    const redeemScript = swapScript(sha256(publicKey), publicKey, publicKey, 1);
+
+    const transaction = new Transaction({ allowUnknownOutputs: true });
+    transaction.addOutput({
+      amount: 42n,
+      script: outputFunctionForType(OutputType.Bech32)!(redeemScript),
+    });
+
+    // The advertised wrapper is not present in the transaction
+    expect(
+      detectSwap(redeemScript, transaction, OutputType.Taproot),
+    ).toBeUndefined();
+
+    // An expected script that is not a valid wrapper of the key is rejected
+    expect(
+      detectSwap(redeemScript, transaction, randomBytes(34)),
+    ).toBeUndefined();
+  });
+
   test('should return undefined no swap can be found', () => {
     const publicKey = secp256k1.getPublicKey(secp256k1.utils.randomSecretKey());
     const transaction = new Transaction({
@@ -100,7 +169,7 @@ describe('SwapDetector', () => {
       amount: 312n,
     });
 
-    const output = detectSwap(randomBytes(32), transaction);
+    const output = detectSwap(randomBytes(32), transaction, OutputType.Bech32);
 
     expect(output).toBeUndefined();
   });