@bitgo/wasm-utxo 1.18.0 → 1.19.0

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

@@ -0,0 +1,79 @@
+import { WasmDimensions } from "../wasm/wasm_utxo.js";
+import { toOutputScriptWithCoin } from "../address.js";
+/**
+ * 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 class Dimensions {
+    _wasm;
+    constructor(_wasm) {
+        this._wasm = _wasm;
+    }
+    /**
+     * Create empty dimensions (zero weight)
+     */
+    static empty() {
+        return new Dimensions(WasmDimensions.empty());
+    }
+    /**
+     * 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) {
+        return new Dimensions(WasmDimensions.from_psbt(psbt.wasm));
+    }
+    /**
+     * Create dimensions for a single input
+     *
+     * @param params - Either `{ chain, signPath? }` or `{ scriptType }`
+     */
+    static fromInput(params) {
+        if ("scriptType" in params) {
+            return new Dimensions(WasmDimensions.from_input_script_type(params.scriptType));
+        }
+        return new Dimensions(WasmDimensions.from_input(params.chain, params.signPath?.signer, params.signPath?.cosigner));
+    }
+    static fromOutput(scriptOrAddress, network) {
+        if (typeof scriptOrAddress === "string") {
+            if (network === undefined) {
+                throw new Error("network is required when passing an address string");
+            }
+            const script = toOutputScriptWithCoin(scriptOrAddress, network);
+            return new Dimensions(WasmDimensions.from_output_script(script));
+        }
+        return new Dimensions(WasmDimensions.from_output_script(scriptOrAddress));
+    }
+    /**
+     * Combine with another Dimensions instance
+     */
+    plus(other) {
+        return new Dimensions(this._wasm.plus(other._wasm));
+    }
+    /**
+     * Whether any inputs are segwit (affects overhead calculation)
+     */
+    get hasSegwit() {
+        return this._wasm.has_segwit();
+    }
+    /**
+     * Get total weight (min or max)
+     * @param size - "min" or "max", defaults to "max"
+     */
+    getWeight(size = "max") {
+        return this._wasm.get_weight(size);
+    }
+    /**
+     * Get virtual size (min or max)
+     * @param size - "min" or "max", defaults to "max"
+     */
+    getVSize(size = "max") {
+        return this._wasm.get_vsize(size);
+    }
+}

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

@@ -1,5 +1,6 @@
 export { RootWalletKeys, type WalletKeysArg, type IWalletKeys } from "./RootWalletKeys.js";
 export { ReplayProtection, type ReplayProtectionArg } from "./ReplayProtection.js";
 export { outputScript, address } from "./address.js";
