feat(core): add descriptor-based PSBT test utils and fixtures

Adds utils to create and test PSBTs from descriptors with mock inputs and
outputs.

Issue: BTC-1845

Author: OttoAllmendinger

packages/wasm-miniscript/test/psbtFromDescriptor.ts

@@ -0,0 +1,67 @@
+import { BIP32Interface } from "@bitgo/utxo-lib";
+import { getKey } from "@bitgo/utxo-lib/dist/src/testutil";
+
+import { DescriptorNode, formatNode } from "../js/ast";
+import { mockPsbtDefault } from "./psbtFromDescriptor.util";
+import { Descriptor } from "../js";
+import { toWrappedPsbt } from "./psbt.util";
+
+function toKeyWithPath(k: BIP32Interface, path = "*"): string {
+  return k.toBase58() + "/" + path;
+}
+
+const external = getKey("external");
+const a = getKey("a");
+const b = getKey("b");
+const c = getKey("c");
+const keys = { external, a, b, c };
+function getKeyName(bipKey: BIP32Interface) {
+  return Object.keys(keys).find(
+    (k) => keys[k as keyof typeof keys] === bipKey,
+  ) as keyof typeof keys;
+}
+
+function describeSignDescriptor(
+  name: string,
+  descriptor: DescriptorNode,
+  signSeqs: BIP32Interface[][],
+) {
+  describe(`psbt with descriptor ${name}`, function () {
+    const psbt = mockPsbtDefault({
+      descriptorSelf: Descriptor.fromString(formatNode(descriptor), "derivable"),
+      descriptorOther: Descriptor.fromString(
+        formatNode({ wpkh: toKeyWithPath(external) }),
+        "derivable",
+      ),
+    });
+
+    signSeqs.forEach((signSeq, i) => {
+      it(`should sign ${signSeq.map((k) => getKeyName(k))}`, function () {
+        const wrappedPsbt = toWrappedPsbt(psbt);
+        signSeq.forEach((key) => {
+          wrappedPsbt.signWithXprv(key.toBase58());
+        });
+        wrappedPsbt.finalize();
+      });
+    });
+  });
+}
+
+describeSignDescriptor(
+  "Wsh2Of3",
+  {
+    wsh: { multi: [2, toKeyWithPath(a), toKeyWithPath(b), toKeyWithPath(c)] },
+  },
+  [
+    [a, b],
+    [b, a],
+  ],
+);
+
+describeSignDescriptor(
+  "Tr1Of3",
+  {
+    tr: [toKeyWithPath(a), [{ pk: toKeyWithPath(b) }, { pk: toKeyWithPath(c) }]],
+  },
+  [[a], [b], [c]],
+);

packages/wasm-miniscript/test/psbtFromDescriptor.util.ts

