@bitgo/wasm-utxo 1.4.0 → 1.5.0

package/dist/esm/test/fixedScriptToDescriptor.js

@@ -0,0 +1,91 @@
+import * as assert from "assert";
+import * as utxolib from "@bitgo/utxo-lib";
+import { Descriptor } from "../js/index.js";
+import { getDescriptorForScriptType } from "./descriptorUtil.js";
+const rootWalletKeys = new utxolib.bitgo.RootWalletKeys(utxolib.testutil.getKeyTriple("wasm"));
+const scriptTypes = ["p2sh", "p2shP2wsh", "p2wsh"];
+const scope = ["external", "internal"];
+const index = [0, 1, 2];
+/** Get the expected max weight to satisfy the descriptor */
+function getExpectedMaxWeightToSatisfy(scriptType) {
+    switch (scriptType) {
+        case "p2sh":
+            return 256;
+        case "p2shP2wsh":
+            return 99;
+        case "p2wsh":
+            return 64;
+        default:
+            throw new Error("unexpected script type");
+    }
+}
+/** Compute the total size of the input, including overhead */
+function getTotalInputSize(vSize) {
+    const sizeOpPushData1 = 1;
+    const sizeOpPushData2 = 2;
+    return (32 /* txid */ +
+        4 /* vout */ +
+        4 /* nSequence */ +
+        (vSize < 255 ? sizeOpPushData1 : sizeOpPushData2) +
+        vSize);
+}
+/** Get the full expected vSize of the input including overhead */
+function getExpectedVSize(scriptType) {
+    // https://github.com/BitGo/BitGoJS/blob/master/modules/unspents/docs/input-costs.md
+    switch (scriptType) {
+        case "p2sh":
+            return 298;
+        case "p2shP2wsh":
+            return 140;
+        case "p2wsh":
+            return 105;
+        default:
+            throw new Error("unexpected script type");
+    }
+}
+function runTest(scriptType, index, scope) {
+    describe(`scriptType=${scriptType}, index=${index}, scope=${scope}`, function () {
+        const chainCode = scope === "external"
+            ? utxolib.bitgo.getExternalChainCode(scriptType)
+            : utxolib.bitgo.getInternalChainCode(scriptType);
+        const derivedKeys = rootWalletKeys.deriveForChainAndIndex(chainCode, index);
+        const scriptUtxolib = utxolib.bitgo.outputScripts.createOutputScript2of3(derivedKeys.publicKeys, scriptType).scriptPubKey;
+        let descriptor;
+        before(function () {
+            descriptor = Descriptor.fromString(getDescriptorForScriptType(rootWalletKeys, scriptType, scope), "derivable");
+        });
+        it("descriptor should have expected format", function () {
+            const [x1, x2, x3] = rootWalletKeys.triple.map((xpub) => xpub.neutered().toBase58());
+            if (scriptType === "p2sh" && scope === "external") {
+                // spot check
+                assert.ok(descriptor
+                    .toString()
+                    .startsWith(`sh(multi(2,${x1}/0/0/0/*,${x2}/0/0/0/*,${x3}/0/0/0/*))`));
+            }
+            if (scriptType === "p2shP2wsh" && scope === "internal") {
+                // spot check
+                assert.ok(descriptor
+                    .toString()
+                    .startsWith(`sh(wsh(multi(2,${x1}/0/0/11/*,${x2}/0/0/11/*,${x3}/0/0/11/*)))`));
+            }
+        });
+        it("address should match descriptor", function () {
+            const scriptFromDescriptor = Buffer.from(descriptor.atDerivationIndex(index).scriptPubkey());
+            assert.deepStrictEqual(scriptUtxolib.toString("hex"), scriptFromDescriptor.toString("hex"));
+        });
+        it("should have expected weights", function () {
+            assert.ok(Number.isInteger(descriptor.maxWeightToSatisfy()));
+            const vSize = Math.ceil(descriptor.maxWeightToSatisfy() / 4);
+            console.log(scriptType, "scriptLength", descriptor.atDerivationIndex(0).encode().length, "vSize", vSize);
+            assert.equal(vSize, getExpectedMaxWeightToSatisfy(scriptType));
+            assert.equal(getTotalInputSize(vSize), getExpectedVSize(scriptType));
+        });
+    });
+}
+scriptTypes.forEach((scriptType) => {
+    index.forEach((index) => {
+        scope.forEach((scope) => {
+            runTest(scriptType, index, scope);
+        });
+    });
+});

