@bitgo/wasm-utxo 4.31.0 → 4.33.0

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

@@ -0,0 +1,222 @@
+import { BitGoPsbt as WasmBitGoPsbt } from "../wasm/wasm_utxo.js";
+import { BIP32, isBIP32Arg } from "../bip32.js";
+import { RootWalletKeys } from "./RootWalletKeys.js";
+import { IRONWOOD_VERSION_GROUP_ID, ZcashBitGoPsbt, } from "./ZcashBitGoPsbt.js";
+/**
+ * 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 function zip302NoMemo() {
+    const memo = new Uint8Array(512);
+    memo[0] = 0xf6;
+    return memo;
+}
+/**
+ * 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 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, walletKeys, options) {
+        const keys = RootWalletKeys.from(walletKeys);
+        const wasm = WasmBitGoPsbt.create_empty_zcash_v6_at_height(network, keys.wasm, options.blockHeight, options.lockTime, options.expiryHeight);
+        return new ZcashIronwoodBitGoPsbt(wasm);
+    }
+    /**
+     * 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, walletKeys, options) {
+        const keys = RootWalletKeys.from(walletKeys);
+        const wasm = WasmBitGoPsbt.create_empty_zcash_v6(network, keys.wasm, options.consensusBranchId, options.lockTime, options.expiryHeight);
+        return new ZcashIronwoodBitGoPsbt(wasm);
+    }
+    /**
+     * 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() {
+        throw new Error("not supported for v6 (Ironwood): the PCZT witness data cannot be recovered from a broadcast " +
+            "transaction; rebuild the PSBT with createEmpty");
+    }
+    /**
+     * 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() {
+        throw new Error("not supported for v6 (Ironwood): the legacy half-signed format is v4-only; " +
+            "rebuild the PSBT with createEmpty");
+    }
+    /**
+     * 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, network) {
+        const wasm = WasmBitGoPsbt.from_bytes(bytes, network);
+        const psbt = new ZcashIronwoodBitGoPsbt(wasm);
+        if (psbt.versionGroupId !== IRONWOOD_VERSION_GROUP_ID) {
+            throw new Error("not a v6 (Ironwood) PSBT: use ZcashBitGoPsbt.fromBytes for v4/Sapling-shaped PSBTs");
+        }
+        return psbt;
+    }
+    /**
+     * 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, amount, options) {
+        const memo = options.memo ?? zip302NoMemo();
+        this.wasm.add_ironwood_output(recipient, amount, options.ovk, options.anchor, memo);
+    }
+    /**
+     * Client-managed `ovk`: re-encrypt the shielded output's `out_ciphertext` under **this wallet's**
+     * `ovk`, derived as the ECDH agreement of `rootWalletKeys.bitgoKey()` and `userKey`. Both are root
+     * keys, so the `ovk` does not depend on which inputs the transaction spends, and the server can
+     * re-derive the identical value from its own private key plus the user's public key in order to
+     * validate `out_ciphertext` before countersigning. The server never sees `userKey` or the `ovk`.
+     *
+     * `userKey` must be the wallet's user root key — passing the backup or BitGo key throws, since an
+     * `ovk` derived from those is one neither the user nor the server can reproduce, and the resulting
+     * transaction would broadcast fine while leaving the shielded output permanently unrecoverable.
+     *
+     * Normally you do not call this directly: {@link sign} performs it on the first signing round.
+     *
+     * Must be called **before** signing: `out_ciphertext` is committed by the ZIP-244 sighash, so
+     * calling this after any transparent signature has been added (via
+     * {@link addTransparentSignature}) throws rather than silently invalidating that signature.
+     *
+     * @param actionIndex - index of the Ironwood action whose output to re-encrypt (always `0`: only
+     *   one shielded output per transaction is supported, see {@link addShieldedOutput})
+     * @param userKey - the wallet's user root key (an xpriv)
+     * @param rootWalletKeys - the wallet's root keys, supplying the BitGo cosigner pubkey
+     */
+    setShieldedOutCiphertext(actionIndex, userKey, rootWalletKeys) {
+        this.wasm.set_ironwood_out_ciphertext(actionIndex, BIP32.from(userKey).wasm, RootWalletKeys.from(rootWalletKeys).wasm);
+    }
+    /**
+     * 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() {
+        return this.wasm.ironwood_v6_txid();
+    }
+    /**
+     * The ZIP-244 per-input transparent sighash (32 bytes) the key controlling transparent input
+     * `index` must sign.
+     */
+    transparentSighash(index) {
+        return this.wasm.ironwood_v6_transparent_sighash(index);
+    }
+    /**
+     * 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, pubkey, sig) {
+        this.wasm.add_ironwood_v6_signature(index, pubkey, sig);
+    }
+    // The second parameter is `WalletKeysArg` in the public (first) overload above — the only form
+    // callers see. It widens here solely to stay assignable to the deprecated `(inputIndex, key)`
+    // overload, whose own second parameter is a key; narrowing it to `WalletKeysArg` is TS2394.
+    sign(keyOrIndex, keyOrRootWalletKeys) {
+        if (typeof keyOrIndex === "number") {
+            throw new Error("not supported for v6 (Ironwood): single-input sign(inputIndex, key) has no ZIP-244 " +
+                "equivalent; use sign(key) to sign all matching inputs");
+        }
+        if (!isBIP32Arg(keyOrIndex)) {
+            throw new Error("not supported for v6 (Ironwood): a raw privkey (ECPairArg) has no bip32_derivation path " +
+                "to resolve out_ciphertext's ovk from; pass an xpriv");
+        }
+        if (keyOrRootWalletKeys === undefined) {
+            throw new Error("rootWalletKeys is required for v6 (Ironwood) signing: sign(key, rootWalletKeys) — pass it " +
+                "on every signing round, even Bitgo's, so the client-managed-ovk step is never silently " +
+                "skipped");
+        }
+        const wasmKey = BIP32.from(keyOrIndex).wasm;
+        const keys = RootWalletKeys.from(keyOrRootWalletKeys);
+        return Array.from(this.wasm.sign_ironwood_v6(wasmKey, keys.wasm), Number);
+    }
+    /**
+     * 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) {
+        return this.wasm.combine_ironwood_proof(proof);
+    }
+}

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

@@ -8,7 +8,8 @@ export { ChainCode, chainCodes, assertChainCode, type Scope } from "./chains.js"
 export { requiresPrevTxForP2sh } from "./prevTx.js";
 export { BitGoPsbt, getWalletKeysFromPsbt, type NetworkName, type ScriptId, type ParsedInput, type ParsedOutput, type ParsedTransaction, type SignPath, type CreateEmptyOptions, type AddInputOptions, type AddOutputOptions, type AddWalletInputOptions, type AddWalletOutputOptions, type ParseTransactionOptions, type ParseOutputsOptions, type HydrationUnspent, } from "./BitGoPsbt.js";
 export { BitGoKeySubtype, type PsbtKvKey } from "./BitGoKeySubtype.js";
-export { ZcashBitGoPsbt, type ZcashNetworkName, type CreateEmptyZcashOptions, } from "./ZcashBitGoPsbt.js";
+export { ZcashBitGoPsbt, type ZcashNetworkName, type CreateEmptyZcashOptions, IRONWOOD_VERSION_GROUP_ID, } from "./ZcashBitGoPsbt.js";
+export { ZcashIronwoodBitGoPsbt, zip302NoMemo, type CreateEmptyIronwoodOptions, type CreateEmptyIronwoodWithConsensusBranchIdOptions, } from "./ZcashIronwoodBitGoPsbt.js";
 export { ZcashUnifiedAddress } from "./ZcashUnifiedAddress.js";
 export { ZcashV6Transaction } from "./ZcashV6Transaction.js";
 import type { ScriptType } from "./scriptType.js";

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

@@ -11,7 +11,9 @@ export { requiresPrevTxForP2sh } from "./prevTx.js";
 export { BitGoPsbt, getWalletKeysFromPsbt, } from "./BitGoPsbt.js";
 export { BitGoKeySubtype } from "./BitGoKeySubtype.js";
 // Zcash-specific PSBT subclass
-export { ZcashBitGoPsbt, } from "./ZcashBitGoPsbt.js";
+export { ZcashBitGoPsbt, IRONWOOD_VERSION_GROUP_ID, } from "./ZcashBitGoPsbt.js";
+// Zcash v6 (Ironwood / NU6.3) shielding PSBT
+export { ZcashIronwoodBitGoPsbt, zip302NoMemo, } from "./ZcashIronwoodBitGoPsbt.js";
 // Zcash ZIP-316 Unified Address
 export { ZcashUnifiedAddress } from "./ZcashUnifiedAddress.js";
 // Zcash v6 (Ironwood / NU6.3) transaction

package/dist/esm/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/esm/js/wasm/wasm_utxo.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./wasm_utxo_bg.js";
 __wbg_set_wasm(wasm);
 
 export {
-    AddressNamespace, Bip322Namespace, BitGoPsbt, FixedScriptWalletNamespace, InscriptionsNamespace, MessageNamespace, UtxolibCompatNamespace, WasmBIP32, WasmDashTransaction, WasmDimensions, WasmECPair, WasmReplayProtection, WasmRootWalletKeys, WasmTransaction, WasmUtxoNamespace, WasmZcashTransaction, WrapDescriptor, WrapMiniscript, WrapPsbt, ZcashUnifiedAddress, ZcashV6Transaction, isInspectEnabled, parsePsbtRawToJson, parsePsbtToJson, parseTxToJson, zcash_branch_id_for_height
+    AddressNamespace, Bip322Namespace, BitGoPsbt, FixedScriptWalletNamespace, InscriptionsNamespace, MessageNamespace, UtxolibCompatNamespace, WasmBIP32, WasmDashTransaction, WasmDimensions, WasmECPair, WasmReplayProtection, WasmRootWalletKeys, WasmTransaction, WasmUtxoNamespace, WasmZcashTransaction, WrapDescriptor, WrapMiniscript, WrapPsbt, ZcashUnifiedAddress, ZcashV6Transaction, isInspectEnabled, parsePsbtRawToJson, parsePsbtToJson, parseTxToJson, zcash_branch_id_for_height, zcash_ironwood_version_group_id
 } from "./wasm_utxo_bg.js";