@@ -0,0 +1,207 @@
+import * as utxolib from "@bitgo/utxo-lib";
+import { toUtxoPsbt, toWrappedPsbt } from "./psbt.util";
+import { Descriptor } from "../js";
+
+export function createScriptPubKeyFromDescriptor(descriptor: Descriptor, index?: number): Buffer {
+  if (index === undefined) {
+    return Buffer.from(descriptor.scriptPubkey());
+  }
+  return createScriptPubKeyFromDescriptor(descriptor.atDerivationIndex(index));
+}
+
+export type Output = {
+  script: Buffer;
+  value: bigint;
+};
+
+export type WithDescriptor<T> = T & {
+  descriptor: Descriptor;
+};
+
+export type PrevOutput = {
+  hash: string;
+  index: number;
+  witnessUtxo: Output;
+};
+
+export type DescriptorWalletOutput = PrevOutput & {
+  descriptorName: string;
+  descriptorIndex: number;
+};
+
+export type DerivedDescriptorWalletOutput = WithDescriptor<PrevOutput>;
+
+export function toDerivedDescriptorWalletOutput(
+  output: DescriptorWalletOutput,
+  descriptor: Descriptor,
+): DerivedDescriptorWalletOutput {
+  const derivedDescriptor = descriptor.atDerivationIndex(output.descriptorIndex);
+  const script = createScriptPubKeyFromDescriptor(derivedDescriptor);
+  if (!script.equals(output.witnessUtxo.script)) {
+    throw new Error(
+      `Script mismatch: descriptor ${output.descriptorName} ${descriptor.toString()} script=${script}`,
+    );
+  }
+  return {
+    hash: output.hash,
+    index: output.index,
+    witnessUtxo: output.witnessUtxo,
+    descriptor: descriptor.atDerivationIndex(output.descriptorIndex),
+  };
+}
+
+/**
+ * Non-Final (Replaceable)
+ * Reference: https://github.com/bitcoin/bitcoin/blob/v25.1/src/rpc/rawtransaction_util.cpp#L49
+ * */
+export const MAX_BIP125_RBF_SEQUENCE = 0xffffffff - 2;
+
+function updateInputsWithDescriptors(psbt: utxolib.bitgo.UtxoPsbt, descriptors: Descriptor[]) {
+  if (psbt.txInputs.length !== descriptors.length) {
+    throw new Error(
+      `Input count mismatch (psbt=${psbt.txInputs.length}, descriptors=${descriptors.length})`,
+    );
+  }
+  const wrappedPsbt = toWrappedPsbt(psbt);
+  for (const [inputIndex, descriptor] of descriptors.entries()) {
+    wrappedPsbt.updateInputWithDescriptor(inputIndex, descriptor);
+  }
+  const unwrappedPsbt = toUtxoPsbt(wrappedPsbt);
+  for (const inputIndex in psbt.txInputs) {
+    psbt.data.inputs[inputIndex] = unwrappedPsbt.data.inputs[inputIndex];
+  }
+}
+
+function updateOutputsWithDescriptors(
+  psbt: utxolib.bitgo.UtxoPsbt,
+  descriptors: WithOptDescriptor<Output>[],
+) {
+  const wrappedPsbt = toWrappedPsbt(psbt);
+  for (const [outputIndex, { descriptor }] of descriptors.entries()) {
+    if (descriptor) {
+      wrappedPsbt.updateOutputWithDescriptor(outputIndex, descriptor);
+    }
+  }
+  const unwrappedPsbt = toUtxoPsbt(wrappedPsbt);
+  for (const outputIndex in psbt.txOutputs) {
+    psbt.data.outputs[outputIndex] = unwrappedPsbt.data.outputs[outputIndex];
+  }
+}
+
+type WithOptDescriptor<T> = T & { descriptor?: Descriptor };
+
+export function createPsbt(
+  params: PsbtParams,
+  inputs: DerivedDescriptorWalletOutput[],
+  outputs: WithOptDescriptor<Output>[],
+): utxolib.bitgo.UtxoPsbt {
+  const psbt = utxolib.bitgo.UtxoPsbt.createPsbt({ network: params.network });
+  psbt.setVersion(params.version ?? 2);
+  psbt.setLocktime(params.locktime ?? 0);
+  psbt.addInputs(
+    inputs.map((i) => ({ ...i, sequence: params.sequence ?? MAX_BIP125_RBF_SEQUENCE })),
+  );
+  psbt.addOutputs(outputs);
+  updateInputsWithDescriptors(
+    psbt,
+    inputs.map((i) => i.descriptor),
+  );
+  updateOutputsWithDescriptors(psbt, outputs);
+  return psbt;
+}
+
+type MockOutputIdParams = { hash?: string; vout?: number };
+
+type BaseMockDescriptorOutputParams = {
+  id?: MockOutputIdParams;
+  index?: number;
+  value?: bigint;
+};
+
+function mockOutputId(id?: MockOutputIdParams): {
+  hash: string;
+  vout: number;
+} {
+  const hash = id?.hash ?? Buffer.alloc(32, 1).toString("hex");
+  const vout = id?.vout ?? 0;
+  return { hash, vout };
+}
+
+export function mockDerivedDescriptorWalletOutput(
+  descriptor: Descriptor,
+  outputParams: BaseMockDescriptorOutputParams = {},
+): DerivedDescriptorWalletOutput {
+  const { value = BigInt(1e6) } = outputParams;
+  const { hash, vout } = mockOutputId(outputParams.id);
+  return {
+    hash,
+    index: vout,
+    witnessUtxo: {
+      script: createScriptPubKeyFromDescriptor(descriptor),
+      value,
+    },
+    descriptor,
+  };
+}
+
+type MockInput = BaseMockDescriptorOutputParams & {
+  index: number;
+  descriptor: Descriptor;
+};
+
+type MockOutput = {
+  descriptor: Descriptor;
+  index: number;
+  value: bigint;
+  external?: boolean;
+};
+
+export function mockPsbt(
+  inputs: MockInput[],
+  outputs: MockOutput[],
+  params: Partial<PsbtParams> = {},
+): utxolib.bitgo.UtxoPsbt {
+  return createPsbt(
+    { ...params, network: params.network ?? utxolib.networks.bitcoin },
+    inputs.map((i) =>
+      mockDerivedDescriptorWalletOutput(i.descriptor.atDerivationIndex(i.index), i),
+    ),
+    outputs.map((o) => {
+      const derivedDescriptor = o.descriptor.atDerivationIndex(o.index);
+      return {
+        script: createScriptPubKeyFromDescriptor(derivedDescriptor),
+        value: o.value,
+        descriptor: o.external ? undefined : derivedDescriptor,
+      };
+    }),
+  );
+}
+
+export type PsbtParams = {
+  network: utxolib.Network;
+  version?: number;
+  locktime?: number;
+  sequence?: number;
+};
+
+export function mockPsbtDefault({
+  descriptorSelf,
+  descriptorOther,
+  params = {},
+}: {
+  descriptorSelf: Descriptor;
+  descriptorOther: Descriptor;
+  params?: Partial<PsbtParams>;
+}): utxolib.bitgo.UtxoPsbt {
+  return mockPsbt(
+    [
+      { descriptor: descriptorSelf, index: 0 },
+      { descriptor: descriptorSelf, index: 1, id: { vout: 1 } },
+    ],
+    [
+      { descriptor: descriptorOther, index: 0, value: BigInt(4e5), external: true },
+      { descriptor: descriptorSelf, index: 0, value: BigInt(4e5) },
+    ],
+    params,
+  );
+}