@bitgo/wasm-utxo 1.18.0 → 1.19.0

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

@@ -181,6 +181,10 @@ const WasmDashTransactionFinalization = (typeof FinalizationRegistry === 'undefi
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmdashtransaction_free(ptr >>> 0, 1));
 
+const WasmDimensionsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmdimensions_free(ptr >>> 0, 1));
+
 const WasmECPairFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmecpair_free(ptr >>> 0, 1));
@@ -1735,6 +1739,181 @@ class WasmDashTransaction {
 if (Symbol.dispose) WasmDashTransaction.prototype[Symbol.dispose] = WasmDashTransaction.prototype.free;
 exports.WasmDashTransaction = WasmDashTransaction;
 
+/**
+ * Dimensions for estimating transaction virtual size.
+ *
+ * Tracks weight internally with min/max bounds to handle ECDSA signature variance.
+ * Schnorr signatures have no variance (always 64 bytes).
+ */
+class WasmDimensions {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmDimensions.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmDimensionsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmDimensionsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmdimensions_free(ptr, 0);
+    }
+    /**
+     * Create dimensions for a single input from chain code
+     *
+     * # Arguments
+     * * `chain` - Chain code (0/1=p2sh, 10/11=p2shP2wsh, 20/21=p2wsh, 30/31=p2tr, 40/41=p2trMusig2)
+     * * `signer` - Optional signer key ("user", "backup", "bitgo")
+     * * `cosigner` - Optional cosigner key ("user", "backup", "bitgo")
+     * @param {number} chain
+     * @param {string | null} [signer]
+     * @param {string | null} [cosigner]
+     * @returns {WasmDimensions}
+     */
+    static from_input(chain, signer, cosigner) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            var ptr0 = isLikeNone(signer) ? 0 : passStringToWasm0(signer, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(cosigner) ? 0 : passStringToWasm0(cosigner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.wasmdimensions_from_input(retptr, chain, 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 WasmDimensions.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get total weight (min or max)
+     *
+     * # Arguments
+     * * `size` - "min" or "max", defaults to "max"
+     * @param {string | null} [size]
+     * @returns {number}
+     */
+    get_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_weight(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * Whether any inputs are segwit (affects overhead calculation)
+     * @returns {boolean}
+     */
+    has_segwit() {
+        const ret = wasm.wasmdimensions_has_segwit(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Create dimensions for a single output from script bytes
+     * @param {Uint8Array} script
+     * @returns {WasmDimensions}
+     */
+    static from_output_script(script) {
+        const ptr0 = passArray8ToWasm0(script, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmdimensions_from_output_script(ptr0, len0);
+        return WasmDimensions.__wrap(ret);
+    }
+    /**
+     * Create dimensions for a single input from script type string
+     *
+     * # Arguments
+     * * `script_type` - One of: "p2sh", "p2shP2wsh", "p2wsh", "p2trLegacy",
+     *                   "p2trMusig2KeyPath", "p2trMusig2ScriptPath", "p2shP2pk"
+     * @param {string} script_type
+     * @returns {WasmDimensions}
+     */
+    static from_input_script_type(script_type) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(script_type, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmdimensions_from_input_script_type(retptr, 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 WasmDimensions.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Combine with another Dimensions instance
+     * @param {WasmDimensions} other
+     * @returns {WasmDimensions}
+     */
+    plus(other) {
+        _assertClass(other, WasmDimensions);
+        const ret = wasm.wasmdimensions_plus(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmDimensions.__wrap(ret);
+    }
+    /**
+     * Create empty dimensions (zero weight)
+     * @returns {WasmDimensions}
+     */
+    static empty() {
+        const ret = wasm.wasmdimensions_empty();
+        return WasmDimensions.__wrap(ret);
+    }
+    /**
+     * Create dimensions from a BitGoPsbt
+     *
+     * Parses PSBT inputs and outputs to compute weight bounds without
+     * requiring wallet keys. Input types are detected from BIP32 derivation
+     * paths stored in the PSBT.
+     * @param {BitGoPsbt} psbt
+     * @returns {WasmDimensions}
+     */
+    static from_psbt(psbt) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(psbt, BitGoPsbt);
+            wasm.wasmdimensions_from_psbt(retptr, psbt.__wbg_ptr);
+            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 WasmDimensions.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get virtual size (min or max)
+     *
+     * # Arguments
+     * * `size` - "min" or "max", defaults to "max"
+     * @param {string | null} [size]
+     * @returns {number}
+     */
+    get_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_vsize(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) WasmDimensions.prototype[Symbol.dispose] = WasmDimensions.prototype.free;
+exports.WasmDimensions = WasmDimensions;
+
 /**
  * WASM wrapper for elliptic curve key pairs (always uses compressed keys)
  */
@@ -2258,6 +2437,20 @@ class WasmTransaction {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Get the virtual size of the transaction
+     *
+     * Virtual size is calculated as ceil(weight / 4), where weight accounts
+     * for the segwit discount on witness data.
+     *
+     * # Returns
+     * The virtual size in virtual bytes (vbytes)
+     * @returns {number}
+     */
+    get_vsize() {
+        const ret = wasm.wasmtransaction_get_vsize(this.__wbg_ptr);
+        return ret >>> 0;
+    }
 }
 if (Symbol.dispose) WasmTransaction.prototype[Symbol.dispose] = WasmTransaction.prototype.free;
 exports.WasmTransaction = WasmTransaction;

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

@@ -1,7 +1,26 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_utxolibcompatnamespace_free: (a: number, b: number) => void;
+export const __wbg_wasmdashtransaction_free: (a: number, b: number) => void;
+export const __wbg_wasmreplayprotection_free: (a: number, b: number) => void;
+export const __wbg_wasmtransaction_free: (a: number, b: number) => void;
+export const __wbg_wasmzcashtransaction_free: (a: number, b: number) => void;
 export const __wbg_wrapdescriptor_free: (a: number, b: number) => void;
+export const __wbg_wrapminiscript_free: (a: number, b: number) => void;
+export const __wbg_wrappsbt_free: (a: number, b: number) => void;
+export const utxolibcompatnamespace_from_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const utxolibcompatnamespace_to_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const wasmdashtransaction_from_bytes: (a: number, b: number, c: number) => void;
+export const wasmdashtransaction_to_bytes: (a: number, b: number) => void;
+export const wasmreplayprotection_from_addresses: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wasmreplayprotection_from_output_scripts: (a: number, b: number) => number;
+export const wasmreplayprotection_from_public_keys: (a: number, b: number, c: number) => void;
+export const wasmtransaction_from_bytes: (a: number, b: number, c: number) => void;
+export const wasmtransaction_get_vsize: (a: number) => number;
+export const wasmtransaction_to_bytes: (a: number, b: number) => void;
+export const wasmzcashtransaction_from_bytes: (a: number, b: number, c: number) => void;
+export const wasmzcashtransaction_to_bytes: (a: number, b: number) => void;
 export const wrapdescriptor_atDerivationIndex: (a: number, b: number, c: number) => void;
 export const wrapdescriptor_descType: (a: number, b: number) => void;
 export const wrapdescriptor_encode: (a: number, b: number) => void;
@@ -13,29 +32,27 @@ export const wrapdescriptor_node: (a: number, b: number) => void;
 export const wrapdescriptor_scriptPubkey: (a: number, b: number) => void;
 export const wrapdescriptor_toAsmString: (a: number, b: number) => void;
 export const wrapdescriptor_toString: (a: number, b: number) => void;
-export const __wbg_utxolibcompatnamespace_free: (a: number, b: number) => void;
-export const __wbg_wasmdashtransaction_free: (a: number, b: number) => void;
-export const __wbg_wrapminiscript_free: (a: number, b: number) => void;
-export const utxolibcompatnamespace_from_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-export const utxolibcompatnamespace_to_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-export const wasmdashtransaction_from_bytes: (a: number, b: number, c: number) => void;
-export const wasmdashtransaction_to_bytes: (a: number, b: number) => void;
 export const wrapminiscript_encode: (a: number, b: number) => void;
 export const wrapminiscript_fromBitcoinScript: (a: number, b: number, c: number, d: number, e: number) => void;
 export const wrapminiscript_fromString: (a: number, b: number, c: number, d: number, e: number) => void;
 export const wrapminiscript_node: (a: number, b: number) => void;
 export const wrapminiscript_toAsmString: (a: number, b: number) => void;
 export const wrapminiscript_toString: (a: number, b: number) => void;
+export const wrappsbt_clone: (a: number) => number;
+export const wrappsbt_deserialize: (a: number, b: number, c: number) => void;
+export const wrappsbt_finalize: (a: number, b: number) => void;
+export const wrappsbt_serialize: (a: number, b: number) => void;
+export const wrappsbt_signWithPrv: (a: number, b: number, c: number, d: number) => void;
+export const wrappsbt_signWithXprv: (a: number, b: number, c: number, d: number) => void;
+export const wrappsbt_updateInputWithDescriptor: (a: number, b: number, c: number, d: number) => void;
+export const wrappsbt_updateOutputWithDescriptor: (a: number, b: number, c: number, d: number) => void;
 export const __wbg_addressnamespace_free: (a: number, b: number) => void;
 export const __wbg_bitgopsbt_free: (a: number, b: number) => void;
 export const __wbg_fixedscriptwalletnamespace_free: (a: number, b: number) => void;
 export const __wbg_wasmbip32_free: (a: number, b: number) => void;
+export const __wbg_wasmdimensions_free: (a: number, b: number) => void;
 export const __wbg_wasmecpair_free: (a: number, b: number) => void;
-export const __wbg_wasmreplayprotection_free: (a: number, b: number) => void;
 export const __wbg_wasmrootwalletkeys_free: (a: number, b: number) => void;
-export const __wbg_wasmtransaction_free: (a: number, b: number) => void;
-export const __wbg_wasmzcashtransaction_free: (a: number, b: number) => void;
-export const __wbg_wrappsbt_free: (a: number, b: number) => void;
 export const addressnamespace_from_output_script_with_coin: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const addressnamespace_to_output_script_with_coin: (a: number, b: number, c: number, d: number, e: number) => void;
 export const bitgopsbt_add_input: (a: number, b: number, c: number, d: number, e: number, f: bigint, g: number, h: number, i: number, j: number, k: number) => void;
@@ -88,6 +105,15 @@ export const wasmbip32_private_key: (a: number) => number;
 export const wasmbip32_public_key: (a: number) => number;
 export const wasmbip32_to_base58: (a: number, b: number) => void;
 export const wasmbip32_to_wif: (a: number, b: number) => void;
+export const wasmdimensions_empty: () => number;
+export const wasmdimensions_from_input: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const wasmdimensions_from_input_script_type: (a: number, b: number, c: number) => void;
+export const wasmdimensions_from_output_script: (a: number, b: number) => number;
+export const wasmdimensions_from_psbt: (a: number, b: number) => void;
+export const wasmdimensions_get_vsize: (a: number, b: number, c: number) => number;
+export const wasmdimensions_get_weight: (a: number, b: number, c: number) => number;
+export const wasmdimensions_has_segwit: (a: number) => number;
+export const wasmdimensions_plus: (a: number, b: number) => number;
 export const wasmecpair_from_private_key: (a: number, b: number, c: number) => void;
 export const wasmecpair_from_public_key: (a: number, b: number, c: number) => void;
 export const wasmecpair_from_wif: (a: number, b: number, c: number) => void;
@@ -98,26 +124,11 @@ export const wasmecpair_public_key: (a: number) => number;
 export const wasmecpair_to_wif: (a: number, b: number) => void;
 export const wasmecpair_to_wif_mainnet: (a: number, b: number) => void;
 export const wasmecpair_to_wif_testnet: (a: number, b: number) => void;
-export const wasmreplayprotection_from_addresses: (a: number, b: number, c: number, d: number, e: number) => void;
-export const wasmreplayprotection_from_output_scripts: (a: number, b: number) => number;
-export const wasmreplayprotection_from_public_keys: (a: number, b: number, c: number) => void;
 export const wasmrootwalletkeys_backup_key: (a: number) => number;
 export const wasmrootwalletkeys_bitgo_key: (a: number) => number;
 export const wasmrootwalletkeys_new: (a: number, b: number, c: number, d: number) => void;
 export const wasmrootwalletkeys_user_key: (a: number) => number;
 export const wasmrootwalletkeys_with_derivation_prefixes: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
-export const wasmtransaction_from_bytes: (a: number, b: number, c: number) => void;
-export const wasmtransaction_to_bytes: (a: number, b: number) => void;
-export const wasmzcashtransaction_from_bytes: (a: number, b: number, c: number) => void;
-export const wasmzcashtransaction_to_bytes: (a: number, b: number) => void;
-export const wrappsbt_clone: (a: number) => number;
-export const wrappsbt_deserialize: (a: number, b: number, c: number) => void;
-export const wrappsbt_finalize: (a: number, b: number) => void;
-export const wrappsbt_serialize: (a: number, b: number) => void;
-export const wrappsbt_signWithPrv: (a: number, b: number, c: number, d: number) => void;
-export const wrappsbt_signWithXprv: (a: number, b: number, c: number, d: number) => void;
-export const wrappsbt_updateInputWithDescriptor: (a: number, b: number, c: number, d: number) => void;
-export const wrappsbt_updateOutputWithDescriptor: (a: number, b: number, c: number, d: number) => void;
 export const wasmbip32_from_bip32_properties: (a: number, b: number) => void;
 export const rustsecp256k1_v0_10_0_context_create: (a: number) => number;
 export const rustsecp256k1_v0_10_0_context_destroy: (a: number) => void;

package/dist/esm/js/fixedScriptWallet/BitGoPsbt.d.ts

@@ -86,8 +86,13 @@ export type AddWalletOutputOptions = {
     value: bigint;
 };
 export declare class BitGoPsbt {
-    protected wasm: WasmBitGoPsbt;
-    protected constructor(wasm: WasmBitGoPsbt);
+    protected _wasm: WasmBitGoPsbt;
+    protected constructor(_wasm: WasmBitGoPsbt);
+    /**
+     * Get the underlying WASM instance
+     * @internal - for use by other wasm-utxo modules
+     */
+    get wasm(): WasmBitGoPsbt;
     /**
      * Create an empty PSBT for the given network with wallet keys
      *

package/dist/esm/js/fixedScriptWallet/BitGoPsbt.js

@@ -4,9 +4,16 @@ import { ReplayProtection } from "./ReplayProtection.js";
 import { BIP32 } from "../bip32.js";
 import { ECPair } from "../ecpair.js";
 export class BitGoPsbt {
-    wasm;
-    constructor(wasm) {
-        this.wasm = wasm;
+    _wasm;
+    constructor(_wasm) {
+        this._wasm = _wasm;
+    }
+    /**
+     * Get the underlying WASM instance
+     * @internal - for use by other wasm-utxo modules
+     */
+    get wasm() {
+        return this._wasm;
     }
     /**
      * Create an empty PSBT for the given network with wallet keys
@@ -32,8 +39,8 @@ export class BitGoPsbt {
      */
     static createEmpty(network, walletKeys, options) {
         const keys = RootWalletKeys.from(walletKeys);
-        const wasm = WasmBitGoPsbt.create_empty(network, keys.wasm, options?.version, options?.lockTime);
-        return new BitGoPsbt(wasm);
+        const wasmPsbt = WasmBitGoPsbt.create_empty(network, keys.wasm, options?.version, options?.lockTime);
+        return new BitGoPsbt(wasmPsbt);
     }
     /**
      * Deserialize a PSBT from bytes
@@ -65,7 +72,7 @@ export class BitGoPsbt {
      * ```
      */
     addInput(options, script) {
-        return this.wasm.add_input(options.txid, options.vout, options.value, script, options.sequence, options.prevTx);
+        return this._wasm.add_input(options.txid, options.vout, options.value, script, options.sequence, options.prevTx);
     }
     /**
      * Add an output to the PSBT
@@ -82,7 +89,7 @@ export class BitGoPsbt {
      * ```
      */
     addOutput(options) {
-        return this.wasm.add_output(options.script, options.value);
+        return this._wasm.add_output(options.script, options.value);
     }
     /**
      * Add a wallet input with full PSBT metadata
@@ -125,7 +132,7 @@ export class BitGoPsbt {
      */
     addWalletInput(inputOptions, walletKeys, walletOptions) {
         const keys = RootWalletKeys.from(walletKeys);
-        return this.wasm.add_wallet_input(inputOptions.txid, inputOptions.vout, inputOptions.value, keys.wasm, walletOptions.scriptId.chain, walletOptions.scriptId.index, walletOptions.signPath?.signer, walletOptions.signPath?.cosigner, inputOptions.sequence, inputOptions.prevTx);
+        return this._wasm.add_wallet_input(inputOptions.txid, inputOptions.vout, inputOptions.value, keys.wasm, walletOptions.scriptId.chain, walletOptions.scriptId.index, walletOptions.signPath?.signer, walletOptions.signPath?.cosigner, inputOptions.sequence, inputOptions.prevTx);
     }
     /**
      * Add a wallet output with full PSBT metadata
@@ -159,7 +166,7 @@ export class BitGoPsbt {
      */
     addWalletOutput(walletKeys, options) {
         const keys = RootWalletKeys.from(walletKeys);
-        return this.wasm.add_wallet_output(options.chain, options.index, options.value, keys.wasm);
+        return this._wasm.add_wallet_output(options.chain, options.index, options.value, keys.wasm);
     }
     /**
      * Add a replay protection input to the PSBT
@@ -182,28 +189,28 @@ export class BitGoPsbt {
      */
     addReplayProtectionInput(inputOptions, key) {
         const ecpair = ECPair.from(key);
-        return this.wasm.add_replay_protection_input(ecpair.wasm, inputOptions.txid, inputOptions.vout, inputOptions.value, inputOptions.sequence);
+        return this._wasm.add_replay_protection_input(ecpair.wasm, inputOptions.txid, inputOptions.vout, inputOptions.value, inputOptions.sequence);
     }
     /**
      * Get the unsigned transaction ID
      * @returns The unsigned transaction ID
      */
     unsignedTxid() {
-        return this.wasm.unsigned_txid();
+        return this._wasm.unsigned_txid();
     }
     /**
      * Get the transaction version
      * @returns The transaction version number
      */
     get version() {
-        return this.wasm.version();
+        return this._wasm.version();
     }
     /**
      * Get the transaction lock time
      * @returns The transaction lock time
      */
     get lockTime() {
-        return this.wasm.lock_time();
+        return this._wasm.lock_time();
     }
     /**
      * Parse transaction with wallet keys to identify wallet inputs/outputs
@@ -214,9 +221,9 @@ export class BitGoPsbt {
      */
     parseTransactionWithWalletKeys(walletKeys, replayProtection, payGoPubkeys) {
         const keys = RootWalletKeys.from(walletKeys);
-        const rp = ReplayProtection.from(replayProtection, this.wasm.network());
+        const rp = ReplayProtection.from(replayProtection, this._wasm.network());
         const pubkeys = payGoPubkeys?.map((arg) => ECPair.from(arg).wasm);
-        return this.wasm.parse_transaction_with_wallet_keys(keys.wasm, rp.wasm, pubkeys);
+        return this._wasm.parse_transaction_with_wallet_keys(keys.wasm, rp.wasm, pubkeys);
     }
     /**
      * Parse outputs with wallet keys to identify which outputs belong to a wallet
@@ -233,7 +240,7 @@ export class BitGoPsbt {
     parseOutputsWithWalletKeys(walletKeys, payGoPubkeys) {
         const keys = RootWalletKeys.from(walletKeys);
         const pubkeys = payGoPubkeys?.map((arg) => ECPair.from(arg).wasm);
-        return this.wasm.parse_outputs_with_wallet_keys(keys.wasm, pubkeys);
+        return this._wasm.parse_outputs_with_wallet_keys(keys.wasm, pubkeys);
     }
     /**
      * Add a PayGo attestation to a PSBT output
@@ -247,7 +254,7 @@ export class BitGoPsbt {
      * @throws Error if output index is out of bounds or entropy is not 64 bytes
      */
     addPayGoAttestation(outputIndex, entropy, signature) {
-        this.wasm.add_paygo_attestation(outputIndex, entropy, signature);
+        this._wasm.add_paygo_attestation(outputIndex, entropy, signature);
     }
     /**
      * Verify if a valid signature exists for a given key at the specified input index.
@@ -288,11 +295,11 @@ export class BitGoPsbt {
         // Try to parse as BIP32Arg first (string or BIP32 instance)
         if (typeof key === "string" || ("derive" in key && typeof key.derive === "function")) {
             const wasmKey = BIP32.from(key).wasm;
-            return this.wasm.verify_signature_with_xpub(inputIndex, wasmKey);
+            return this._wasm.verify_signature_with_xpub(inputIndex, wasmKey);
         }
         // Otherwise it's an ECPairArg (Uint8Array, ECPair, or WasmECPair)
         const wasmECPair = ECPair.from(key).wasm;
-        return this.wasm.verify_signature_with_pub(inputIndex, wasmECPair);
+        return this._wasm.verify_signature_with_pub(inputIndex, wasmECPair);
     }
     /**
      * Sign a single input with a private key
@@ -344,12 +351,12 @@ export class BitGoPsbt {
                 typeof key.derive === "function")) {
             // It's a BIP32Arg
             const wasmKey = BIP32.from(key);
-            this.wasm.sign_with_xpriv(inputIndex, wasmKey.wasm);
+            this._wasm.sign_with_xpriv(inputIndex, wasmKey.wasm);
         }
         else {
             // It's an ECPairArg
             const wasmKey = ECPair.from(key);
-            this.wasm.sign_with_privkey(inputIndex, wasmKey.wasm);
+            this._wasm.sign_with_privkey(inputIndex, wasmKey.wasm);
         }
     }
     /**
@@ -373,8 +380,8 @@ export class BitGoPsbt {
      * @throws Error if the input is not a replay protection input, index is out of bounds, or scripts are invalid
      */
     verifyReplayProtectionSignature(inputIndex, replayProtection) {
-        const rp = ReplayProtection.from(replayProtection, this.wasm.network());
-        return this.wasm.verify_replay_protection_signature(inputIndex, rp.wasm);
+        const rp = ReplayProtection.from(replayProtection, this._wasm.network());
+        return this._wasm.verify_replay_protection_signature(inputIndex, rp.wasm);
     }
     /**
      * Serialize the PSBT to bytes
@@ -382,7 +389,7 @@ export class BitGoPsbt {
      * @returns The serialized PSBT as a byte array
      */
     serialize() {
-        return this.wasm.serialize();
+        return this._wasm.serialize();
     }
     /**
      * Generate and store MuSig2 nonces for all MuSig2 inputs
@@ -424,7 +431,7 @@ export class BitGoPsbt {
      */
     generateMusig2Nonces(key, sessionId) {
         const wasmKey = BIP32.from(key);
-        this.wasm.generate_musig2_nonces(wasmKey.wasm, sessionId);
+        this._wasm.generate_musig2_nonces(wasmKey.wasm, sessionId);
     }
     /**
      * Combine/merge data from another PSBT into this one
@@ -446,7 +453,7 @@ export class BitGoPsbt {
      * ```
      */
     combineMusig2Nonces(sourcePsbt) {
-        this.wasm.combine_musig2_nonces(sourcePsbt.wasm);
+        this._wasm.combine_musig2_nonces(sourcePsbt.wasm);
     }
     /**
      * Finalize all inputs in the PSBT
@@ -454,7 +461,7 @@ export class BitGoPsbt {
      * @throws Error if any input failed to finalize
      */
     finalizeAllInputs() {
-        this.wasm.finalize_all_inputs();
+        this._wasm.finalize_all_inputs();
     }
     /**
      * Extract the final transaction from a finalized PSBT
@@ -463,6 +470,6 @@ export class BitGoPsbt {
      * @throws Error if the PSBT is not fully finalized or extraction fails
      */
     extractTransaction() {
-        return this.wasm.extract_transaction();
+        return this._wasm.extract_transaction();
     }
 }

package/dist/esm/js/fixedScriptWallet/Dimensions.d.ts

@@ -0,0 +1,65 @@
+import type { BitGoPsbt, InputScriptType, SignPath } from "./BitGoPsbt.js";
+import type { CoinName } from "../coinName.js";
+type FromInputParams = {
+    chain: number;
+    signPath?: SignPath;
+} | {
+    scriptType: InputScriptType;
+};
+/**
+ * Dimensions class for estimating transaction virtual size.
+ *
+ * Tracks weight internally with min/max bounds to handle ECDSA signature variance.
+ * Schnorr signatures have no variance (always 64 bytes).
+ *
+ * This is a thin wrapper over the WASM implementation.
+ */
+export declare class Dimensions {
+    private _wasm;
+    private constructor();
+    /**
+     * Create empty dimensions (zero weight)
+     */
+    static empty(): Dimensions;
+    /**
+     * Create dimensions from a BitGoPsbt
+     *
+     * Parses PSBT inputs and outputs to compute weight bounds without
+     * requiring wallet keys. Input types are detected from BIP32 derivation
+     * paths stored in the PSBT.
+     */
+    static fromPsbt(psbt: BitGoPsbt): Dimensions;
+    /**
+     * Create dimensions for a single input
+     *
+     * @param params - Either `{ chain, signPath? }` or `{ scriptType }`
+     */
+    static fromInput(params: FromInputParams): Dimensions;
+    /**
+     * Create dimensions for a single output from script bytes
+     */
+    static fromOutput(script: Uint8Array): Dimensions;
+    /**
+     * Create dimensions for a single output from an address
+     */
+    static fromOutput(address: string, network: CoinName): Dimensions;
+    /**
+     * Combine with another Dimensions instance
+     */
+    plus(other: Dimensions): Dimensions;
+    /**
+     * Whether any inputs are segwit (affects overhead calculation)
+     */
+    get hasSegwit(): boolean;
+    /**
+     * Get total weight (min or max)
+     * @param size - "min" or "max", defaults to "max"
+     */
+    getWeight(size?: "min" | "max"): number;
+    /**
+     * Get virtual size (min or max)
+     * @param size - "min" or "max", defaults to "max"
+     */
+    getVSize(size?: "min" | "max"): number;
+}
+export {};