@bitgo/abstract-utxo 13.0.0 → 13.1.1

package/dist/esm/impl/zec/index.d.ts

@@ -1,5 +1,6 @@
 export * from './zec';
 export * from './tzec';
+export * from './shieldedAddress';
 export * from './address';
 export * from './recipients';
 export * from './types';

package/dist/esm/impl/zec/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/impl/zec/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/impl/zec/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC;AACvB,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}

package/dist/esm/impl/zec/index.js

@@ -1,6 +1,7 @@
 export * from './zec';
 export * from './tzec';
+export * from './shieldedAddress';
 export * from './address';
 export * from './recipients';
 export * from './types';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvaW1wbC96ZWMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxPQUFPLENBQUM7QUFDdEIsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3plYyc7XG5leHBvcnQgKiBmcm9tICcuL3R6ZWMnO1xuZXhwb3J0ICogZnJvbSAnLi9hZGRyZXNzJztcbmV4cG9ydCAqIGZyb20gJy4vcmVjaXBpZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvaW1wbC96ZWMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxPQUFPLENBQUM7QUFDdEIsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vemVjJztcbmV4cG9ydCAqIGZyb20gJy4vdHplYyc7XG5leHBvcnQgKiBmcm9tICcuL3NoaWVsZGVkQWRkcmVzcyc7XG5leHBvcnQgKiBmcm9tICcuL2FkZHJlc3MnO1xuZXhwb3J0ICogZnJvbSAnLi9yZWNpcGllbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuIl19

package/dist/esm/impl/zec/shieldedAddress.d.ts

@@ -0,0 +1,36 @@
+import type { UtxoCoinName } from '../../names';
+/**
+ * Platform-reported shielded address details (wallet-platform
+ * `coinSpecific.shielded` for Zcash Orchard/Ironwood addresses).
+ */
+export interface ShieldedAddressDetails {
+    /** Receiver type, e.g. 'ironwood'. */
+    type?: string;
+    /** 11-byte hex diversifier. */
+    diversifier?: string;
+    /** 32-byte hex `pk_d`. */
+    pkD?: string;
+    /** Wallet address index the diversifier was derived from. */
+    diversifierIndex?: number;
+}
+/**
+ * Verify a Zcash shielded (Orchard/Ironwood) wallet address returned by the platform.
+ *
+ * Shielded custodial wallets use RedPallas threshold keys whose keychains carry no
+ * secp256k1 xpubs, so the address cannot be locally rederived the way fixed-script
+ * (transparent) addresses are (`assertFixedScriptWalletAddress` would throw reading
+ * `pub`). Instead, this checks the address is a well-formed Orchard Unified Address
+ * whose 43-byte receiver matches the diversifier and `pk_d` the platform reports in
+ * `coinSpecific.shielded` — i.e. the UA really encodes the reported shielded receiver.
+ *
+ * @throws {UnexpectedAddressError} if the address is not a valid Orchard UA, the
+ *   platform-reported data is missing/malformed, or the UA's Orchard receiver does
+ *   not match the reported diversifier/`pk_d`
+ */
+export declare function assertShieldedWalletAddress(coinName: UtxoCoinName, params: {
+    address: string;
+    coinSpecific?: {
+        shielded?: ShieldedAddressDetails;
+    };
+}): void;
+//# sourceMappingURL=shieldedAddress.d.ts.map

package/dist/esm/impl/zec/shieldedAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shieldedAddress.d.ts","sourceRoot":"","sources":["../../../../src/impl/zec/shieldedAddress.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+BAA+B;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0BAA0B;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,YAAY,EACtB,MAAM,EAAE;IACN,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,sBAAsB,CAAA;KAAE,CAAC;CACtD,GACA,IAAI,CAoCN"}

package/dist/esm/impl/zec/shieldedAddress.js

