@bitgo/wasm-utxo 1.14.1 → 1.16.0

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

@@ -1,4 +1,5 @@
 export { RootWalletKeys, type WalletKeysArg, type IWalletKeys } from "./RootWalletKeys.js";
 export { ReplayProtection, type ReplayProtectionArg } from "./ReplayProtection.js";
 export { outputScript, address } from "./address.js";
-export { BitGoPsbt, type NetworkName, type ScriptId, type InputScriptType, type ParsedInput, type ParsedOutput, type ParsedTransaction, } from "./BitGoPsbt.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/cjs/js/fixedScriptWallet/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BitGoPsbt = exports.address = exports.outputScript = exports.ReplayProtection = exports.RootWalletKeys = void 0;
+exports.ZcashBitGoPsbt = exports.BitGoPsbt = exports.address = exports.outputScript = exports.ReplayProtection = exports.RootWalletKeys = void 0;
 var RootWalletKeys_js_1 = require("./RootWalletKeys.js");
 Object.defineProperty(exports, "RootWalletKeys", { enumerable: true, get: function () { return RootWalletKeys_js_1.RootWalletKeys; } });
 var ReplayProtection_js_1 = require("./ReplayProtection.js");
@@ -8,5 +8,9 @@ Object.defineProperty(exports, "ReplayProtection", { enumerable: true, get: func
 var address_js_1 = require("./address.js");
 Object.defineProperty(exports, "outputScript", { enumerable: true, get: function () { return address_js_1.outputScript; } });
 Object.defineProperty(exports, "address", { enumerable: true, get: function () { return address_js_1.address; } });
+// 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; } });
+// Zcash-specific PSBT subclass
+var ZcashBitGoPsbt_js_1 = require("./ZcashBitGoPsbt.js");
+Object.defineProperty(exports, "ZcashBitGoPsbt", { enumerable: true, get: function () { return ZcashBitGoPsbt_js_1.ZcashBitGoPsbt; } });

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

@@ -13,10 +13,35 @@ export class BitGoPsbt {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Add an output to the PSBT
+   *
+   * # Arguments
+   * * `script` - The output script (scriptPubKey)
+   * * `value` - The value in satoshis
+   *
+   * # Returns
+   * The index of the newly added output
+   */
+  add_output(script: Uint8Array, value: bigint): number;
   /**
    * Deserialize a PSBT from bytes with network-specific logic
    */
   static from_bytes(bytes: Uint8Array, network: string): BitGoPsbt;
+  /**
+   * Create an empty PSBT for the given network with wallet keys
+   *
+   * # Arguments
+   * * `network` - Network name (utxolib or coin name)
+   * * `wallet_keys` - The wallet's root keys (used to set global xpubs)
+   * * `version` - Optional transaction version (default: 2)
+   * * `lock_time` - Optional lock time (default: 0)
+   */
+  static create_empty(network: string, wallet_keys: WasmRootWalletKeys, version?: number | null, lock_time?: number | null): BitGoPsbt;
+  /**
+   * Get the Zcash expiry height (returns None for non-Zcash PSBTs)
+   */
+  expiry_height(): number | undefined;
   /**
    * Get the unsigned transaction ID
    */
@@ -41,6 +66,48 @@ export class BitGoPsbt {
    * - `Err(WasmUtxoError)` if signing fails
    */
   sign_with_xpriv(input_index: number, xpriv: WasmBIP32): void;
+  /**
+   * Add a wallet input with full PSBT metadata
+   *
+   * This is a higher-level method that adds an input and populates all required
+   * PSBT fields (scripts, derivation info, etc.) based on the wallet's chain type.
+   *
+   * # Arguments
+   * * `txid` - The transaction ID (hex string)
+   * * `vout` - The output index being spent
+   * * `value` - The value in satoshis
+   * * `chain` - The chain code (0/1=p2sh, 10/11=p2shP2wsh, 20/21=p2wsh, 30/31=p2tr, 40/41=p2trMusig2)
+   * * `index` - The derivation index
+   * * `wallet_keys` - The root wallet keys
+   * * `signer` - The key that will sign ("user", "backup", or "bitgo") - required for p2tr/p2trMusig2
+   * * `cosigner` - The key that will co-sign - required for p2tr/p2trMusig2
+   * * `sequence` - Optional sequence number (default: 0xFFFFFFFE for RBF)
+   * * `prev_tx` - Optional full previous transaction bytes (for non-segwit)
+   *
+   * # Returns
+   * The index of the newly added input
+   */
+  add_wallet_input(txid: string, vout: number, value: bigint, wallet_keys: WasmRootWalletKeys, chain: number, index: number, signer?: string | null, cosigner?: string | null, sequence?: number | null, prev_tx?: Uint8Array | null): number;
+  /**
+   * Get the Zcash version group ID (returns None for non-Zcash PSBTs)
+   */
+  version_group_id(): number | undefined;
+  /**
+   * Add a wallet output with full PSBT metadata
+   *
+   * This creates a verifiable wallet output (typically for change) with all required
+   * PSBT fields (scripts, derivation info) based on the wallet's chain type.
+   *
+   * # Arguments
+   * * `chain` - The chain code (0/1=p2sh, 10/11=p2shP2wsh, 20/21=p2wsh, 30/31=p2tr, 40/41=p2trMusig2)
+   * * `index` - The derivation index
+   * * `value` - The value in satoshis
+   * * `wallet_keys` - The root wallet keys
+   *
+   * # Returns
+   * The index of the newly added output
+   */
+  add_wallet_output(chain: number, index: number, value: bigint, wallet_keys: WasmRootWalletKeys): number;
   /**
    * Sign a single input with a raw private key
    *
@@ -61,6 +128,22 @@ export class BitGoPsbt {
    * - `Err(WasmUtxoError)` if signing fails
    */
   sign_with_privkey(input_index: number, ecpair: WasmECPair): void;
+  /**
+   * Create an empty Zcash PSBT with the required consensus branch ID
+   *
+   * This method is specifically for Zcash networks which require additional
+   * parameters for sighash computation.
+   *
+   * # Arguments
+   * * `network` - Network name (must be "zcash" or "zcashTest")
+   * * `wallet_keys` - The wallet's root keys (used to set global xpubs)
+   * * `consensus_branch_id` - Zcash consensus branch ID (e.g., 0xC2D6D0B4 for NU5)
+   * * `version` - Optional transaction version (default: 4 for Zcash Sapling+)
+   * * `lock_time` - Optional lock time (default: 0)
+   * * `version_group_id` - Optional version group ID (defaults to Sapling: 0x892F2085)
+   * * `expiry_height` - Optional expiry height
+   */
+  static create_empty_zcash(network: string, wallet_keys: WasmRootWalletKeys, consensus_branch_id: number, version?: number | null, lock_time?: number | null, version_group_id?: number | null, expiry_height?: number | null): BitGoPsbt;
   /**
    * Extract the final transaction from a finalized PSBT
    *
@@ -181,6 +264,42 @@ export class BitGoPsbt {
    * - `Err(WasmUtxoError)` if the input index is out of bounds, derivation fails, or verification fails
    */
   verify_signature_with_xpub(input_index: number, xpub: WasmBIP32): boolean;
+  /**
+   * Add a replay protection input to the PSBT
+   *
+   * Replay protection inputs are P2SH-P2PK inputs used on forked networks to prevent
+   * transaction replay attacks. They use a simple pubkey script without wallet derivation.
+   *
+   * # Arguments
+   * * `ecpair` - The ECPair containing the public key for the replay protection input
+   * * `txid` - The transaction ID (hex string) of the output being spent
+   * * `vout` - The output index being spent
+   * * `value` - The value in satoshis
+   * * `sequence` - Optional sequence number (default: 0xFFFFFFFE for RBF)
+   *
+   * # Returns
+   * The index of the newly added input
+   */
+  add_replay_protection_input(ecpair: WasmECPair, txid: string, vout: number, value: bigint, sequence?: number | null): number;
+  /**
+   * Create an empty Zcash PSBT with consensus branch ID determined from block height
+   *
+   * This method automatically determines the correct consensus branch ID based on
+   * the network and block height using the network upgrade activation heights.
+   *
+   * # Arguments
+   * * `network` - Network name (must be "zcash" or "zcashTest")
+   * * `wallet_keys` - The wallet's root keys (used to set global xpubs)
+   * * `block_height` - Block height to determine consensus rules
+   * * `version` - Optional transaction version (default: 4 for Zcash Sapling+)
+   * * `lock_time` - Optional lock time (default: 0)
+   * * `version_group_id` - Optional version group ID (defaults to Sapling: 0x892F2085)
+   * * `expiry_height` - Optional expiry height
+   *
+   * # Errors
+   * Returns error if block height is before Overwinter activation
+   */
+  static create_empty_zcash_at_height(network: string, wallet_keys: WasmRootWalletKeys, block_height: number, version?: number | null, lock_time?: number | null, version_group_id?: number | null, expiry_height?: number | null): BitGoPsbt;
   /**
    * Parse outputs with wallet keys to identify which outputs belong to a wallet
    *
@@ -213,6 +332,28 @@ export class BitGoPsbt {
    * Get the network of the PSBT
    */
   network(): string;
+  /**
+   * Get the transaction version
+   */
+  version(): number;
+  /**
+   * Add an input to the PSBT
+   *
+   * # Arguments
+   * * `txid` - The transaction ID (hex string) of the output being spent
+   * * `vout` - The output index being spent
+   * * `value` - The value in satoshis of the output being spent
+   * * `script` - The output script (scriptPubKey) of the output being spent
+   * * `sequence` - Optional sequence number (default: 0xFFFFFFFE for RBF)
+   *
+   * # Returns
+   * The index of the newly added input
+   */
+  add_input(txid: string, vout: number, value: bigint, script: Uint8Array, sequence?: number | null, prev_tx?: Uint8Array | null): number;
+  /**
+   * Get the transaction lock time
+   */
+  lock_time(): number;
   /**
    * Serialize the PSBT to bytes
    *

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

@@ -297,6 +297,36 @@ class BitGoPsbt {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_bitgopsbt_free(ptr, 0);
     }
+    /**
+     * Add an output to the PSBT
+     *
+     * # Arguments
+     * * `script` - The output script (scriptPubKey)
+     * * `value` - The value in satoshis
+     *
+     * # Returns
+     * The index of the newly added output
+     * @param {Uint8Array} script
+     * @param {bigint} value
+     * @returns {number}
+     */
+    add_output(script, value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(script, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.bitgopsbt_add_output(retptr, this.__wbg_ptr, ptr0, len0, value);
+            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);
+        }
+    }
     /**
      * Deserialize a PSBT from bytes with network-specific logic
      * @param {Uint8Array} bytes
@@ -322,6 +352,46 @@ class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Create an empty PSBT for the given network with wallet keys
+     *
+     * # Arguments
+     * * `network` - Network name (utxolib or coin name)
+     * * `wallet_keys` - The wallet's root keys (used to set global xpubs)
+     * * `version` - Optional transaction version (default: 2)
+     * * `lock_time` - Optional lock time (default: 0)
+     * @param {string} network
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @param {number | null} [version]
+     * @param {number | null} [lock_time]
+     * @returns {BitGoPsbt}
+     */
+    static create_empty(network, wallet_keys, version, lock_time) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(network, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            _assertClass(wallet_keys, WasmRootWalletKeys);
+            wasm.bitgopsbt_create_empty(retptr, ptr0, len0, wallet_keys.__wbg_ptr, isLikeNone(version) ? 0x100000001 : (version) >> 0, isLikeNone(lock_time) ? 0x100000001 : (lock_time) >>> 0);
+            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 BitGoPsbt.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the Zcash expiry height (returns None for non-Zcash PSBTs)
+     * @returns {number | undefined}
+     */
+    expiry_height() {
+        const ret = wasm.bitgopsbt_expiry_height(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
     /**
      * Get the unsigned transaction ID
      * @returns {string}
@@ -377,6 +447,106 @@ class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Add a wallet input with full PSBT metadata
+     *
+     * This is a higher-level method that adds an input and populates all required
+     * PSBT fields (scripts, derivation info, etc.) based on the wallet's chain type.
+     *
+     * # Arguments
+     * * `txid` - The transaction ID (hex string)
+     * * `vout` - The output index being spent
+     * * `value` - The value in satoshis
+     * * `chain` - The chain code (0/1=p2sh, 10/11=p2shP2wsh, 20/21=p2wsh, 30/31=p2tr, 40/41=p2trMusig2)
+     * * `index` - The derivation index
+     * * `wallet_keys` - The root wallet keys
+     * * `signer` - The key that will sign ("user", "backup", or "bitgo") - required for p2tr/p2trMusig2
+     * * `cosigner` - The key that will co-sign - required for p2tr/p2trMusig2
+     * * `sequence` - Optional sequence number (default: 0xFFFFFFFE for RBF)
+     * * `prev_tx` - Optional full previous transaction bytes (for non-segwit)
+     *
+     * # Returns
+     * The index of the newly added input
+     * @param {string} txid
+     * @param {number} vout
+     * @param {bigint} value
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @param {number} chain
+     * @param {number} index
+     * @param {string | null} [signer]
+     * @param {string | null} [cosigner]
+     * @param {number | null} [sequence]
+     * @param {Uint8Array | null} [prev_tx]
+     * @returns {number}
+     */
+    add_wallet_input(txid, vout, value, wallet_keys, chain, index, signer, cosigner, sequence, prev_tx) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(txid, 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(prev_tx) ? 0 : passArray8ToWasm0(prev_tx, wasm.__wbindgen_export);
+            var len3 = WASM_VECTOR_LEN;
+            wasm.bitgopsbt_add_wallet_input(retptr, this.__wbg_ptr, ptr0, len0, vout, value, wallet_keys.__wbg_ptr, chain, index, ptr1, len1, ptr2, len2, isLikeNone(sequence) ? 0x100000001 : (sequence) >>> 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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return r0 >>> 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the Zcash version group ID (returns None for non-Zcash PSBTs)
+     * @returns {number | undefined}
+     */
+    version_group_id() {
+        const ret = wasm.bitgopsbt_version_group_id(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * Add a wallet output with full PSBT metadata
+     *
+     * This creates a verifiable wallet output (typically for change) with all required
+     * PSBT fields (scripts, derivation info) based on the wallet's chain type.
+     *
+     * # Arguments
+     * * `chain` - The chain code (0/1=p2sh, 10/11=p2shP2wsh, 20/21=p2wsh, 30/31=p2tr, 40/41=p2trMusig2)
+     * * `index` - The derivation index
+     * * `value` - The value in satoshis
+     * * `wallet_keys` - The root wallet keys
+     *
+     * # Returns
+     * The index of the newly added output
+     * @param {number} chain
+     * @param {number} index
+     * @param {bigint} value
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @returns {number}
+     */
+    add_wallet_output(chain, index, value, wallet_keys) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(wallet_keys, WasmRootWalletKeys);
+            wasm.bitgopsbt_add_wallet_output(retptr, this.__wbg_ptr, chain, index, value, wallet_keys.__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 r0 >>> 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Sign a single input with a raw private key
      *
@@ -412,6 +582,47 @@ class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Create an empty Zcash PSBT with the required consensus branch ID
+     *
+     * This method is specifically for Zcash networks which require additional
+     * parameters for sighash computation.
+     *
+     * # Arguments
+     * * `network` - Network name (must be "zcash" or "zcashTest")
+     * * `wallet_keys` - The wallet's root keys (used to set global xpubs)
+     * * `consensus_branch_id` - Zcash consensus branch ID (e.g., 0xC2D6D0B4 for NU5)
+     * * `version` - Optional transaction version (default: 4 for Zcash Sapling+)
+     * * `lock_time` - Optional lock time (default: 0)
+     * * `version_group_id` - Optional version group ID (defaults to Sapling: 0x892F2085)
+     * * `expiry_height` - Optional expiry height
+     * @param {string} network
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @param {number} consensus_branch_id
+     * @param {number | null} [version]
+     * @param {number | null} [lock_time]
+     * @param {number | null} [version_group_id]
+     * @param {number | null} [expiry_height]
+     * @returns {BitGoPsbt}
+     */
+    static create_empty_zcash(network, wallet_keys, consensus_branch_id, version, lock_time, version_group_id, expiry_height) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(network, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            _assertClass(wallet_keys, WasmRootWalletKeys);
+            wasm.bitgopsbt_create_empty_zcash(retptr, ptr0, len0, wallet_keys.__wbg_ptr, consensus_branch_id, isLikeNone(version) ? 0x100000001 : (version) >> 0, isLikeNone(lock_time) ? 0x100000001 : (lock_time) >>> 0, isLikeNone(version_group_id) ? 0x100000001 : (version_group_id) >>> 0, isLikeNone(expiry_height) ? 0x100000001 : (expiry_height) >>> 0);
+            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 BitGoPsbt.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Extract the final transaction from a finalized PSBT
      *
@@ -648,6 +859,90 @@ class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Add a replay protection input to the PSBT
+     *
+     * Replay protection inputs are P2SH-P2PK inputs used on forked networks to prevent
+     * transaction replay attacks. They use a simple pubkey script without wallet derivation.
+     *
+     * # Arguments
+     * * `ecpair` - The ECPair containing the public key for the replay protection input
+     * * `txid` - The transaction ID (hex string) of the output being spent
+     * * `vout` - The output index being spent
+     * * `value` - The value in satoshis
+     * * `sequence` - Optional sequence number (default: 0xFFFFFFFE for RBF)
+     *
+     * # Returns
+     * The index of the newly added input
+     * @param {WasmECPair} ecpair
+     * @param {string} txid
+     * @param {number} vout
+     * @param {bigint} value
+     * @param {number | null} [sequence]
+     * @returns {number}
+     */
+    add_replay_protection_input(ecpair, txid, vout, value, sequence) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(ecpair, WasmECPair);
+            const ptr0 = passStringToWasm0(txid, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.bitgopsbt_add_replay_protection_input(retptr, this.__wbg_ptr, ecpair.__wbg_ptr, ptr0, len0, vout, value, isLikeNone(sequence) ? 0x100000001 : (sequence) >>> 0);
+            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);
+        }
+    }
+    /**
+     * Create an empty Zcash PSBT with consensus branch ID determined from block height
+     *
+     * This method automatically determines the correct consensus branch ID based on
+     * the network and block height using the network upgrade activation heights.
+     *
+     * # Arguments
+     * * `network` - Network name (must be "zcash" or "zcashTest")
+     * * `wallet_keys` - The wallet's root keys (used to set global xpubs)
+     * * `block_height` - Block height to determine consensus rules
+     * * `version` - Optional transaction version (default: 4 for Zcash Sapling+)
+     * * `lock_time` - Optional lock time (default: 0)
+     * * `version_group_id` - Optional version group ID (defaults to Sapling: 0x892F2085)
+     * * `expiry_height` - Optional expiry height
+     *
+     * # Errors
+     * Returns error if block height is before Overwinter activation
+     * @param {string} network
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @param {number} block_height
+     * @param {number | null} [version]
+     * @param {number | null} [lock_time]
+     * @param {number | null} [version_group_id]
+     * @param {number | null} [expiry_height]
+     * @returns {BitGoPsbt}
+     */
+    static create_empty_zcash_at_height(network, wallet_keys, block_height, version, lock_time, version_group_id, expiry_height) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(network, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            _assertClass(wallet_keys, WasmRootWalletKeys);
+            wasm.bitgopsbt_create_empty_zcash_at_height(retptr, ptr0, len0, wallet_keys.__wbg_ptr, block_height, isLikeNone(version) ? 0x100000001 : (version) >> 0, isLikeNone(lock_time) ? 0x100000001 : (lock_time) >>> 0, isLikeNone(version_group_id) ? 0x100000001 : (version_group_id) >>> 0, isLikeNone(expiry_height) ? 0x100000001 : (expiry_height) >>> 0);
+            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 BitGoPsbt.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Parse outputs with wallet keys to identify which outputs belong to a wallet
      *
@@ -756,6 +1051,63 @@ class BitGoPsbt {
             wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Get the transaction version
+     * @returns {number}
+     */
+    version() {
+        const ret = wasm.bitgopsbt_version(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Add an input to the PSBT
+     *
+     * # Arguments
+     * * `txid` - The transaction ID (hex string) of the output being spent
+     * * `vout` - The output index being spent
+     * * `value` - The value in satoshis of the output being spent
+     * * `script` - The output script (scriptPubKey) of the output being spent
+     * * `sequence` - Optional sequence number (default: 0xFFFFFFFE for RBF)
+     *
+     * # Returns
+     * The index of the newly added input
+     * @param {string} txid
+     * @param {number} vout
+     * @param {bigint} value
+     * @param {Uint8Array} script
+     * @param {number | null} [sequence]
+     * @param {Uint8Array | null} [prev_tx]
+     * @returns {number}
+     */
+    add_input(txid, vout, value, script, sequence, prev_tx) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(txid, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray8ToWasm0(script, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(prev_tx) ? 0 : passArray8ToWasm0(prev_tx, wasm.__wbindgen_export);
+            var len2 = WASM_VECTOR_LEN;
+            wasm.bitgopsbt_add_input(retptr, this.__wbg_ptr, ptr0, len0, vout, value, ptr1, len1, isLikeNone(sequence) ? 0x100000001 : (sequence) >>> 0, ptr2, len2);
+            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);
+        }
+    }
+    /**
+     * Get the transaction lock time
+     * @returns {number}
+     */
+    lock_time() {
+        const ret = wasm.bitgopsbt_lock_time(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Serialize the PSBT to bytes
      *