@bitgo/wasm-utxo 5.3.0 → 5.5.0

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

@@ -1,4 +1,20 @@
 import { IronwoodWitness as WasmIronwoodWitness } from "../wasm/wasm_utxo.js";
+/**
+ * A node of a pruned Orchard note-commitment (sub)tree, for {@link ZcashIronwoodWitness.buildFromShard}'s
+ * `shard`/`cap` inputs. Mirrors a real pruned tree store's shape (e.g. a `shardtree::ShardTree`):
+ * most leaves are never individually retained, only enough annotated hashes to reproduce a witness.
+ */
+export type ShardTreeNode = {
+    type: "Nil";
+} | {
+    type: "Leaf";
+    hash: Uint8Array;
+} | {
+    type: "Parent";
+    hash?: Uint8Array;
+    left: ShardTreeNode;
+    right: ShardTreeNode;
+};
 /**
  * A validated Merkle witness for an Ironwood/Orchard note commitment.
  *
@@ -19,6 +35,19 @@ export declare class ZcashIronwoodWitness {
      *   recompute to `anchor`
      */
     static build(cmx: Uint8Array, position: number, authPath: Uint8Array[], anchor: Uint8Array): ZcashIronwoodWitness;
+    /**
+     * Build and validate a Merkle witness from a pruned shard + cap, instead of a
+     * caller-precomputed 32-entry path.
+     *
+     * `shardHeight` chooses which level the shard's root sits at (it spans up to `2^shardHeight`
+     * leaves); `shard` is the pruned subtree containing `position`, rooted at that level; `cap` is
+     * the pruned tree above every shard, down to (and including) shard-root nodes. `leafCount` is
+     * the total number of leaves committed to the tree as of `anchor` — positions beyond it are
+     * treated as canonically empty.
+     * @throws Under the same conditions as {@link build}, plus if `shard`/`cap` don't have enough
+     *   detail to witness `position` as of `leafCount`
+     */
+    static buildFromShard(position: number, shardHeight: number, leafCount: bigint, cmx: Uint8Array, shard: ShardTreeNode, cap: ShardTreeNode, anchor: Uint8Array): ZcashIronwoodWitness;
     /** The leaf's position in the note commitment tree. */
     get position(): number;
     /**

package/dist/cjs/js/fixedScriptWallet/ZcashIronwoodWitness.js

@@ -26,6 +26,21 @@ class ZcashIronwoodWitness {
     static build(cmx, position, authPath, anchor) {
         return new ZcashIronwoodWitness((0, wasm_utxo_js_1.ironwood_build_witness)(cmx, position, authPath, anchor));
     }
+    /**
+     * Build and validate a Merkle witness from a pruned shard + cap, instead of a
+     * caller-precomputed 32-entry path.
+     *
+     * `shardHeight` chooses which level the shard's root sits at (it spans up to `2^shardHeight`
+     * leaves); `shard` is the pruned subtree containing `position`, rooted at that level; `cap` is
+     * the pruned tree above every shard, down to (and including) shard-root nodes. `leafCount` is
+     * the total number of leaves committed to the tree as of `anchor` — positions beyond it are
+     * treated as canonically empty.
+     * @throws Under the same conditions as {@link build}, plus if `shard`/`cap` don't have enough
+     *   detail to witness `position` as of `leafCount`
+     */
+    static buildFromShard(position, shardHeight, leafCount, cmx, shard, cap, anchor) {
+        return new ZcashIronwoodWitness((0, wasm_utxo_js_1.ironwood_build_witness_from_shard)(position, shardHeight, leafCount, cmx, shard, cap, anchor));
+    }
     /** The leaf's position in the note commitment tree. */
     get position() {
         return this._wasm.position;

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

@@ -1,4 +1,5 @@
 import { ZcashV6Transaction as WasmZcashV6Transaction } from "../wasm/wasm_utxo.js";
+import type { TxInputData } from "../wasm/wasm_utxo.js";
 /**
  * A parsed Zcash v6 (Ironwood / NU6.3) transaction — for inspection and txid.
  *
@@ -49,6 +50,12 @@ export declare class ZcashV6Transaction {
      * scriptPubKeys for *every* transparent input of this transaction, in input order.
      */
     transparentSighash(index: number, inputAmounts: bigint[], inputScriptPubkeys: Uint8Array[]): Uint8Array;
+    /**
+     * The transparent inputs of this transaction, in input order — e.g. each input's
+     * `previousOutput` (display-order txid + vout) for looking up the spent UTXOs of a broadcast
+     * shielding transaction. Empty for a fully shielded transaction.
+     */
+    getInputs(): TxInputData[];
     /** @internal */
     get wasm(): WasmZcashV6Transaction;
 }

package/dist/cjs/js/fixedScriptWallet/ZcashV6Transaction.js

