@bitgo/wasm-utxo 1.21.0 → 1.23.0

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

@@ -4,6 +4,7 @@ export { ReplayProtection, type ReplayProtectionArg } from "./ReplayProtection.j
 export { outputScript, address } from "./address.js";
 export { Dimensions } from "./Dimensions.js";
 export { type OutputScriptType, type InputScriptType, type ScriptType } from "./scriptType.js";
+export { ChainCode, chainCodes, type Scope } from "./chains.js";
 export { BitGoPsbt, type NetworkName, type ScriptId, type ParsedInput, type ParsedOutput, type ParsedTransaction, type SignPath, type CreateEmptyOptions, type AddInputOptions, type AddOutputOptions, type AddWalletInputOptions, type AddWalletOutputOptions, } from "./BitGoPsbt.js";
 export { ZcashBitGoPsbt, type ZcashNetworkName, type CreateEmptyZcashOptions, } from "./ZcashBitGoPsbt.js";
 import type { ScriptType } from "./scriptType.js";

package/dist/cjs/js/fixedScriptWallet/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZcashBitGoPsbt = exports.BitGoPsbt = exports.Dimensions = exports.address = exports.outputScript = exports.ReplayProtection = exports.RootWalletKeys = void 0;
+exports.ZcashBitGoPsbt = exports.BitGoPsbt = exports.chainCodes = exports.ChainCode = exports.Dimensions = exports.address = exports.outputScript = exports.ReplayProtection = exports.RootWalletKeys = void 0;
 exports.supportsScriptType = supportsScriptType;
 const wasm_utxo_js_1 = require("../wasm/wasm_utxo.js");
 var RootWalletKeys_js_1 = require("./RootWalletKeys.js");
