@bitgo/wasm-utxo 1.35.0 → 1.37.0

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

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

package/dist/esm/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;

package/dist/esm/js/testutils/fixtures.js

@@ -0,0 +1,205 @@
+/// <reference types="node" />
+/**
+ * Generic test fixture and serialization utilities.
+ * Ported from @bitgo/utxo-core/testutil/fixtures.utils.ts
+ * and @bitgo/utxo-core/testutil/toPlainObject.utils.ts.
+ *
+ * NOTE: getFixture requires Node.js (fs, process.env).
+ * The toPlainObject / jsonNormalize utilities are platform-independent.
+ */
+import * as fs from "fs";
+import * as mpath from "path";
+function isNodeJsError(e) {
+    return e instanceof Error && typeof e.code === "string";
+}
+function fixtureEncoding(path) {
+    if (path.endsWith(".json")) {
+        return "json";
+    }
+    if (path.endsWith(".hex")) {
+        return "hex";
+    }
+    if (path.endsWith(".txt")) {
+        return "txt";
+    }
+    throw new Error(`unknown fixture encoding for ${path}`);
+}
+function hexToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+    }
+    return bytes;
+}
+function bytesToHex(bytes) {
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function decodeFixture(raw, encoding) {
+    switch (encoding) {
+        case "json":
+            return JSON.parse(raw);
+        case "hex":
+            return hexToBytes(raw);
+        case "txt":
+            return raw;
+    }
+}
+function encodeFixture(value, encoding) {
+    switch (encoding) {
+        case "json":
+            return JSON.stringify(value, null, 2) + "\n";
+        case "hex":
+            if (!(value instanceof Uint8Array)) {
+                throw new Error(`expected Uint8Array, got ${typeof value}`);
+            }
+            return bytesToHex(value);
+        case "txt":
+            if (typeof value !== "string") {
+                throw new Error(`expected string, got ${typeof value}`);
+            }
+            return value;
+    }
+}
+/**
+ * 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 async function getFixture(path, defaultValue) {
+    try {
+        await fs.promises.stat(mpath.dirname(path));
+    }
+    catch (e) {
+        if (isNodeJsError(e) && e.code === "ENOENT") {
+            throw new Error(`fixture directory ${mpath.dirname(path)} not found, please create it first`);
+        }
+        throw e;
+    }
+    const encoding = fixtureEncoding(path);
+    try {
+        return decodeFixture(await fs.promises.readFile(path, "utf8"), encoding);
+    }
+    catch (e) {
+        if (isNodeJsError(e) && e.code === "ENOENT") {
+            // eslint-disable-next-line no-restricted-globals
+            if (process.env.WRITE_FIXTURES === "0") {
+                throw new Error(`fixture ${path} not found, WRITE_FIXTURES=0`);
+            }
+            if (defaultValue === undefined) {
+                throw new Error(`fixture ${path} not found and no default value given`);
+            }
+            if (typeof defaultValue === "function") {
+                defaultValue = await defaultValue();
+            }
+            await fs.promises.writeFile(path, encodeFixture(defaultValue, encoding));
+            throw new Error(`wrote default value for ${path}, please inspect and restart test`);
+        }
+        throw e;
+    }
+}
+/**
+ * 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 function jsonNormalize(v) {
+    return JSON.parse(JSON.stringify(v));
+}
+export function matchPath(a, b) {
+    return a.length === b.length && a.every((e, i) => e === b[i]);
+}
+function includePath(opts, path) {
+    if (!opts.ignorePaths) {
+        return true;
+    }
+    if (typeof opts.ignorePaths === "function") {
+        return !opts.ignorePaths(path);
+    }
+    return !opts.ignorePaths.some((ignorePath) => matchPath(path, ignorePath.split(".")));
+}
+function toPlainEntries(key, value, opts, path) {
+    if (!includePath(opts, [...path, key])) {
+        return [];
+    }
+    if (value === undefined && (opts.skipUndefinedValues ?? true)) {
+        return [];
+    }
+    return [[key, toPlainObject(value, opts, [...path, key])]];
+}
+function getAllPropertyDescriptors(v) {
+    if (v === null || typeof v !== "object") {
+        return {};
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(v);
+    const proto = Object.getPrototypeOf(v);
+    if (proto) {
+        Object.assign(descriptors, getAllPropertyDescriptors(proto));
+    }
+    return descriptors;
+}
+function toPlainObjectFromPropertyDescriptors(v, opts, path) {
+    const descriptors = getAllPropertyDescriptors(v);
+    return Object.fromEntries(Object.entries(descriptors).flatMap(([key, descriptor]) => {
+        if (typeof descriptor.value === "function") {
+            return [];
+        }
+        if (descriptor.value !== undefined) {
+            return toPlainEntries(key, descriptor.value, opts, path);
+        }
+        if (typeof descriptor.get === "function") {
+            return toPlainEntries(key, descriptor.get.call(v), opts, path);
+        }
+        return [];
+    }));
+}
+/**
+ * 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 function toPlainObject(v, opts = {}, path = []) {
+    if (opts.apply) {
+        const result = opts.apply(v, path);
+        if (result !== undefined) {
+            return result;
+        }
+    }
+    switch (typeof v) {
+        case "string":
+        case "number":
+        case "boolean":
+        case "undefined":
+            return v;
+        case "bigint":
+            return v.toString();
+        case "function":
+        case "symbol":
+            return undefined;
+    }
+    if (v === null) {
+        return v;
+    }
+    if (v instanceof Uint8Array) {
+        return Array.from(v, (b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    if (Array.isArray(v)) {
+        return v.map((e, i) => toPlainObject(e, opts, [...path, i]));
+    }
+    if (typeof v === "object") {
+        const result = Object.fromEntries(Object.entries(v).flatMap(([key, value]) => toPlainEntries(key, value, opts, path)));
+        if (opts.propertyDescriptors) {
+            Object.assign(result, toPlainObjectFromPropertyDescriptors(v, opts, path));
+        }
+        return result;
+    }
+    throw new Error(`unknown v ${typeof v}`);
+}

package/dist/esm/js/testutils/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./keys.js";
 export * from "./AcidTest.js";
+export * from "./fixtures.js";
+export * as descriptor from "./descriptor/index.js";

package/dist/esm/js/testutils/index.js

@@ -1,2 +1,4 @@
 export * from "./keys.js";
 export * from "./AcidTest.js";
+export * from "./fixtures.js";
+export * as descriptor from "./descriptor/index.js";

package/dist/esm/js/wasm/wasm_utxo.d.ts

@@ -784,6 +784,26 @@ export class InscriptionsNamespace {
     static sign_reveal_transaction(private_key: Uint8Array, tap_leaf_script: any, commit_tx: WasmTransaction, commit_output_script: Uint8Array, recipient_output_script: Uint8Array, output_value_sats: bigint): Uint8Array;
 }
 
+export class MessageNamespace {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Sign a message using Bitcoin message signing (BIP-137)
+     *
+     * Returns 65-byte signature (1-byte header + 64-byte signature).
+     * The key must have a private key (cannot sign with public key only).
+     */
+    static sign_message(key: WasmECPair, message_str: string): Uint8Array;
+    /**
+     * Verify a Bitcoin message signature (BIP-137)
+     *
+     * Signature must be 65 bytes (1-byte header + 64-byte signature).
+     * Returns true if the signature is valid for this key.
+     */
+    static verify_message(key: WasmECPair, message_str: string, signature: Uint8Array): boolean;
+}
+
 export class UtxolibCompatNamespace {
     private constructor();
     free(): void;
@@ -828,6 +848,12 @@ export class WasmBIP32 {
      * Derive a key using a derivation path (e.g., "0/1/2" or "m/0/1/2")
      */
     derive_path(path: string): WasmBIP32;
+    /**
+     * Check equality with another WasmBIP32 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).
+     */
+    equals(other: WasmBIP32): boolean;
     /**
      * Create a BIP32 key from a base58 string (xpub/xprv/tpub/tprv)
      */
@@ -1334,6 +1360,13 @@ export class WrapPsbt {
      * for each output. This is useful for introspecting the PSBT structure.
      */
     getOutputs(): any;
+    /**
+     * Get all PSBT outputs with resolved address strings.
+     *
+     * Like `getOutputs()` but each element also includes an `address` field
+     * derived from the output script using the given coin name (e.g. "btc", "tbtc").
+     */
+    getOutputsWithAddress(coin: string): any;
     /**
      * Get partial signatures for an input
      * Returns array of { pubkey: Uint8Array, signature: Uint8Array }

package/dist/esm/js/wasm/wasm_utxo.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./wasm_utxo_bg.js";
 __wbg_set_wasm(wasm);
 
 export {
-    AddressNamespace, Bip322Namespace, BitGoPsbt, FixedScriptWalletNamespace, InscriptionsNamespace, UtxolibCompatNamespace, WasmBIP32, WasmDashTransaction, WasmDimensions, WasmECPair, WasmReplayProtection, WasmRootWalletKeys, WasmTransaction, WasmZcashTransaction, WrapDescriptor, WrapMiniscript, WrapPsbt
+    AddressNamespace, Bip322Namespace, BitGoPsbt, FixedScriptWalletNamespace, InscriptionsNamespace, MessageNamespace, UtxolibCompatNamespace, WasmBIP32, WasmDashTransaction, WasmDimensions, WasmECPair, WasmReplayProtection, WasmRootWalletKeys, WasmTransaction, WasmZcashTransaction, WrapDescriptor, WrapMiniscript, WrapPsbt
 } from "./wasm_utxo_bg.js";

package/dist/esm/js/wasm/wasm_utxo_bg.js

@@ -2005,6 +2005,77 @@ export class InscriptionsNamespace {
 }
 if (Symbol.dispose) InscriptionsNamespace.prototype[Symbol.dispose] = InscriptionsNamespace.prototype.free;
 
+export class MessageNamespace {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MessageNamespaceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_messagenamespace_free(ptr, 0);
+    }
+    /**
+     * Sign a message using Bitcoin message signing (BIP-137)
+     *
+     * Returns 65-byte signature (1-byte header + 64-byte signature).
+     * The key must have a private key (cannot sign with public key only).
+     * @param {WasmECPair} key
+     * @param {string} message_str
+     * @returns {Uint8Array}
+     */
+    static sign_message(key, message_str) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(key, WasmECPair);
+            const ptr0 = passStringToWasm0(message_str, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.messagenamespace_sign_message(retptr, key.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Verify a Bitcoin message signature (BIP-137)
+     *
+     * Signature must be 65 bytes (1-byte header + 64-byte signature).
+     * Returns true if the signature is valid for this key.
+     * @param {WasmECPair} key
+     * @param {string} message_str
+     * @param {Uint8Array} signature
+     * @returns {boolean}
+     */
+    static verify_message(key, message_str, signature) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(key, WasmECPair);
+            const ptr0 = passStringToWasm0(message_str, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray8ToWasm0(signature, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.messagenamespace_verify_message(retptr, key.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return r0 !== 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) MessageNamespace.prototype[Symbol.dispose] = MessageNamespace.prototype.free;
+
 export class UtxolibCompatNamespace {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -2193,6 +2264,18 @@ export class WasmBIP32 {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Check equality with another WasmBIP32 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).
+     * @param {WasmBIP32} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        _assertClass(other, WasmBIP32);
+        const ret = wasm.wasmbip32_equals(this.__wbg_ptr, other.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * Get the fingerprint as a Uint8Array
      * @returns {Uint8Array}
@@ -4128,6 +4211,31 @@ export class WrapPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Get all PSBT outputs with resolved address strings.
+     *
+     * Like `getOutputs()` but each element also includes an `address` field
+     * derived from the output script using the given coin name (e.g. "btc", "tbtc").
+     * @param {string} coin
+     * @returns {any}
+     */
+    getOutputsWithAddress(coin) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(coin, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wrappsbt_getOutputsWithAddress(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Get partial signatures for an input
      * Returns array of { pubkey: Uint8Array, signature: Uint8Array }
@@ -4679,6 +4787,9 @@ const FixedScriptWalletNamespaceFinalization = (typeof FinalizationRegistry ===
 const InscriptionsNamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_inscriptionsnamespace_free(ptr >>> 0, 1));
+const MessageNamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_messagenamespace_free(ptr >>> 0, 1));
 const UtxolibCompatNamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_utxolibcompatnamespace_free(ptr >>> 0, 1));