feat(abstract-utxo): implement sign for descriptor wallets

Issue: BTC-1450

Author: OttoAllmendinger

modules/abstract-utxo/src/abstractUtxoCoin.ts

@@ -835,7 +835,7 @@ export abstract class AbstractUtxoCoin extends BaseCoin {
   async signTransaction<TNumber extends number | bigint = number>(
     params: SignTransactionOptions<TNumber>
   ): Promise<SignedTransaction | HalfSignedUtxoTransaction> {
-    return signTransaction<TNumber>(this, params);
+    return signTransaction<TNumber>(this, this.bitgo, params);
   }
 
   /**

modules/abstract-utxo/src/transaction/descriptor/index.ts

@@ -3,3 +3,4 @@ export { explainPsbt } from './explainPsbt';
 export { parse } from './parse';
 export { parseToAmountType } from './parseToAmountType';
 export { verifyTransaction } from './verifyTransaction';
+export { signPsbt } from './signPsbt';

modules/abstract-utxo/src/transaction/descriptor/signPsbt.ts

@@ -0,0 +1,47 @@
+import * as utxolib from '@bitgo/utxo-lib';
+import { DescriptorMap } from '../../core/descriptor';
+import { findDescriptorForInput } from '../../core/descriptor/psbt/findDescriptors';
+
+export class ErrorUnknownInput extends Error {
+  constructor(public vin: number) {
+    super(`missing descriptor for input ${vin}`);
+  }
+}
+
+/**
+ * Sign a PSBT with the given keychain.
+ *
+ * Checks the descriptor map for each input in the PSBT. If the input is not
+ * found in the descriptor map, the behavior is determined by the `onUnknownInput`
+ * parameter.
+ *
+ *
+ * @param tx - psbt to sign
+ * @param descriptorMap - map of input index to descriptor
+ * @param signerKeychain - key to sign with
+ * @param params - onUnknownInput: 'throw' | 'skip' | 'sign'.
+ *                 Determines what to do when an input is not found in the
+ *                 descriptor map.
+ */
+export function signPsbt(
+  tx: utxolib.Psbt,
+  descriptorMap: DescriptorMap,
+  signerKeychain: utxolib.BIP32Interface,
+  params: {
+    onUnknownInput: 'throw' | 'skip' | 'sign';
+  }
+): void {
+  for (const [vin, input] of tx.data.inputs.entries()) {
+    if (!findDescriptorForInput(input, descriptorMap)) {
+      switch (params.onUnknownInput) {
+        case 'skip':
+          continue;
+        case 'throw':
+          throw new ErrorUnknownInput(vin);
+        case 'sign':
+          break;
+      }
+    }
+    tx.signInputHD(vin, signerKeychain);
+  }
+}

modules/abstract-utxo/src/transaction/signTransaction.ts

@@ -1,12 +1,14 @@
 import _ from 'lodash';
-import { IWallet } from '@bitgo/sdk-core';
+import { BitGoBase } from '@bitgo/sdk-core';
 import * as utxolib from '@bitgo/utxo-lib';
 import { bip32 } from '@bitgo/utxo-lib';
 import buildDebug from 'debug';
 
 import { AbstractUtxoCoin, SignTransactionOptions } from '../abstractUtxoCoin';
-import { isDescriptorWallet } from '../descriptor';
+import { getDescriptorMapFromWallet, getPolicyForEnv, isDescriptorWallet } from '../descriptor';
 import * as fixedScript from './fixedScript';
+import * as descriptor from './descriptor';
+import { fetchKeychains, toBip32Triple } from '../keychains';
 
 const debug = buildDebug('bitgo:abstract-utxo:transaction:signTransaction');
 
@@ -27,6 +29,7 @@ function getSignerKeychain(userPrv: unknown): utxolib.BIP32Interface | undefined
 
 export async function signTransaction<TNumber extends number | bigint>(
   coin: AbstractUtxoCoin,
+  bitgo: BitGoBase,
   params: SignTransactionOptions<TNumber>
 ): Promise<{ txHex: string }> {
   const txPrebuild = params.txPrebuild;
@@ -40,8 +43,24 @@ export async function signTransaction<TNumber extends number | bigint>(
 
   const tx = coin.decodeTransactionFromPrebuild(params.txPrebuild);
 
-  if (params.wallet && isDescriptorWallet(params.wallet as IWallet)) {
-    throw new Error('Descriptor wallets are not supported');
+  const signerKeychain = getSignerKeychain(params.prv);
+
+  const { wallet } = params;
+
+  if (wallet && isDescriptorWallet(wallet)) {
+    if (!signerKeychain) {
+      throw new Error('missing signer');
+    }
+    const walletKeys = toBip32Triple(await fetchKeychains(coin, wallet));
+    const descriptorMap = getDescriptorMapFromWallet(wallet, walletKeys, getPolicyForEnv(bitgo.env));
+    if (tx instanceof utxolib.bitgo.UtxoPsbt) {
+      descriptor.signPsbt(tx, descriptorMap, signerKeychain, {
+        onUnknownInput: 'throw',
+      });
+      return { txHex: tx.toHex() };
+    } else {
+      throw new Error('expected a UtxoPsbt object');
+    }
   } else {
     return fixedScript.signTransaction(coin, tx, getSignerKeychain(params.prv), {
       walletId: params.txPrebuild.walletId,

modules/abstract-utxo/test/transaction/descriptor/sign.ts

@@ -0,0 +1,30 @@
+import { mockPsbtDefaultWithDescriptorTemplate } from '../../core/descriptor/psbt/mock.utils';
+import { signPsbt } from '../../../src/transaction/descriptor';
+import { getKeyTriple } from '../../core/key.utils';
+import { getDescriptorMap } from '../../core/descriptor/descriptor.utils';
+import assert from 'assert';
+import { ErrorUnknownInput } from '../../../src/transaction/descriptor/signPsbt';
+
+describe('sign', function () {
+  const psbtUnsigned = mockPsbtDefaultWithDescriptorTemplate('Wsh2Of3');
+  const keychain = getKeyTriple('a');
+  const descriptorMap = getDescriptorMap('Wsh2Of3', keychain);
+  const emptyDescriptorMap = new Map();
+
+  it('should sign a transaction', async function () {
+    const psbt = psbtUnsigned.clone();
+    signPsbt(psbt, descriptorMap, keychain[0], { onUnknownInput: 'throw' });
+    assert(psbt.validateSignaturesOfAllInputs());
+  });
+
+  it('should be sensitive to onUnknownInput', async function () {
+    const psbt = psbtUnsigned.clone();
+    assert.throws(() => {
+      signPsbt(psbt, emptyDescriptorMap, keychain[0], { onUnknownInput: 'throw' });
+    }, new ErrorUnknownInput(0));
+    signPsbt(psbt, emptyDescriptorMap, keychain[0], { onUnknownInput: 'skip' });
+    assert(psbt.data.inputs[0].partialSig === undefined);
+    signPsbt(psbt, emptyDescriptorMap, keychain[0], { onUnknownInput: 'sign' });
+    assert(psbt.validateSignaturesOfAllInputs());
+  });
+});