@@ -0,0 +1,48 @@
+import { fixedScriptWallet } from '@bitgo/wasm-utxo';
+import { UnexpectedAddressError } from '@bitgo/sdk-core';
+/**
+ * Verify a Zcash shielded (Orchard/Ironwood) wallet address returned by the platform.
+ *
+ * Shielded custodial wallets use RedPallas threshold keys whose keychains carry no
+ * secp256k1 xpubs, so the address cannot be locally rederived the way fixed-script
+ * (transparent) addresses are (`assertFixedScriptWalletAddress` would throw reading
+ * `pub`). Instead, this checks the address is a well-formed Orchard Unified Address
+ * whose 43-byte receiver matches the diversifier and `pk_d` the platform reports in
+ * `coinSpecific.shielded` — i.e. the UA really encodes the reported shielded receiver.
+ *
+ * @throws {UnexpectedAddressError} if the address is not a valid Orchard UA, the
+ *   platform-reported data is missing/malformed, or the UA's Orchard receiver does
+ *   not match the reported diversifier/`pk_d`
+ */
+export function assertShieldedWalletAddress(coinName, params) {
+    const shielded = params.coinSpecific?.shielded;
+    if (!shielded?.diversifier || !shielded.pkD) {
+        throw new UnexpectedAddressError('address validation failure: shielded address missing diversifier or pkD');
+    }
+    const diversifier = Buffer.from(shielded.diversifier, 'hex');
+    const pkD = Buffer.from(shielded.pkD, 'hex');
+    if (diversifier.length !== 11) {
+        throw new UnexpectedAddressError(`address validation failure: invalid diversifier length ${diversifier.length}`);
+    }
+    if (pkD.length !== 32) {
+        throw new UnexpectedAddressError(`address validation failure: invalid pkD length ${pkD.length}`);
+    }
+    // Only zec/tzec produce shielded addresses, so the name is always a valid ZcashNetworkName.
+    const network = coinName;
+    let ua;
+    try {
+        ua = fixedScriptWallet.ZcashUnifiedAddress.parse(params.address, network);
+    }
+    catch (e) {
+        throw new UnexpectedAddressError(`address validation failure: not a valid unified address: ${params.address}`);
+    }
+    const orchard = ua.orchardReceiver;
+    if (!orchard || orchard.length !== 43) {
+        throw new UnexpectedAddressError('address validation failure: unified address carries no Orchard receiver');
+    }
+    const expectedReceiver = Buffer.concat([diversifier, pkD]);
+    if (!Buffer.from(orchard).equals(expectedReceiver)) {
+        throw new UnexpectedAddressError('address validation failure: unified address Orchard receiver does not match shielded coinSpecific');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/impl/zec/signIronwoodTransaction.d.ts

@@ -0,0 +1,29 @@
+import { BIP32, fixedScriptWallet } from '@bitgo/wasm-utxo';
+import { SignTransactionOptions } from '../../abstractUtxoCoin';
+import { ReplayProtectionKeys } from '../../transaction/fixedScript/signPsbtWasm';
+import type { Zec } from './zec';
+/**
+ * Sign all transparent inputs of a v6 (Ironwood) Zcash PSBT and verify the signatures.
+ *
+ * v6 PSBTs override `sign(key)` to require the wallet root keys: on the first signing round —
+ * which the wasm enforces to be the user's root key — they derive the wallet ovk (the ECDH
+ * agreement of `rootWalletKeys.bitgoKey()` and the user root key) and finalize the shielded
+ * output's out_ciphertext before computing any transparent sighash. Later rounds no-op that
+ * step, so rootWalletKeys is passed unconditionally. Transparent inputs are signed with
+ * ordinary ECDSA over the ZIP-244 sighash either way.
+ *
+ * The generic `signAndVerifyPsbtWasm` cannot provide this: its `tx.sign(wasmSigner)` call does
+ * not satisfy the v6 override's rootWalletKeys requirement. Verification and signed-with
+ * metadata are shared with the generic path.
+ */
+export declare function signAndVerifyIronwoodPsbt(tx: fixedScriptWallet.ZcashIronwoodBitGoPsbt, signerKeychain: BIP32, rootWalletKeys: fixedScriptWallet.RootWalletKeys, replayProtection: ReplayProtectionKeys, { writeSignedWith }?: {
+    writeSignedWith?: boolean;
+}): fixedScriptWallet.ZcashIronwoodBitGoPsbt;
+/**
+ * Sign a v6 (Ironwood) Zcash prebuild. Called from `Zec.signTransaction` once the decoded
+ * prebuild is known to be an Ironwood PSBT; every other prebuild keeps the generic path.
+ */
+export declare function signIronwoodTransaction<TNumber extends number | bigint = number>(coin: Zec, tx: fixedScriptWallet.ZcashIronwoodBitGoPsbt, params: SignTransactionOptions<TNumber>): {
+    txHex: string;
+};
+//# sourceMappingURL=signIronwoodTransaction.d.ts.map

package/dist/esm/impl/zec/signIronwoodTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signIronwoodTransaction.d.ts","sourceRoot":"","sources":["../../../../src/impl/zec/signIronwoodTransaction.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAIhE,OAAO,EACL,oBAAoB,EAGrB,MAAM,4CAA4C,CAAC;AAGpD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAEjC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,iBAAiB,CAAC,sBAAsB,EAC5C,cAAc,EAAE,KAAK,EACrB,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,gBAAgB,EAAE,oBAAoB,EACtC,EAAE,eAAuB,EAAE,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9D,iBAAiB,CAAC,sBAAsB,CAc1C;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAC9E,IAAI,EAAE,GAAG,EACT,EAAE,EAAE,iBAAiB,CAAC,sBAAsB,EAC5C,MAAM,EAAE,sBAAsB,CAAC,OAAO,CAAC,GACtC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAkBnB"}

package/dist/esm/impl/zec/signIronwoodTransaction.js

@@ -0,0 +1,50 @@
+import assert from 'assert';
+import { isTriple } from '@bitgo/sdk-core';
+import { fixedScriptWallet } from '@bitgo/wasm-utxo';
+import { getReplayProtectionPubkeys } from '../../transaction/fixedScript/replayProtection';
+import { BulkSigningError } from '../../transaction/fixedScript/SigningError';
+import { finalizeSignedPsbt } from '../../transaction/fixedScript/signTransaction';
+import { verifyPsbtSignaturesWasm, writeWasmUtxoSignedWithKv, } from '../../transaction/fixedScript/signPsbtWasm';
+import { getSignerKeychain, toSignTransactionResult } from '../../transaction/signTransaction';
+/**
+ * Sign all transparent inputs of a v6 (Ironwood) Zcash PSBT and verify the signatures.
+ *
+ * v6 PSBTs override `sign(key)` to require the wallet root keys: on the first signing round —
+ * which the wasm enforces to be the user's root key — they derive the wallet ovk (the ECDH
+ * agreement of `rootWalletKeys.bitgoKey()` and the user root key) and finalize the shielded
+ * output's out_ciphertext before computing any transparent sighash. Later rounds no-op that
+ * step, so rootWalletKeys is passed unconditionally. Transparent inputs are signed with
+ * ordinary ECDSA over the ZIP-244 sighash either way.
+ *
+ * The generic `signAndVerifyPsbtWasm` cannot provide this: its `tx.sign(wasmSigner)` call does
+ * not satisfy the v6 override's rootWalletKeys requirement. Verification and signed-with
+ * metadata are shared with the generic path.
+ */
+export function signAndVerifyIronwoodPsbt(tx, signerKeychain, rootWalletKeys, replayProtection, { writeSignedWith = false } = {}) {
+    try {
+        tx.sign(signerKeychain, rootWalletKeys);
+    }
+    catch (e) {
+        throw new BulkSigningError(e);
+    }
+    verifyPsbtSignaturesWasm(tx, signerKeychain, rootWalletKeys, replayProtection);
+    if (writeSignedWith) {
+        writeWasmUtxoSignedWithKv(tx);
+    }
+    return tx;
+}
+/**
+ * Sign a v6 (Ironwood) Zcash prebuild. Called from `Zec.signTransaction` once the decoded
+ * prebuild is known to be an Ironwood PSBT; every other prebuild keeps the generic path.
+ */
+export function signIronwoodTransaction(coin, tx, params) {
+    const signerKeychain = getSignerKeychain('prv' in params ? params.prv : undefined);
+    assert(signerKeychain, 'missing signer keychain');
+    assert(params.pubs, 'pubs are required for fixed script signing');
+    assert(isTriple(params.pubs), 'pubs must be a triple');
+    const rootWalletKeys = fixedScriptWallet.RootWalletKeys.fromXpubs(params.pubs);
+    const signedPsbt = signAndVerifyIronwoodPsbt(tx, signerKeychain, rootWalletKeys, { publicKeys: getReplayProtectionPubkeys(coin.wasmName) }, { writeSignedWith: params.writeSignedWith });
+    const signedTx = finalizeSignedPsbt(signedPsbt, params);
+    return toSignTransactionResult(signedTx, params);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/impl/zec/zec.d.ts

@@ -2,8 +2,8 @@
  * @prettier
  */
 import { fixedScriptWallet } from '@bitgo/wasm-utxo';
-import { BitGoBase, ExtraPrebuildParamsOptions, MPCAlgorithm, Wallet } from '@bitgo/sdk-core';
-import { AbstractUtxoCoin, ParseTransactionOptions } from '../../abstractUtxoCoin';
+import { BitGoBase, ExtraPrebuildParamsOptions, HalfSignedUtxoTransaction, IWallet, MPCAlgorithm, SignedTransaction, Wallet } from '@bitgo/sdk-core';
+import { AbstractUtxoCoin, ParseTransactionOptions, SignTransactionOptions, UtxoCoinSpecific, VerifyAddressOptions } from '../../abstractUtxoCoin';
 import type { ParsedTransaction } from '../../transaction/types';
 import { UtxoCoinName } from '../../names';
 import { ZecAddressCodec } from './address';
@@ -20,6 +20,14 @@ export declare class Zec extends AbstractUtxoCoin {
     getMPCAlgorithm(): MPCAlgorithm;
     static createInstance(bitgo: BitGoBase): Zec;
     get addressCodec(): ZecAddressCodec;
+    /**
+     * Shielded (Orchard/Ironwood) addresses are returned with `coinSpecific.shielded` and
+     * cannot be locally rederived from secp256k1 xpubs (RedPallas keychains carry none), so
+     * verify them against the platform-reported diversifier/pkD instead of the fixed-script
+     * transparent derivation the base class performs.
+     * @inheritdoc
+     */
+    isWalletAddress(params: VerifyAddressOptions<UtxoCoinSpecific>, wallet?: IWallet): Promise<boolean>;
     isValidAddress(address: string, param?: {
         anyFormat?: boolean;
         allowLightning?: boolean;
@@ -39,6 +47,12 @@ export declare class Zec extends AbstractUtxoCoin {
         allowedInputScriptTypes?: ("p2sh" | "p2wsh" | "p2shP2wsh" | "p2trMusig2" | "p2tr")[];
     }>;
     decodeTransaction(input: Buffer | string): fixedScriptWallet.BitGoPsbt;
+    /**
+     * Route v6 (Ironwood) prebuilds to the Ironwood signing path — its `sign` override requires
+     * the wallet root keys to derive the ovk on the user's first signing round — and keep every
+     * other prebuild (v4 and non-PSBT) on the generic path.
+     */
+    signTransaction<TNumber extends number | bigint = number>(params: SignTransactionOptions<TNumber>): Promise<SignedTransaction | HalfSignedUtxoTransaction>;
     resolveRecipientsFromPsbt(input: Buffer | string, walletKeys: fixedScriptWallet.RootWalletKeys): PsbtRecipient[];
 }
 //# sourceMappingURL=zec.d.ts.map

package/dist/esm/impl/zec/zec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zec.d.ts","sourceRoot":"","sources":["../../../../src/impl/zec/zec.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,iBAAiB,EAA8B,MAAM,kBAAkB,CAAC;AACjF,OAAO,EACL,SAAS,EACT,0BAA0B,EAC1B,YAAY,EACZ,MAAM,EAEP,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACnF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAsB,MAAM,aAAa,CAAC;AAG/D,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAyB,aAAa,EAAE,MAAM,cAAc,CAAC;AAGpE,qBAAa,GAAI,SAAQ,gBAAgB;IACvC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAS;gBAExB,KAAK,EAAE,SAAS;IAI5B;;;;;OAKG;IACH,eAAe,IAAI,YAAY;IAI/B,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,GAAG;IAI5C,IAAa,YAAY,IAAI,eAAe,CAE3C;IAED,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,cAAc,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,GAAG,OAAO;IAI7G,OAAO,CAAC,+BAA+B;IAyBxB,gBAAgB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EACtE,MAAM,EAAE,uBAAuB,CAAC,OAAO,CAAC,GACvC,OAAO,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;IASvB,sBAAsB,CAAC,WAAW,EAAE,0BAA0B,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;IASzF,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,iBAAiB,CAAC,SAAS;IAO/E,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,UAAU,EAAE,iBAAiB,CAAC,cAAc,GAAG,aAAa,EAAE;CAOjH"}
+{"version":3,"file":"zec.d.ts","sourceRoot":"","sources":["../../../../src/impl/zec/zec.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,iBAAiB,EAA8B,MAAM,kBAAkB,CAAC;AACjF,OAAO,EACL,SAAS,EACT,0BAA0B,EAC1B,yBAAyB,EACzB,OAAO,EACP,YAAY,EACZ,iBAAiB,EACjB,MAAM,EAEP,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EACvB,sBAAsB,EACtB,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAsB,MAAM,aAAa,CAAC;AAG/D,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C,OAAO,EAAyB,aAAa,EAAE,MAAM,cAAc,CAAC;AAIpE,qBAAa,GAAI,SAAQ,gBAAgB;IACvC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAS;gBAExB,KAAK,EAAE,SAAS;IAI5B;;;;;OAKG;IACH,eAAe,IAAI,YAAY;IAI/B,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,GAAG;IAI5C,IAAa,YAAY,IAAI,eAAe,CAE3C;IAED;;;;;;OAMG;IACY,eAAe,CAAC,MAAM,EAAE,oBAAoB,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAQlH,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,cAAc,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,GAAG,OAAO;IAI7G,OAAO,CAAC,+BAA+B;IAyBxB,gBAAgB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EACtE,MAAM,EAAE,uBAAuB,CAAC,OAAO,CAAC,GACvC,OAAO,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;IASvB,sBAAsB,CAAC,WAAW,EAAE,0BAA0B,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;IASzF,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,iBAAiB,CAAC,SAAS;IAQ/E;;;;OAIG;IACY,eAAe,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EACrE,MAAM,EAAE,sBAAsB,CAAC,OAAO,CAAC,GACtC,OAAO,CAAC,iBAAiB,GAAG,yBAAyB,CAAC;IAYzD,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,UAAU,EAAE,iBAAiB,CAAC,cAAc,GAAG,aAAa,EAAE;CAOjH"}

package/dist/esm/impl/zec/zec.js

@@ -2,12 +2,15 @@
  * @prettier
  */
 import { fixedScriptWallet, hasPsbtMagic, zcashAddress } from '@bitgo/wasm-utxo';
-import { AbstractUtxoCoin } from '../../abstractUtxoCoin';
+import _ from 'lodash';
+import { AbstractUtxoCoin, } from '../../abstractUtxoCoin';
 import { stringToBufferTryFormats } from '../../transaction/decode';
 import { toWasmUtxoCoinName } from '../../names';
 import { AddressCodec } from '../../transaction/recipient';
 import { ZecAddressCodec } from './address';
+import { signIronwoodTransaction } from './signIronwoodTransaction';
 import { resolvePsbtRecipients } from './recipients';
+import { assertShieldedWalletAddress } from './shieldedAddress';
 export class Zec extends AbstractUtxoCoin {
     constructor(bitgo) {
         super(bitgo);
@@ -28,6 +31,20 @@ export class Zec extends AbstractUtxoCoin {
     get addressCodec() {
         return new ZecAddressCodec(this.name, this.wasmName);
     }
+    /**
+     * Shielded (Orchard/Ironwood) addresses are returned with `coinSpecific.shielded` and
+     * cannot be locally rederived from secp256k1 xpubs (RedPallas keychains carry none), so
+     * verify them against the platform-reported diversifier/pkD instead of the fixed-script
+     * transparent derivation the base class performs.
+     * @inheritdoc
+     */
+    async isWalletAddress(params, wallet) {
+        if (params.coinSpecific?.shielded) {
+            assertShieldedWalletAddress(this.name, params);
+            return true;
+        }
+        return super.isWalletAddress(params, wallet);
+    }
     isValidAddress(address, param) {
         return this.addressCodec.isValidAddress(address);
     }
@@ -72,6 +89,23 @@ export class Zec extends AbstractUtxoCoin {
         }
         return fixedScriptWallet.ZcashPsbt.fromBytes(buffer, toWasmUtxoCoinName(this.name));
     }
+    /**
+     * Route v6 (Ironwood) prebuilds to the Ironwood signing path — its `sign` override requires
+     * the wallet root keys to derive the ovk on the user's first signing round — and keep every
+     * other prebuild (v4 and non-PSBT) on the generic path.
+     */
+    async signTransaction(params) {
+        const txPrebuild = params?.txPrebuild;
+        if (!_.isObject(txPrebuild)) {
+            // Defer to the base path for its standard missing/malformed-prebuild validation errors.
+            return super.signTransaction(params);
+        }
+        const tx = this.decodeTransactionFromPrebuild(txPrebuild);
+        if (!(tx instanceof fixedScriptWallet.ZcashIronwoodBitGoPsbt)) {
+            return super.signTransaction(params);
+        }
+        return signIronwoodTransaction(this, tx, params);
+    }
     resolveRecipientsFromPsbt(input, walletKeys) {
         const psbt = this.decodeTransaction(input);
         if (!(psbt instanceof fixedScriptWallet.ZcashBitGoPsbt)) {
@@ -80,4 +114,4 @@ export class Zec extends AbstractUtxoCoin {
         return resolvePsbtRecipients(psbt, walletKeys, this.addressCodec);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zec.js","sourceRoot":"","sources":["../../../../src/impl/zec/zec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport { fixedScriptWallet, hasPsbtMagic, zcashAddress } from '@bitgo/wasm-utxo';\nimport {\n  BitGoBase,\n  ExtraPrebuildParamsOptions,\n  MPCAlgorithm,\n  Wallet,\n  UnifiedRecipientPreference,\n} from '@bitgo/sdk-core';\n\nimport { AbstractUtxoCoin, ParseTransactionOptions } from '../../abstractUtxoCoin';\nimport type { ParsedTransaction } from '../../transaction/types';\nimport { stringToBufferTryFormats } from '../../transaction/decode';\nimport { UtxoCoinName, toWasmUtxoCoinName } from '../../names';\nimport { AddressCodec } from '../../transaction/recipient';\n\nimport { ZecAddressCodec } from './address';\nimport { resolvePsbtRecipients, PsbtRecipient } from './recipients';\nimport type { ZcashCoinName } from './types';\n\nexport class Zec extends AbstractUtxoCoin {\n  readonly name: UtxoCoinName = 'zec';\n\n  constructor(bitgo: BitGoBase) {\n    super(bitgo);\n  }\n\n  /**\n   * ZEC shielded (Orchard/Ironwood) custodial wallets use RedPallas threshold keys.\n   * Transparent (secp256k1 multisig) flows are unaffected: MPCAlgorithm is only\n   * consulted on the TSS custodial wallet-creation path.\n   * @inheritdoc\n   */\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'redpallas';\n  }\n\n  static createInstance(bitgo: BitGoBase): Zec {\n    return new Zec(bitgo);\n  }\n\n  override get addressCodec(): ZecAddressCodec {\n    return new ZecAddressCodec(this.name, this.wasmName);\n  }\n\n  isValidAddress(address: string, param?: { anyFormat?: boolean; allowLightning?: boolean } | boolean): boolean {\n    return this.addressCodec.isValidAddress(address);\n  }\n\n  private inferUnifiedRecipientPreference(\n    recipients: { address: string | undefined }[] | undefined\n  ): UnifiedRecipientPreference | undefined {\n    const shieldedness = (recipients ?? []).map((recipient): UnifiedRecipientPreference | undefined => {\n      const address = recipient.address;\n      if (address === undefined) {\n        return 'transparent';\n      }\n      if (AddressCodec.isScriptRecipient(address)) {\n        return 'transparent';\n      }\n      const hasTransparentReceiver = zcashAddress.hasTransparentReceiver(address, this.wasmName);\n      const hasOrchardReceiver = zcashAddress.hasOrchardReceiver(address, this.wasmName);\n      return hasOrchardReceiver && !hasTransparentReceiver\n        ? 'shielded'\n        : hasTransparentReceiver\n        ? 'transparent'\n        : undefined;\n    });\n    if (shieldedness.includes('shielded') && shieldedness.includes('transparent')) {\n      throw new Error('Mixed shielded and transparent recipients are not supported');\n    }\n    return shieldedness.includes('shielded') ? 'shielded' : undefined;\n  }\n\n  override async parseTransaction<TNumber extends number | bigint = number>(\n    params: ParseTransactionOptions<TNumber>\n  ): Promise<ParsedTransaction<TNumber>> {\n    const preference =\n      params.txParams.unifiedRecipientPreference ?? this.inferUnifiedRecipientPreference(params.txParams.recipients);\n    return this.parseTransactionWithAddressCodec(\n      params,\n      new ZecAddressCodec(this.name, this.wasmName, preference ?? 'transparent')\n    );\n  }\n\n  override async getExtraPrebuildParams(buildParams: ExtraPrebuildParamsOptions & { wallet: Wallet }) {\n    const extraParams = await super.getExtraPrebuildParams(buildParams);\n    const { unifiedRecipientPreference } = buildParams;\n    if (unifiedRecipientPreference === undefined) {\n      return extraParams;\n    }\n    return { ...extraParams, unifiedRecipientPreference };\n  }\n\n  override decodeTransaction(input: Buffer | string): fixedScriptWallet.BitGoPsbt {\n    const buffer = typeof input === 'string' ? stringToBufferTryFormats(input, ['hex', 'base64']) : input;\n    if (!hasPsbtMagic(buffer)) {\n      return super.decodeTransaction(input);\n    }\n    return fixedScriptWallet.ZcashPsbt.fromBytes(buffer, toWasmUtxoCoinName(this.name) as ZcashCoinName);\n  }\n  resolveRecipientsFromPsbt(input: Buffer | string, walletKeys: fixedScriptWallet.RootWalletKeys): PsbtRecipient[] {\n    const psbt = this.decodeTransaction(input);\n    if (!(psbt instanceof fixedScriptWallet.ZcashBitGoPsbt)) {\n      throw new Error('expected a Zcash PSBT');\n    }\n    return resolvePsbtRecipients(psbt, walletKeys, this.addressCodec);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zec.js","sourceRoot":"","sources":["../../../../src/impl/zec/zec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport { fixedScriptWallet, hasPsbtMagic, zcashAddress } from '@bitgo/wasm-utxo';\nimport {\n  BitGoBase,\n  ExtraPrebuildParamsOptions,\n  HalfSignedUtxoTransaction,\n  IWallet,\n  MPCAlgorithm,\n  SignedTransaction,\n  Wallet,\n  UnifiedRecipientPreference,\n} from '@bitgo/sdk-core';\nimport _ from 'lodash';\n\nimport {\n  AbstractUtxoCoin,\n  ParseTransactionOptions,\n  SignTransactionOptions,\n  UtxoCoinSpecific,\n  VerifyAddressOptions,\n} from '../../abstractUtxoCoin';\nimport type { ParsedTransaction } from '../../transaction/types';\nimport { stringToBufferTryFormats } from '../../transaction/decode';\nimport { UtxoCoinName, toWasmUtxoCoinName } from '../../names';\nimport { AddressCodec } from '../../transaction/recipient';\n\nimport { ZecAddressCodec } from './address';\nimport { signIronwoodTransaction } from './signIronwoodTransaction';\nimport { resolvePsbtRecipients, PsbtRecipient } from './recipients';\nimport { assertShieldedWalletAddress } from './shieldedAddress';\nimport type { ZcashCoinName } from './types';\n\nexport class Zec extends AbstractUtxoCoin {\n  readonly name: UtxoCoinName = 'zec';\n\n  constructor(bitgo: BitGoBase) {\n    super(bitgo);\n  }\n\n  /**\n   * ZEC shielded (Orchard/Ironwood) custodial wallets use RedPallas threshold keys.\n   * Transparent (secp256k1 multisig) flows are unaffected: MPCAlgorithm is only\n   * consulted on the TSS custodial wallet-creation path.\n   * @inheritdoc\n   */\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'redpallas';\n  }\n\n  static createInstance(bitgo: BitGoBase): Zec {\n    return new Zec(bitgo);\n  }\n\n  override get addressCodec(): ZecAddressCodec {\n    return new ZecAddressCodec(this.name, this.wasmName);\n  }\n\n  /**\n   * Shielded (Orchard/Ironwood) addresses are returned with `coinSpecific.shielded` and\n   * cannot be locally rederived from secp256k1 xpubs (RedPallas keychains carry none), so\n   * verify them against the platform-reported diversifier/pkD instead of the fixed-script\n   * transparent derivation the base class performs.\n   * @inheritdoc\n   */\n  override async isWalletAddress(params: VerifyAddressOptions<UtxoCoinSpecific>, wallet?: IWallet): Promise<boolean> {\n    if (params.coinSpecific?.shielded) {\n      assertShieldedWalletAddress(this.name, params);\n      return true;\n    }\n    return super.isWalletAddress(params, wallet);\n  }\n\n  isValidAddress(address: string, param?: { anyFormat?: boolean; allowLightning?: boolean } | boolean): boolean {\n    return this.addressCodec.isValidAddress(address);\n  }\n\n  private inferUnifiedRecipientPreference(\n    recipients: { address: string | undefined }[] | undefined\n  ): UnifiedRecipientPreference | undefined {\n    const shieldedness = (recipients ?? []).map((recipient): UnifiedRecipientPreference | undefined => {\n      const address = recipient.address;\n      if (address === undefined) {\n        return 'transparent';\n      }\n      if (AddressCodec.isScriptRecipient(address)) {\n        return 'transparent';\n      }\n      const hasTransparentReceiver = zcashAddress.hasTransparentReceiver(address, this.wasmName);\n      const hasOrchardReceiver = zcashAddress.hasOrchardReceiver(address, this.wasmName);\n      return hasOrchardReceiver && !hasTransparentReceiver\n        ? 'shielded'\n        : hasTransparentReceiver\n        ? 'transparent'\n        : undefined;\n    });\n    if (shieldedness.includes('shielded') && shieldedness.includes('transparent')) {\n      throw new Error('Mixed shielded and transparent recipients are not supported');\n    }\n    return shieldedness.includes('shielded') ? 'shielded' : undefined;\n  }\n\n  override async parseTransaction<TNumber extends number | bigint = number>(\n    params: ParseTransactionOptions<TNumber>\n  ): Promise<ParsedTransaction<TNumber>> {\n    const preference =\n      params.txParams.unifiedRecipientPreference ?? this.inferUnifiedRecipientPreference(params.txParams.recipients);\n    return this.parseTransactionWithAddressCodec(\n      params,\n      new ZecAddressCodec(this.name, this.wasmName, preference ?? 'transparent')\n    );\n  }\n\n  override async getExtraPrebuildParams(buildParams: ExtraPrebuildParamsOptions & { wallet: Wallet }) {\n    const extraParams = await super.getExtraPrebuildParams(buildParams);\n    const { unifiedRecipientPreference } = buildParams;\n    if (unifiedRecipientPreference === undefined) {\n      return extraParams;\n    }\n    return { ...extraParams, unifiedRecipientPreference };\n  }\n\n  override decodeTransaction(input: Buffer | string): fixedScriptWallet.BitGoPsbt {\n    const buffer = typeof input === 'string' ? stringToBufferTryFormats(input, ['hex', 'base64']) : input;\n    if (!hasPsbtMagic(buffer)) {\n      return super.decodeTransaction(input);\n    }\n    return fixedScriptWallet.ZcashPsbt.fromBytes(buffer, toWasmUtxoCoinName(this.name) as ZcashCoinName);\n  }\n\n  /**\n   * Route v6 (Ironwood) prebuilds to the Ironwood signing path — its `sign` override requires\n   * the wallet root keys to derive the ovk on the user's first signing round — and keep every\n   * other prebuild (v4 and non-PSBT) on the generic path.\n   */\n  override async signTransaction<TNumber extends number | bigint = number>(\n    params: SignTransactionOptions<TNumber>\n  ): Promise<SignedTransaction | HalfSignedUtxoTransaction> {\n    const txPrebuild = params?.txPrebuild;\n    if (!_.isObject(txPrebuild)) {\n      // Defer to the base path for its standard missing/malformed-prebuild validation errors.\n      return super.signTransaction(params);\n    }\n    const tx = this.decodeTransactionFromPrebuild(txPrebuild);\n    if (!(tx instanceof fixedScriptWallet.ZcashIronwoodBitGoPsbt)) {\n      return super.signTransaction(params);\n    }\n    return signIronwoodTransaction(this, tx, params);\n  }\n  resolveRecipientsFromPsbt(input: Buffer | string, walletKeys: fixedScriptWallet.RootWalletKeys): PsbtRecipient[] {\n    const psbt = this.decodeTransaction(input);\n    if (!(psbt instanceof fixedScriptWallet.ZcashBitGoPsbt)) {\n      throw new Error('expected a Zcash PSBT');\n    }\n    return resolvePsbtRecipients(psbt, walletKeys, this.addressCodec);\n  }\n}\n"]}

package/dist/esm/transaction/fixedScript/signPsbtWasm.d.ts

@@ -3,6 +3,13 @@ import { Musig2Participant } from './musig2';
 export type ReplayProtectionKeys = {
     publicKeys: (Uint8Array | ECPair)[];
 };
+/**
+ * Verify signatures on all signed inputs, per-input for granular error reporting.
+ * Shared by the generic wasm signing path and Zec's Ironwood (v6) signing path.
+ */
+export declare function verifyPsbtSignaturesWasm(tx: fixedScriptWallet.BitGoPsbt, wasmSigner: BIP32, rootWalletKeys: fixedScriptWallet.RootWalletKeys, replayProtection: ReplayProtectionKeys): void;
+/** Embed the wasm-utxo version metadata into the signed PSBT. Shared by all wasm signing paths. */
+export declare function writeWasmUtxoSignedWithKv(tx: fixedScriptWallet.BitGoPsbt): void;
 /**
  * Sign all inputs of a PSBT and verify signatures after signing.
  * Uses bulk signing for performance (signs all matching inputs in one pass).

package/dist/esm/transaction/fixedScript/signPsbtWasm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signPsbtWasm.d.ts","sourceRoot":"","sources":["../../../../src/transaction/fixedScript/signPsbtWasm.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAsB,MAAM,kBAAkB,CAAC;AAG/F,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAM7C,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,CAAC,UAAU,GAAG,MAAM,CAAC,EAAE,CAAC;CACrC,CAAC;AAmBF;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,cAAc,EAAE,KAAK,CAAC,cAAc,GAAG,KAAK,EAC5C,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,gBAAgB,EAAE,oBAAoB,EACtC,EAAE,eAAuB,EAAE,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9D,iBAAiB,CAAC,SAAS,CAgD7B;AAED,wBAAsB,iCAAiC,CACrD,IAAI,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,SAAS,CAAC,EACpD,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,cAAc,EAAE,KAAK,CAAC,cAAc,GAAG,SAAS,EAChD,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,MAAM,EAAE;IACN,gBAAgB,EAAE,oBAAoB,CAAC;IACvC,WAAW,EAAE,aAAa,GAAG,eAAe,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAC7E,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,GACA,OAAO,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAmDtC"}
+{"version":3,"file":"signPsbtWasm.d.ts","sourceRoot":"","sources":["../../../../src/transaction/fixedScript/signPsbtWasm.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAsB,MAAM,kBAAkB,CAAC;AAG/F,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAM7C,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,CAAC,UAAU,GAAG,MAAM,CAAC,EAAE,CAAC;CACrC,CAAC;AAmBF;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,UAAU,EAAE,KAAK,EACjB,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,gBAAgB,EAAE,oBAAoB,GACrC,IAAI,CAyBN;AAED,mGAAmG;AACnG,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,iBAAiB,CAAC,SAAS,GAAG,IAAI,CAS/E;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,cAAc,EAAE,KAAK,CAAC,cAAc,GAAG,KAAK,EAC5C,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,gBAAgB,EAAE,oBAAoB,EACtC,EAAE,eAAuB,EAAE,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9D,iBAAiB,CAAC,SAAS,CAiB7B;AAED,wBAAsB,iCAAiC,CACrD,IAAI,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,SAAS,CAAC,EACpD,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,cAAc,EAAE,KAAK,CAAC,cAAc,GAAG,SAAS,EAChD,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,MAAM,EAAE;IACN,gBAAgB,EAAE,oBAAoB,CAAC;IACvC,WAAW,EAAE,aAAa,GAAG,eAAe,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAC7E,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,GACA,OAAO,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAmDtC"}

package/dist/esm/transaction/fixedScript/signPsbtWasm.js

@@ -16,20 +16,10 @@ function hasKeyPathSpendInput(tx, rootWalletKeys, replayProtection) {
     return parsed.inputs.some((input) => input.scriptType === 'p2trMusig2KeyPath');
 }
 /**
- * Sign all inputs of a PSBT and verify signatures after signing.
- * Uses bulk signing for performance (signs all matching inputs in one pass).
- * Collects and logs signing errors and verification errors, throws error in the end if any of them failed.
+ * Verify signatures on all signed inputs, per-input for granular error reporting.
+ * Shared by the generic wasm signing path and Zec's Ironwood (v6) signing path.
  */
-export function signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, replayProtection, { writeSignedWith = false } = {}) {
-    const wasmSigner = toWasmBIP32(signerKeychain);
-    // Bulk sign all wallet inputs (ECDSA + MuSig2) - much faster than per-input signing
-    try {
-        tx.sign(wasmSigner);
-    }
-    catch (e) {
-        throw new BulkSigningError(e);
-    }
-    // Verify signatures for all signed inputs (still per-input for granular error reporting)
+export function verifyPsbtSignaturesWasm(tx, wasmSigner, rootWalletKeys, replayProtection) {
     const parsed = tx.parseTransactionWithWalletKeys(rootWalletKeys, { replayProtection });
     const verifyErrors = [];
     parsed.inputs.forEach((input, inputIndex) => {
@@ -50,13 +40,33 @@ export function signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, replay
     if (verifyErrors.length) {
         throw new TransactionSigningError([], verifyErrors);
     }
+}
+/** Embed the wasm-utxo version metadata into the signed PSBT. Shared by all wasm signing paths. */
+export function writeWasmUtxoSignedWithKv(tx) {
+    const versionInfo = getWasmUtxoVersion();
+    const versionPayload = new TextEncoder().encode(JSON.stringify({
+        version: versionInfo.version,
+        gitHash: versionInfo.gitHash,
+    }));
+    tx.setKV({ type: 'bitgo', subtype: fixedScriptWallet.BitGoKeySubtype.WasmUtxoSignedWith }, versionPayload);
+}
+/**
+ * Sign all inputs of a PSBT and verify signatures after signing.
+ * Uses bulk signing for performance (signs all matching inputs in one pass).
+ * Collects and logs signing errors and verification errors, throws error in the end if any of them failed.
+ */
+export function signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, replayProtection, { writeSignedWith = false } = {}) {
+    const wasmSigner = toWasmBIP32(signerKeychain);
+    // Bulk sign all wallet inputs (ECDSA + MuSig2) - much faster than per-input signing
+    try {
+        tx.sign(wasmSigner);
+    }
+    catch (e) {
+        throw new BulkSigningError(e);
+    }
+    verifyPsbtSignaturesWasm(tx, wasmSigner, rootWalletKeys, replayProtection);
     if (writeSignedWith) {
-        const versionInfo = getWasmUtxoVersion();
-        const versionPayload = new TextEncoder().encode(JSON.stringify({
-            version: versionInfo.version,
-            gitHash: versionInfo.gitHash,
-        }));
-        tx.setKV({ type: 'bitgo', subtype: fixedScriptWallet.BitGoKeySubtype.WasmUtxoSignedWith }, versionPayload);
+        writeWasmUtxoSignedWithKv(tx);
     }
     return tx;
 }
@@ -108,4 +118,4 @@ export async function signPsbtWithMusig2ParticipantWasm(coin, tx, signerKeychain
         writeSignedWith: params.writeSignedWith,
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signPsbtWasm.js","sourceRoot":"","sources":["../../../../src/transaction/fixedScript/signPsbtWasm.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\n\nimport { BIP32, bip32, ECPair, fixedScriptWallet, getWasmUtxoVersion } from '@bitgo/wasm-utxo';\n\nimport { BulkSigningError, InputSigningError, TransactionSigningError } from './SigningError';\nimport { Musig2Participant } from './musig2';\n\nfunction toWasmBIP32(key: bip32.BIP32Interface | BIP32): BIP32 {\n  return key instanceof BIP32 ? key : BIP32.fromBase58(key.toBase58());\n}\n\nexport type ReplayProtectionKeys = {\n  publicKeys: (Uint8Array | ECPair)[];\n};\n\n/**\n * Key Value: Unsigned tx id => PSBT\n * It is used to cache PSBTs with taproot key path (MuSig2) inputs during external express signer is activated.\n * Reason: MuSig2 signer secure nonce is cached in the BitGoPsbt object. It will be required during the signing step.\n * For more info, check SignTransactionOptions.signingStep\n */\nconst PSBT_CACHE_WASM = new Map<string, fixedScriptWallet.BitGoPsbt>();\n\nfunction hasKeyPathSpendInput(\n  tx: fixedScriptWallet.BitGoPsbt,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  replayProtection: ReplayProtectionKeys\n): boolean {\n  const parsed = tx.parseTransactionWithWalletKeys(rootWalletKeys, { replayProtection });\n  return parsed.inputs.some((input) => input.scriptType === 'p2trMusig2KeyPath');\n}\n\n/**\n * Sign all inputs of a PSBT and verify signatures after signing.\n * Uses bulk signing for performance (signs all matching inputs in one pass).\n * Collects and logs signing errors and verification errors, throws error in the end if any of them failed.\n */\nexport function signAndVerifyPsbtWasm(\n  tx: fixedScriptWallet.BitGoPsbt,\n  signerKeychain: bip32.BIP32Interface | BIP32,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  replayProtection: ReplayProtectionKeys,\n  { writeSignedWith = false }: { writeSignedWith?: boolean } = {}\n): fixedScriptWallet.BitGoPsbt {\n  const wasmSigner = toWasmBIP32(signerKeychain);\n\n  // Bulk sign all wallet inputs (ECDSA + MuSig2) - much faster than per-input signing\n  try {\n    tx.sign(wasmSigner);\n  } catch (e) {\n    throw new BulkSigningError(e);\n  }\n\n  // Verify signatures for all signed inputs (still per-input for granular error reporting)\n  const parsed = tx.parseTransactionWithWalletKeys(rootWalletKeys, { replayProtection });\n  const verifyErrors: InputSigningError<bigint>[] = [];\n\n  parsed.inputs.forEach((input, inputIndex) => {\n    if (input.scriptType === 'p2shP2pk') {\n      // Skip replay protection inputs - they are platform signed only\n      return;\n    }\n\n    const outputId = `${input.previousOutput.txid}:${input.previousOutput.vout}`;\n    try {\n      if (!tx.verifySignature(inputIndex, wasmSigner)) {\n        verifyErrors.push(\n          new InputSigningError(inputIndex, input.scriptType, { id: outputId }, new Error('invalid signature'))\n        );\n      }\n    } catch (e) {\n      verifyErrors.push(new InputSigningError<bigint>(inputIndex, input.scriptType, { id: outputId }, e));\n    }\n  });\n\n  if (verifyErrors.length) {\n    throw new TransactionSigningError([], verifyErrors);\n  }\n\n  if (writeSignedWith) {\n    const versionInfo = getWasmUtxoVersion();\n    const versionPayload = new TextEncoder().encode(\n      JSON.stringify({\n        version: versionInfo.version,\n        gitHash: versionInfo.gitHash,\n      })\n    );\n    tx.setKV({ type: 'bitgo', subtype: fixedScriptWallet.BitGoKeySubtype.WasmUtxoSignedWith }, versionPayload);\n  }\n\n  return tx;\n}\n\nexport async function signPsbtWithMusig2ParticipantWasm(\n  coin: Musig2Participant<fixedScriptWallet.BitGoPsbt>,\n  tx: fixedScriptWallet.BitGoPsbt,\n  signerKeychain: bip32.BIP32Interface | undefined,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  params: {\n    replayProtection: ReplayProtectionKeys;\n    signingStep: 'signerNonce' | 'cosignerNonce' | 'signerSignature' | undefined;\n    walletId: string | undefined;\n    writeSignedWith?: boolean;\n  }\n): Promise<fixedScriptWallet.BitGoPsbt> {\n  const wasmSigner = signerKeychain ? toWasmBIP32(signerKeychain) : undefined;\n\n  if (hasKeyPathSpendInput(tx, rootWalletKeys, params.replayProtection)) {\n    switch (params.signingStep) {\n      case 'signerNonce':\n        assert(wasmSigner);\n        tx.generateMusig2Nonces(wasmSigner);\n        PSBT_CACHE_WASM.set(tx.unsignedTxId(), tx);\n        return tx;\n      case 'cosignerNonce':\n        assert(params.walletId, 'walletId is required for MuSig2 bitgo nonce');\n        return await coin.getMusig2Nonces(tx, params.walletId);\n      case 'signerSignature': {\n        const txId = tx.unsignedTxId();\n        const cachedPsbt = PSBT_CACHE_WASM.get(txId);\n        assert(\n          cachedPsbt,\n          `Psbt is missing from txCache (cache size ${PSBT_CACHE_WASM.size}).\n            This may be due to the request being routed to a different BitGo-Express instance that for signing step 'signerNonce'.`\n        );\n        PSBT_CACHE_WASM.delete(txId);\n        cachedPsbt.combineMusig2Nonces(tx);\n        tx = cachedPsbt;\n        break;\n      }\n      default:\n        // this instance is not an external signer\n        assert(params.walletId, 'walletId is required for MuSig2 bitgo nonce');\n        assert(wasmSigner);\n        tx.generateMusig2Nonces(wasmSigner);\n        const response = await coin.getMusig2Nonces(tx, params.walletId);\n        tx.combineMusig2Nonces(response);\n        break;\n    }\n  } else {\n    switch (params.signingStep) {\n      case 'signerNonce':\n      case 'cosignerNonce':\n        /**\n         * In certain cases, the caller of this method may not know whether the txHex contains a psbt with taproot key path spend input(s).\n         * Instead of throwing error, no-op and return the txHex. So that the caller can call this method in the same sequence.\n         */\n        return tx;\n    }\n  }\n\n  assert(signerKeychain);\n  return signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, params.replayProtection, {\n    writeSignedWith: params.writeSignedWith,\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signPsbtWasm.js","sourceRoot":"","sources":["../../../../src/transaction/fixedScript/signPsbtWasm.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\n\nimport { BIP32, bip32, ECPair, fixedScriptWallet, getWasmUtxoVersion } from '@bitgo/wasm-utxo';\n\nimport { BulkSigningError, InputSigningError, TransactionSigningError } from './SigningError';\nimport { Musig2Participant } from './musig2';\n\nfunction toWasmBIP32(key: bip32.BIP32Interface | BIP32): BIP32 {\n  return key instanceof BIP32 ? key : BIP32.fromBase58(key.toBase58());\n}\n\nexport type ReplayProtectionKeys = {\n  publicKeys: (Uint8Array | ECPair)[];\n};\n\n/**\n * Key Value: Unsigned tx id => PSBT\n * It is used to cache PSBTs with taproot key path (MuSig2) inputs during external express signer is activated.\n * Reason: MuSig2 signer secure nonce is cached in the BitGoPsbt object. It will be required during the signing step.\n * For more info, check SignTransactionOptions.signingStep\n */\nconst PSBT_CACHE_WASM = new Map<string, fixedScriptWallet.BitGoPsbt>();\n\nfunction hasKeyPathSpendInput(\n  tx: fixedScriptWallet.BitGoPsbt,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  replayProtection: ReplayProtectionKeys\n): boolean {\n  const parsed = tx.parseTransactionWithWalletKeys(rootWalletKeys, { replayProtection });\n  return parsed.inputs.some((input) => input.scriptType === 'p2trMusig2KeyPath');\n}\n\n/**\n * Verify signatures on all signed inputs, per-input for granular error reporting.\n * Shared by the generic wasm signing path and Zec's Ironwood (v6) signing path.\n */\nexport function verifyPsbtSignaturesWasm(\n  tx: fixedScriptWallet.BitGoPsbt,\n  wasmSigner: BIP32,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  replayProtection: ReplayProtectionKeys\n): void {\n  const parsed = tx.parseTransactionWithWalletKeys(rootWalletKeys, { replayProtection });\n  const verifyErrors: InputSigningError<bigint>[] = [];\n\n  parsed.inputs.forEach((input, inputIndex) => {\n    if (input.scriptType === 'p2shP2pk') {\n      // Skip replay protection inputs - they are platform signed only\n      return;\n    }\n\n    const outputId = `${input.previousOutput.txid}:${input.previousOutput.vout}`;\n    try {\n      if (!tx.verifySignature(inputIndex, wasmSigner)) {\n        verifyErrors.push(\n          new InputSigningError(inputIndex, input.scriptType, { id: outputId }, new Error('invalid signature'))\n        );\n      }\n    } catch (e) {\n      verifyErrors.push(new InputSigningError<bigint>(inputIndex, input.scriptType, { id: outputId }, e));\n    }\n  });\n\n  if (verifyErrors.length) {\n    throw new TransactionSigningError([], verifyErrors);\n  }\n}\n\n/** Embed the wasm-utxo version metadata into the signed PSBT. Shared by all wasm signing paths. */\nexport function writeWasmUtxoSignedWithKv(tx: fixedScriptWallet.BitGoPsbt): void {\n  const versionInfo = getWasmUtxoVersion();\n  const versionPayload = new TextEncoder().encode(\n    JSON.stringify({\n      version: versionInfo.version,\n      gitHash: versionInfo.gitHash,\n    })\n  );\n  tx.setKV({ type: 'bitgo', subtype: fixedScriptWallet.BitGoKeySubtype.WasmUtxoSignedWith }, versionPayload);\n}\n\n/**\n * Sign all inputs of a PSBT and verify signatures after signing.\n * Uses bulk signing for performance (signs all matching inputs in one pass).\n * Collects and logs signing errors and verification errors, throws error in the end if any of them failed.\n */\nexport function signAndVerifyPsbtWasm(\n  tx: fixedScriptWallet.BitGoPsbt,\n  signerKeychain: bip32.BIP32Interface | BIP32,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  replayProtection: ReplayProtectionKeys,\n  { writeSignedWith = false }: { writeSignedWith?: boolean } = {}\n): fixedScriptWallet.BitGoPsbt {\n  const wasmSigner = toWasmBIP32(signerKeychain);\n\n  // Bulk sign all wallet inputs (ECDSA + MuSig2) - much faster than per-input signing\n  try {\n    tx.sign(wasmSigner);\n  } catch (e) {\n    throw new BulkSigningError(e);\n  }\n\n  verifyPsbtSignaturesWasm(tx, wasmSigner, rootWalletKeys, replayProtection);\n\n  if (writeSignedWith) {\n    writeWasmUtxoSignedWithKv(tx);\n  }\n\n  return tx;\n}\n\nexport async function signPsbtWithMusig2ParticipantWasm(\n  coin: Musig2Participant<fixedScriptWallet.BitGoPsbt>,\n  tx: fixedScriptWallet.BitGoPsbt,\n  signerKeychain: bip32.BIP32Interface | undefined,\n  rootWalletKeys: fixedScriptWallet.RootWalletKeys,\n  params: {\n    replayProtection: ReplayProtectionKeys;\n    signingStep: 'signerNonce' | 'cosignerNonce' | 'signerSignature' | undefined;\n    walletId: string | undefined;\n    writeSignedWith?: boolean;\n  }\n): Promise<fixedScriptWallet.BitGoPsbt> {\n  const wasmSigner = signerKeychain ? toWasmBIP32(signerKeychain) : undefined;\n\n  if (hasKeyPathSpendInput(tx, rootWalletKeys, params.replayProtection)) {\n    switch (params.signingStep) {\n      case 'signerNonce':\n        assert(wasmSigner);\n        tx.generateMusig2Nonces(wasmSigner);\n        PSBT_CACHE_WASM.set(tx.unsignedTxId(), tx);\n        return tx;\n      case 'cosignerNonce':\n        assert(params.walletId, 'walletId is required for MuSig2 bitgo nonce');\n        return await coin.getMusig2Nonces(tx, params.walletId);\n      case 'signerSignature': {\n        const txId = tx.unsignedTxId();\n        const cachedPsbt = PSBT_CACHE_WASM.get(txId);\n        assert(\n          cachedPsbt,\n          `Psbt is missing from txCache (cache size ${PSBT_CACHE_WASM.size}).\n            This may be due to the request being routed to a different BitGo-Express instance that for signing step 'signerNonce'.`\n        );\n        PSBT_CACHE_WASM.delete(txId);\n        cachedPsbt.combineMusig2Nonces(tx);\n        tx = cachedPsbt;\n        break;\n      }\n      default:\n        // this instance is not an external signer\n        assert(params.walletId, 'walletId is required for MuSig2 bitgo nonce');\n        assert(wasmSigner);\n        tx.generateMusig2Nonces(wasmSigner);\n        const response = await coin.getMusig2Nonces(tx, params.walletId);\n        tx.combineMusig2Nonces(response);\n        break;\n    }\n  } else {\n    switch (params.signingStep) {\n      case 'signerNonce':\n      case 'cosignerNonce':\n        /**\n         * In certain cases, the caller of this method may not know whether the txHex contains a psbt with taproot key path spend input(s).\n         * Instead of throwing error, no-op and return the txHex. So that the caller can call this method in the same sequence.\n         */\n        return tx;\n    }\n  }\n\n  assert(signerKeychain);\n  return signAndVerifyPsbtWasm(tx, signerKeychain, rootWalletKeys, params.replayProtection, {\n    writeSignedWith: params.writeSignedWith,\n  });\n}\n"]}

package/dist/esm/transaction/fixedScript/signTransaction.d.ts

@@ -6,6 +6,15 @@ import { ReplayProtectionKeys } from './signPsbtWasm';
 export declare function signAndVerifyPsbt(psbt: fixedScriptWallet.BitGoPsbt, signerKeychain: bip32.BIP32Interface | BIP32, rootWalletKeys: fixedScriptWallet.RootWalletKeys, replayProtection: ReplayProtectionKeys, options?: {
     writeSignedWith?: boolean;
 }): fixedScriptWallet.BitGoPsbt;
+/**
+ * Finalize a signed PSBT into its final form: the extracted transaction bytes on the last
+ * signature round (unless the caller asked to keep the PSBT), otherwise the signed PSBT itself.
+ * Shared by the generic signing path and Zec's Ironwood (v6) signing path.
+ */
+export declare function finalizeSignedPsbt(signedPsbt: fixedScriptWallet.BitGoPsbt, { isLastSignature, extractTransaction }: {
+    isLastSignature?: boolean;
+    extractTransaction?: boolean;
+}): fixedScriptWallet.BitGoPsbt | Buffer;
 export declare function signTransaction(coin: Musig2Participant<fixedScriptWallet.BitGoPsbt>, tx: fixedScriptWallet.BitGoPsbt, signerKeychain: bip32.BIP32Interface | undefined, coinName: UtxoCoinName | WasmUtxoCoinName, params: {
     walletId: string | undefined;
     txInfo: {

package/dist/esm/transaction/fixedScript/signTransaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signTransaction.d.ts","sourceRoot":"","sources":["../../../../src/transaction/fixedScript/signTransaction.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAEnE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAA4D,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAGhH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,iBAAiB,CAAC,SAAS,EACjC,cAAc,EAAE,KAAK,CAAC,cAAc,GAAG,KAAK,EAC5C,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,gBAAgB,EAAE,oBAAoB,EACtC,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1C,iBAAiB,CAAC,SAAS,CAI7B;AAED,wBAAsB,eAAe,CACnC,IAAI,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,SAAS,CAAC,EACpD,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,cAAc,EAAE,KAAK,CAAC,cAAc,GAAG,SAAS,EAChD,QAAQ,EAAE,YAAY,GAAG,gBAAgB,EACzC,MAAM,EAAE;IACN,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,MAAM,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;KAAE,GAAG,SAAS,CAAC;IAC9D,eAAe,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE,aAAa,GAAG,eAAe,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAC7E,IAAI,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,mHAAmH;IACnH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,GACA,OAAO,CAAC,iBAAiB,CAAC,SAAS,GAAG,MAAM,CAAC,CA4B/C"}
+{"version":3,"file":"signTransaction.d.ts","sourceRoot":"","sources":["../../../../src/transaction/fixedScript/signTransaction.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAEnE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAA4D,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAGhH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,iBAAiB,CAAC,SAAS,EACjC,cAAc,EAAE,KAAK,CAAC,cAAc,GAAG,KAAK,EAC5C,cAAc,EAAE,iBAAiB,CAAC,cAAc,EAChD,gBAAgB,EAAE,oBAAoB,EACtC,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1C,iBAAiB,CAAC,SAAS,CAI7B;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,iBAAiB,CAAC,SAAS,EACvC,EAAE,eAAuB,EAAE,kBAAyB,EAAE,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAC;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAAE,GAClH,iBAAiB,CAAC,SAAS,GAAG,MAAM,CAStC;AAED,wBAAsB,eAAe,CACnC,IAAI,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,SAAS,CAAC,EACpD,EAAE,EAAE,iBAAiB,CAAC,SAAS,EAC/B,cAAc,EAAE,KAAK,CAAC,cAAc,GAAG,SAAS,EAChD,QAAQ,EAAE,YAAY,GAAG,gBAAgB,EACzC,MAAM,EAAE;IACN,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,MAAM,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;KAAE,GAAG,SAAS,CAAC;IAC9D,eAAe,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE,aAAa,GAAG,eAAe,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAC7E,IAAI,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,mHAAmH;IACnH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,GACA,OAAO,CAAC,iBAAiB,CAAC,SAAS,GAAG,MAAM,CAAC,CAqB/C"}