@bitgo/wasm-utxo 4.34.0 → 4.36.0

package/dist/cjs/js/address.d.ts

@@ -4,5 +4,13 @@ import type { CoinName } from "./coinName.js";
  * For Bitcoin Cash and eCash, we can select between base58check and cashaddr.
  */
 export type AddressFormat = "default" | "cashaddr";
-export declare function toOutputScriptWithCoin(address: string, coin: CoinName): Uint8Array;
+/**
+ * @param canBeShieldedOutput - When set and `address` is a ZIP-316 unified address carrying an
+ * Orchard/Ironwood receiver, returns that raw 43-byte receiver instead of a transparent
+ * scriptPubKey (there is no scriptPubKey for a shielded output). `address` is only even
+ * attempted as a unified address when this is set. If `address` looks like a unified address for
+ * this coin's network but is malformed, or has no Orchard/Ironwood receiver (e.g. Sapling-only),
+ * this throws rather than falling back to the transparent path.
+ */
+export declare function toOutputScriptWithCoin(address: string, coin: CoinName, canBeShieldedOutput?: boolean): Uint8Array;
 export declare function fromOutputScriptWithCoin(script: Uint8Array, coin: CoinName, format?: AddressFormat): string;

package/dist/cjs/js/address.js

@@ -3,8 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.toOutputScriptWithCoin = toOutputScriptWithCoin;
 exports.fromOutputScriptWithCoin = fromOutputScriptWithCoin;
 const wasm_utxo_js_1 = require("./wasm/wasm_utxo.js");
