@bitgo/wasm-utxo 1.35.0 → 1.37.0

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

@@ -0,0 +1,244 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFixture = getFixture;
+exports.jsonNormalize = jsonNormalize;
+exports.matchPath = matchPath;
+exports.toPlainObject = toPlainObject;
+/// <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.
+ */
+const fs = __importStar(require("fs"));
+const mpath = __importStar(require("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
+ */
+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).
+ */
+function jsonNormalize(v) {
+    return JSON.parse(JSON.stringify(v));
+}
+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)
+ */
+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/cjs/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/cjs/js/testutils/index.js

@@ -10,9 +10,34 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 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);
 };
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.descriptor = void 0;
 __exportStar(require("./keys.js"), exports);
 __exportStar(require("./AcidTest.js"), exports);
+__exportStar(require("./fixtures.js"), exports);
+exports.descriptor = __importStar(require("./descriptor/index.js"));

package/dist/cjs/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/cjs/js/wasm/wasm_utxo.js

@@ -2012,6 +2012,78 @@ class InscriptionsNamespace {
 if (Symbol.dispose) InscriptionsNamespace.prototype[Symbol.dispose] = InscriptionsNamespace.prototype.free;
 exports.InscriptionsNamespace = InscriptionsNamespace;
 
+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;
+exports.MessageNamespace = MessageNamespace;
+
 class UtxolibCompatNamespace {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -2201,6 +2273,18 @@ 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}
@@ -4146,6 +4230,31 @@ 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 }
@@ -4709,6 +4818,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));