@bitgo/wasm-utxo 4.31.0 → 4.33.0

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

@@ -136,6 +136,26 @@ export class BitGoPsbt {
      * The index of the newly added input
      */
     add_input_at_index(index: number, txid: string, vout: number, value: bigint, script: Uint8Array, sequence?: number | null, prev_tx?: Uint8Array | null): number;
+    /**
+     * Constructor: add the shielded Ironwood output as an orchard PCZT stored in the PSBT.
+     *
+     * * `recipient` - raw Orchard/Ironwood address ([`ORCHARD_ADDRESS_SIZE`] bytes)
+     * * `amount` - note value in zatoshi
+     * * `ovk` - optional outgoing viewing key ([`OVK_SIZE`] bytes; `None` for a keyless build)
+     * * `anchor` - Ironwood note-commitment-tree root ([`ANCHOR_SIZE`] bytes)
+     * * `memo` - ZIP-302 memo field ([`MEMO_SIZE`] bytes)
+     *
+     * [`ORCHARD_ADDRESS_SIZE`]: crate::zcash::ironwood_build::ORCHARD_ADDRESS_SIZE
+     * [`OVK_SIZE`]: crate::zcash::ironwood_build::OVK_SIZE
+     * [`ANCHOR_SIZE`]: crate::zcash::ironwood_build::ANCHOR_SIZE
+     * [`MEMO_SIZE`]: crate::zcash::ironwood_build::MEMO_SIZE
+     */
+    add_ironwood_output(recipient: Uint8Array, amount: bigint, ovk: Uint8Array | null | undefined, anchor: Uint8Array, memo: Uint8Array): void;
+    /**
+     * Ingest a transparent-input signature (`sig`: DER ECDSA with the trailing SIGHASH_ALL byte)
+     * after verifying it against `ironwood_v6_transparent_sighash(index)`.
+     */
+    add_ironwood_v6_signature(index: number, pubkey: Uint8Array, sig: Uint8Array): void;
     add_output(script: Uint8Array, value: bigint): number;
     add_output_at_index(index: number, script: Uint8Array, value: bigint): number;
     add_output_with_address(address: string, value: bigint): number;
@@ -170,6 +190,17 @@ export class BitGoPsbt {
      * Returns error if PSBT parsing fails or input counts don't match
      */
     combine_inputs(other_bytes: Uint8Array): void;
+    /**
+     * Transaction Extractor: given the external prover's `proof` bytes, finalize the transparent
+     * inputs, apply the shielded binding signature, and return the broadcast-ready v6 transaction
+     * bytes. Requires the transparent inputs to be signed (via `add_ironwood_v6_signature`).
+     *
+     * Terminal: on success the stored PCZT is dropped, so a second call — or any other Ironwood
+     * operation, including after a `serialize`/`from_bytes` round-trip — fails rather than silently
+     * re-running against already-extracted state. Build a fresh PSBT instead. On failure nothing is
+     * dropped, so a call that errors (bad proof, unsigned input) leaves the PSBT retryable.
+     */
+    combine_ironwood_proof(proof: Uint8Array): Uint8Array;
     /**
      * Combine/merge data from another PSBT into this one
      *
@@ -236,6 +267,23 @@ export class BitGoPsbt {
      * 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;
+    /**
+     * Create an empty Zcash **v6 (Ironwood)** shielding PSBT with an explicit consensus branch id.
+     *
+     * The version group id is fixed by the v6 format, but the consensus branch id tracks the active
+     * network upgrade and stays caller-supplied — the v6 analogue of `create_empty_zcash`. Prefer
+     * `create_empty_zcash_v6_at_height`, which derives it from a block height and rejects heights
+     * before NU6.3 activation; this is the escape hatch for callers that already know the value.
+     */
+    static create_empty_zcash_v6(network: string, wallet_keys: WasmRootWalletKeys, consensus_branch_id: number, lock_time?: number | null, expiry_height?: number | null): BitGoPsbt;
+    /**
+     * Create an empty Zcash **v6 (Ironwood)** shielding PSBT, with the consensus branch id
+     * resolved from `block_height`. Transparent inputs/outputs are added with the usual
+     * `add_wallet_input` / `add_wallet_output`; the shielded output and the v6 sign/combine
+     * steps use the dedicated `add_ironwood_output` / `ironwood_v6_*` / `combine_ironwood_proof`
+     * methods.
+     */
+    static create_empty_zcash_v6_at_height(network: string, wallet_keys: WasmRootWalletKeys, block_height: number, lock_time?: number | null, expiry_height?: number | null): BitGoPsbt;
     delete_input_kv(index: number, key: any): void;
     delete_kv(key: any): void;
     delete_output_kv(index: number, key: any): void;
@@ -426,6 +474,16 @@ export class BitGoPsbt {
      */
     get_unsigned_tx(): Uint8Array;
     input_count(): number;
+    /**
+     * The ZIP-244 per-input transparent sighash (32 bytes) that the key controlling transparent
+     * input `index` must sign.
+     */
+    ironwood_v6_transparent_sighash(index: number): Uint8Array;
+    /**
+     * The canonical (display-order) ZIP-244 v6 txid as a lowercase hex string, matching the
+     * `getId()` convention used elsewhere (see [`crate::wasm::zcash::ZcashV6Transaction::get_id`]).
+     */
+    ironwood_v6_txid(): string;
     /**
      * Check if an input is a MuSig2 keypath input.
      *
@@ -466,6 +524,21 @@ export class BitGoPsbt {
      */
     serialize(): Uint8Array;
     set_input_kv(index: number, key: any, value: Uint8Array): void;
+    /**
+     * Client-managed `ovk`: re-encrypt the Ironwood output's `out_ciphertext` under this wallet's
+     * `ovk`, derived as the ECDH agreement of `root_wallet_keys.bitgo_key()` and `user_xpriv` — two
+     * root keys, so the result is transaction-independent and the server can re-derive the identical
+     * `ovk` from its own privkey plus the user's pubkey in order to validate `out_ciphertext`. The
+     * server never sees `user_xpriv` or the `ovk` itself.
+     *
+     * `user_xpriv` must be the wallet's user root key; any other key is rejected, since an `ovk`
+     * derived from it is one neither the user nor the server can reproduce.
+     *
+     * Must be called before signing: `out_ciphertext` is ZIP-244 sighash-committed, so calling this
+     * after any transparent signature has been collected for the PSBT is rejected (it would
+     * silently invalidate that signature).
+     */
+    set_ironwood_out_ciphertext(action_index: number, user_xpriv: WasmBIP32, root_wallet_keys: WasmRootWalletKeys): void;
     set_kv(key: any, value: Uint8Array): void;
     set_output_kv(index: number, key: any, value: Uint8Array): void;
     /**
@@ -535,6 +608,22 @@ export class BitGoPsbt {
      * - `Err(WasmUtxoError)` if signing fails
      */
     sign_all_with_xpriv(xpriv: WasmBIP32): any;
+    /**
+     * Sign every transparent input `xpriv` resolves a key for, over the ZIP-244 transparent
+     * sighash — the v6 (Ironwood) counterpart to `sign_all_wallet_inputs`, which rejects v6 PSBTs
+     * (it only knows the ZIP-243 digest).
+     *
+     * If no transparent signature has been collected yet, this is the first signing round and
+     * `xpriv` must be the wallet's user root key: it is used with `root_wallet_keys.bitgo_key()` to
+     * derive this wallet's `ovk` and finalize `out_ciphertext` before computing any sighash (it is
+     * sighash-committed). Any other key signing first is rejected, rather than deriving an `ovk`
+     * nobody can reproduce. Once a signature exists, the step is skipped and any key may sign — so
+     * callers pass `root_wallet_keys` unconditionally on every signing round without needing to know
+     * which key is signing; it is mandatory precisely so the step can never be skipped by omission.
+     *
+     * Returns the indices of the transparent inputs that were signed.
+     */
+    sign_ironwood_v6(xpriv: WasmBIP32, root_wallet_keys: WasmRootWalletKeys): Uint32Array;
     /**
      * Sign a single MuSig2 keypath input.
      *
@@ -1761,3 +1850,12 @@ export function parseTxToJson(tx_bytes: Uint8Array, coin_name: string): string;
  * with `.message` and `.code`), not a bare string.
  */
 export function zcash_branch_id_for_height(network: string, height: number): number | undefined;
+
+/**
+ * The Zcash v6 (Ironwood / NU6.3) version group id.
+ *
+ * Exported so the TypeScript layer can derive its `IRONWOOD_VERSION_GROUP_ID` from the Rust
+ * constant instead of hard-coding a second copy: the two are used together to tell v6 PSBTs from
+ * v4/Sapling ones, and a silent divergence would route v6 bytes down the v4 path.
+ */
+export function zcash_ironwood_version_group_id(): number;

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

@@ -469,6 +469,70 @@ class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Constructor: add the shielded Ironwood output as an orchard PCZT stored in the PSBT.
+     *
+     * * `recipient` - raw Orchard/Ironwood address ([`ORCHARD_ADDRESS_SIZE`] bytes)
+     * * `amount` - note value in zatoshi
+     * * `ovk` - optional outgoing viewing key ([`OVK_SIZE`] bytes; `None` for a keyless build)
+     * * `anchor` - Ironwood note-commitment-tree root ([`ANCHOR_SIZE`] bytes)
+     * * `memo` - ZIP-302 memo field ([`MEMO_SIZE`] bytes)
+     *
+     * [`ORCHARD_ADDRESS_SIZE`]: crate::zcash::ironwood_build::ORCHARD_ADDRESS_SIZE
+     * [`OVK_SIZE`]: crate::zcash::ironwood_build::OVK_SIZE
+     * [`ANCHOR_SIZE`]: crate::zcash::ironwood_build::ANCHOR_SIZE
+     * [`MEMO_SIZE`]: crate::zcash::ironwood_build::MEMO_SIZE
+     * @param {Uint8Array} recipient
+     * @param {bigint} amount
+     * @param {Uint8Array | null | undefined} ovk
+     * @param {Uint8Array} anchor
+     * @param {Uint8Array} memo
+     */
+    add_ironwood_output(recipient, amount, ovk, anchor, memo) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(recipient, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(ovk) ? 0 : passArray8ToWasm0(ovk, wasm.__wbindgen_export);
+            var len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray8ToWasm0(anchor, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArray8ToWasm0(memo, wasm.__wbindgen_export);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.bitgopsbt_add_ironwood_output(retptr, this.__wbg_ptr, ptr0, len0, amount, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Ingest a transparent-input signature (`sig`: DER ECDSA with the trailing SIGHASH_ALL byte)
+     * after verifying it against `ironwood_v6_transparent_sighash(index)`.
+     * @param {number} index
+     * @param {Uint8Array} pubkey
+     * @param {Uint8Array} sig
+     */
+    add_ironwood_v6_signature(index, pubkey, sig) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(pubkey, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray8ToWasm0(sig, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.bitgopsbt_add_ironwood_v6_signature(retptr, this.__wbg_ptr, index, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * @param {Uint8Array} script
      * @param {bigint} value
@@ -798,6 +862,38 @@ class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Transaction Extractor: given the external prover's `proof` bytes, finalize the transparent
+     * inputs, apply the shielded binding signature, and return the broadcast-ready v6 transaction
+     * bytes. Requires the transparent inputs to be signed (via `add_ironwood_v6_signature`).
+     *
+     * Terminal: on success the stored PCZT is dropped, so a second call — or any other Ironwood
+     * operation, including after a `serialize`/`from_bytes` round-trip — fails rather than silently
+     * re-running against already-extracted state. Build a fresh PSBT instead. On failure nothing is
+     * dropped, so a call that errors (bad proof, unsigned input) leaves the PSBT retryable.
+     * @param {Uint8Array} proof
+     * @returns {Uint8Array}
+     */
+    combine_ironwood_proof(proof) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(proof, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.bitgopsbt_combine_ironwood_proof(retptr, this.__wbg_ptr, 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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Combine/merge data from another PSBT into this one
      *
@@ -954,6 +1050,69 @@ class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Create an empty Zcash **v6 (Ironwood)** shielding PSBT with an explicit consensus branch id.
+     *
+     * The version group id is fixed by the v6 format, but the consensus branch id tracks the active
+     * network upgrade and stays caller-supplied — the v6 analogue of `create_empty_zcash`. Prefer
+     * `create_empty_zcash_v6_at_height`, which derives it from a block height and rejects heights
+     * before NU6.3 activation; this is the escape hatch for callers that already know the value.
+     * @param {string} network
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @param {number} consensus_branch_id
+     * @param {number | null} [lock_time]
+     * @param {number | null} [expiry_height]
+     * @returns {BitGoPsbt}
+     */
+    static create_empty_zcash_v6(network, wallet_keys, consensus_branch_id, lock_time, 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_v6(retptr, ptr0, len0, wallet_keys.__wbg_ptr, consensus_branch_id, isLikeNone(lock_time) ? 0x100000001 : (lock_time) >>> 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);
+        }
+    }
+    /**
+     * Create an empty Zcash **v6 (Ironwood)** shielding PSBT, with the consensus branch id
+     * resolved from `block_height`. Transparent inputs/outputs are added with the usual
+     * `add_wallet_input` / `add_wallet_output`; the shielded output and the v6 sign/combine
+     * steps use the dedicated `add_ironwood_output` / `ironwood_v6_*` / `combine_ironwood_proof`
+     * methods.
+     * @param {string} network
+     * @param {WasmRootWalletKeys} wallet_keys
+     * @param {number} block_height
+     * @param {number | null} [lock_time]
+     * @param {number | null} [expiry_height]
+     * @returns {BitGoPsbt}
+     */
+    static create_empty_zcash_v6_at_height(network, wallet_keys, block_height, lock_time, 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_v6_at_height(retptr, ptr0, len0, wallet_keys.__wbg_ptr, block_height, isLikeNone(lock_time) ? 0x100000001 : (lock_time) >>> 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);
+        }
+    }
     /**
      * @param {number} index
      * @param {any} key
@@ -1633,6 +1792,59 @@ class BitGoPsbt {
         const ret = wasm.bitgopsbt_input_count(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * The ZIP-244 per-input transparent sighash (32 bytes) that the key controlling transparent
+     * input `index` must sign.
+     * @param {number} index
+     * @returns {Uint8Array}
+     */
+    ironwood_v6_transparent_sighash(index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bitgopsbt_ironwood_v6_transparent_sighash(retptr, this.__wbg_ptr, index);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The canonical (display-order) ZIP-244 v6 txid as a lowercase hex string, matching the
+     * `getId()` convention used elsewhere (see [`crate::wasm::zcash::ZcashV6Transaction::get_id`]).
+     * @returns {string}
+     */
+    ironwood_v6_txid() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bitgopsbt_ironwood_v6_txid(retptr, this.__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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * Check if an input is a MuSig2 keypath input.
      *
@@ -1815,6 +2027,38 @@ class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Client-managed `ovk`: re-encrypt the Ironwood output's `out_ciphertext` under this wallet's
+     * `ovk`, derived as the ECDH agreement of `root_wallet_keys.bitgo_key()` and `user_xpriv` — two
+     * root keys, so the result is transaction-independent and the server can re-derive the identical
+     * `ovk` from its own privkey plus the user's pubkey in order to validate `out_ciphertext`. The
+     * server never sees `user_xpriv` or the `ovk` itself.
+     *
+     * `user_xpriv` must be the wallet's user root key; any other key is rejected, since an `ovk`
+     * derived from it is one neither the user nor the server can reproduce.
+     *
+     * Must be called before signing: `out_ciphertext` is ZIP-244 sighash-committed, so calling this
+     * after any transparent signature has been collected for the PSBT is rejected (it would
+     * silently invalidate that signature).
+     * @param {number} action_index
+     * @param {WasmBIP32} user_xpriv
+     * @param {WasmRootWalletKeys} root_wallet_keys
+     */
+    set_ironwood_out_ciphertext(action_index, user_xpriv, root_wallet_keys) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(user_xpriv, WasmBIP32);
+            _assertClass(root_wallet_keys, WasmRootWalletKeys);
+            wasm.bitgopsbt_set_ironwood_out_ciphertext(retptr, this.__wbg_ptr, action_index, user_xpriv.__wbg_ptr, root_wallet_keys.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * @param {any} key
      * @param {Uint8Array} value
@@ -1989,6 +2233,44 @@ class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Sign every transparent input `xpriv` resolves a key for, over the ZIP-244 transparent
+     * sighash — the v6 (Ironwood) counterpart to `sign_all_wallet_inputs`, which rejects v6 PSBTs
+     * (it only knows the ZIP-243 digest).
+     *
+     * If no transparent signature has been collected yet, this is the first signing round and
+     * `xpriv` must be the wallet's user root key: it is used with `root_wallet_keys.bitgo_key()` to
+     * derive this wallet's `ovk` and finalize `out_ciphertext` before computing any sighash (it is
+     * sighash-committed). Any other key signing first is rejected, rather than deriving an `ovk`
+     * nobody can reproduce. Once a signature exists, the step is skipped and any key may sign — so
+     * callers pass `root_wallet_keys` unconditionally on every signing round without needing to know
+     * which key is signing; it is mandatory precisely so the step can never be skipped by omission.
+     *
+     * Returns the indices of the transparent inputs that were signed.
+     * @param {WasmBIP32} xpriv
+     * @param {WasmRootWalletKeys} root_wallet_keys
+     * @returns {Uint32Array}
+     */
+    sign_ironwood_v6(xpriv, root_wallet_keys) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(xpriv, WasmBIP32);
+            _assertClass(root_wallet_keys, WasmRootWalletKeys);
+            wasm.bitgopsbt_sign_ironwood_v6(retptr, this.__wbg_ptr, xpriv.__wbg_ptr, root_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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Sign a single MuSig2 keypath input.
      *
@@ -6731,6 +7013,20 @@ function zcash_branch_id_for_height(network, height) {
 }
 exports.zcash_branch_id_for_height = zcash_branch_id_for_height;
 
+/**
+ * The Zcash v6 (Ironwood / NU6.3) version group id.
+ *
+ * Exported so the TypeScript layer can derive its `IRONWOOD_VERSION_GROUP_ID` from the Rust
+ * constant instead of hard-coding a second copy: the two are used together to tell v6 PSBTs from
+ * v4/Sapling ones, and a silent divergence would route v6 bytes down the v4 path.
+ * @returns {number}
+ */
+function zcash_ironwood_version_group_id() {
+    const ret = wasm.zcash_ironwood_version_group_id();
+    return ret >>> 0;
+}
+exports.zcash_ironwood_version_group_id = zcash_ironwood_version_group_id;
+
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,