feat(abstract-utxo): explain and verify tx with op return

TICKET: BTC-1582

Author: davidkaplanbitgo

modules/abstract-utxo/src/abstractUtxoCoin.ts

@@ -449,16 +449,18 @@ export abstract class AbstractUtxoCoin extends BaseCoin {
   }
 
   preprocessBuildParams(params: Record<string, any>): Record<string, any> {
-    params.recipients =
-      params.recipients && params.recipients instanceof Array
-        ? params?.recipients?.map((recipient) => {
-            if (recipient.address.startsWith(ScriptRecipientPrefix)) {
-              const { address, ...rest } = recipient;
-              return { ...rest, script: address.replace(ScriptRecipientPrefix, '') };
-            }
-            return recipient;
-          })
-        : params.recipients;
+    if (params.recipients !== undefined) {
+      params.recipients =
+        params.recipients instanceof Array
+          ? params?.recipients?.map((recipient) => {
+              if (recipient.address.startsWith(ScriptRecipientPrefix)) {
+                const { address, ...rest } = recipient;
+                return { ...rest, script: address.replace(ScriptRecipientPrefix, '') };
+              }
+              return recipient;
+            })
+          : params.recipients;
+    }
 
     return params;
   }
@@ -594,25 +596,47 @@ export abstract class AbstractUtxoCoin extends BaseCoin {
       assert(txParams.rbfTxIds.length === 1);
 
       const txToBeReplaced = await wallet.getTransaction({ txHash: txParams.rbfTxIds[0], includeRbf: true });
-      expectedOutputs = txToBeReplaced.outputs
-        .filter((output) => output.wallet !== wallet.id()) // For self-sends, the walletId will be the same as the wallet's id
-        .map((output) => {
-          return { amount: BigInt(output.valueString), address: this.canonicalAddress(output.address) };
-        });
+      expectedOutputs = txToBeReplaced.outputs.flatMap(
+        (output: { valueString: string; address?: string; wallet?: string }) => {
+          // For self-sends, the walletId will be the same as the wallet's id
+          if (output.wallet === wallet.id()) {
+            return [];
+          }
+          // In the case that this is an OP_RETURN output or another non-encodable scriptPubkey, we dont have an address.
+          // We will verify that the amount is zero, and if it isnt then we will throw an error.
+          if (!output.address) {
+            if (output.valueString !== '0') {
+              throw new Error(`Only zero amounts allowed for non-encodeable scriptPubkeys: ${JSON.stringify(output)}`);
+            }
+            return [{ amount: BigInt(0) }];
+          }
+          return [{ amount: BigInt(output.valueString), address: this.canonicalAddress(output.address) }];
+        }
+      );
     } else {
       // verify that each recipient from txParams has their own output
-      expectedOutputs = _.get(txParams, 'recipients', [] as TransactionRecipient[]).map((output) => {
-        return { ...output, address: this.canonicalAddress(output.address) };
+      expectedOutputs = _.get(txParams, 'recipients', [] as TransactionRecipient[]).flatMap((output) => {
+        if (output.address === undefined) {
+          if (output.amount.toString() !== '0') {
+            throw new Error(`Only zero amounts allowed for non-encodeable scriptPubkeys: ${output}`);
+          }
+          return [output];
+        }
+        return [{ ...output, address: this.canonicalAddress(output.address) }];
       });
       if (params.txParams.allowExternalChangeAddress && params.txParams.changeAddress) {
         // when an external change address is explicitly specified, count all outputs going towards that
         // address in the expected outputs (regardless of the output amount)
         expectedOutputs.push(
-          ...allOutputs
-            .map((output) => {
-              return { ...output, address: this.canonicalAddress(output.address) };
-            })
-            .filter((output) => output.address === this.canonicalAddress(params.txParams.changeAddress as string))
+          ...allOutputs.flatMap((output) => {
+            if (
+              output.address === undefined ||
+              output.address !== this.canonicalAddress(params.txParams.changeAddress as string)
+            ) {
+              return [];
+            }
+            return [{ ...output, address: this.canonicalAddress(output.address) }];
+          })
         );
       }
     }

modules/abstract-utxo/src/parseOutput.ts

@@ -213,6 +213,15 @@ export async function parseOutput({
   const disableNetworking = !!verification.disableNetworking;
   const currentAddress = currentOutput.address;
 
+  if (currentAddress === undefined) {
+    // In the case that the address is undefined, it means that the output has a non-encodeable scriptPubkey
+    // If this is the case, then we need to check that the amount is 0 and we can skip the rest.
+    if (currentOutput.amount.toString() !== '0') {
+      throw new Error('output with undefined address must have amount of 0');
+    }
+    return currentOutput;
+  }
+
   // attempt to grab the address details from either the prebuilt tx, or the verification params.
   // If both of these are empty, then we will try to get the address details from bitgo instead
   const addressDetailsPrebuild = _.get(txPrebuild, `txInfo.walletAddressDetails.${currentAddress}`, {});

modules/abstract-utxo/src/transaction.ts

@@ -8,9 +8,13 @@ import {
   TransactionExplanation,
   TransactionPrebuild,
   Output,
+  ScriptRecipientPrefix,
 } from './abstractUtxoCoin';
 import { bip32, BIP32Interface, bitgo } from '@bitgo/utxo-lib';
 
+// https://github.com/bitcoin/bitcoin/blob/5961b23898ee7c0af2626c46d5d70e80136578d3/src/script/script.h#L47
+const OP_RETURN_IDENTIFIER = Buffer.from('6a', 'hex');
+
 /**
  * Get the inputs for a psbt from a prebuild.
  */
@@ -106,7 +110,14 @@ function explainCommon<TNumber extends number | bigint>(
   const changeAddresses = changeInfo?.map((info) => info.address) ?? [];
 
   tx.outs.forEach((currentOutput) => {
-    const currentAddress = utxolib.address.fromOutputScript(currentOutput.script, network);
+    // Try to encode the script pubkey with an address. If it fails, try to parse it as an OP_RETURN output with the prefix.
+    // If that fails, then it is an unrecognized scriptPubkey and should fail
+    let currentAddress: string;
+    if (currentOutput.script.subarray(0, 1).equals(OP_RETURN_IDENTIFIER)) {
+      currentAddress = `${ScriptRecipientPrefix}${currentOutput.script.toString('hex')}`;
+    } else {
+      currentAddress = utxolib.address.fromOutputScript(currentOutput.script, network);
+    }
     const currentAmount = BigInt(currentOutput.value);
 
     if (changeAddresses.includes(currentAddress)) {

modules/bitgo/test/v2/unit/wallet.ts

@@ -1859,6 +1859,30 @@ describe('V2 Wallet:', function () {
       postProcessStub.restore();
     });
 
+    it('should pass script outputs with the proper structure to wallet platform', async function () {
+      const script = '6a11223344556677889900';
+      nock(bgUrl)
+        .post(`/api/v2/${wallet.coin()}/wallet/${wallet.id()}/tx/build`, {
+          ...tbtcHotWalletDefaultParams,
+          recipients: [{ script, amount: 1e6 }],
+        })
+        .query({})
+        .reply(200, {});
+
+      const blockHeight = 100;
+      const blockHeightStub = sinon.stub(basecoin, 'getLatestBlockHeight').resolves(blockHeight);
+      const postProcessStub = sinon.stub(basecoin, 'postProcessPrebuild').resolves({});
+      await wallet.prebuildTransaction({ recipients: [{ address: `scriptPubkey:${script}`, amount: 1e6 }] });
+      blockHeightStub.should.have.been.calledOnce();
+      postProcessStub.should.have.been.calledOnceWith({
+        blockHeight: 100,
+        wallet: wallet,
+        buildParams: { ...tbtcHotWalletDefaultParams, recipients: [{ script, amount: 1e6 }] },
+      });
+      blockHeightStub.restore();
+      postProcessStub.restore();
+    });
+
     it('prebuild should call build and getLatestBlockHeight for utxo coins', async function () {
       const params = {};
       nock(bgUrl)