@bitgo/wasm-utxo 1.18.0 → 1.20.0

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,24 +72,26 @@ 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
-     *
-     * @param options - Output options (script, value)
-     * @returns The index of the newly added output
-     *
-     * @example
-     * ```typescript
-     * const outputIndex = psbt.addOutput({
-     *   script: outputScript,
-     *   value: 50000n,
-     * });
-     * ```
-     */
-    addOutput(options) {
-        return this.wasm.add_output(options.script, options.value);
+    addOutput(scriptOrOptions, value) {
+        if (scriptOrOptions instanceof Uint8Array || typeof scriptOrOptions === "string") {
+            if (value === undefined) {
+                throw new Error("Value is required when passing a script or address");
+            }
+            if (scriptOrOptions instanceof Uint8Array) {
+                return this._wasm.add_output(scriptOrOptions, value);
+            }
+            return this._wasm.add_output_with_address(scriptOrOptions, value);
+        }
+        const options = scriptOrOptions;
+        if ("script" in options) {
+            return this._wasm.add_output(options.script, options.value);
+        }
+        if ("address" in options) {
+            return this._wasm.add_output_with_address(options.address, options.value);
+        }
+        throw new Error("Invalid output options");
     }
     /**
      * Add a wallet input with full PSBT metadata
@@ -125,7 +134,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 +168,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 +191,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 +223,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 +242,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 +256,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 +297,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 +353,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 +382,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 +391,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 +433,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 +455,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 +463,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 +472,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 {};

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

@@ -225,6 +225,17 @@ export class BitGoPsbt {
    * generated for security. Custom session_id is only allowed on testnets for testing purposes.
    */
   generate_musig2_nonces(xpriv: WasmBIP32, session_id_bytes?: Uint8Array | null): void;
+  /**
+   * Add an output to the PSBT by address
+   *
+   * # Arguments
+   * * `address` - The destination address
+   * * `value` - The value in satoshis
+   *
+   * # Returns
+   * The index of the newly added output
+   */
+  add_output_with_address(address: string, value: bigint): number;
   /**
    * Verify if a valid signature exists for a given ECPair key at the specified input index
    *
@@ -502,6 +513,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 +701,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 {