@@ -12,6 +12,9 @@ Object.defineProperty(exports, "outputScript", { enumerable: true, get: function
 Object.defineProperty(exports, "address", { enumerable: true, get: function () { return address_js_1.address; } });
 var Dimensions_js_1 = require("./Dimensions.js");
 Object.defineProperty(exports, "Dimensions", { enumerable: true, get: function () { return Dimensions_js_1.Dimensions; } });
+var chains_js_1 = require("./chains.js");
+Object.defineProperty(exports, "ChainCode", { enumerable: true, get: function () { return chains_js_1.ChainCode; } });
+Object.defineProperty(exports, "chainCodes", { enumerable: true, get: function () { return chains_js_1.chainCodes; } });
 // Bitcoin-like PSBT (for all non-Zcash networks)
 var BitGoPsbt_js_1 = require("./BitGoPsbt.js");
 Object.defineProperty(exports, "BitGoPsbt", { enumerable: true, get: function () { return BitGoPsbt_js_1.BitGoPsbt; } });

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

@@ -1,5 +1,6 @@
 export * as address from "./address.js";
 export * as ast from "./ast/index.js";
+export * as bip322 from "./bip322/index.js";
 export * as utxolibCompat from "./utxolibCompat.js";
 export * as fixedScriptWallet from "./fixedScriptWallet/index.js";
 export * as bip32 from "./bip32.js";

package/dist/cjs/js/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZcashTransaction = exports.Transaction = exports.DashTransaction = exports.Psbt = exports.Miniscript = exports.Descriptor = exports.Dimensions = exports.BIP32 = exports.ECPair = exports.ecpair = exports.bip32 = exports.fixedScriptWallet = exports.utxolibCompat = exports.ast = exports.address = void 0;
+exports.ZcashTransaction = exports.Transaction = exports.DashTransaction = exports.Psbt = exports.Miniscript = exports.Descriptor = exports.Dimensions = exports.BIP32 = exports.ECPair = exports.ecpair = exports.bip32 = exports.fixedScriptWallet = exports.utxolibCompat = 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
@@ -42,6 +42,7 @@ void wasm;
 // and to make imports more explicit (e.g., `import { address } from '@bitgo/wasm-utxo'`)
 exports.address = __importStar(require("./address.js"));
 exports.ast = __importStar(require("./ast/index.js"));
+exports.bip322 = __importStar(require("./bip322/index.js"));
 exports.utxolibCompat = __importStar(require("./utxolibCompat.js"));
 exports.fixedScriptWallet = __importStar(require("./fixedScriptWallet/index.js"));
 exports.bip32 = __importStar(require("./bip32.js"));

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

@@ -9,6 +9,106 @@ export class AddressNamespace {
   static from_output_script_with_coin(script: Uint8Array, coin: string, format?: string | null): string;
 }
 
+export class Bip322Namespace {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Add a BIP-0322 message input to an existing BitGoPsbt
+   *
+   * If this is the first input, also adds the OP_RETURN output.
+   * The PSBT must have version 0 per BIP-0322 specification.
+   *
+   * # Arguments
+   * * `psbt` - The BitGoPsbt to add the input to
+   * * `message` - The message to sign
+   * * `chain` - The wallet chain (e.g., 10 for external, 20 for internal)
+   * * `index` - The address index
+   * * `wallet_keys` - The wallet's root keys
+   * * `signer` - Optional signer key name for taproot (e.g., "user", "backup", "bitgo")
+   * * `cosigner` - Optional cosigner key name for taproot
+   * * `tag` - Optional custom tag for message hashing
+   *
+   * # Returns
+   * The index of the added input
+   */
+  static add_bip322_input(psbt: BitGoPsbt, message: string, chain: number, index: number, wallet_keys: WasmRootWalletKeys, signer?: string | null, cosigner?: string | null, tag?: string | null): number;
+  /**
+   * Verify a single input of a BIP-0322 transaction proof
+   *
+   * # Arguments
+   * * `tx` - The signed transaction
+   * * `input_index` - The index of the input to verify
+   * * `message` - The message that was signed
+   * * `chain` - The wallet chain
+   * * `index` - The address index
+   * * `wallet_keys` - The wallet's root keys
+   * * `network` - Network name
+   * * `tag` - Optional custom tag for message hashing
+   *
+   * # Throws
+   * Throws an error if verification fails
+   */
+  static verify_bip322_tx_input(tx: WasmTransaction, input_index: number, message: string, chain: number, index: number, wallet_keys: WasmRootWalletKeys, network: string, tag?: string | null): void;
+  /**
+   * Verify a single input of a BIP-0322 PSBT proof
+   *
+   * # Arguments
+   * * `psbt` - The signed BitGoPsbt
+   * * `input_index` - The index of the input to verify
+   * * `message` - The message that was signed
+   * * `chain` - The wallet chain
+   * * `index` - The address index
+   * * `wallet_keys` - The wallet's root keys
+   * * `tag` - Optional custom tag for message hashing
+   *
+   * # Returns
+   * An array of signer names ("user", "backup", "bitgo") that have valid signatures
+   *
+   * # Throws
+   * Throws an error if verification fails or no valid signatures found
+   */
+  static verify_bip322_psbt_input(psbt: BitGoPsbt, input_index: number, message: string, chain: number, index: number, wallet_keys: WasmRootWalletKeys, tag?: string | null): string[];
+  /**
+   * Verify a single input of a BIP-0322 transaction proof using pubkeys directly
+   *
+   * # Arguments
+   * * `tx` - The signed transaction
+   * * `input_index` - The index of the input to verify
+   * * `message` - The message that was signed
+   * * `pubkeys` - Array of 3 hex-encoded pubkeys [user, backup, bitgo]
+   * * `script_type` - One of: "p2sh", "p2shP2wsh", "p2wsh", "p2tr", "p2trMusig2"
+   * * `is_script_path` - For taproot types, whether script path was used
+   * * `tag` - Optional custom tag for message hashing
+   *
+   * # Returns
+   * An array of pubkey indices (0, 1, 2) that have valid signatures
+   *
+   * # Throws
+   * Throws an error if verification fails
+   */
+  static verify_bip322_tx_input_with_pubkeys(tx: WasmTransaction, input_index: number, message: string, pubkeys: string[], script_type: string, is_script_path?: boolean | null, tag?: string | null): Uint32Array;
+  /**
+   * Verify a single input of a BIP-0322 PSBT proof using pubkeys directly
+   *
+   * # Arguments
+   * * `psbt` - The signed BitGoPsbt
+   * * `input_index` - The index of the input to verify
+   * * `message` - The message that was signed
+   * * `pubkeys` - Array of 3 hex-encoded pubkeys [user, backup, bitgo]
+   * * `script_type` - One of: "p2sh", "p2shP2wsh", "p2wsh", "p2tr", "p2trMusig2"
+   * * `is_script_path` - For taproot types, whether script path was used
+   * * `tag` - Optional custom tag for message hashing
+   *
+   * # Returns
+   * An array of pubkey indices (0, 1, 2) that have valid signatures
+   *
+   * # Throws
+   * Throws an error if verification fails or no valid signatures found
+   */
+  static verify_bip322_psbt_input_with_pubkeys(psbt: BitGoPsbt, input_index: number, message: string, pubkeys: string[], script_type: string, is_script_path?: boolean | null, tag?: string | null): Uint32Array;
+}
+
 export class BitGoPsbt {
   private constructor();
   free(): void;
@@ -379,6 +479,15 @@ export class FixedScriptWalletNamespace {
   free(): void;
   [Symbol.dispose](): void;
   static output_script(keys: WasmRootWalletKeys, chain: number, index: number, network: any): Uint8Array;
+  /**
+   * Get all chain code metadata for building TypeScript lookup tables
+   *
+   * Returns an array of [chainCode, scriptType, scope] tuples where:
+   * - chainCode: u32 (0, 1, 10, 11, 20, 21, 30, 31, 40, 41)
+   * - scriptType: string ("p2sh", "p2shP2wsh", "p2wsh", "p2trLegacy", "p2trMusig2")
+   * - scope: string ("external" or "internal")
+   */
+  static chain_code_table(): any;
   /**
    * Check if a network supports a given fixed-script wallet script type
    *
@@ -553,6 +662,28 @@ export class WasmDimensions {
    * Whether any inputs are segwit (affects overhead calculation)
    */
   has_segwit(): boolean;
+  /**
+   * Get input virtual size (min or max)
+   *
+   * # Arguments
+   * * `size` - "min" or "max", defaults to "max"
+   */
+  get_input_vsize(size?: string | null): number;
+  /**
+   * Get input weight only (min or max)
+   *
+   * # Arguments
+   * * `size` - "min" or "max", defaults to "max"
+   */
+  get_input_weight(size?: string | null): number;
+  /**
+   * Get output virtual size
+   */
+  get_output_vsize(): number;
+  /**
+   * Get output weight
+   */
+  get_output_weight(): number;
   /**
    * Create dimensions for a single output from script bytes
    */
@@ -573,6 +704,10 @@ export class WasmDimensions {
    * Create empty dimensions (zero weight)
    */
   static empty(): WasmDimensions;
+  /**
+   * Multiply dimensions by a scalar
+   */
+  times(n: number): WasmDimensions;
   /**
    * Create dimensions from a BitGoPsbt
    *

package/dist/cjs/js/wasm/wasm_utxo.js

@@ -29,6 +29,21 @@ function dropObject(idx) {
     heap_next = idx;
 }
 
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(takeObject(mem.getUint32(i, true)));
+    }
+    return result;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -47,6 +62,14 @@ function getStringFromWasm0(ptr, len) {
     return decodeText(ptr, len);
 }
 
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -161,6 +184,10 @@ const AddressNamespaceFinalization = (typeof FinalizationRegistry === 'undefined
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_addressnamespace_free(ptr >>> 0, 1));
 
+const Bip322NamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bip322namespace_free(ptr >>> 0, 1));
+
 const BitGoPsbtFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_bitgopsbt_free(ptr >>> 0, 1));
@@ -295,6 +322,278 @@ class AddressNamespace {
 if (Symbol.dispose) AddressNamespace.prototype[Symbol.dispose] = AddressNamespace.prototype.free;
 exports.AddressNamespace = AddressNamespace;
 
+/**
+ * Namespace for BIP-0322 functions
+ */
+class Bip322Namespace {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Bip322NamespaceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bip322namespace_free(ptr, 0);
+    }
+    /**
+     * Add a BIP-0322 message input to an existing BitGoPsbt
+     *
+     * If this is the first input, also adds the OP_RETURN output.
+     * The PSBT must have version 0 per BIP-0322 specification.
+     *
+     * # Arguments
+     * * `psbt` - The BitGoPsbt to add the input to
+     * * `message` - The message to sign
+     * * `chain` - The wallet chain (e.g., 10 for external, 20 for internal)
+     * * `index` - The address index
+     * * `wallet_keys` - The wallet's root keys
+     * * `signer` - Optional signer key name for taproot (e.g., "user", "backup", "bitgo")
+     * * `cosigner` - Optional cosigner key name for taproot
+     * * `tag` - Optional custom tag for message hashing
+     *
+     * # Returns
+     * The index of the added input
+     * @param {BitGoPsbt} psbt
+     * @param {string} message
+     * @param {number} chain
+     * @param {number} index
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @param {string | null} [signer]
+     * @param {string | null} [cosigner]
+     * @param {string | null} [tag]
+     * @returns {number}
+     */
+    static add_bip322_input(psbt, message, chain, index, wallet_keys, signer, cosigner, tag) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(psbt, BitGoPsbt);
+            const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            _assertClass(wallet_keys, WasmRootWalletKeys);
+            var ptr1 = isLikeNone(signer) ? 0 : passStringToWasm0(signer, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(cosigner) ? 0 : passStringToWasm0(cosigner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len2 = WASM_VECTOR_LEN;
+            var ptr3 = isLikeNone(tag) ? 0 : passStringToWasm0(tag, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len3 = WASM_VECTOR_LEN;
+            wasm.bip322namespace_add_bip322_input(retptr, psbt.__wbg_ptr, ptr0, len0, chain, index, wallet_keys.__wbg_ptr, ptr1, len1, ptr2, len2, ptr3, len3);
+            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);
+        }
+    }
+    /**
+     * Verify a single input of a BIP-0322 transaction proof
+     *
+     * # Arguments
+     * * `tx` - The signed transaction
+     * * `input_index` - The index of the input to verify
+     * * `message` - The message that was signed
+     * * `chain` - The wallet chain
+     * * `index` - The address index
+     * * `wallet_keys` - The wallet's root keys
+     * * `network` - Network name
+     * * `tag` - Optional custom tag for message hashing
+     *
+     * # Throws
+     * Throws an error if verification fails
+     * @param {WasmTransaction} tx
+     * @param {number} input_index
+     * @param {string} message
+     * @param {number} chain
+     * @param {number} index
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @param {string} network
+     * @param {string | null} [tag]
+     */
+    static verify_bip322_tx_input(tx, input_index, message, chain, index, wallet_keys, network, tag) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(tx, WasmTransaction);
+            const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            _assertClass(wallet_keys, WasmRootWalletKeys);
+            const ptr1 = passStringToWasm0(network, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(tag) ? 0 : passStringToWasm0(tag, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len2 = WASM_VECTOR_LEN;
+            wasm.bip322namespace_verify_bip322_tx_input(retptr, tx.__wbg_ptr, input_index, ptr0, len0, chain, index, wallet_keys.__wbg_ptr, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Verify a single input of a BIP-0322 PSBT proof
+     *
+     * # Arguments
+     * * `psbt` - The signed BitGoPsbt
+     * * `input_index` - The index of the input to verify
+     * * `message` - The message that was signed
+     * * `chain` - The wallet chain
+     * * `index` - The address index
+     * * `wallet_keys` - The wallet's root keys
+     * * `tag` - Optional custom tag for message hashing
+     *
+     * # Returns
+     * An array of signer names ("user", "backup", "bitgo") that have valid signatures
+     *
+     * # Throws
+     * Throws an error if verification fails or no valid signatures found
+     * @param {BitGoPsbt} psbt
+     * @param {number} input_index
+     * @param {string} message
+     * @param {number} chain
+     * @param {number} index
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @param {string | null} [tag]
+     * @returns {string[]}
+     */
+    static verify_bip322_psbt_input(psbt, input_index, message, chain, index, wallet_keys, tag) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(psbt, BitGoPsbt);
+            const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            _assertClass(wallet_keys, WasmRootWalletKeys);
+            var ptr1 = isLikeNone(tag) ? 0 : passStringToWasm0(tag, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.bip322namespace_verify_bip322_psbt_input(retptr, psbt.__wbg_ptr, input_index, ptr0, len0, chain, index, wallet_keys.__wbg_ptr, 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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v3 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v3;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Verify a single input of a BIP-0322 transaction proof using pubkeys directly
+     *
+     * # Arguments
+     * * `tx` - The signed transaction
+     * * `input_index` - The index of the input to verify
+     * * `message` - The message that was signed
+     * * `pubkeys` - Array of 3 hex-encoded pubkeys [user, backup, bitgo]
+     * * `script_type` - One of: "p2sh", "p2shP2wsh", "p2wsh", "p2tr", "p2trMusig2"
+     * * `is_script_path` - For taproot types, whether script path was used
+     * * `tag` - Optional custom tag for message hashing
+     *
+     * # Returns
+     * An array of pubkey indices (0, 1, 2) that have valid signatures
+     *
+     * # Throws
+     * Throws an error if verification fails
+     * @param {WasmTransaction} tx
+     * @param {number} input_index
+     * @param {string} message
+     * @param {string[]} pubkeys
+     * @param {string} script_type
+     * @param {boolean | null} [is_script_path]
+     * @param {string | null} [tag]
+     * @returns {Uint32Array}
+     */
+    static verify_bip322_tx_input_with_pubkeys(tx, input_index, message, pubkeys, script_type, is_script_path, tag) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(tx, WasmTransaction);
+            const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayJsValueToWasm0(pubkeys, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(script_type, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len2 = WASM_VECTOR_LEN;
+            var ptr3 = isLikeNone(tag) ? 0 : passStringToWasm0(tag, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len3 = WASM_VECTOR_LEN;
+            wasm.bip322namespace_verify_bip322_tx_input_with_pubkeys(retptr, tx.__wbg_ptr, input_index, ptr0, len0, ptr1, len1, ptr2, len2, isLikeNone(is_script_path) ? 0xFFFFFF : is_script_path ? 1 : 0, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v5 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v5;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Verify a single input of a BIP-0322 PSBT proof using pubkeys directly
+     *
+     * # Arguments
+     * * `psbt` - The signed BitGoPsbt
+     * * `input_index` - The index of the input to verify
+     * * `message` - The message that was signed
+     * * `pubkeys` - Array of 3 hex-encoded pubkeys [user, backup, bitgo]
+     * * `script_type` - One of: "p2sh", "p2shP2wsh", "p2wsh", "p2tr", "p2trMusig2"
+     * * `is_script_path` - For taproot types, whether script path was used
+     * * `tag` - Optional custom tag for message hashing
+     *
+     * # Returns
+     * An array of pubkey indices (0, 1, 2) that have valid signatures
+     *
+     * # Throws
+     * Throws an error if verification fails or no valid signatures found
+     * @param {BitGoPsbt} psbt
+     * @param {number} input_index
+     * @param {string} message
+     * @param {string[]} pubkeys
+     * @param {string} script_type
+     * @param {boolean | null} [is_script_path]
+     * @param {string | null} [tag]
+     * @returns {Uint32Array}
+     */
+    static verify_bip322_psbt_input_with_pubkeys(psbt, input_index, message, pubkeys, script_type, is_script_path, tag) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(psbt, BitGoPsbt);
+            const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayJsValueToWasm0(pubkeys, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(script_type, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len2 = WASM_VECTOR_LEN;
+            var ptr3 = isLikeNone(tag) ? 0 : passStringToWasm0(tag, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len3 = WASM_VECTOR_LEN;
+            wasm.bip322namespace_verify_bip322_psbt_input_with_pubkeys(retptr, psbt.__wbg_ptr, input_index, ptr0, len0, ptr1, len1, ptr2, len2, isLikeNone(is_script_path) ? 0xFFFFFF : is_script_path ? 1 : 0, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v5 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v5;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) Bip322Namespace.prototype[Symbol.dispose] = Bip322Namespace.prototype.free;
+exports.Bip322Namespace = Bip322Namespace;
+
 class BitGoPsbt {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -1220,6 +1519,19 @@ class FixedScriptWalletNamespace {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Get all chain code metadata for building TypeScript lookup tables
+     *
+     * Returns an array of [chainCode, scriptType, scope] tuples where:
+     * - chainCode: u32 (0, 1, 10, 11, 20, 21, 30, 31, 40, 41)
+     * - scriptType: string ("p2sh", "p2shP2wsh", "p2wsh", "p2trLegacy", "p2trMusig2")
+     * - scope: string ("external" or "internal")
+     * @returns {any}
+     */
+    static chain_code_table() {
+        const ret = wasm.fixedscriptwalletnamespace_chain_code_table();
+        return takeObject(ret);
+    }
     /**
      * Check if a network supports a given fixed-script wallet script type
      *
@@ -1883,6 +2195,50 @@ class WasmDimensions {
         const ret = wasm.wasmdimensions_has_segwit(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Get input virtual size (min or max)
+     *
+     * # Arguments
+     * * `size` - "min" or "max", defaults to "max"
+     * @param {string | null} [size]
+     * @returns {number}
+     */
+    get_input_vsize(size) {
+        var ptr0 = isLikeNone(size) ? 0 : passStringToWasm0(size, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmdimensions_get_input_vsize(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * Get input weight only (min or max)
+     *
+     * # Arguments
+     * * `size` - "min" or "max", defaults to "max"
+     * @param {string | null} [size]
+     * @returns {number}
+     */
+    get_input_weight(size) {
+        var ptr0 = isLikeNone(size) ? 0 : passStringToWasm0(size, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmdimensions_get_input_weight(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * Get output virtual size
+     * @returns {number}
+     */
+    get_output_vsize() {
+        const ret = wasm.wasmdimensions_get_output_vsize(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get output weight
+     * @returns {number}
+     */
+    get_output_weight() {
+        const ret = wasm.wasmdimensions_get_output_weight(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Create dimensions for a single output from script bytes
      * @param {Uint8Array} script
@@ -1938,6 +2294,15 @@ class WasmDimensions {
         const ret = wasm.wasmdimensions_empty();
         return WasmDimensions.__wrap(ret);
     }
+    /**
+     * Multiply dimensions by a scalar
+     * @param {number} n
+     * @returns {WasmDimensions}
+     */
+    times(n) {
+        const ret = wasm.wasmdimensions_times(this.__wbg_ptr, n);
+        return WasmDimensions.__wrap(ret);
+    }
     /**
      * Create dimensions from a BitGoPsbt
      *