-function toOutputScriptWithCoin(address, coin) {
-    return wasm_utxo_js_1.AddressNamespace.to_output_script_with_coin(address, coin);
+/**
+ * @param canBeShieldedOutput - When set and `address` is a ZIP-316 unified address carrying an
+ * Orchard/Ironwood receiver, returns that raw 43-byte receiver instead of a transparent
+ * scriptPubKey (there is no scriptPubKey for a shielded output). `address` is only even
+ * attempted as a unified address when this is set. If `address` looks like a unified address for
+ * this coin's network but is malformed, or has no Orchard/Ironwood receiver (e.g. Sapling-only),
+ * this throws rather than falling back to the transparent path.
+ */
+function toOutputScriptWithCoin(address, coin, canBeShieldedOutput) {
+    return wasm_utxo_js_1.AddressNamespace.to_output_script_with_coin(address, coin, canBeShieldedOutput);
 }
 function fromOutputScriptWithCoin(script, coin, format) {
     return wasm_utxo_js_1.AddressNamespace.from_output_script_with_coin(script, coin, format);

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

@@ -40,6 +40,16 @@ export type ParsedOutput = {
     paygo: boolean;
     /** Full BIP32 derivation path from the wallet xpub (e.g. "0/1"). Null for external outputs. */
     derivationPath: string | null;
+    /**
+     * True for a shielded (Orchard/Ironwood) output. Such an output has no `unsigned_tx` entry of
+     * its own — it lives in the PSBT's proprietary-map PCZT, read from its plaintext (not
+     * encrypted/decrypted) recipient field. `address` is a single-receiver ZIP-316 unified address
+     * (`u1...`/`utest1...`) encoding that receiver — a real, usable Zcash address, though not
+     * necessarily byte-identical to whatever multi-receiver UA the sender originally pasted in (a
+     * UA with a transparent/Sapling receiver too would round-trip to a different string carrying
+     * only the Orchard one). `script` holds the same receiver as raw 43 bytes.
+     */
+    isShielded: boolean;
 };
 export type ParsedTransaction = {
     inputs: ParsedInput[];

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

@@ -230,4 +230,18 @@ export declare class ZcashIronwoodBitGoPsbt extends ZcashBitGoPsbt {
      * errors (bad proof, unsigned input) leaves the PSBT retryable.
      */
     combineProof(proof: Uint8Array): Uint8Array;
+    /**
+     * The raw serialized orchard PCZT (Partially Created Zcash Transaction) bundle stored in this
+     * PSBT, or `undefined` if none is present.
+     *
+     * A PCZT is the shielded-bundle counterpart to a PSBT: it accumulates the orchard action
+     * (spend + output), the ZIP-244-committed `out_ciphertext`, and — once {@link combineProof} has
+     * run — the Halo2 `zkproof` and binding signature, bridging this PSBT to the external proof
+     * service and back.
+     *
+     * Present only after {@link addShieldedOutput} has been called; `undefined` beforehand, and
+     * `undefined` again after {@link combineProof} succeeds, since that call drops the stored PCZT
+     * to make extraction terminal (see its doc comment).
+     */
+    getPczt(): Uint8Array | undefined;
 }

package/dist/cjs/js/fixedScriptWallet/ZcashIronwoodBitGoPsbt.js

@@ -223,5 +223,21 @@ class ZcashIronwoodBitGoPsbt extends ZcashBitGoPsbt_js_1.ZcashBitGoPsbt {
     combineProof(proof) {
         return this.wasm.combine_ironwood_proof(proof);
     }
+    /**
+     * The raw serialized orchard PCZT (Partially Created Zcash Transaction) bundle stored in this
+     * PSBT, or `undefined` if none is present.
+     *
+     * A PCZT is the shielded-bundle counterpart to a PSBT: it accumulates the orchard action
+     * (spend + output), the ZIP-244-committed `out_ciphertext`, and — once {@link combineProof} has
+     * run — the Halo2 `zkproof` and binding signature, bridging this PSBT to the external proof
+     * service and back.
+     *
+     * Present only after {@link addShieldedOutput} has been called; `undefined` beforehand, and
+     * `undefined` again after {@link combineProof} succeeds, since that call drops the stored PCZT
+     * to make extraction terminal (see its doc comment).
+     */
+    getPczt() {
+        return this.wasm.ironwood_pczt_bytes();
+    }
 }
 exports.ZcashIronwoodBitGoPsbt = ZcashIronwoodBitGoPsbt;

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

@@ -52,6 +52,19 @@ export declare class ZcashUnifiedAddress {
      * @throws If `candidate` is malformed or on the wrong network
      */
     contains(candidate: string): boolean;
+    /**
+     * Encode a raw 43-byte Orchard/Ironwood receiver as a single-receiver Unified Address.
+     *
+     * Deliberately narrower than a general UA encoder: this always produces exactly one receiver,
+     * so it can't reproduce a multi-receiver UA (transparent + Sapling + Orchard) a sender might
+     * have originally pasted in — it only gives back *a* valid, usable address for the
+     * Orchard/Ironwood receiver itself.
+     *
+     * @param receiver - 43-byte raw Orchard/Ironwood receiver
+     * @param network - Zcash network name ("zcash", "zcashTest", "zec", "tzec")
+     * @throws If `receiver` is not 43 bytes, or `network` is unrecognized
+     */
+    static encodeOrchardReceiver(receiver: Uint8Array, network: ZcashNetworkName): string;
     /** @internal */
     get wasm(): WasmZcashUnifiedAddress;
 }

package/dist/cjs/js/fixedScriptWallet/ZcashUnifiedAddress.js

@@ -66,6 +66,21 @@ class ZcashUnifiedAddress {
     contains(candidate) {
         return this._wasm.contains(candidate);
     }
+    /**
+     * Encode a raw 43-byte Orchard/Ironwood receiver as a single-receiver Unified Address.
+     *
+     * Deliberately narrower than a general UA encoder: this always produces exactly one receiver,
+     * so it can't reproduce a multi-receiver UA (transparent + Sapling + Orchard) a sender might
+     * have originally pasted in — it only gives back *a* valid, usable address for the
+     * Orchard/Ironwood receiver itself.
+     *
+     * @param receiver - 43-byte raw Orchard/Ironwood receiver
+     * @param network - Zcash network name ("zcash", "zcashTest", "zec", "tzec")
+     * @throws If `receiver` is not 43 bytes, or `network` is unrecognized
+     */
+    static encodeOrchardReceiver(receiver, network) {
+        return wasm_utxo_js_1.ZcashUnifiedAddress.encodeOrchardReceiver(receiver, network);
+    }
     /** @internal */
     get wasm() {
         return this._wasm;

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

@@ -40,6 +40,15 @@ export declare class ZcashV6Transaction {
     get ironwoodFlags(): number | undefined;
     /** The Ironwood note-commitment tree anchor (32 bytes), or `undefined`. */
     get ironwoodAnchor(): Uint8Array | undefined;
+    /**
+     * The ZIP-244 per-input transparent sighash (32 bytes) for transparent input `index` —
+     * for a transaction inspected directly from its raw bytes rather than one built via a
+     * PSBT (e.g. independently verifying an already-broadcast transaction's signatures).
+     *
+     * `inputAmounts`/`inputScriptPubkeys` are the spent outputs' values (zatoshi) and
+     * scriptPubKeys for *every* transparent input of this transaction, in input order.
+     */
+    transparentSighash(index: number, inputAmounts: bigint[], inputScriptPubkeys: Uint8Array[]): Uint8Array;
     /** @internal */
     get wasm(): WasmZcashV6Transaction;
 }

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

@@ -65,6 +65,17 @@ class ZcashV6Transaction {
     get ironwoodAnchor() {
         return this._wasm.ironwoodAnchor;
     }
+    /**
+     * The ZIP-244 per-input transparent sighash (32 bytes) for transparent input `index` —
+     * for a transaction inspected directly from its raw bytes rather than one built via a
+     * PSBT (e.g. independently verifying an already-broadcast transaction's signatures).
+     *
+     * `inputAmounts`/`inputScriptPubkeys` are the spent outputs' values (zatoshi) and
+     * scriptPubKeys for *every* transparent input of this transaction, in input order.
+     */
+    transparentSighash(index, inputAmounts, inputScriptPubkeys) {
+        return this._wasm.transparentSighash(index, BigInt64Array.from(inputAmounts), inputScriptPubkeys);
+    }
     /** @internal */
     get wasm() {
         return this._wasm;

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

@@ -6,7 +6,13 @@ export class AddressNamespace {
     free(): void;
     [Symbol.dispose](): void;
     static from_output_script_with_coin(script: Uint8Array, coin: string, format?: string | null): string;
-    static to_output_script_with_coin(address: string, coin: string): Uint8Array;
+    /**
+     * `can_be_shielded_output`: when set and `address` is a ZIP-316 unified address carrying an
+     * Orchard/Ironwood receiver, returns that raw 43-byte receiver instead of a transparent
+     * scriptPubKey. See [`to_output_script_or_shielded_receiver_with_coin`] for the exact
+     * fallback/error rules.
+     */
+    static to_output_script_with_coin(address: string, coin: string, can_be_shielded_output?: boolean | null): Uint8Array;
 }
 
 /**
@@ -474,6 +480,21 @@ export class BitGoPsbt {
      */
     get_unsigned_tx(): Uint8Array;
     input_count(): number;
+    /**
+     * The raw serialized orchard PCZT (Partially Created Zcash Transaction) bundle stored in
+     * this v6 (Ironwood) PSBT's proprietary key-value map, or `undefined` if none is present.
+     *
+     * A PCZT is the shielded-bundle counterpart to a PSBT: it accumulates the orchard action
+     * (spend + output), the ZIP-244-committed `out_ciphertext`, and — once
+     * [`Self::combine_ironwood_proof`] has run — the Halo2 `zkproof` and binding signature,
+     * bridging this PSBT to the external proof service and back (see
+     * [`crate::zcash::ironwood_pczt`] / [`crate::zcash::ironwood_build`]).
+     *
+     * Present only after [`Self::add_ironwood_output`] has been called on a v6 PSBT; `undefined`
+     * beforehand, and `undefined` again after [`Self::combine_ironwood_proof`] succeeds, since
+     * that call drops the stored PCZT to make extraction terminal (see its doc comment).
+     */
+    ironwood_pczt_bytes(): Uint8Array | undefined;
     /**
      * The ZIP-244 per-input transparent sighash (32 bytes) that the key controlling transparent
      * input `index` must sign.
@@ -1689,6 +1710,16 @@ export class ZcashUnifiedAddress {
      * on the same network) is a receiver of this Unified Address.
      */
     contains(candidate: string): boolean;
+    /**
+     * Encode a raw 43-byte Orchard/Ironwood receiver as a single-receiver Unified Address for
+     * `network` ("zcash"/"zec" or "zcashTest"/"tzec").
+     *
+     * Deliberately narrower than a general UA encoder: this always produces exactly one
+     * receiver, so it can't reproduce a multi-receiver UA (transparent + Sapling + Orchard) a
+     * sender might have originally pasted in — only give back *a* valid, usable address for the
+     * Orchard/Ironwood receiver itself.
+     */
+    static encodeOrchardReceiver(receiver: Uint8Array, network: string): string;
     /**
      * Parse a Unified Address for `network` ("zcash"/"zec" or "zcashTest"/"tzec").
      *
@@ -1738,6 +1769,18 @@ export class ZcashV6Transaction {
      * Serialize back to raw v6 wire bytes.
      */
     toBytes(): Uint8Array;
+    /**
+     * The ZIP-244 per-input transparent sighash (32 bytes) for transparent input `index` of
+     * this transaction — the free-standing counterpart to
+     * `ZcashIronwoodBitGoPsbt.transparentSighash`, for a transaction inspected directly from
+     * its raw bytes rather than one built via this codebase's PSBT flow (e.g. independently
+     * verifying an already-broadcast transaction's signatures).
+     *
+     * `input_amounts`/`input_script_pubkeys` are the spent outputs' values (zatoshi) and
+     * scriptPubKeys for *every* transparent input of this transaction, in input order — the
+     * same data `add-input`/`addWalletInput` would have carried in a PSBT's `witness_utxo`.
+     */
+    transparentSighash(index: number, input_amounts: BigInt64Array, input_script_pubkeys: Uint8Array[]): Uint8Array;
     /**
      * The ZIP-244 txid in internal (non-reversed) byte order.
      */

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

@@ -48,18 +48,23 @@ class AddressNamespace {
         }
     }
     /**
+     * `can_be_shielded_output`: when set and `address` is a ZIP-316 unified address carrying an
+     * Orchard/Ironwood receiver, returns that raw 43-byte receiver instead of a transparent
+     * scriptPubKey. See [`to_output_script_or_shielded_receiver_with_coin`] for the exact
+     * fallback/error rules.
      * @param {string} address
      * @param {string} coin
+     * @param {boolean | null} [can_be_shielded_output]
      * @returns {Uint8Array}
      */
-    static to_output_script_with_coin(address, coin) {
+    static to_output_script_with_coin(address, coin, can_be_shielded_output) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passStringToWasm0(address, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passStringToWasm0(coin, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len1 = WASM_VECTOR_LEN;
-            wasm.addressnamespace_to_output_script_with_coin(retptr, ptr0, len0, ptr1, len1);
+            wasm.addressnamespace_to_output_script_with_coin(retptr, ptr0, len0, ptr1, len1, isLikeNone(can_be_shielded_output) ? 0xFFFFFF : can_be_shielded_output ? 1 : 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);
@@ -1792,6 +1797,37 @@ class BitGoPsbt {
         const ret = wasm.bitgopsbt_input_count(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * The raw serialized orchard PCZT (Partially Created Zcash Transaction) bundle stored in
+     * this v6 (Ironwood) PSBT's proprietary key-value map, or `undefined` if none is present.
+     *
+     * A PCZT is the shielded-bundle counterpart to a PSBT: it accumulates the orchard action
+     * (spend + output), the ZIP-244-committed `out_ciphertext`, and — once
+     * [`Self::combine_ironwood_proof`] has run — the Halo2 `zkproof` and binding signature,
+     * bridging this PSBT to the external proof service and back (see
+     * [`crate::zcash::ironwood_pczt`] / [`crate::zcash::ironwood_build`]).
+     *
+     * Present only after [`Self::add_ironwood_output`] has been called on a v6 PSBT; `undefined`
+     * beforehand, and `undefined` again after [`Self::combine_ironwood_proof`] succeeds, since
+     * that call drops the stored PCZT to make extraction terminal (see its doc comment).
+     * @returns {Uint8Array | undefined}
+     */
+    ironwood_pczt_bytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bitgopsbt_ironwood_pczt_bytes(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getArrayU8FromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * The ZIP-244 per-input transparent sighash (32 bytes) that the key controlling transparent
      * input `index` must sign.
@@ -6545,6 +6581,46 @@ class ZcashUnifiedAddress {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Encode a raw 43-byte Orchard/Ironwood receiver as a single-receiver Unified Address for
+     * `network` ("zcash"/"zec" or "zcashTest"/"tzec").
+     *
+     * Deliberately narrower than a general UA encoder: this always produces exactly one
+     * receiver, so it can't reproduce a multi-receiver UA (transparent + Sapling + Orchard) a
+     * sender might have originally pasted in — only give back *a* valid, usable address for the
+     * Orchard/Ironwood receiver itself.
+     * @param {Uint8Array} receiver
+     * @param {string} network
+     * @returns {string}
+     */
+    static encodeOrchardReceiver(receiver, network) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(receiver, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(network, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.zcashunifiedaddress_encodeOrchardReceiver(retptr, ptr0, len0, 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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr3 = r0;
+            var len3 = r1;
+            if (r3) {
+                ptr3 = 0; len3 = 0;
+                throw takeObject(r2);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+        }
+    }
     /**
      * The Orchard/Ironwood receiver's raw 43 bytes (diversifier + pk_d), or `undefined`.
      * @returns {Uint8Array | undefined}
@@ -6791,6 +6867,43 @@ class ZcashV6Transaction {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * The ZIP-244 per-input transparent sighash (32 bytes) for transparent input `index` of
+     * this transaction — the free-standing counterpart to
+     * `ZcashIronwoodBitGoPsbt.transparentSighash`, for a transaction inspected directly from
+     * its raw bytes rather than one built via this codebase's PSBT flow (e.g. independently
+     * verifying an already-broadcast transaction's signatures).
+     *
+     * `input_amounts`/`input_script_pubkeys` are the spent outputs' values (zatoshi) and
+     * scriptPubKeys for *every* transparent input of this transaction, in input order — the
+     * same data `add-input`/`addWalletInput` would have carried in a PSBT's `witness_utxo`.
+     * @param {number} index
+     * @param {BigInt64Array} input_amounts
+     * @param {Uint8Array[]} input_script_pubkeys
+     * @returns {Uint8Array}
+     */
+    transparentSighash(index, input_amounts, input_script_pubkeys) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray64ToWasm0(input_amounts, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayJsValueToWasm0(input_script_pubkeys, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.zcashv6transaction_transparentSighash(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);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v3 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v3;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * The ZIP-244 txid in internal (non-reversed) byte order.
      * @returns {Uint8Array}
@@ -7445,6 +7558,14 @@ function getArrayU8FromWasm0(ptr, len) {
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+let cachedBigUint64ArrayMemory0 = null;
+function getBigUint64ArrayMemory0() {
+    if (cachedBigUint64ArrayMemory0 === null || cachedBigUint64ArrayMemory0.byteLength === 0) {
+        cachedBigUint64ArrayMemory0 = new BigUint64Array(wasm.memory.buffer);
+    }
+    return cachedBigUint64ArrayMemory0;
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -7493,6 +7614,13 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function passArray64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getBigUint64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);