package/dist/esm/test/fixtures.d.ts

@@ -0,0 +1 @@
+export declare function getFixture(path: string, defaultValue: unknown): Promise<unknown>;

package/dist/esm/test/fixtures.js

@@ -0,0 +1,12 @@
+import * as fs from "fs/promises";
+export async function getFixture(path, defaultValue) {
+    try {
+        return JSON.parse(await fs.readFile(path, "utf8"));
+    }
+    catch (e) {
+        if (e.code === "ENOENT") {
+            await fs.writeFile(path, JSON.stringify(defaultValue, null, 2));
+            throw new Error(`Fixture not found at ${path}, created a new one`);
+        }
+    }
+}

package/dist/esm/test/opdrop.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/test/opdrop.js

@@ -0,0 +1,85 @@
+import * as assert from "assert";
+import * as utxolib from "@bitgo/utxo-lib";
+import { Descriptor } from "../js/index.js";
+import { finalizePsbt, updateInputWithDescriptor } from "./psbt.util.js";
+import { getFixture } from "./fixtures.js";
+const rootWalletKeys = new utxolib.bitgo.RootWalletKeys(utxolib.testutil.getKeyTriple("wasm"));
+function getDescriptorOpDropP2ms(locktime, keys) {
+    const xpubs = keys.map((key) => key.toBase58() + "/*");
+    // the `r:` prefix is a custom BitGo modification of miniscript to allow OP_DROP
+    return `wsh(and_v(r:after(${locktime}),multi(2,${xpubs.join(",")})))`;
+}
+describe("CLV with OP_DROP", function () {
+    const locktime = 1024;
+    const descriptor = Descriptor.fromString(getDescriptorOpDropP2ms(locktime, rootWalletKeys.triple), "derivable");
+    it("has expected AST", () => {
+        assert.deepStrictEqual(descriptor.node(), {
+            Wsh: {
+                Ms: {
+                    AndV: [
+                        {
+                            Drop: {
+                                After: {
+                                    absLockTime: 1024,
+                                },
+                            },
+                        },
+                        {
+                            Multi: [
+                                2,
+                                {
+                                    XPub: "xpub661MyMwAqRbcFNusVUbSN3nbanHMtJjLgZGrs1wxH6f77kKQd6Vq4HfkZQNPC1vSbN6RTiBWJJV6FwJtCfBon2SgaT2J3MSkydukstKjwbJ/*",
+                                },
+                                {
+                                    XPub: "xpub661MyMwAqRbcFo3t7PUqvbgvAcEuuoeVib5aapsg52inrG6KGF5aNtR5ey1FNCt1zJpMQiNec5XpofQmLNRhHvQRbhkc8UsWwwMwsXW6ogU/*",
+                                },
+                                {
+                                    XPub: "xpub661MyMwAqRbcGg7f22Kcg2gy1F4jBjWR3xQTECVeJPHmxvhg5gUAZC6EYFtnyi6aMDQir1kV8HzCqC2FzTowGgEZqRh7rinqUCDeNDdmYzH/*",
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        });
+    });
+    it("has expected asm", () => {
+        assert.deepStrictEqual(descriptor.atDerivationIndex(0).toAsmString().split(" "), [
+            "OP_PUSHBYTES_2",
+            "0004",
+            "OP_CLTV",
+            "OP_DROP",
+            "OP_PUSHNUM_2",
+            "OP_PUSHBYTES_33",
+            "02ae7c3c0ebc315a33151a1985ebb1fdcae72b3b91c38e3193c40ebabfffe9c343",
+            "OP_PUSHBYTES_33",
+            "0260ba2407f7c75d525db9f171e9b2f3cf5ba3f0d7fc6067b20d4b91585432f974",
+            "OP_PUSHBYTES_33",
+            "03eadd6e4300dac62f1d4cf1131a06c5e140911f04245c64934c27510e93dbe843",
+            "OP_PUSHNUM_3",
+            "OP_CHECKMULTISIG",
+        ]);
+    });
+    it("can be signed", async function () {
+        const psbt = Object.assign(new utxolib.Psbt({ network: utxolib.networks.bitcoin }), {
+            locktime,
+        });
+        const signers = rootWalletKeys.triple.slice(0, 2);
+        const descriptorAt0 = descriptor.atDerivationIndex(0);
+        const script = Buffer.from(descriptorAt0.scriptPubkey());
+        psbt.addInput({
+            hash: Buffer.alloc(32),
+            index: 0,
+            sequence: 0xfffffffe,
+            witnessUtxo: { script, value: BigInt(1e8) },
+        });
+        psbt.addOutput({ script, value: BigInt(1e8) });
+        updateInputWithDescriptor(psbt, 0, descriptorAt0);
+        for (const signer of signers) {
+            psbt.signAllInputsHD(signer);
+        }
+        finalizePsbt(psbt);
+        const signedTx = psbt.extractTransaction().toBuffer();
+        assert.strictEqual(signedTx.toString("hex"), await getFixture("test/fixtures/opdrop.json", signedTx.toString("hex")));
+    });
+});

package/dist/esm/test/psbt.util.d.ts

@@ -0,0 +1,8 @@
+import * as utxolib from "@bitgo/utxo-lib";
+import { Descriptor, Psbt } from "../js/index.js";
+export declare function toWrappedPsbt(psbt: utxolib.bitgo.UtxoPsbt | utxolib.Psbt | Buffer | Uint8Array): Psbt;
+export declare function toUtxoPsbt(psbt: Psbt | Buffer | Uint8Array): utxolib.bitgo.UtxoPsbt<utxolib.bitgo.UtxoTransaction<bigint>>;
+export declare function updateInputWithDescriptor(psbt: utxolib.Psbt, inputIndex: number, descriptor: Descriptor): void;
+export declare function updateOutputWithDescriptor(psbt: utxolib.Psbt, outputIndex: number, descriptor: Descriptor): void;
+export declare function finalizePsbt(psbt: utxolib.Psbt): void;
+export declare function assertEqualPsbt(a: utxolib.Psbt, b: utxolib.Psbt): void;

package/dist/esm/test/psbt.util.js

@@ -0,0 +1,116 @@
+import * as assert from "node:assert";
+import * as utxolib from "@bitgo/utxo-lib";
+import { Psbt } from "../js/index.js";
+function toAddress(descriptor, network) {
+    utxolib.address.fromOutputScript(Buffer.from(descriptor.scriptPubkey()), network);
+}
+export function toWrappedPsbt(psbt) {
+    if (psbt instanceof utxolib.bitgo.UtxoPsbt || psbt instanceof utxolib.Psbt) {
+        psbt = psbt.toBuffer();
+    }
+    if (psbt instanceof Buffer || psbt instanceof Uint8Array) {
+        return Psbt.deserialize(psbt);
+    }
+    throw new Error("Invalid input");
+}
+export function toUtxoPsbt(psbt) {
+    if (psbt instanceof Psbt) {
+        psbt = psbt.serialize();
+    }
+    if (psbt instanceof Buffer || psbt instanceof Uint8Array) {
+        return utxolib.bitgo.UtxoPsbt.fromBuffer(Buffer.from(psbt), {
+            network: utxolib.networks.bitcoin,
+        });
+    }
+    throw new Error("Invalid input");
+}
+export function updateInputWithDescriptor(psbt, inputIndex, descriptor) {
+    const wrappedPsbt = toWrappedPsbt(psbt);
+    wrappedPsbt.updateInputWithDescriptor(inputIndex, descriptor);
+    psbt.data.inputs[inputIndex] = toUtxoPsbt(wrappedPsbt).data.inputs[inputIndex];
+}
+export function updateOutputWithDescriptor(psbt, outputIndex, descriptor) {
+    const wrappedPsbt = toWrappedPsbt(psbt);
+    wrappedPsbt.updateOutputWithDescriptor(outputIndex, descriptor);
+    psbt.data.outputs[outputIndex] = toUtxoPsbt(wrappedPsbt).data.outputs[outputIndex];
+}
+export function finalizePsbt(psbt) {
+    const wrappedPsbt = toWrappedPsbt(psbt);
+    wrappedPsbt.finalize();
+    const unwrappedPsbt = toUtxoPsbt(wrappedPsbt);
+    for (let i = 0; i < psbt.data.inputs.length; i++) {
+        psbt.data.inputs[i] = unwrappedPsbt.data.inputs[i];
+    }
+}
+function toEntries(k, v, path) {
+    if (matchPath(path, ["data", "inputs", any, "sighashType"])) {
+        return [];
+    }
+    if (matchPath(path.slice(-1), ["unknownKeyVals"])) {
+        if (Array.isArray(v) && v.length === 0) {
+            return [];
+        }
+    }
+    return [[k, toPlainObject(v, path)]];
+}
+const any = Symbol("any");
+function matchPath(path, pattern) {
+    if (path.length !== pattern.length) {
+        return false;
+    }
+    for (let i = 0; i < path.length; i++) {
+        if (pattern[i] !== any && path[i] !== pattern[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+function normalizeBip32Derivation(v) {
+    if (!Array.isArray(v)) {
+        throw new Error("Expected bip32Derivation to be an array");
+    }
+    return [...v]
+        .map((e) => {
+        let { path } = e;
+        if (path.startsWith("m/")) {
+            path = path.slice(2);
+        }
+        return {
+            ...e,
+            path,
+        };
+    })
+        .sort((a, b) => a.masterFingerprint.toString().localeCompare(b.masterFingerprint.toString()));
+}
+function toPlainObject(v, path) {
+    // psbts have fun getters and other types of irregular properties that we mash into shape here
+    if (v === null || v === undefined) {
+        return v;
+    }
+    if (matchPath(path, ["data", "inputs", any, "bip32Derivation"]) ||
+        matchPath(path, ["data", "outputs", any, "bip32Derivation"])) {
+        v = normalizeBip32Derivation(v);
+    }
+    switch (typeof v) {
+        case "number":
+        case "bigint":
+        case "string":
+        case "boolean":
+            return v;
+        case "object":
+            if (v instanceof Buffer || v instanceof Uint8Array) {
+                return v.toString("hex");
+            }
+            if (Array.isArray(v)) {
+                return v.map((v, i) => toPlainObject(v, [...path, i]));
+            }
+            return Object.fromEntries(Object.entries(v)
+                .flatMap(([k, v]) => toEntries(k, v, [...path, k]))
+                .sort(([a], [b]) => a.localeCompare(b)));
+        default:
+            throw new Error(`Unsupported type: ${typeof v}`);
+    }
+}
+export function assertEqualPsbt(a, b) {
+    assert.deepStrictEqual(toPlainObject(a, []), toPlainObject(b, []));
+}

package/dist/esm/test/psbtFixedScriptCompat.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/test/psbtFixedScriptCompat.js

@@ -0,0 +1,114 @@
+import * as utxolib from "@bitgo/utxo-lib";
+import * as assert from "node:assert";
+import { getPsbtFixtures } from "./psbtFixedScriptCompatFixtures.js";
+import { Descriptor } from "../js/index.js";
+import { getDescriptorForScriptType } from "./descriptorUtil.js";
+import { assertEqualPsbt, toUtxoPsbt, toWrappedPsbt, updateInputWithDescriptor, } from "./psbt.util.js";
+import { getKey } from "@bitgo/utxo-lib/dist/src/testutil";
+const rootWalletKeys = new utxolib.bitgo.RootWalletKeys(utxolib.testutil.getKeyTriple("wasm"));
+function assertEqualBuffer(a, b, message) {
+    assert.strictEqual(Buffer.from(a).toString("hex"), Buffer.from(b).toString("hex"), message);
+}
+const fixtures = getPsbtFixtures(rootWalletKeys);
+function describeUpdateInputWithDescriptor(psbt, scriptType) {
+    function getFixtureAtStage(stage) {
+        const f = fixtures.find((f) => f.scriptType === scriptType && f.stage === stage);
+        if (!f) {
+            throw new Error(`Could not find fixture for scriptType ${scriptType} and stage ${stage}`);
+        }
+        return f;
+    }
+    const descriptorStr = getDescriptorForScriptType(rootWalletKeys, scriptType, "internal");
+    const index = 0;
+    const descriptor = Descriptor.fromString(descriptorStr, "derivable");
+    function getWrappedPsbt() {
+        return toWrappedPsbt(psbt);
+    }
+    function getWrappedPsbtWithDescriptorInfo() {
+        const wrappedPsbt = getWrappedPsbt();
+        const descriptorAtDerivation = descriptor.atDerivationIndex(index);
+        wrappedPsbt.updateInputWithDescriptor(0, descriptorAtDerivation);
+        wrappedPsbt.updateOutputWithDescriptor(0, descriptorAtDerivation);
+        return wrappedPsbt;
+    }
+    describe("Wrapped PSBT updateInputWithDescriptor", function () {
+        it("should update the input with the descriptor", function () {
+            const wrappedPsbt = getWrappedPsbtWithDescriptorInfo();
+            const updatedPsbt = toUtxoPsbt(wrappedPsbt);
+            assertEqualPsbt(updatedPsbt, getFixtureAtStage("unsigned").psbt);
+            updatedPsbt.signAllInputsHD(rootWalletKeys.triple[0]);
+            updatedPsbt.signAllInputsHD(rootWalletKeys.triple[2]);
+            const wrappedSignedPsbt = toWrappedPsbt(updatedPsbt);
+            updatedPsbt.finalizeAllInputs();
+            wrappedSignedPsbt.finalize();
+            assertEqualBuffer(updatedPsbt.toBuffer(), wrappedSignedPsbt.serialize());
+            assertEqualBuffer(getFixtureAtStage("fullsigned")
+                .psbt.clone()
+                .finalizeAllInputs()
+                .extractTransaction()
+                .toBuffer(), updatedPsbt.extractTransaction().toBuffer());
+        });
+    });
+    describe("updateInputWithDescriptor util", function () {
+        it("should update the input with the descriptor", function () {
+            const cloned = psbt.clone();
+            updateInputWithDescriptor(cloned, 0, descriptor.atDerivationIndex(index));
+            cloned.signAllInputsHD(rootWalletKeys.triple[0]);
+            cloned.signAllInputsHD(rootWalletKeys.triple[2]);
+            cloned.finalizeAllInputs();
+            assertEqualBuffer(getFixtureAtStage("fullsigned")
+                .psbt.clone()
+                .finalizeAllInputs()
+                .extractTransaction()
+                .toBuffer(), cloned.extractTransaction().toBuffer());
+        });
+    });
+    describe("psbt signWithXprv", function () {
+        function signWithKey(keys, { checkFinalized = false } = {}) {
+            it(`signs the input with keys ${keys}`, function () {
+                const psbt = getWrappedPsbtWithDescriptorInfo();
+                keys.forEach((keyName) => {
+                    const key = keyName === "unrelated" ? getKey(keyName) : rootWalletKeys[keyName];
+                    const derivationPaths = toUtxoPsbt(psbt).data.inputs[0].bip32Derivation.map((d) => d.path);
+                    assert.ok(derivationPaths.every((p) => p === derivationPaths[0]));
+                    const derived = key.derivePath(derivationPaths[0]);
+                    assert.deepStrictEqual(psbt.signWithXprv(key.toBase58()), {
+                        // map: input index -> pubkey array
+                        0: { Ecdsa: keyName === "unrelated" ? [] : [derived.publicKey.toString("hex")] },
+                    });
+                });
+                if (checkFinalized) {
+                    psbt.finalize();
+                    assertEqualBuffer(toUtxoPsbt(psbt).extractTransaction().toBuffer(), getFixtureAtStage("fullsigned")
+                        .psbt.finalizeAllInputs()
+                        .extractTransaction()
+                        .toBuffer());
+                }
+            });
+        }
+        signWithKey(["user"]);
+        signWithKey(["backup"]);
+        signWithKey(["bitgo"]);
+        signWithKey(["unrelated"]);
+        signWithKey(["user", "bitgo"], { checkFinalized: true });
+    });
+}
+fixtures.forEach(({ psbt, scriptType, stage }) => {
+    describe(`PSBT fixture ${scriptType} ${stage}`, function () {
+        let buf;
+        let wrappedPsbt;
+        before(function () {
+            buf = psbt.toBuffer();
+            wrappedPsbt = toWrappedPsbt(buf);
+        });
+        it("should map to same hex", function () {
+            assertEqualBuffer(buf, wrappedPsbt.serialize());
+        });
+        it("should round-trip utxolib -> ms -> utxolib", function () {
+            assertEqualBuffer(buf, toUtxoPsbt(wrappedPsbt).toBuffer());
+        });
+        if (stage === "bare") {
+            describeUpdateInputWithDescriptor(psbt, scriptType);
+        }
+    });
+});

package/dist/esm/test/psbtFixedScriptCompatFixtures.d.ts

@@ -0,0 +1,10 @@
+import * as utxolib from "@bitgo/utxo-lib";
+import { RootWalletKeys } from "@bitgo/utxo-lib/dist/src/bitgo";
+export type PsbtStage = "bare" | "unsigned" | "halfsigned" | "fullsigned";
+export declare function toPsbtWithPrevOutOnly(psbt: utxolib.bitgo.UtxoPsbt): utxolib.bitgo.UtxoPsbt<utxolib.bitgo.UtxoTransaction<bigint>>;
+export type PsbtFixture = {
+    psbt: utxolib.bitgo.UtxoPsbt;
+    scriptType: utxolib.bitgo.outputScripts.ScriptType2Of3;
+    stage: PsbtStage;
+};
+export declare function getPsbtFixtures(keys: RootWalletKeys): PsbtFixture[];

package/dist/esm/test/psbtFixedScriptCompatFixtures.js

@@ -0,0 +1,53 @@
+import * as utxolib from "@bitgo/utxo-lib";
+export function toPsbtWithPrevOutOnly(psbt) {
+    const psbtCopy = utxolib.bitgo.UtxoPsbt.createPsbt({
+        network: utxolib.networks.bitcoin,
+    });
+    psbtCopy.setVersion(psbt.version);
+    psbtCopy.setLocktime(psbt.locktime);
+    psbt.txInputs.forEach((input, vin) => {
+        const { witnessUtxo, nonWitnessUtxo } = psbt.data.inputs[vin];
+        psbtCopy.addInput({
+            hash: input.hash,
+            index: input.index,
+            sequence: input.sequence,
+            ...(witnessUtxo ? { witnessUtxo } : { nonWitnessUtxo }),
+        });
+    });
+    psbt.txOutputs.forEach((output, vout) => {
+        psbtCopy.addOutput(output);
+    });
+    return psbtCopy;
+}
+function getPsbtWithScriptTypeAndStage(keys, scriptType, stage) {
+    if (stage === "bare") {
+        const psbt = getPsbtWithScriptTypeAndStage(keys, scriptType, "unsigned");
+        return toPsbtWithPrevOutOnly(psbt);
+    }
+    return utxolib.testutil.constructPsbt([
+        {
+            scriptType,
+            value: BigInt(1e8),
+        },
+    ], [
+        {
+            value: BigInt(1e8 - 1000),
+            scriptType,
+            isInternalAddress: true,
+        },
+    ], utxolib.networks.bitcoin, keys, stage);
+}
+export function getPsbtFixtures(keys) {
+    const testMatrixScriptTypes = ["p2sh", "p2shP2wsh", "p2wsh"];
+    const testMatrixStages = ["bare", "unsigned", "halfsigned", "fullsigned"];
+    return testMatrixStages.flatMap((stage) => {
+        return testMatrixScriptTypes.map((scriptType) => {
+            return {
+                psbt: getPsbtWithScriptTypeAndStage(keys, scriptType, stage),
+                name: `${scriptType}-${stage}`,
+                scriptType,
+                stage,
+            };
+        });
+    });
+}

package/dist/esm/test/psbtFromDescriptor.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/test/psbtFromDescriptor.js

@@ -0,0 +1,107 @@
+import assert from "node:assert";
+import { ECPair } from "@bitgo/utxo-lib";
+import { getKey } from "@bitgo/utxo-lib/dist/src/testutil";
+import { formatNode } from "../js/ast/index.js";
+import { mockPsbtDefault } from "./psbtFromDescriptor.util.js";
+import { Descriptor } from "../js/index.js";
+import { toWrappedPsbt } from "./psbt.util.js";
+function toKeyWithPath(k, path = "*") {
+    return k.neutered().toBase58() + "/" + path;
+}
+function toKeyPlain(k) {
+    return k.toString("hex");
+}
+function toECPair(k) {
+    assert(k.privateKey);
+    return ECPair.fromPrivateKey(k.privateKey);
+}
+function toKeyPlainXOnly(k) {
+    return k.subarray(1).toString("hex");
+}
+const external = getKey("external");
+const a = getKey("a");
+const b = getKey("b");
+const c = getKey("c");
+const keys = { external, a, b, c };
+function getKeyName(k) {
+    const objKeys = Object.keys(keys);
+    return objKeys.find((key) => keys[key] === k || toECPair(keys[key]).publicKey.equals(k.publicKey));
+}
+function describeSignDescriptor(name, descriptor, { signBip32 = [], signECPair = [], }) {
+    describe(`psbt with descriptor ${name}`, function () {
+        const isTaproot = Object.keys(descriptor.node())[0] === "Tr";
+        const psbt = mockPsbtDefault({
+            descriptorSelf: descriptor,
+            descriptorOther: Descriptor.fromString(formatNode({ wpkh: toKeyWithPath(external) }), "derivable"),
+        });
+        function getSigResult(keys) {
+            return {
+                [isTaproot ? "Schnorr" : "Ecdsa"]: keys.map((key) => key.publicKey.subarray(isTaproot ? 1 : 0).toString("hex")),
+            };
+        }
+        signBip32.forEach((signSeq, i) => {
+            it(`should sign ${signSeq.map((k) => getKeyName(k))} xprv`, function () {
+                const wrappedPsbt = toWrappedPsbt(psbt);
+                signSeq.forEach((key) => {
+                    assert.deepStrictEqual(wrappedPsbt.signWithXprv(key.toBase58()), {
+                        0: getSigResult([key.derive(0)]),
+                        1: getSigResult([key.derive(1)]),
+                    });
+                });
+                wrappedPsbt.finalize();
+            });
+            it(`should sign ${signSeq.map((k) => getKeyName(k))} prv buffer`, function () {
+                const wrappedPsbt = toWrappedPsbt(psbt);
+                signSeq.forEach((key) => {
+                    assert.deepStrictEqual(wrappedPsbt.signWithPrv(key.derive(0).privateKey), {
+                        // NOTE: signing with a plain derived key does not work for taproot
+                        // see SingleKeySigner implementation in psbt.rs for details
+                        0: getSigResult(isTaproot ? [] : [key.derive(0)]),
+                        1: getSigResult([]),
+                    });
+                });
+            });
+        });
+        signECPair.forEach((signSeq, i) => {
+            it(`should sign ${signSeq.map((k) => getKeyName(k))} ec pair`, function () {
+                const wrappedPsbt = toWrappedPsbt(psbt);
+                signSeq.forEach((key) => {
+                    assert(key.privateKey);
+                    assert.deepStrictEqual(wrappedPsbt.signWithPrv(key.privateKey), {
+                        0: getSigResult([key]),
+                        1: getSigResult([key]),
+                    });
+                });
+                wrappedPsbt.finalize();
+            });
+        });
+    });
+}
+function fromNodes(node, type) {
+    return Descriptor.fromString(formatNode(node), type);
+}
+describeSignDescriptor("Wsh2Of3", fromNodes({
+    wsh: { multi: [2, toKeyWithPath(a), toKeyWithPath(b), toKeyWithPath(c)] },
+}, "derivable"), {
+    signBip32: [
+        [a, b],
+        [b, a],
+    ],
+});
+describeSignDescriptor("Tr1Of3", fromNodes({
+    tr: [toKeyWithPath(a), [{ pk: toKeyWithPath(b) }, { pk: toKeyWithPath(c) }]],
+}, "derivable"), { signBip32: [[a], [b], [c]] });
+describeSignDescriptor("TrWithExternalPlain", fromNodes({
+    tr: [
+        toKeyPlainXOnly(external.publicKey),
+        [
+            { pk: toKeyPlainXOnly(external.publicKey) },
+            {
+                or_b: [
+                    { pk: toKeyPlainXOnly(external.publicKey) },
+                    { "s:pk": toKeyPlainXOnly(a.publicKey) },
+                ],
+            },
+        ],
+    ],
+}, "definite"), { signECPair: [[toECPair(a)]] });