@@ -76,6 +76,14 @@ class ZcashV6Transaction {
     transparentSighash(index, inputAmounts, inputScriptPubkeys) {
         return this._wasm.transparentSighash(index, BigInt64Array.from(inputAmounts), inputScriptPubkeys);
     }
+    /**
+     * The transparent inputs of this transaction, in input order — e.g. each input's
+     * `previousOutput` (display-order txid + vout) for looking up the spent UTXOs of a broadcast
+     * shielding transaction. Empty for a fully shielded transaction.
+     */
+    getInputs() {
+        return this._wasm.getInputs();
+    }
     /** @internal */
     get wasm() {
         return this._wasm;

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

@@ -14,6 +14,7 @@ export { ZcashIronwoodBitGoPsbt, zip302NoMemo, type CreateEmptyIronwoodOptions,
 export { ZcashUnifiedAddress } from "./ZcashUnifiedAddress.js";
 export { ZcashV6Transaction } from "./ZcashV6Transaction.js";
 export { ZcashIronwoodWitness } from "./ZcashIronwoodWitness.js";
+export type { ShardTreeNode } from "./ZcashIronwoodWitness.js";
 import type { ScriptType } from "./scriptType.js";
 /**
  * Check if a network supports a given fixed-script wallet script type

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

@@ -1865,6 +1865,12 @@ export class ZcashV6Transaction {
      * transaction id is printed everywhere else in the codebase.
      */
     getId(): string;
+    /**
+     * The transparent inputs of this transaction, in input order — each input's
+     * `previousOutput` (display-order txid + vout), sequence, scriptSig, and witness, carried
+     * verbatim from the wire. Empty for a fully shielded transaction.
+     */
+    getInputs(): TxInputData[];
     /**
      * Serialize back to raw v6 wire bytes.
      */
@@ -1924,6 +1930,23 @@ export class ZcashV6Transaction {
  */
 export function ironwood_build_witness(cmx: Uint8Array, position: number, auth_path: Uint8Array[], anchor: Uint8Array): IronwoodWitness;
 
+/**
+ * Build and validate an Ironwood witness from a pruned shard + cap, instead of a
+ * caller-precomputed 32-entry path (see `ironwood_build_witness`).
+ *
+ * `shardHeight` chooses which level the shard's root sits at (it spans up to `2^shardHeight`
+ * leaves); `shard` is the pruned subtree containing `position`, rooted at that level; `cap` is the
+ * pruned tree above every shard, down to (and including) shard-root nodes. `leafCount` is the
+ * total number of leaves committed to the tree as of `anchor` — positions beyond it are treated
+ * as canonically empty. `shard`/`cap` are plain JS objects (not JSON strings) shaped like:
+ * `{ type: "Nil" } | { type: "Leaf", hash: Uint8Array } | { type: "Parent", hash?: Uint8Array,
+ * left: ShardTreeNode, right: ShardTreeNode }`.
+ *
+ * Throws under the same conditions as `ironwood_build_witness`, plus if `shard`/`cap` don't have
+ * enough detail to witness `position` as of `leafCount`.
+ */
+export function ironwood_build_witness_from_shard(position: number, shard_height: number, leaf_count: bigint, cmx: Uint8Array, shard: any, cap: any, anchor: Uint8Array): IronwoodWitness;
+
 /**
  * Check if the inspect feature is enabled.
  *

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

@@ -7106,6 +7106,27 @@ class ZcashV6Transaction {
             wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * The transparent inputs of this transaction, in input order — each input's
+     * `previousOutput` (display-order txid + vout), sequence, scriptSig, and witness, carried
+     * verbatim from the wire. Empty for a fully shielded transaction.
+     * @returns {TxInputData[]}
+     */
+    getInputs() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.zcashv6transaction_getInputs(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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Number of Ironwood actions (0 when the Ironwood slot is empty).
      * @returns {number}
@@ -7269,6 +7290,50 @@ function ironwood_build_witness(cmx, position, auth_path, anchor) {
 }
 exports.ironwood_build_witness = ironwood_build_witness;
 
+/**
+ * Build and validate an Ironwood witness from a pruned shard + cap, instead of a
+ * caller-precomputed 32-entry path (see `ironwood_build_witness`).
+ *
+ * `shardHeight` chooses which level the shard's root sits at (it spans up to `2^shardHeight`
+ * leaves); `shard` is the pruned subtree containing `position`, rooted at that level; `cap` is the
+ * pruned tree above every shard, down to (and including) shard-root nodes. `leafCount` is the
+ * total number of leaves committed to the tree as of `anchor` — positions beyond it are treated
+ * as canonically empty. `shard`/`cap` are plain JS objects (not JSON strings) shaped like:
+ * `{ type: "Nil" } | { type: "Leaf", hash: Uint8Array } | { type: "Parent", hash?: Uint8Array,
+ * left: ShardTreeNode, right: ShardTreeNode }`.
+ *
+ * Throws under the same conditions as `ironwood_build_witness`, plus if `shard`/`cap` don't have
+ * enough detail to witness `position` as of `leafCount`.
+ * @param {number} position
+ * @param {number} shard_height
+ * @param {bigint} leaf_count
+ * @param {Uint8Array} cmx
+ * @param {any} shard
+ * @param {any} cap
+ * @param {Uint8Array} anchor
+ * @returns {IronwoodWitness}
+ */
+function ironwood_build_witness_from_shard(position, shard_height, leaf_count, cmx, shard, cap, anchor) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(cmx, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(anchor, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.ironwood_build_witness_from_shard(retptr, position, shard_height, leaf_count, ptr0, len0, addHeapObject(shard), addHeapObject(cap), ptr1, len1);
+        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 IronwoodWitness.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.ironwood_build_witness_from_shard = ironwood_build_witness_from_shard;
+
 /**
  * Check if the inspect feature is enabled.
  *
@@ -7602,6 +7667,13 @@ function __wbg_get_imports() {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
         },
+        __wbg_String_8f0eb39a4a4c2f66: function(arg0, arg1) {
+            const ret = String(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg___wbindgen_bigint_get_as_i64_8fcf4ce7f1ca72a2: function(arg0, arg1) {
             const v = getObject(arg1);
             const ret = typeof(v) === 'bigint' ? v : undefined;
@@ -7620,6 +7692,10 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
+        __wbg___wbindgen_in_47fa6863be6f2f25: function(arg0, arg1) {
+            const ret = getObject(arg0) in getObject(arg1);
+            return ret;
+        },
         __wbg___wbindgen_is_bigint_31b12575b56f32fc: function(arg0) {
             const ret = typeof(getObject(arg0)) === 'bigint';
             return ret;
@@ -7649,6 +7725,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0) === getObject(arg1);
             return ret;
         },
+        __wbg___wbindgen_jsval_loose_eq_9dd77d8cd6671811: function(arg0, arg1) {
+            const ret = getObject(arg0) == getObject(arg1);
+            return ret;
+        },
         __wbg___wbindgen_number_get_8ff4255516ccad3e: function(arg0, arg1) {
             const obj = getObject(arg1);
             const ret = typeof(obj) === 'number' ? obj : undefined;
@@ -7678,6 +7758,14 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).crypto;
             return addHeapObject(ret);
         },
+        __wbg_done_57b39ecd9addfe81: function(arg0) {
+            const ret = getObject(arg0).done;
+            return ret;
+        },
+        __wbg_entries_58c7934c745daac7: function(arg0) {
+            const ret = Object.entries(getObject(arg0));
+            return addHeapObject(ret);
+        },
         __wbg_for_c3adefd268cb6f1c: function(arg0, arg1) {
             const ret = Symbol.for(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
@@ -7697,6 +7785,48 @@ function __wbg_get_imports() {
             const ret = Reflect.get(getObject(arg0), getObject(arg1));
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_instanceof_ArrayBuffer_c367199e2fa2aa04: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof ArrayBuffer;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Map_53af74335dec57f4: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Map;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_9b9075935c74707c: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_isArray_d314bb98fcf08331: function(arg0) {
+            const ret = Array.isArray(getObject(arg0));
+            return ret;
+        },
+        __wbg_isSafeInteger_bfbc7332a9768d2a: function(arg0) {
+            const ret = Number.isSafeInteger(getObject(arg0));
+            return ret;
+        },
+        __wbg_iterator_6ff6560ca1568e55: function() {
+            const ret = Symbol.iterator;
+            return addHeapObject(ret);
+        },
         __wbg_length_32ed9a279acd054c: function(arg0) {
             const ret = getObject(arg0).length;
             return ret;
@@ -7737,6 +7867,14 @@ function __wbg_get_imports() {
             const ret = new Uint8Array(arg0 >>> 0);
             return addHeapObject(ret);
         },
+        __wbg_next_3482f54c49e8af19: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).next();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_next_418f80d8f5303233: function(arg0) {
+            const ret = getObject(arg0).next;
+            return addHeapObject(ret);
+        },
         __wbg_node_905d3e251edff8a2: function(arg0) {
             const ret = getObject(arg0).node;
             return addHeapObject(ret);
@@ -7783,6 +7921,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
             return addHeapObject(ret);
         },
+        __wbg_value_0546255b415e96c1: function(arg0) {
+            const ret = getObject(arg0).value;
+            return addHeapObject(ret);
+        },
         __wbg_versions_c01dfd4722a88165: function(arg0) {
             const ret = getObject(arg0).versions;
             return addHeapObject(ret);
@@ -7812,17 +7954,22 @@ function __wbg_get_imports() {
             const ret = arg0;
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000002: function(arg0) {
+            // Cast intrinsic for `I64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
             const ret = getArrayU8FromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000004: function(arg0) {
+        __wbindgen_cast_0000000000000005: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return addHeapObject(ret);