@bitgo/wasm-utxo 1.7.0 → 1.9.0

package/dist/esm/test/fixedScript/verifySignature.js

@@ -1,187 +0,0 @@
-import assert from "node:assert";
-import * as utxolib from "@bitgo/utxo-lib";
-import { fixedScriptWallet, BIP32 } from "../../js/index.js";
-import { loadPsbtFixture, loadWalletKeysFromFixture, getPsbtBuffer, loadReplayProtectionKeyFromFixture, } from "./fixtureUtil.js";
-/**
- * Get expected signature state for an input based on type and signing stage
- * @param inputType - The type of input (e.g., "p2shP2pk", "p2trMusig2")
- * @param signatureStage - The signing stage (unsigned, halfsigned, fullsigned)
- * @returns Expected signature state for replay protection OR multi-key signatures
- */
-function getExpectedSignatures(inputType, signatureStage) {
-    // p2shP2pk inputs use replay protection signature verification
-    if (inputType === "p2shP2pk") {
-        return {
-            hasReplayProtectionSignature: signatureStage === "halfsigned" || signatureStage === "fullsigned",
-        };
-    }
-    switch (signatureStage) {
-        case "unsigned":
-            return { user: false, backup: false, bitgo: false };
-        case "halfsigned":
-            // User signs first
-            return { user: true, backup: false, bitgo: false };
-        case "fullsigned":
-            // p2trMusig2 uses user + backup for 2-of-2 MuSig2
-            if (inputType === "p2trMusig2") {
-                return { user: true, backup: true, bitgo: false };
-            }
-            // Regular multisig uses user + bitgo
-            return { user: true, backup: false, bitgo: true };
-        default:
-            throw new Error(`Unknown signature stage: ${String(signatureStage)}`);
-    }
-}
-/**
- * Verify signature state for a specific input in a PSBT
- * @param bitgoPsbt - The PSBT to verify
- * @param rootWalletKeys - Wallet keys for verification
- * @param inputIndex - The input index to verify
- * @param inputType - The type of input (for replay protection handling)
- * @param expectedSignatures - Expected signature state for each key or replay protection
- */
-function verifyInputSignatures(bitgoPsbt, parsed, rootWalletKeys, replayProtectionKey, inputIndex, expectedSignatures) {
-    // Handle replay protection inputs (P2shP2pk)
-    if ("hasReplayProtectionSignature" in expectedSignatures) {
-        const hasReplaySig = bitgoPsbt.verifyReplayProtectionSignature(inputIndex, {
-            publicKeys: [replayProtectionKey],
-        });
-        assert.strictEqual(hasReplaySig, expectedSignatures.hasReplayProtectionSignature, `Input ${inputIndex} replay protection signature mismatch`);
-        return;
-    }
-    if (parsed.inputs[inputIndex].scriptType === "p2shP2pk") {
-        const hasReplaySig = bitgoPsbt.verifySignature(inputIndex, replayProtectionKey);
-        assert.ok("hasReplayProtectionSignature" in expectedSignatures, "Expected hasReplayProtectionSignature to be present");
-        assert.strictEqual(hasReplaySig, expectedSignatures.hasReplayProtectionSignature, `Input ${inputIndex} replay protection signature mismatch`);
-        return;
-    }
-    // Handle standard multisig inputs
-    const hasUserSig = bitgoPsbt.verifySignature(inputIndex, rootWalletKeys.userKey());
-    const hasBackupSig = bitgoPsbt.verifySignature(inputIndex, rootWalletKeys.backupKey());
-    const hasBitGoSig = bitgoPsbt.verifySignature(inputIndex, rootWalletKeys.bitgoKey());
-    assert.strictEqual(hasUserSig, expectedSignatures.user, `Input ${inputIndex} user key signature mismatch`);
-    assert.strictEqual(hasBackupSig, expectedSignatures.backup, `Input ${inputIndex} backup key signature mismatch`);
-    assert.strictEqual(hasBitGoSig, expectedSignatures.bitgo, `Input ${inputIndex} BitGo key signature mismatch`);
-}
-/**
- * Helper to verify signatures for all inputs in a PSBT
- * @param bitgoPsbt - The PSBT to verify
- * @param fixture - The test fixture containing input metadata
- * @param rootWalletKeys - Wallet keys for verification
- * @param replayProtectionKey - Key for replay protection inputs
- * @param signatureStage - The signing stage (unsigned, halfsigned, fullsigned)
- */
-function verifyAllInputSignatures(bitgoPsbt, fixture, rootWalletKeys, replayProtectionKey, signatureStage) {
-    const parsed = bitgoPsbt.parseTransactionWithWalletKeys(rootWalletKeys, {
-        publicKeys: [replayProtectionKey],
-    });
-    fixture.psbtInputs.forEach((input, index) => {
-        verifyInputSignatures(bitgoPsbt, parsed, rootWalletKeys, replayProtectionKey, index, getExpectedSignatures(input.type, signatureStage));
-    });
-}
-describe("verifySignature", function () {
-    const supportedNetworks = utxolib.getNetworkList().filter((network) => {
-        return (utxolib.isMainnet(network) &&
-            network !== utxolib.networks.bitcoincash &&
-            network !== utxolib.networks.bitcoingold &&
-            network !== utxolib.networks.bitcoinsv &&
-            network !== utxolib.networks.ecash &&
-            network !== utxolib.networks.zcash);
-    });
-    supportedNetworks.forEach((network) => {
-        const networkName = utxolib.getNetworkName(network);
-        describe(`network: ${networkName}`, function () {
-            let rootWalletKeys;
-            let replayProtectionKey;
-            let unsignedFixture;
-            let halfsignedFixture;
-            let fullsignedFixture;
-            let unsignedBitgoPsbt;
-            let halfsignedBitgoPsbt;
-            let fullsignedBitgoPsbt;
-            before(function () {
-                unsignedFixture = loadPsbtFixture(networkName, "unsigned");
-                halfsignedFixture = loadPsbtFixture(networkName, "halfsigned");
-                fullsignedFixture = loadPsbtFixture(networkName, "fullsigned");
-                rootWalletKeys = loadWalletKeysFromFixture(fullsignedFixture);
-                replayProtectionKey = loadReplayProtectionKeyFromFixture(fullsignedFixture);
-                unsignedBitgoPsbt = fixedScriptWallet.BitGoPsbt.fromBytes(getPsbtBuffer(unsignedFixture), networkName);
-                halfsignedBitgoPsbt = fixedScriptWallet.BitGoPsbt.fromBytes(getPsbtBuffer(halfsignedFixture), networkName);
-                fullsignedBitgoPsbt = fixedScriptWallet.BitGoPsbt.fromBytes(getPsbtBuffer(fullsignedFixture), networkName);
-            });
-            describe("unsigned PSBT", function () {
-                it("should return false for unsigned inputs", function () {
-                    verifyAllInputSignatures(unsignedBitgoPsbt, unsignedFixture, rootWalletKeys, replayProtectionKey, "unsigned");
-                });
-            });
-            describe("half-signed PSBT", function () {
-                it("should return true for signed xpubs and false for unsigned", function () {
-                    verifyAllInputSignatures(halfsignedBitgoPsbt, halfsignedFixture, rootWalletKeys, replayProtectionKey, "halfsigned");
-                });
-            });
-            describe("fully signed PSBT", function () {
-                it("should have 2 signatures (2-of-3 multisig)", function () {
-                    verifyAllInputSignatures(fullsignedBitgoPsbt, fullsignedFixture, rootWalletKeys, replayProtectionKey, "fullsigned");
-                });
-            });
-            describe("error handling", function () {
-                it("should throw error for out of bounds input index", function () {
-                    assert.throws(() => {
-                        fullsignedBitgoPsbt.verifySignature(999, rootWalletKeys.userKey());
-                    }, (error) => {
-                        return error.message.includes("Input index 999 out of bounds");
-                    }, "Should throw error for out of bounds input index");
-                });
-                it("should throw error for invalid xpub", function () {
-                    assert.throws(() => {
-                        fullsignedBitgoPsbt.verifySignature(0, "invalid-xpub");
-                    }, (error) => {
-                        return error.message.includes("Invalid");
-                    }, "Should throw error for invalid xpub");
-                });
-                it("should return false for xpub not in derivation path", function () {
-                    // Create a different xpub that's not in the wallet
-                    // Use a proper 32-byte seed (256 bits)
-                    const differentSeed = Buffer.alloc(32, 0xaa); // 32 bytes filled with 0xaa
-                    const differentKey = BIP32.fromSeed(differentSeed);
-                    const differentXpub = differentKey.neutered();
-                    const result = fullsignedBitgoPsbt.verifySignature(0, differentXpub);
-                    assert.strictEqual(result, false, "Should return false for xpub not in PSBT derivation paths");
-                });
-                it("should verify signature with raw public key (Uint8Array)", function () {
-                    // Verify that xpub-based verification works
-                    const userKey = rootWalletKeys.userKey();
-                    const hasXpubSig = fullsignedBitgoPsbt.verifySignature(0, userKey);
-                    // This test specifically checks that raw public key verification works
-                    // We test the underlying WASM API by ensuring both xpub and raw pubkey
-                    // calls reach the correct methods
-                    // Use a random public key that's not in the PSBT to test the API works
-                    const randomSeed = Buffer.alloc(32, 0xcc);
-                    const randomKey = BIP32.fromSeed(randomSeed);
-                    const randomPubkey = randomKey.publicKey;
-                    // This should return false (no signature for this key)
-                    const result = fullsignedBitgoPsbt.verifySignature(0, randomPubkey);
-                    assert.strictEqual(result, false, "Should return false for public key not in PSBT");
-                    // Verify the xpub check still works (regression test)
-                    assert.strictEqual(hasXpubSig, true, "Should still verify with xpub");
-                });
-                it("should return false for raw public key with no signature", function () {
-                    // Create a random public key that's not in the PSBT
-                    const randomSeed = Buffer.alloc(32, 0xbb);
-                    const randomKey = BIP32.fromSeed(randomSeed);
-                    const randomPubkey = randomKey.publicKey;
-                    const result = fullsignedBitgoPsbt.verifySignature(0, randomPubkey);
-                    assert.strictEqual(result, false, "Should return false for public key not in PSBT signatures");
-                });
-                it("should throw error for invalid key length", function () {
-                    const invalidKey = Buffer.alloc(31); // Invalid length (should be 32 for private key or 33 for public key)
-                    assert.throws(() => {
-                        fullsignedBitgoPsbt.verifySignature(0, invalidKey);
-                    }, (error) => {
-                        return error.message.includes("Invalid key length");
-                    }, "Should throw error for invalid key length");
-                });
-            });
-        });
-    });
-});

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

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

package/dist/esm/test/fixedScriptToDescriptor.js

@@ -1,93 +0,0 @@
-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));
-        });
-    });
-}
-describe("fixedScript to descriptor", function () {
-    scriptTypes.forEach((scriptType) => {
-        index.forEach((index) => {
-            scope.forEach((scope) => {
-                runTest(scriptType, index, scope);
-            });
-        });
-    });
-});

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

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

package/dist/esm/test/fixtures.js

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

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

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

package/dist/esm/test/opdrop.js

@@ -1,85 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,113 +0,0 @@
-import * as assert from "node:assert";
-import * as utxolib from "@bitgo/utxo-lib";
-import { Psbt } from "../js/index.js";
-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

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

package/dist/esm/test/psbtFixedScriptCompat.js

@@ -1,116 +0,0 @@
-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.join(", ")}`, 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 });
-    });
-}
-describe("PSBT fixture", function () {
-    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

@@ -1,10 +0,0 @@
-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[];