@bitgo/wasm-utxo 1.35.0 → 1.37.0

package/dist/cjs/js/bip32.d.ts

@@ -140,6 +140,25 @@ export declare class BIP32 implements BIP32Interface {
      * @returns A new BIP32 instance for the derived key
      */
     derivePath(path: string): BIP32;
+    /**
+     * Check equality with another BIP32 key.
+     * Two keys are equal if they have the same type (public/private) and identical
+     * BIP32 metadata (depth, parent fingerprint, child index, chain code, key data).
+     * This is a fast comparison that does not require serialization.
+     *
+     * @param other - The other key to compare with. Accepts BIP32, or any BIP32Interface.
+     * @returns True if the keys are equal
+     */
+    equals(other: BIP32Interface): boolean;
+    /**
+     * Custom JSON representation for debugging.
+     * Always serializes the public key (xpub) to avoid leaking private keys.
+     * Includes a `hasPrivateKey` flag to indicate whether the key is neutered.
+     */
+    toJSON(): {
+        xpub: string;
+        hasPrivateKey: boolean;
+    };
     /**
      * Get the underlying WASM instance (internal use only)
      * @internal

package/dist/cjs/js/bip32.js

@@ -178,6 +178,35 @@ class BIP32 {
         const wasm = this._wasm.derive_path(path);
         return new BIP32(wasm);
     }
+    /**
+     * Check equality with another BIP32 key.
+     * Two keys are equal if they have the same type (public/private) and identical
+     * BIP32 metadata (depth, parent fingerprint, child index, chain code, key data).
+     * This is a fast comparison that does not require serialization.
+     *
+     * @param other - The other key to compare with. Accepts BIP32, or any BIP32Interface.
+     * @returns True if the keys are equal
+     */
+    equals(other) {
+        const otherWasm = other instanceof BIP32 ? other._wasm : BIP32.from(other)._wasm;
+        return this._wasm.equals(otherWasm);
+    }
+    /**
+     * Custom JSON representation for debugging.
+     * Always serializes the public key (xpub) to avoid leaking private keys.
+     * Includes a `hasPrivateKey` flag to indicate whether the key is neutered.
+     */
+    toJSON() {
+        return { xpub: this.neutered().toBase58(), hasPrivateKey: !this.isNeutered() };
+    }
+    /**
+     * Custom inspect representation for Node.js util.inspect and console.log.
+     * Always shows the public key (xpub) to avoid leaking private keys.
+     */
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        const flag = this.isNeutered() ? "" : ", hasPrivateKey";
+        return `BIP32(${this.neutered().toBase58()}${flag})`;
+    }
     /**
      * Get the underlying WASM instance (internal use only)
      * @internal

package/dist/cjs/js/index.d.ts

@@ -2,16 +2,16 @@ export * as address from "./address.js";
 export * as ast from "./ast/index.js";
 export * as bip322 from "./bip322/index.js";
 export * as inscriptions from "./inscriptions.js";
+export * as message from "./message.js";
 export * as utxolibCompat from "./utxolibCompat.js";
 export * as fixedScriptWallet from "./fixedScriptWallet/index.js";
 export * as descriptorWallet from "./descriptorWallet/index.js";
 export * as bip32 from "./bip32.js";
 export * as ecpair from "./ecpair.js";
-export * as testutils from "./testutils/index.js";
 export { ECPair } from "./ecpair.js";
 export { BIP32 } from "./bip32.js";
 export { Dimensions } from "./fixedScriptWallet/Dimensions.js";
-export type { CoinName } from "./coinName.js";
+export type { CoinName, getMainnet, isMainnet, isTestnet, isCoinName } from "./coinName.js";
 export type { Triple } from "./triple.js";
 export type { AddressFormat } from "./address.js";
 export type { TapLeafScript, PreparedInscriptionRevealData } from "./inscriptions.js";
@@ -60,6 +60,10 @@ declare module "./wasm/wasm_utxo.js" {
         bip32Derivation: PsbtBip32Derivation[];
         tapBip32Derivation: PsbtBip32Derivation[];
     }
+    /** PSBT output data with resolved address, returned by getOutputsWithAddress() */
+    interface PsbtOutputDataWithAddress extends PsbtOutputData {
+        address: string;
+    }
     interface WrapPsbt {
         signWithXprv(this: WrapPsbt, xprv: string): SignPsbtResult;
         signWithPrv(this: WrapPsbt, prv: Uint8Array): SignPsbtResult;
@@ -69,6 +73,7 @@ declare module "./wasm/wasm_utxo.js" {
         outputCount(): number;
         getInputs(): PsbtInputData[];
         getOutputs(): PsbtOutputData[];
+        getOutputsWithAddress(coin: import("./coinName.js").CoinName): PsbtOutputDataWithAddress[];
         getPartialSignatures(inputIndex: number): Array<{
             pubkey: Uint8Array;
             signature: Uint8Array;

package/dist/cjs/js/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasPsbtMagic = exports.ZcashTransaction = exports.Transaction = exports.DashTransaction = exports.Psbt = exports.Miniscript = exports.Descriptor = exports.Dimensions = exports.BIP32 = exports.ECPair = exports.testutils = exports.ecpair = exports.bip32 = exports.descriptorWallet = exports.fixedScriptWallet = exports.utxolibCompat = exports.inscriptions = exports.bip322 = exports.ast = exports.address = void 0;
+exports.hasPsbtMagic = exports.ZcashTransaction = exports.Transaction = exports.DashTransaction = exports.Psbt = exports.Miniscript = exports.Descriptor = exports.Dimensions = exports.BIP32 = exports.ECPair = exports.ecpair = exports.bip32 = exports.descriptorWallet = exports.fixedScriptWallet = exports.utxolibCompat = exports.message = exports.inscriptions = exports.bip322 = exports.ast = exports.address = void 0;
 const wasm = __importStar(require("./wasm/wasm_utxo.js"));
 // we need to access the wasm module here, otherwise webpack gets all weird
 // and forgets to include it in the bundle
@@ -44,12 +44,12 @@ exports.address = __importStar(require("./address.js"));
 exports.ast = __importStar(require("./ast/index.js"));
 exports.bip322 = __importStar(require("./bip322/index.js"));
 exports.inscriptions = __importStar(require("./inscriptions.js"));
+exports.message = __importStar(require("./message.js"));
 exports.utxolibCompat = __importStar(require("./utxolibCompat.js"));
 exports.fixedScriptWallet = __importStar(require("./fixedScriptWallet/index.js"));
 exports.descriptorWallet = __importStar(require("./descriptorWallet/index.js"));
 exports.bip32 = __importStar(require("./bip32.js"));
 exports.ecpair = __importStar(require("./ecpair.js"));
-exports.testutils = __importStar(require("./testutils/index.js"));
 // Only the most commonly used classes and types are exported at the top level for convenience
 var ecpair_js_1 = require("./ecpair.js");
 Object.defineProperty(exports, "ECPair", { enumerable: true, get: function () { return ecpair_js_1.ECPair; } });

package/dist/cjs/js/message.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Bitcoin message signing and verification (BIP-137)
+ *
+ * This module provides functions for signing and verifying Bitcoin messages
+ * using the standard Bitcoin Signed Message format (BIP-137).
+ *
+ * @example
+ * ```typescript
+ * import { message, ECPair } from '@bitgo/wasm-utxo';
+ *
+ * // Sign a message
+ * const key = ECPair.fromWIF('L1TnU2zbNaAqMoVh65Cyvmcjzbrj41Gs9iTLcWbpJCpV1iNMXpuR');
+ * const signature = message.signMessage('Hello, Bitcoin!', key);
+ *
+ * // Verify a message
+ * const isValid = message.verifyMessage('Hello, Bitcoin!', key, signature);
+ * ```
+ */
+import { type ECPairArg } from "./ecpair.js";
+/**
+ * Sign a message using Bitcoin message signing (BIP-137)
+ *
+ * @param message - The message to sign
+ * @param key - The key to sign with (must have a private key)
+ * @returns 65-byte signature (1-byte header + 64-byte signature)
+ */
+export declare function signMessage(message: string, key: ECPairArg): Uint8Array;
+/**
+ * Verify a Bitcoin message signature (BIP-137)
+ *
+ * @param message - The message that was signed
+ * @param key - The key to verify against
+ * @param signature - 65-byte signature (1-byte header + 64-byte signature)
+ * @returns True if the signature is valid for this key
+ */
+export declare function verifyMessage(message: string, key: ECPairArg, signature: Uint8Array): boolean;

package/dist/cjs/js/message.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Bitcoin message signing and verification (BIP-137)
+ *
+ * This module provides functions for signing and verifying Bitcoin messages
+ * using the standard Bitcoin Signed Message format (BIP-137).
+ *
+ * @example
+ * ```typescript
+ * import { message, ECPair } from '@bitgo/wasm-utxo';
+ *
+ * // Sign a message
+ * const key = ECPair.fromWIF('L1TnU2zbNaAqMoVh65Cyvmcjzbrj41Gs9iTLcWbpJCpV1iNMXpuR');
+ * const signature = message.signMessage('Hello, Bitcoin!', key);
+ *
+ * // Verify a message
+ * const isValid = message.verifyMessage('Hello, Bitcoin!', key, signature);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signMessage = signMessage;
+exports.verifyMessage = verifyMessage;
+const wasm_utxo_js_1 = require("./wasm/wasm_utxo.js");
+const ecpair_js_1 = require("./ecpair.js");
+/**
+ * Sign a message using Bitcoin message signing (BIP-137)
+ *
+ * @param message - The message to sign
+ * @param key - The key to sign with (must have a private key)
+ * @returns 65-byte signature (1-byte header + 64-byte signature)
+ */
+function signMessage(message, key) {
+    const ecpair = ecpair_js_1.ECPair.from(key);
+    return new Uint8Array(wasm_utxo_js_1.MessageNamespace.sign_message(ecpair.wasm, message));
+}
+/**
+ * Verify a Bitcoin message signature (BIP-137)
+ *
+ * @param message - The message that was signed
+ * @param key - The key to verify against
+ * @param signature - 65-byte signature (1-byte header + 64-byte signature)
+ * @returns True if the signature is valid for this key
+ */
+function verifyMessage(message, key, signature) {
+    const ecpair = ecpair_js_1.ECPair.from(key);
+    return wasm_utxo_js_1.MessageNamespace.verify_message(ecpair.wasm, message, signature);
+}

package/dist/cjs/js/testutils/descriptor/descriptors.d.ts

@@ -0,0 +1,27 @@
+import type { BIP32Interface } from "../../bip32.js";
+import { Descriptor, Miniscript, ast } from "../../index.js";
+import type { Triple } from "../../triple.js";
+import { DescriptorMap, PsbtParams } from "../../descriptorWallet/index.js";
+type KeyTriple = Triple<BIP32Interface>;
+export type DescriptorTemplate = "Wsh2Of3" | "Tr1Of3-NoKeyPath-Tree" | "Tr1Of3-NoKeyPath-Tree-Plain" | "Tr2Of3-NoKeyPath" | "Wsh2Of2"
+/**
+ * Wrapped segwit 2of3 multisig with a relative locktime OP_DROP
+ * (requiring a miniscript extension). Used in CoreDao staking transactions.
+ */
+ | "Wsh2Of3CltvDrop";
+/**
+ * Get the BIP-341 "Nothing Up My Sleeve" (NUMS) unspendable key.
+ * This is the x-only public key with unknown discrete logarithm
+ * constructed by hashing the uncompressed secp256k1 base point G.
+ *
+ * @see https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#constructing-and-spending-taproot-outputs
+ */
+export declare function getUnspendableKey(): string;
+export declare function getDefaultXPubs(seed?: string): Triple<string>;
+export declare function getPsbtParams(t: DescriptorTemplate): Partial<PsbtParams>;
+export declare function getDescriptorNode(template: DescriptorTemplate, keys?: KeyTriple | string[], path?: string): ast.DescriptorNode;
+export declare function containsKey(script: Miniscript | ast.MiniscriptNode, key: BIP32Interface | string): boolean;
+export declare function getTapLeafScripts(d: Descriptor): string[];
+export declare function getDescriptor(template: DescriptorTemplate, keys?: KeyTriple | string[], path?: string): Descriptor;
+export declare function getDescriptorMap(template: DescriptorTemplate, keys?: KeyTriple | string[]): DescriptorMap;
+export {};

package/dist/cjs/js/testutils/descriptor/descriptors.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnspendableKey = getUnspendableKey;
+exports.getDefaultXPubs = getDefaultXPubs;
+exports.getPsbtParams = getPsbtParams;
+exports.getDescriptorNode = getDescriptorNode;
+exports.containsKey = containsKey;
+exports.getTapLeafScripts = getTapLeafScripts;
+exports.getDescriptor = getDescriptor;
+exports.getDescriptorMap = getDescriptorMap;
+/**
+ * Descriptor test utilities for building common descriptor templates.
+ * Ported from @bitgo/utxo-core/testutil/descriptor/descriptors.ts.
+ */
+const assert_1 = __importDefault(require("assert"));
+const bip32_js_1 = require("../../bip32.js");
+const index_js_1 = require("../../index.js");
+const keys_js_1 = require("../keys.js");
+/**
+ * Get the BIP-341 "Nothing Up My Sleeve" (NUMS) unspendable key.
+ * This is the x-only public key with unknown discrete logarithm
+ * constructed by hashing the uncompressed secp256k1 base point G.
+ *
+ * @see https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#constructing-and-spending-taproot-outputs
+ */
+function getUnspendableKey() {
+    return "50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0";
+}
+function getDefaultXPubs(seed) {
+    return (0, keys_js_1.getKeyTriple)(seed ?? "default").map((k) => k.neutered().toBase58());
+}
+function toDescriptorMap(v) {
+    return new Map(Object.entries(v).map(([k, v]) => [k, index_js_1.Descriptor.fromString(v, "derivable")]));
+}
+function toXPub(k, path) {
+    if (typeof k === "string") {
+        return k + "/" + path;
+    }
+    return k.neutered().toBase58() + "/" + path;
+}
+function toPlain(k, { xonly = false } = {}) {
+    if (typeof k === "string") {
+        if (k.startsWith("xpub") || k.startsWith("xprv")) {
+            return toPlain(bip32_js_1.BIP32.fromBase58(k), { xonly });
+        }
+        return k;
+    }
+    return toHex(k.publicKey.subarray(xonly ? 1 : 0));
+}
+function toHex(bytes) {
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function toXOnly(k) {
+    return toPlain(k, { xonly: true });
+}
+function multiArgs(m, n, keys, path) {
+    if (n < m) {
+        throw new Error(`Cannot create ${m} of ${n} multisig`);
+    }
+    if (keys.length < n) {
+        throw new Error(`Not enough keys for ${m} of ${n} multisig: keys.length=${keys.length}`);
+    }
+    keys = keys.slice(0, n);
+    return [m, ...keys.map((k) => toXPub(k, path))];
+}
+function getPsbtParams(t) {
+    switch (t) {
+        case "Wsh2Of3CltvDrop":
+            return { locktime: 1 };
+        default:
+            return {};
+    }
+}
+function getDescriptorNode(template, keys = getDefaultXPubs(), path = "0/*") {
+    switch (template) {
+        case "Wsh2Of3":
+            return {
+                wsh: { multi: multiArgs(2, 3, keys, path) },
+            };
+        case "Wsh2Of3CltvDrop": {
+            const { locktime } = getPsbtParams(template);
+            (0, assert_1.default)(locktime);
+            return {
+                wsh: {
+                    and_v: [{ "r:after": locktime }, { multi: multiArgs(2, 3, keys, path) }],
+                },
+            };
+        }
+        case "Wsh2Of2":
+            return {
+                wsh: { multi: multiArgs(2, 2, keys, path) },
+            };
+        case "Tr2Of3-NoKeyPath":
+            return {
+                tr: [getUnspendableKey(), { multi_a: multiArgs(2, 3, keys, path) }],
+            };
+        case "Tr1Of3-NoKeyPath-Tree":
+            return {
+                tr: [
+                    getUnspendableKey(),
+                    [
+                        { pk: toXPub(keys[0], path) },
+                        [{ pk: toXPub(keys[1], path) }, { pk: toXPub(keys[2], path) }],
+                    ],
+                ],
+            };
+        case "Tr1Of3-NoKeyPath-Tree-Plain":
+            return {
+                tr: [
+                    getUnspendableKey(),
+                    [{ pk: toXOnly(keys[0]) }, [{ pk: toXOnly(keys[1]) }, { pk: toXOnly(keys[2]) }]],
+                ],
+            };
+    }
+    throw new Error(`Unknown descriptor template: ${template}`);
+}
+function getTapLeafScriptNodes(t) {
+    if (Array.isArray(t)) {
+        if (t.length !== 2) {
+            throw new Error(`expected tuple, got: ${JSON.stringify(t)}`);
+        }
+        return t.map((v) => (Array.isArray(v) ? getTapLeafScriptNodes(v) : v)).flat();
+    }
+    if (typeof t === "object") {
+        const node = t;
+        if (!("tr" in node)) {
+            throw new Error(`TapLeafScripts are only supported for Taproot descriptors, got: ${JSON.stringify(t)}`);
+        }
+        if (!Array.isArray(node.tr) || node.tr.length !== 2) {
+            throw new Error(`expected tuple, got: ${JSON.stringify(node.tr)}`);
+        }
+        const tapscript = node.tr[1];
+        if (!Array.isArray(tapscript)) {
+            throw new Error(`expected tapscript to be an array, got: ${JSON.stringify(tapscript)}`);
+        }
+        return getTapLeafScriptNodes(tapscript);
+    }
+    throw new Error(`Invalid input: ${JSON.stringify(t)}`);
+}
+function containsKey(script, key) {
+    if (script instanceof index_js_1.Miniscript) {
+        script = index_js_1.ast.fromMiniscript(script);
+    }
+    if ("pk" in script) {
+        return script.pk === toXOnly(key);
+    }
+    throw new Error(`Unsupported script type: ${JSON.stringify(script)}`);
+}
+function getTapLeafScripts(d) {
+    return getTapLeafScriptNodes(index_js_1.ast.fromDescriptor(d)).map((n) => index_js_1.Miniscript.fromString(index_js_1.ast.formatNode(n), "tap").toString());
+}
+function getDescriptor(template, keys = getDefaultXPubs(), path = "0/*") {
+    return index_js_1.Descriptor.fromStringDetectType(index_js_1.ast.formatNode(getDescriptorNode(template, keys, path)));
+}
+function getDescriptorMap(template, keys = getDefaultXPubs()) {
+    return toDescriptorMap({
+        external: getDescriptor(template, keys, "0/*").toString(),
+        internal: getDescriptor(template, keys, "1/*").toString(),
+    });
+}

package/dist/cjs/js/testutils/descriptor/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./descriptors.js";
+export * from "./mockPsbt.js";

package/dist/cjs/js/testutils/descriptor/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./descriptors.js"), exports);
+__exportStar(require("./mockPsbt.js"), exports);

package/dist/cjs/js/testutils/descriptor/mockPsbt.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Mock PSBT utilities for descriptor wallet testing.
+ * Ported from @bitgo/utxo-core/testutil/descriptor/mock.utils.ts.
+ *
+ * Key difference from utxo-core: returns wasm-utxo Psbt instances directly
+ * instead of utxolib.bitgo.UtxoPsbt. PsbtParams does not require a network field.
+ */
+import { Descriptor, Miniscript, Psbt } from "../../index.js";
+import { PsbtParams, DerivedDescriptorTransactionInput } from "../../descriptorWallet/index.js";
+import { DescriptorTemplate } from "./descriptors.js";
+type MockOutputIdParams = {
+    hash?: string;
+    vout?: number;
+};
+type BaseMockDescriptorOutputParams = {
+    id?: MockOutputIdParams;
+    index?: number;
+    value?: bigint;
+    sequence?: number;
+    selectTapLeafScript?: Miniscript;
+};
+export declare function mockDerivedDescriptorWalletOutput(descriptor: Descriptor, outputParams?: BaseMockDescriptorOutputParams): DerivedDescriptorTransactionInput;
+type MockInput = BaseMockDescriptorOutputParams & {
+    index: number;
+    descriptor: Descriptor;
+    selectTapLeafScript?: Miniscript;
+};
+type MockOutput = {
+    descriptor: Descriptor;
+    index: number;
+    value: bigint;
+    external?: boolean;
+};
+export declare function mockPsbt(inputs: MockInput[], outputs: MockOutput[], params?: Partial<PsbtParams>): Psbt;
+export declare function mockPsbtDefault({ descriptorSelf, descriptorOther, params, }?: {
+    descriptorSelf?: Descriptor;
+    descriptorOther?: Descriptor;
+    params?: Partial<PsbtParams>;
+}): Psbt;
+export declare function mockPsbtDefaultWithDescriptorTemplate(t: DescriptorTemplate, params?: Partial<PsbtParams>): Psbt;
+export {};

package/dist/cjs/js/testutils/descriptor/mockPsbt.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockDerivedDescriptorWalletOutput = mockDerivedDescriptorWalletOutput;
+exports.mockPsbt = mockPsbt;
+exports.mockPsbtDefault = mockPsbtDefault;
+exports.mockPsbtDefaultWithDescriptorTemplate = mockPsbtDefaultWithDescriptorTemplate;
+const index_js_1 = require("../../descriptorWallet/index.js");
+const descriptors_js_1 = require("./descriptors.js");
+function mockOutputId(id) {
+    const hash = id?.hash ?? "0101010101010101010101010101010101010101010101010101010101010101";
+    const vout = id?.vout ?? 0;
+    return { hash, vout };
+}
+function mockDerivedDescriptorWalletOutput(descriptor, outputParams = {}) {
+    const { value = BigInt(1e6) } = outputParams;
+    const { hash, vout } = mockOutputId(outputParams.id);
+    return {
+        hash,
+        index: vout,
+        witnessUtxo: {
+            script: (0, index_js_1.createScriptPubKeyFromDescriptor)(descriptor, undefined),
+            value,
+        },
+        descriptor,
+        selectTapLeafScript: outputParams.selectTapLeafScript,
+        sequence: outputParams.sequence,
+    };
+}
+function tryDeriveAtIndex(descriptor, index) {
+    return descriptor.hasWildcard() ? descriptor.atDerivationIndex(index) : descriptor;
+}
+function mockPsbt(inputs, outputs, params = {}) {
+    return (0, index_js_1.createPsbt)(params, inputs.map((i) => mockDerivedDescriptorWalletOutput(tryDeriveAtIndex(i.descriptor, i.index), i)), outputs.map((o) => {
+        const derivedDescriptor = tryDeriveAtIndex(o.descriptor, o.index);
+        return {
+            script: (0, index_js_1.createScriptPubKeyFromDescriptor)(derivedDescriptor, undefined),
+            value: o.value,
+            descriptor: o.external ? undefined : derivedDescriptor,
+        };
+    }));
+}
+function mockPsbtDefault({ descriptorSelf = (0, descriptors_js_1.getDescriptor)("Wsh2Of3", (0, descriptors_js_1.getDefaultXPubs)("a")), descriptorOther = (0, descriptors_js_1.getDescriptor)("Wsh2Of3", (0, descriptors_js_1.getDefaultXPubs)("b")), params = {}, } = {}) {
+    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);
+}
+function mockPsbtDefaultWithDescriptorTemplate(t, params = {}) {
+    return mockPsbtDefault({
+        descriptorSelf: (0, descriptors_js_1.getDescriptor)(t, (0, descriptors_js_1.getDefaultXPubs)("a")),
+        descriptorOther: (0, descriptors_js_1.getDescriptor)(t, (0, descriptors_js_1.getDefaultXPubs)("b")),
+        params: { ...(0, descriptors_js_1.getPsbtParams)(t), ...params },
+    });
+}

package/dist/cjs/js/testutils/fixtures.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Return fixture described in `path`.
+ *
+ * If the file does not exist and `defaultValue` is provided,
+ * writes defaultValue to `path` and throws an error prompting
+ * the developer to inspect and re-run.
+ *
+ * @param path - Path to the fixture file (.json, .hex, or .txt)
+ * @param defaultValue - Default value to write if fixture is missing
+ * @returns The fixture content
+ */
+export declare function getFixture<T>(path: string, defaultValue?: T | (() => Promise<T>)): Promise<T>;
+/**
+ * JSON round-trip normalization.
+ * Converts a value to JSON and back, stripping non-serializable properties
+ * and normalizing types (e.g. undefined -> null in arrays).
+ */
+export declare function jsonNormalize<T>(v: T): T;
+export type ToPlainObjectOpts = {
+    propertyDescriptors?: boolean;
+    skipUndefinedValues?: boolean;
+    ignorePaths?: string[] | ((path: PathElement[]) => boolean);
+    apply?: (v: unknown, path: PathElement[]) => unknown;
+};
+export type PathElement = string | number;
+export declare function matchPath(a: PathElement[], b: PathElement[]): boolean;
+/**
+ * Recursively convert a value to a plain JSON-serializable object.
+ * Handles Uint8Array (to hex), bigint (to string), Buffer, and more.
+ *
+ * @param v - The value to convert
+ * @param opts - Options for customizing the conversion
+ * @param path - Current property path (used for ignorePaths)
+ */
+export declare function toPlainObject(v: unknown, opts?: ToPlainObjectOpts, path?: PathElement[]): unknown;