Fix bug with placeholder unlocker in wc utils (#326)

Co-authored-by: Mathieu Geukens <[email protected]>

Author: rkalis

packages/cashscript/src/TransactionBuilder.ts

@@ -224,20 +224,15 @@ export class TransactionBuilder {
   }
 
   generateWcTransactionObject(options?: WcTransactionOptions): WcTransactionObject {
-    const inputs = this.inputs;
-    if (!inputs.every(input => isStandardUnlockableUtxo(input))) {
-      throw new Error('All inputs must be StandardUnlockableUtxos to generate the wcSourceOutputs');
-    }
-
     const encodedTransaction = this.build();
     const transaction = decodeTransactionUnsafe(hexToBin(encodedTransaction));
 
-    const libauthSourceOutputs = generateLibauthSourceOutputs(inputs);
+    const libauthSourceOutputs = generateLibauthSourceOutputs(this.inputs);
     const sourceOutputs: WcSourceOutput[] = libauthSourceOutputs.map((sourceOutput, index) => {
       return {
         ...sourceOutput,
         ...transaction.inputs[index],
-        ...getWcContractInfo(inputs[index]),
+        ...getWcContractInfo(this.inputs[index]),
       };
     });
     return { ...options, transaction, sourceOutputs };

packages/cashscript/src/interfaces.ts

@@ -56,6 +56,9 @@ export interface P2PKHUnlocker extends Unlocker {
 
 export type StandardUnlocker = ContractUnlocker | P2PKHUnlocker;
 
+export type PlaceholderP2PKHUnlocker = Unlocker & { placeholder: true };
+
+
 export function isContractUnlocker(unlocker: Unlocker): unlocker is ContractUnlocker {
   return 'contract' in unlocker;
 }
@@ -68,6 +71,10 @@ export function isStandardUnlocker(unlocker: Unlocker): unlocker is StandardUnlo
   return isContractUnlocker(unlocker) || isP2PKHUnlocker(unlocker);
 }
 
+export function isPlaceholderUnlocker(unlocker: Unlocker): unlocker is PlaceholderP2PKHUnlocker {
+  return 'placeholder' in unlocker;
+}
+
 export interface UtxoP2PKH extends Utxo {
   template: SignatureTemplate;
 }

packages/cashscript/src/walletconnect-utils.ts

@@ -1,4 +1,4 @@
-import type { StandardUnlockableUtxo, LibauthOutput, Unlocker } from './interfaces.js';
+import { type LibauthOutput, isContractUnlocker, type PlaceholderP2PKHUnlocker, type UnlockableUtxo } from './interfaces.js';
 import { type AbiFunction, type Artifact, scriptToBytecode } from '@cashscript/utils';
 import { cashAddressToLockingBytecode, type Input, type TransactionCommon } from '@bitauth/libauth';
 
@@ -11,7 +11,7 @@ export interface WcTransactionOptions {
 }
 
 export interface WcTransactionObject {
-  transaction: TransactionCommon | string;
+  transaction: TransactionCommon; // spec also allows for a tx hex string but we use the libauth transaction object
   sourceOutputs: WcSourceOutput[];
   broadcast?: boolean;
   userPrompt?: string;
@@ -27,9 +27,9 @@ export interface WcContractInfo {
   }
 }
 
-export function getWcContractInfo(input: StandardUnlockableUtxo): WcContractInfo | {} {
+export function getWcContractInfo(input: UnlockableUtxo): WcContractInfo | {} {
   // If the input does not have a contract unlocker, return an empty object
-  if (!('contract' in input.unlocker)) return {};
+  if (!(isContractUnlocker(input.unlocker))) return {};
   const contract = input.unlocker.contract;
   const abiFunctionName = input.unlocker.abiFunction?.name;
   const abiFunction = contract.artifact.abi.find(abi => abi.name === abiFunctionName);
@@ -49,7 +49,7 @@ export function getWcContractInfo(input: StandardUnlockableUtxo): WcContractInfo
 export const placeholderSignature = (): Uint8Array => Uint8Array.from(Array(65));
 export const placeholderPublicKey = (): Uint8Array => Uint8Array.from(Array(33));
 
-export const placeholderP2PKHUnlocker = (userAddress: string): Unlocker => {
+export const placeholderP2PKHUnlocker = (userAddress: string): PlaceholderP2PKHUnlocker => {
   const decodeAddressResult = cashAddressToLockingBytecode(userAddress);
 
   if (typeof decodeAddressResult === 'string') {
@@ -60,5 +60,6 @@ export const placeholderP2PKHUnlocker = (userAddress: string): Unlocker => {
   return {
     generateLockingBytecode: () => lockingBytecode,
     generateUnlockingBytecode: () => Uint8Array.from(Array(0)),
+    placeholder: true,
   };
 };

packages/cashscript/test/TransactionBuilder.test.ts

@@ -1,5 +1,5 @@
 import { decodeTransactionUnsafe, hexToBin, stringify } from '@bitauth/libauth';
-import { Contract, SignatureTemplate, ElectrumNetworkProvider, MockNetworkProvider } from '../src/index.js';
+import { Contract, SignatureTemplate, ElectrumNetworkProvider, MockNetworkProvider, placeholderP2PKHUnlocker, placeholderPublicKey, placeholderSignature } from '../src/index.js';
 import {
   bobAddress,
   bobPub,
@@ -16,6 +16,7 @@ import p2pkhArtifact from './fixture/p2pkh.artifact.js';
 import twtArtifact from './fixture/transfer_with_timeout.artifact.js';
 import { TransactionBuilder } from '../src/TransactionBuilder.js';
 import { gatherUtxos, getTxOutputs } from './test-util.js';
+import { generateWcTransactionObjectFixture } from './fixture/walletconnect/fixtures.js';
 
 describe('Transaction Builder', () => {
   const provider = process.env.TESTS_USE_MOCKNET
@@ -136,131 +137,160 @@ describe('Transaction Builder', () => {
     });
   });
 
-  it('should build a transaction that can spend from 2 different contracts and P2PKH + OP_RETURN', async () => {
-    const fee = 1000n;
+  describe('test TransactionBuilder.build', () => {
+    it('should build a transaction that can spend from 2 different contracts and P2PKH + OP_RETURN', async () => {
+      const fee = 1000n;
 
-    const carolUtxos = (await provider.getUtxos(carolAddress)).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
-    const p2pkhUtxos = (await p2pkhInstance.getUtxos()).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
-    const twtUtxos = (await twtInstance.getUtxos()).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
+      const carolUtxos = (await provider.getUtxos(carolAddress)).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
+      const p2pkhUtxos = (await p2pkhInstance.getUtxos()).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
+      const twtUtxos = (await twtInstance.getUtxos()).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
 
-    const change = carolUtxos[0].satoshis - fee;
-    const dustAmount = calculateDust({ to: carolAddress, amount: change });
+      const change = carolUtxos[0].satoshis - fee;
+      const dustAmount = calculateDust({ to: carolAddress, amount: change });
 
-    const outputs = [
-      { to: p2pkhInstance.address, amount: p2pkhUtxos[0].satoshis },
-      { to: twtInstance.address, amount: twtUtxos[0].satoshis },
-      ...(change > dustAmount ? [{ to: carolAddress, amount: change }] : []),
-    ];
+      const outputs = [
+        { to: p2pkhInstance.address, amount: p2pkhUtxos[0].satoshis },
+        { to: twtInstance.address, amount: twtUtxos[0].satoshis },
+        ...(change > dustAmount ? [{ to: carolAddress, amount: change }] : []),
+      ];
 
-    if (change < 0) {
-      throw new Error('Not enough funds to send transaction');
-    }
+      if (change < 0) {
+        throw new Error('Not enough funds to send transaction');
+      }
 
-    const tx = new TransactionBuilder({ provider })
-      .addInput(p2pkhUtxos[0], p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
-      .addInput(twtUtxos[0], twtInstance.unlock.transfer(new SignatureTemplate(carolPriv)))
-      .addInput(carolUtxos[0], new SignatureTemplate(carolPriv).unlockP2PKH())
-      .addOpReturnOutput(['Hello new transaction builder'])
-      .addOutputs(outputs)
-      .build();
+      const tx = new TransactionBuilder({ provider })
+        .addInput(p2pkhUtxos[0], p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
+        .addInput(twtUtxos[0], twtInstance.unlock.transfer(new SignatureTemplate(carolPriv)))
+        .addInput(carolUtxos[0], new SignatureTemplate(carolPriv).unlockP2PKH())
+        .addOpReturnOutput(['Hello new transaction builder'])
+        .addOutputs(outputs)
+        .build();
 
-    const txOutputs = getTxOutputs(decodeTransactionUnsafe(hexToBin(tx)));
-    expect(txOutputs).toEqual(expect.arrayContaining(outputs));
-  });
+      const txOutputs = getTxOutputs(decodeTransactionUnsafe(hexToBin(tx)));
+      expect(txOutputs).toEqual(expect.arrayContaining(outputs));
+    });
+
+    it('should fail when fee is higher than maxFee', async () => {
+      const fee = 2000n;
+      const maxFee = 1000n;
+      const p2pkhUtxos = (await p2pkhInstance.getUtxos()).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
 
-  it('should fail when fee is higher than maxFee', async () => {
-    const fee = 2000n;
-    const maxFee = 1000n;
-    const p2pkhUtxos = (await p2pkhInstance.getUtxos()).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
+      const amount = p2pkhUtxos[0].satoshis - fee;
+      const dustAmount = calculateDust({ to: p2pkhInstance.address, amount });
 
-    const amount = p2pkhUtxos[0].satoshis - fee;
-    const dustAmount = calculateDust({ to: p2pkhInstance.address, amount });
+      if (amount < dustAmount) {
+        throw new Error('Not enough funds to send transaction');
+      }
+
+      expect(() => {
+        new TransactionBuilder({ provider })
+          .addInput(p2pkhUtxos[0], p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
+          .addOutput({ to: p2pkhInstance.address, amount })
+          .setMaxFee(maxFee)
+          .build();
+      }).toThrow(`Transaction fee of ${fee} is higher than max fee of ${maxFee}`);
+    });
+
+    it('should succeed when fee is lower than maxFee', async () => {
+      const fee = 1000n;
+      const maxFee = 2000n;
+      const p2pkhUtxos = (await p2pkhInstance.getUtxos()).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
 
-    if (amount < dustAmount) {
-      throw new Error('Not enough funds to send transaction');
-    }
+      const amount = p2pkhUtxos[0].satoshis - fee;
+      const dustAmount = calculateDust({ to: p2pkhInstance.address, amount });
 
-    expect(() => {
-      new TransactionBuilder({ provider })
+      if (amount < dustAmount) {
+        throw new Error('Not enough funds to send transaction');
+      }
+
+      const tx = new TransactionBuilder({ provider })
         .addInput(p2pkhUtxos[0], p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
         .addOutput({ to: p2pkhInstance.address, amount })
         .setMaxFee(maxFee)
         .build();
-    }).toThrow(`Transaction fee of ${fee} is higher than max fee of ${maxFee}`);
-  });
 
-  it('should succeed when fee is lower than maxFee', async () => {
-    const fee = 1000n;
-    const maxFee = 2000n;
-    const p2pkhUtxos = (await p2pkhInstance.getUtxos()).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
-
-    const amount = p2pkhUtxos[0].satoshis - fee;
-    const dustAmount = calculateDust({ to: p2pkhInstance.address, amount });
+      expect(tx).toBeDefined();
+    });
 
-    if (amount < dustAmount) {
-      throw new Error('Not enough funds to send transaction');
-    }
+    // TODO: Consider improving error messages checked below to also include the input/output index
 
-    const tx = new TransactionBuilder({ provider })
-      .addInput(p2pkhUtxos[0], p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
-      .addOutput({ to: p2pkhInstance.address, amount })
-      .setMaxFee(maxFee)
-      .build();
+    it('should fail when trying to send to invalid address', async () => {
+      const p2pkhUtxos = (await p2pkhInstance.getUtxos()).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
 
-    expect(tx).toBeDefined();
-  });
+      expect(() => {
+        new TransactionBuilder({ provider })
+          .addInput(p2pkhUtxos[0], p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
+          .addOutput({ to: bobAddress.slice(0, -1), amount: 1000n })
+          .build();
+      }).toThrow('CashAddress decoding error');
+    });
 
-  // TODO: Consider improving error messages checked below to also include the input/output index
+    it('should fail when trying to send tokens to non-token address', async () => {
+      const tokenUtxo = (await p2pkhInstance.getUtxos()).find(isFungibleTokenUtxo)!;
 
-  it('should fail when trying to send to invalid address', async () => {
-    const p2pkhUtxos = (await p2pkhInstance.getUtxos()).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
+      expect(() => {
+        new TransactionBuilder({ provider })
+          .addInput(tokenUtxo, p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
+          .addOutput({ to: bobAddress, amount: 1000n, token: tokenUtxo.token })
+          .build();
+      }).toThrow('Tried to send tokens to an address without token support');
+    });
 
-    expect(() => {
-      new TransactionBuilder({ provider })
-        .addInput(p2pkhUtxos[0], p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
-        .addOutput({ to: bobAddress.slice(0, -1), amount: 1000n })
-        .build();
-    }).toThrow('CashAddress decoding error');
-  });
+    it('should fail when trying to send negative BCH amount or token amount', async () => {
+      const tokenUtxo = (await p2pkhInstance.getUtxos()).find(isFungibleTokenUtxo)!;
+
+      expect(() => {
+        new TransactionBuilder({ provider })
+          .addInput(tokenUtxo, p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
+          .addOutput({ to: bobTokenAddress, amount: -1000n, token: tokenUtxo.token })
+          .build();
+      }).toThrow('Tried to add an output with -1000 satoshis, which is less than the required minimum for this output-type');
+
+      expect(() => {
+        new TransactionBuilder({ provider })
+          .addInput(tokenUtxo, p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
+          .addOutput({ to: bobTokenAddress, amount: 1000n, token: { amount: -1000n, category: tokenUtxo.token!.category } })
+          .build();
+      }).toThrow('Tried to add an output with -1000 tokens, which is invalid');
+    });
 
-  it('should fail when trying to send tokens to non-token address', async () => {
-    const tokenUtxo = (await p2pkhInstance.getUtxos()).find(isFungibleTokenUtxo)!;
+    it('should fail when adding undefined input', async () => {
+      const p2pkhUtxos = (await p2pkhInstance.getUtxos()).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
+      const undefinedUtxo = p2pkhUtxos[1000];
 
-    expect(() => {
-      new TransactionBuilder({ provider })
-        .addInput(tokenUtxo, p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
-        .addOutput({ to: bobAddress, amount: 1000n, token: tokenUtxo.token })
-        .build();
-    }).toThrow('Tried to send tokens to an address without token support');
+      expect(() => {
+        new TransactionBuilder({ provider })
+          .addInput(undefinedUtxo, p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
+          .addOutput({ to: bobAddress, amount: 1000n })
+          .build();
+      }).toThrow('Input is undefined');
+    });
   });
 
-  it('should fail when trying to send negative BCH amount or token amount', async () => {
-    const tokenUtxo = (await p2pkhInstance.getUtxos()).find(isFungibleTokenUtxo)!;
+  describe('test TransactionBuilder.generateWcTransactionObject', () => {
+    it('should match the generateWcTransactionObjectFixture ', async () => {
+      const p2pkhUtxos = (await p2pkhInstance.getUtxos()).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
+      const contractUtxo = p2pkhUtxos[0];
+      const bobUtxos = await provider.getUtxos(bobAddress);
 
-    expect(() => {
-      new TransactionBuilder({ provider })
-        .addInput(tokenUtxo, p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
-        .addOutput({ to: bobTokenAddress, amount: -1000n, token: tokenUtxo.token })
-        .build();
-    }).toThrow('Tried to add an output with -1000 satoshis, which is less than the required minimum for this output-type');
+      const placeholderUnlocker = placeholderP2PKHUnlocker(bobAddress);
+      const placeholderPubKey = placeholderPublicKey();
+      const placeholderSig = placeholderSignature();
 
-    expect(() => {
-      new TransactionBuilder({ provider })
-        .addInput(tokenUtxo, p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
-        .addOutput({ to: bobTokenAddress, amount: 1000n, token: { amount: -1000n, category: tokenUtxo.token!.category } })
-        .build();
-    }).toThrow('Tried to add an output with -1000 tokens, which is invalid');
-  });
+      // use the CashScript SDK to construct a transaction
+      const transactionBuilder = new TransactionBuilder({ provider })
+        .addInput(contractUtxo, p2pkhInstance.unlock.spend(placeholderPubKey, placeholderSig))
+        .addInput(bobUtxos[0], placeholderUnlocker)
+        .addOutput({ to: bobAddress, amount: 100_000n });
 
-  it('should fail when adding undefined input', async () => {
-    const p2pkhUtxos = (await p2pkhInstance.getUtxos()).filter(isNonTokenUtxo).sort(utxoComparator).reverse();
-    const undefinedUtxo = p2pkhUtxos[1000];
+      // Generate WalletConnect transaction object with custom 'broadcast' and 'userPrompt' options
+      const wcTransactionObj = transactionBuilder.generateWcTransactionObject({
+        broadcast: true,
+        userPrompt: 'Example Contract transaction',
+      });
 
-    expect(() => {
-      new TransactionBuilder({ provider })
-        .addInput(undefinedUtxo, p2pkhInstance.unlock.spend(carolPub, new SignatureTemplate(carolPriv)))
-        .addOutput({ to: bobAddress, amount: 1000n })
-        .build();
-    }).toThrow('Input is undefined');
+      const expectedResult = generateWcTransactionObjectFixture;
+      expect(JSON.parse(stringify(wcTransactionObj))).toEqual(expectedResult);
+    });
   });
 });