+export { Dimensions } from "./Dimensions.js";
 export { BitGoPsbt, type NetworkName, type ScriptId, type InputScriptType, 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";

package/dist/esm/js/fixedScriptWallet/index.js

@@ -1,6 +1,7 @@
 export { RootWalletKeys } from "./RootWalletKeys.js";
 export { ReplayProtection } from "./ReplayProtection.js";
 export { outputScript, address } from "./address.js";
+export { Dimensions } from "./Dimensions.js";
 // Bitcoin-like PSBT (for all non-Zcash networks)
 export { BitGoPsbt, } from "./BitGoPsbt.js";
 // Zcash-specific PSBT subclass

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

@@ -6,6 +6,7 @@ export * as bip32 from "./bip32.js";
 export * as ecpair from "./ecpair.js";
 export { ECPair } from "./ecpair.js";
 export { BIP32 } from "./bip32.js";
+export { Dimensions } from "./fixedScriptWallet/Dimensions.js";
 export type { CoinName } from "./coinName.js";
 export type { Triple } from "./triple.js";
 export type { AddressFormat } from "./address.js";

package/dist/esm/js/index.js

@@ -13,6 +13,7 @@ export * as ecpair from "./ecpair.js";
 // Only the most commonly used classes and types are exported at the top level for convenience
 export { ECPair } from "./ecpair.js";
 export { BIP32 } from "./bip32.js";
+export { Dimensions } from "./fixedScriptWallet/Dimensions.js";
 export { WrapDescriptor as Descriptor } from "./wasm/wasm_utxo.js";
 export { WrapMiniscript as Miniscript } from "./wasm/wasm_utxo.js";
 export { WrapPsbt as Psbt } from "./wasm/wasm_utxo.js";

package/dist/esm/js/transaction.d.ts

@@ -9,6 +9,14 @@ export declare class Transaction {
     private constructor();
     static fromBytes(bytes: Uint8Array): Transaction;
     toBytes(): Uint8Array;
+    /**
+     * Get the virtual size of the transaction
+     *
+     * Virtual size accounts for the segwit discount on witness data.
+     *
+     * @returns The virtual size in virtual bytes (vbytes)
+     */
+    getVSize(): number;
     /**
      * @internal
      */

package/dist/esm/js/transaction.js

@@ -15,6 +15,16 @@ export class Transaction {
     toBytes() {
         return this._wasm.to_bytes();
     }
+    /**
+     * Get the virtual size of the transaction
+     *
+     * Virtual size accounts for the segwit discount on witness data.
+     *
+     * @returns The virtual size in virtual bytes (vbytes)
+     */
+    getVSize() {
+        return this._wasm.get_vsize();
+    }
     /**
      * @internal
      */

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

@@ -502,6 +502,67 @@ export class WasmDashTransaction {
   to_bytes(): Uint8Array;
 }
 
+export class WasmDimensions {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * 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")
+   */
+  static from_input(chain: number, signer?: string | null, cosigner?: string | null): WasmDimensions;
+  /**
+   * Get total weight (min or max)
+   *
+   * # Arguments
+   * * `size` - "min" or "max", defaults to "max"
+   */
+  get_weight(size?: string | null): number;
+  /**
+   * Whether any inputs are segwit (affects overhead calculation)
+   */
+  has_segwit(): boolean;
+  /**
+   * Create dimensions for a single output from script bytes
+   */
+  static from_output_script(script: Uint8Array): WasmDimensions;
+  /**
+   * Create dimensions for a single input from script type string
+   *
+   * # Arguments
+   * * `script_type` - One of: "p2sh", "p2shP2wsh", "p2wsh", "p2trLegacy",
+   *                   "p2trMusig2KeyPath", "p2trMusig2ScriptPath", "p2shP2pk"
+   */
+  static from_input_script_type(script_type: string): WasmDimensions;
+  /**
+   * Combine with another Dimensions instance
+   */
+  plus(other: WasmDimensions): WasmDimensions;
+  /**
+   * Create empty dimensions (zero weight)
+   */
+  static empty(): WasmDimensions;
+  /**
+   * 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 from_psbt(psbt: BitGoPsbt): WasmDimensions;
+  /**
+   * Get virtual size (min or max)
+   *
+   * # Arguments
+   * * `size` - "min" or "max", defaults to "max"
+   */
+  get_vsize(size?: string | null): number;
+}
+
 export class WasmECPair {
   private constructor();
   free(): void;
@@ -629,6 +690,16 @@ export class WasmTransaction {
    * The serialized transaction bytes
    */
   to_bytes(): Uint8Array;
+  /**
+   * 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)
+   */
+  get_vsize(): number;
 }
 
 export class WasmZcashTransaction {

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

@@ -190,6 +190,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));
@@ -1738,6 +1742,180 @@ export class WasmDashTransaction {
 }
 if (Symbol.dispose) WasmDashTransaction.prototype[Symbol.dispose] = WasmDashTransaction.prototype.free;
 
+/**
+ * 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).
+ */
+export 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;
+
 /**
  * WASM wrapper for elliptic curve key pairs (always uses compressed keys)
  */
@@ -2258,6 +2436,20 @@ export 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;
 

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

@@ -1,7 +1,7 @@
 {
   "name": "@bitgo/wasm-utxo",
   "description": "WebAssembly wrapper for rust-bitcoin (beta)",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "type": "module",
   "repository": {
     "type": "git",