@bitgo/wasm-utxo 4.30.0 → 4.32.0

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.
      *
@@ -6731,6 +6943,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,

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

@@ -1,7 +1,9 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_addressnamespace_free: (a: number, b: number) => void;
 export const __wbg_inscriptionsnamespace_free: (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_wasmecpair_free: (a: number, b: number) => void;
 export const __wbg_wasmtransaction_free: (a: number, b: number) => void;
@@ -9,8 +11,12 @@ export const __wbg_wasmzcashtransaction_free: (a: number, b: number) => void;
 export const __wbg_wrappsbt_free: (a: number, b: number) => void;
 export const __wbg_zcashunifiedaddress_free: (a: number, b: number) => void;
 export const __wbg_zcashv6transaction_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 inscriptionsnamespace_create_inscription_reveal_data: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const inscriptionsnamespace_sign_reveal_transaction: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: bigint) => 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_get_inputs: (a: number, b: number) => void;
 export const wasmdashtransaction_get_outputs: (a: number, b: number) => void;
@@ -93,6 +99,7 @@ export const wrappsbt_update_output_with_descriptor: (a: number, b: number, c: n
 export const wrappsbt_validate_signature_at_input: (a: number, b: number, c: number, d: number, e: number) => void;
 export const wrappsbt_verify_signature_with_key: (a: number, b: number, c: number, d: number) => void;
 export const zcash_branch_id_for_height: (a: number, b: number, c: number, d: number) => void;
+export const zcash_ironwood_version_group_id: () => number;
 export const zcashunifiedaddress_contains: (a: number, b: number, c: number, d: number) => void;
 export const zcashunifiedaddress_orchardReceiver: (a: number, b: number) => void;
 export const zcashunifiedaddress_parse: (a: number, b: number, c: number, d: number, e: number) => void;
@@ -118,36 +125,12 @@ export const wasmzcashtransaction_lock_time: (a: number) => number;
 export const wasmzcashtransaction_version: (a: number) => number;
 export const wrappsbt_lock_time: (a: number) => number;
 export const wrappsbt_version: (a: number) => number;
-export const __wbg_addressnamespace_free: (a: number, b: number) => void;
-export const __wbg_utxolibcompatnamespace_free: (a: number, b: number) => void;
-export const __wbg_wasmdimensions_free: (a: number, b: number) => void;
 export const __wbg_wasmutxonamespace_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 __wbg_wrapdescriptor_free: (a: number, b: number) => void;
+export const __wbg_wrapminiscript_free: (a: number, b: number) => void;
 export const isInspectEnabled: () => number;
 export const parsePsbtRawToJson: (a: number, b: number, c: number, d: number, e: 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 wasmdimensions_empty: () => number;
-export const wasmdimensions_from_input: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
-export const wasmdimensions_from_input_script_type: (a: number, b: number, c: number, d: number) => void;
-export const wasmdimensions_from_output_script_length: (a: number) => number;
-export const wasmdimensions_from_output_script_type: (a: number, b: number, c: number) => void;
-export const wasmdimensions_from_psbt: (a: number, b: number) => void;
-export const wasmdimensions_get_input_vsize: (a: number, b: number, c: number) => number;
-export const wasmdimensions_get_input_weight: (a: number, b: number, c: number) => number;
-export const wasmdimensions_get_output_vsize: (a: number) => number;
-export const wasmdimensions_get_output_weight: (a: number) => number;
-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 wasmdimensions_times: (a: number, b: number) => number;
 export const wasmutxonamespace_get_wasm_utxo_version: (a: number) => void;
-export const parsePsbtToJson: (a: number, b: number, c: number, d: number, e: number) => void;
-export const parseTxToJson: (a: number, b: number, c: number, d: number, e: number) => void;
-export const __wbg_wrapdescriptor_free: (a: number, b: number) => void;
-export const __wbg_wrapminiscript_free: (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;
@@ -168,11 +151,14 @@ export const wrapminiscript_fromStringExt: (a: number, b: number, c: number, d:
 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 parsePsbtToJson: (a: number, b: number, c: number, d: number, e: number) => void;
+export const parseTxToJson: (a: number, b: number, c: number, d: number, e: number) => void;
 export const __wbg_bip322namespace_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_messagenamespace_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_wasmreplayprotection_free: (a: number, b: number) => void;
 export const __wbg_wasmrootwalletkeys_free: (a: number, b: number) => void;
 export const bip322namespace_add_bip322_input: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => void;
@@ -183,6 +169,8 @@ export const bip322namespace_verify_bip322_tx_input: (a: number, b: number, c: n
 export const bip322namespace_verify_bip322_tx_input_with_pubkeys: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: 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;
 export const bitgopsbt_add_input_at_index: (a: number, b: number, c: number, d: number, e: number, f: number, g: bigint, h: number, i: number, j: number, k: number, l: number) => void;
+export const bitgopsbt_add_ironwood_output: (a: number, b: number, c: number, d: number, e: bigint, f: number, g: number, h: number, i: number, j: number, k: number) => void;
+export const bitgopsbt_add_ironwood_v6_signature: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const bitgopsbt_add_output: (a: number, b: number, c: number, d: number, e: bigint) => void;
 export const bitgopsbt_add_output_at_index: (a: number, b: number, c: number, d: number, e: number, f: bigint) => void;
 export const bitgopsbt_add_output_with_address: (a: number, b: number, c: number, d: number, e: bigint) => void;
@@ -195,11 +183,14 @@ export const bitgopsbt_add_wallet_input_at_index: (a: number, b: number, c: numb
 export const bitgopsbt_add_wallet_output: (a: number, b: number, c: number, d: number, e: bigint, f: number) => void;
 export const bitgopsbt_add_wallet_output_at_index: (a: number, b: number, c: number, d: number, e: number, f: bigint, g: number) => void;
 export const bitgopsbt_combine_inputs: (a: number, b: number, c: number, d: number) => void;
+export const bitgopsbt_combine_ironwood_proof: (a: number, b: number, c: number, d: number) => void;
 export const bitgopsbt_combine_musig2_nonces: (a: number, b: number, c: number) => void;
 export const bitgopsbt_consensus_branch_id: (a: number) => number;
 export const bitgopsbt_create_empty: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const bitgopsbt_create_empty_zcash: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
 export const bitgopsbt_create_empty_zcash_at_height: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+export const bitgopsbt_create_empty_zcash_v6: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const bitgopsbt_create_empty_zcash_v6_at_height: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const bitgopsbt_delete_input_kv: (a: number, b: number, c: number, d: number) => void;
 export const bitgopsbt_delete_kv: (a: number, b: number, c: number) => void;
 export const bitgopsbt_delete_output_kv: (a: number, b: number, c: number, d: number) => void;
@@ -228,6 +219,8 @@ export const bitgopsbt_get_outputs: (a: number, b: number) => void;
 export const bitgopsbt_get_outputs_with_address: (a: number, b: number) => void;
 export const bitgopsbt_get_unsigned_tx: (a: number, b: number) => void;
 export const bitgopsbt_input_count: (a: number) => number;
+export const bitgopsbt_ironwood_v6_transparent_sighash: (a: number, b: number, c: number) => void;
+export const bitgopsbt_ironwood_v6_txid: (a: number, b: number) => void;
 export const bitgopsbt_is_musig2_input: (a: number, b: number) => number;
 export const bitgopsbt_lock_time: (a: number) => number;
 export const bitgopsbt_network: (a: number, b: number) => void;
@@ -288,6 +281,21 @@ 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, g: number) => void;
+export const wasmdimensions_from_input_script_type: (a: number, b: number, c: number, d: number) => void;
+export const wasmdimensions_from_output_script_length: (a: number) => number;
+export const wasmdimensions_from_output_script_type: (a: number, b: number, c: number) => void;
+export const wasmdimensions_from_psbt: (a: number, b: number) => void;
+export const wasmdimensions_get_input_vsize: (a: number, b: number, c: number) => number;
+export const wasmdimensions_get_input_weight: (a: number, b: number, c: number) => number;
+export const wasmdimensions_get_output_vsize: (a: number) => number;
+export const wasmdimensions_get_output_weight: (a: number) => number;
+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 wasmdimensions_times: (a: number, b: number) => number;
 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;

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

@@ -3,6 +3,15 @@ import { BitGoPsbt, type CreateEmptyOptions, type HydrationUnspent } from "./Bit
 import { ZcashTransaction, type ITransaction } from "../transaction.js";
 /** Zcash network names */
 export type ZcashNetworkName = "zcash" | "zcashTest" | "zec" | "tzec";
+/**
+ * Zcash v6 (Ironwood) version group id (0xd884b698). Its presence marks a PSBT as v6 — see
+ * `ZcashIronwoodBitGoPsbt`.
+ *
+ * Read from the wasm layer rather than hard-coded, so it cannot drift from
+ * `ZCASH_IRONWOOD_VERSION_GROUP_ID` in `src/zcash/transaction.rs`: a divergence would make the
+ * v4/v6 discrimination in {@link ZcashBitGoPsbt.fromBytes} silently classify v6 bytes as v4.
+ */
+export declare const IRONWOOD_VERSION_GROUP_ID: number;
 /** Options for creating an empty Zcash PSBT (preferred method using block height) */
 export type CreateEmptyZcashOptions = CreateEmptyOptions & {
     /** Block height to determine consensus branch ID automatically */
@@ -98,6 +107,8 @@ export declare class ZcashBitGoPsbt extends BitGoPsbt {
      *
      * @param bytes - The PSBT bytes
      * @param network - Zcash network name ("zcash", "zcashTest", "zec", "tzec")
+     * @throws Error if the deserialized PSBT is a v6 (Ironwood) PSBT — use
+     *   {@link ZcashIronwoodBitGoPsbt.fromBytes} instead
      * @returns A ZcashBitGoPsbt instance
      */
     static fromBytes(bytes: Uint8Array, network: ZcashNetworkName): ZcashBitGoPsbt;

package/dist/esm/js/fixedScriptWallet/ZcashBitGoPsbt.js

@@ -1,7 +1,16 @@
-import { BitGoPsbt as WasmBitGoPsbt, zcash_branch_id_for_height } from "../wasm/wasm_utxo.js";
+import { BitGoPsbt as WasmBitGoPsbt, zcash_branch_id_for_height, zcash_ironwood_version_group_id, } from "../wasm/wasm_utxo.js";
 import { RootWalletKeys } from "./RootWalletKeys.js";
 import { BitGoPsbt } from "./BitGoPsbt.js";
 import { ZcashTransaction } from "../transaction.js";
+/**
+ * Zcash v6 (Ironwood) version group id (0xd884b698). Its presence marks a PSBT as v6 — see
+ * `ZcashIronwoodBitGoPsbt`.
+ *
+ * Read from the wasm layer rather than hard-coded, so it cannot drift from
+ * `ZCASH_IRONWOOD_VERSION_GROUP_ID` in `src/zcash/transaction.rs`: a divergence would make the
+ * v4/v6 discrimination in {@link ZcashBitGoPsbt.fromBytes} silently classify v6 bytes as v4.
+ */
+export const IRONWOOD_VERSION_GROUP_ID = zcash_ironwood_version_group_id();
 /**
  * Zcash-specific PSBT implementation
  *
@@ -87,11 +96,17 @@ export class ZcashBitGoPsbt extends BitGoPsbt {
      *
      * @param bytes - The PSBT bytes
      * @param network - Zcash network name ("zcash", "zcashTest", "zec", "tzec")
+     * @throws Error if the deserialized PSBT is a v6 (Ironwood) PSBT — use
+     *   {@link ZcashIronwoodBitGoPsbt.fromBytes} instead
      * @returns A ZcashBitGoPsbt instance
      */
     static fromBytes(bytes, network) {
         const wasm = WasmBitGoPsbt.from_bytes(bytes, network);
-        return new ZcashBitGoPsbt(wasm);
+        const psbt = new ZcashBitGoPsbt(wasm);
+        if (psbt.versionGroupId === IRONWOOD_VERSION_GROUP_ID) {
+            throw new Error("this is a v6 (Ironwood) PSBT: use ZcashIronwoodBitGoPsbt.fromBytes instead");
+        }
+        return psbt;
     }
     /**
      * Reconstruct a Zcash PSBT from a network-format transaction (unsigned, half-signed, or fully-signed).

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

@@ -0,0 +1,172 @@
+import { type WalletKeysArg } from "./RootWalletKeys.js";
+import { ZcashBitGoPsbt, type ZcashNetworkName } from "./ZcashBitGoPsbt.js";
+/**
+ * Options for creating an empty Zcash v6 (Ironwood) shielding PSBT.
+ *
+ * Deliberately narrower than `CreateEmptyZcashOptions`: `version` and `versionGroupId` are fixed by
+ * the v6 format, so accepting them would only let a caller ask for something that is then ignored.
+ */
+export type CreateEmptyIronwoodOptions = {
+    /** Block height to determine the consensus branch ID automatically (at/after NU6.3 activation) */
+    blockHeight: number;
+    /** Lock time (default: 0) */
+    lockTime?: number;
+    /** Zcash transaction expiry height */
+    expiryHeight?: number;
+};
+/**
+ * Options for creating an empty Zcash v6 (Ironwood) shielding PSBT with an explicit consensus
+ * branch ID.
+ *
+ * Like {@link CreateEmptyIronwoodOptions}, this omits `version` and `versionGroupId` — both are
+ * fixed by the v6 format. The consensus branch ID is *not* fixed: it tracks the active network
+ * upgrade, so it stays a caller-supplied parameter exactly as it is for v4.
+ */
+export type CreateEmptyIronwoodWithConsensusBranchIdOptions = {
+    /** Zcash consensus branch ID (e.g. the NU6.3 branch ID) */
+    consensusBranchId: number;
+    /** Lock time (default: 0) */
+    lockTime?: number;
+    /** Zcash transaction expiry height */
+    expiryHeight?: number;
+};
+/**
+ * A fresh ZIP-302 "no memo" memo field: the `0xf6` marker byte followed by 511 zero bytes. The
+ * default for {@link ZcashIronwoodBitGoPsbt.addShieldedOutput}'s `memo` option.
+ *
+ * Not the same as an all-zeros memo, which decodes as a *text* memo holding the empty string and is
+ * rendered as such by wallets. Exported so callers can pass it explicitly, and so the distinction is
+ * visible rather than buried in a default.
+ *
+ * A function rather than a shared constant: a module-level `Uint8Array` is mutable, so one caller
+ * writing into it would silently change the default memo for every later output.
+ */
+export declare function zip302NoMemo(): Uint8Array;
+/**
+ * A Zcash **v6 (Ironwood / NU6.3)** shielding PSBT.
+ *
+ * Distinct from the generic `ZcashBitGoPsbt` (v4/Sapling-shaped transactions): a v6 PSBT carries
+ * its shielded side as an orchard PCZT in the proprietary map rather than Sapling fields, and its
+ * lifecycle mirrors the microservice build → sign → combine flow rather than the v4 ZIP-243
+ * signing path.
+ *
+ * Method names carry no `ironwood` prefix — the class name already says it. They follow the base
+ * `BitGoPsbt` vocabulary (`createEmpty`, `fromBytes`, `addOutput`-style adders, `getId`) so the v6
+ * surface reads the same as the v4 one; the wasm bindings keep their `ironwood_v6_*` names because
+ * they live on the single flat `BitGoPsbt` struct, where the prefix is what disambiguates them.
+ *
+ * @example
+ * ```typescript
+ * const psbt = ZcashIronwoodBitGoPsbt.createEmpty("zcash", walletKeys, { blockHeight });
+ * psbt.addWalletInput(...);
+ * psbt.addWalletOutput(...);
+ * psbt.addShieldedOutput(recipient, amount, { anchor });
+ * const sighash = psbt.transparentSighash(0);
+ * // ... sign sighash externally, then:
+ * psbt.addTransparentSignature(0, pubkey, sig);
+ * const tx = psbt.combineProof(proof);
+ * ```
+ */
+export declare class ZcashIronwoodBitGoPsbt extends ZcashBitGoPsbt {
+    /**
+     * Create an empty Zcash **v6 (Ironwood)** shielding PSBT, with the consensus branch ID
+     * determined from block height.
+     *
+     * Add transparent inputs/outputs with the usual `addWalletInput` / `addWalletOutput`, the
+     * shielded output with {@link addShieldedOutput}, then sign the transparent inputs over
+     * {@link transparentSighash} and finish with {@link combineProof}.
+     *
+     * @param network - Zcash network name ("zcash", "zcashTest", "zec", "tzec")
+     * @param walletKeys - The wallet's root keys (sets global xpubs in the PSBT)
+     * @param options - Options including blockHeight (at/after NU6.3 activation)
+     */
+    static createEmpty(network: ZcashNetworkName, walletKeys: WalletKeysArg, options: CreateEmptyIronwoodOptions): ZcashIronwoodBitGoPsbt;
+    /**
+     * Create an empty Zcash **v6 (Ironwood)** shielding PSBT with an explicit consensus branch ID.
+     *
+     * **Advanced use only.** Prefer {@link createEmpty}, which derives the branch ID from a block
+     * height and rejects heights before NU6.3 activation. Reach for this only when you already know
+     * the branch ID — regtest, a future upgrade, or replaying a known-good value.
+     *
+     * Only the *version group ID* is fixed by the v6 format; the consensus branch ID tracks the active
+     * network upgrade and remains caller-supplied, exactly as for v4.
+     *
+     * @param network - Zcash network name ("zcash", "zcashTest", "zec", "tzec")
+     * @param walletKeys - The wallet's root keys (sets global xpubs in the PSBT)
+     * @param options - Options including the required consensusBranchId
+     */
+    static createEmptyWithConsensusBranchId(network: ZcashNetworkName, walletKeys: WalletKeysArg, options: CreateEmptyIronwoodWithConsensusBranchIdOptions): ZcashIronwoodBitGoPsbt;
+    /**
+     * Not applicable to v6, and not implementable: a broadcast v6 transaction carries the shielded
+     * side as a proof plus a binding signature, while every v6 operation here needs the PCZT — which
+     * holds witness data (`rseed`, `rcv`, `alpha`, the note plaintext) that is deliberately *not*
+     * recoverable from the transaction. Decoding the transparent skeleton alone would yield a PSBT
+     * that `getId`, `transparentSighash`, `combineProof`, and even `serialize`/{@link fromBytes} all
+     * reject. Inherited only because JS statics are inherited.
+     */
+    static fromNetworkFormat(): never;
+    /**
+     * Not applicable to v6: the legacy half-signed format is a v4-era p2ms encoding with no way to
+     * carry the PCZT, and no v6 transaction has ever been produced in it. Inherited only because JS
+     * statics are inherited.
+     */
+    static fromHalfSignedLegacyTransaction(): never;
+    /**
+     * Deserialize a v6 (Ironwood) Zcash PSBT from bytes.
+     *
+     * @param bytes - The PSBT bytes
+     * @param network - Zcash network name ("zcash", "zcashTest", "zec", "tzec")
+     * @throws Error if the deserialized PSBT is not a v6 (Ironwood) PSBT
+     * @returns A ZcashIronwoodBitGoPsbt instance
+     */
+    static fromBytes(bytes: Uint8Array, network: ZcashNetworkName): ZcashIronwoodBitGoPsbt;
+    /**
+     * Add the shielded output (Constructor role). Stores the orchard PCZT in the PSBT.
+     *
+     * Named for the shielded/transparent split rather than the note type, leaving room for a
+     * transparent-output variant alongside the inherited `addOutput` / `addWalletOutput`.
+     *
+     * @param recipient - 43-byte raw Orchard/Ironwood address
+     * @param amount - note value in zatoshi
+     * @param options.anchor - 32-byte Ironwood note-commitment-tree root
+     * @param options.memo - optional 512-byte memo (defaults to the ZIP-302 "no memo" encoding)
+     * @param options.ovk - optional 32-byte outgoing viewing key (omit for a keyless build)
+     */
+    addShieldedOutput(recipient: Uint8Array, amount: bigint, options: {
+        anchor: Uint8Array;
+        memo?: Uint8Array;
+        ovk?: Uint8Array;
+    }): void;
+    /**
+     * The canonical (display-order) ZIP-244 v6 txid as a lowercase hex string, matching
+     * `ITransaction.getId()`. Defined once the transparent inputs/outputs and the shielded output are
+     * in place; unchanged by signing or proving.
+     */
+    getId(): string;
+    /**
+     * The ZIP-244 per-input transparent sighash (32 bytes) the key controlling transparent input
+     * `index` must sign.
+     */
+    transparentSighash(index: number): Uint8Array;
+    /**
+     * Ingest a transparent-input signature returned by the client/HSM, after verifying it against
+     * {@link transparentSighash} for that input.
+     *
+     * @param index - transparent input index
+     * @param pubkey - the signing public key
+     * @param sig - DER ECDSA signature with the trailing SIGHASH_ALL byte (as in a scriptSig)
+     */
+    addTransparentSignature(index: number, pubkey: Uint8Array, sig: Uint8Array): void;
+    /**
+     * Transaction Extractor role: 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 every transparent input to be signed via
+     * {@link addTransparentSignature}.
+     *
+     * Terminal: the wasm binding drops the stored PCZT on success, so any later v6 call on this PSBT
+     * throws — including after a `serialize`/{@link fromBytes} round-trip, since the PCZT is gone
+     * from the bytes too. Build a fresh PSBT instead. On failure nothing is dropped, so a call that
+     * errors (bad proof, unsigned input) leaves the PSBT retryable.
+     */
+    combineProof(proof: Uint8Array): Uint8Array;
+}