@bitgo-beta/abstract-utxo 1.1.1-beta.232 → 1.1.1-beta.2321

package/dist/cjs/src/impl/zec/address.d.ts

@@ -0,0 +1,79 @@
+import { fixedScriptWallet } from '@bitgo/wasm-utxo';
+import type { UnifiedRecipientPreference } from '@bitgo-beta/sdk-core';
+import { AddressCodec } from '../../transaction/recipient';
+import { UtxoCoinName, WasmUtxoCoinName } from '../../names';
+import type { ZecAddressCodecOutput } from './types';
+export type ZcashAddressKind = 'transparent' | 'shielded';
+/**
+ * Address codec for Zcash coins ('zec'/'tzec') that understands ZIP-316
+ * Unified Addresses in addition to ordinary transparent addresses.
+ *
+ * - `decode` resolves the bytes a recipient pays to (see its doc): by default
+ *   the transparent scriptPubKey; with `unifiedRecipientPreference: 'shielded'`
+ *   the raw Orchard/Ironwood receiver of a Unified Address.
+ * - `encode`/`toExtendedAddressFormat` are unchanged: scripts can only be
+ *   written back out as transparent addresses.
+ * - `isValidAddress` accepts transparent addresses and Unified Addresses with
+ *   a transparent or Orchard receiver.
+ */
+export declare class ZecAddressCodec extends AddressCodec {
+    /** The Zcash network name for wasm calls — 'zec' or 'tzec'. */
+    private readonly zcashNetworkName;
+    /** How Unified Address recipients resolve when this codec decodes them. */
+    private readonly unifiedRecipientPreference;
+    constructor(coinName: UtxoCoinName, wasmName: WasmUtxoCoinName, unifiedRecipientPreference?: UnifiedRecipientPreference);
+    /**
+     * Whether `address` is a valid Zcash address for this coin's network.
+     *
+     * Mirrors the pre-codec `Zec.isValidAddress` logic exactly: the address is
+     * valid iff it has a usable transparent receiver (an ordinary transparent
+     * address, or a UA carrying a transparent receiver) or an Orchard receiver
+     * (a UA carrying one).
+     */
+    isValidAddress(address: string): boolean;
+    /**
+     * Resolve `address` to the bytes this codec's unified-recipient preference pays to.
+     *
+     * - `'transparent'` (default) resolves the scriptPubKey: an ordinary
+     *   transparent address decodes to its own script, and a UA with a
+     *   transparent receiver decodes to that receiver's script. A UA without a
+     *   transparent receiver (e.g. Orchard-only) throws, since a shielded
+     *   output has no script.
+     * - `'shielded'` resolves the raw Orchard (Ironwood) receiver — the
+     *   43-byte diversifier + `pk_d` — of a UA carrying one. Any other address
+     *   (plain transparent, transparent-only UA, malformed, wrong network)
+     *   throws, since it has no Orchard receiver to resolve.
+     */
+    decode(address: string): Uint8Array;
+    /** Change addresses are always transparent wallet addresses. */
+    decodeChangeAddress(address: string): Uint8Array;
+    isMatchingScript(output: ZecAddressCodecOutput): boolean;
+    /** Preserve a shielded output's original UA only after validating it against the raw script. */
+    toExtendedAddressFormat(script: Buffer, address?: string): string;
+}
+/**
+ * Whether `address` is a well-formed ZIP-316 Unified Address for `network`
+ * with an Orchard receiver. BitGo only supports Orchard, so a UA without one
+ * (e.g. Sapling- or transparent-only) is not considered valid here.
+ */
+export declare function isShieldedZcashAddress(address: string, network: fixedScriptWallet.ZcashNetworkName): boolean;
+/**
+ * Classify a Zcash address string as transparent or shielded, validating it in
+ * the process. Returns undefined if the address is neither a valid transparent
+ * address nor a well-formed ZIP-316 Unified Address for `network`.
+ */
+export declare function getZcashAddressKind(address: string, network: fixedScriptWallet.ZcashNetworkName): ZcashAddressKind | undefined;
+/**
+ * Standalone counterpart to `Zec.isValidAddress`, parameterized by `network`
+ * instead of requiring a coin instance. Accepts transparent addresses and
+ * shielded ZIP-316 Unified Addresses.
+ *
+ * Not structurally identical to `Zec.isValidAddress`: the base class also
+ * round-trips the parsed script through each known encoding format (see
+ * `AbstractUtxoCoin.isValidAddress`), whereas this only calls
+ * `toOutputScriptWithCoin` once via `getZcashAddressKind`. They agree in
+ * practice since zec/tzec have no alternate transparent-address encoding to
+ * round-trip against, but that's not guaranteed to remain true.
+ */
+export declare function isValidZcashAddress(address: string, network: fixedScriptWallet.ZcashNetworkName): boolean;
+//# sourceMappingURL=address.d.ts.map

package/dist/cjs/src/impl/zec/address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../../../../src/impl/zec/address.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,iBAAiB,EAA4B,MAAM,kBAAkB,CAAC;AACvG,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAEvE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG,UAAU,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,qBAAa,eAAgB,SAAQ,YAAY;IAC/C,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAqC;IACtE,2EAA2E;IAC3E,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAA6B;gBAGtE,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,gBAAgB,EAC1B,0BAA0B,GAAE,0BAA0C;IAOxE;;;;;;;OAOG;IACM,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAOjD;;;;;;;;;;;;OAYG;IACM,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAkB5C,gEAAgE;IACvD,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAGhD,gBAAgB,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO;IA6BjE,gGAAgG;IACvF,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM;CAM3E;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,CAAC,gBAAgB,GAAG,OAAO,CAM5G;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,iBAAiB,CAAC,gBAAgB,GAC1C,gBAAgB,GAAG,SAAS,CAa9B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,CAAC,gBAAgB,GAAG,OAAO,CAEzG"}

package/dist/cjs/src/impl/zec/address.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZecAddressCodec = void 0;
+exports.isShieldedZcashAddress = isShieldedZcashAddress;
+exports.getZcashAddressKind = getZcashAddressKind;
+exports.isValidZcashAddress = isValidZcashAddress;
+const wasm_utxo_1 = require("@bitgo/wasm-utxo");
+const recipient_1 = require("../../transaction/recipient");
+/**
+ * Address codec for Zcash coins ('zec'/'tzec') that understands ZIP-316
+ * Unified Addresses in addition to ordinary transparent addresses.
+ *
+ * - `decode` resolves the bytes a recipient pays to (see its doc): by default
+ *   the transparent scriptPubKey; with `unifiedRecipientPreference: 'shielded'`
+ *   the raw Orchard/Ironwood receiver of a Unified Address.
+ * - `encode`/`toExtendedAddressFormat` are unchanged: scripts can only be
+ *   written back out as transparent addresses.
+ * - `isValidAddress` accepts transparent addresses and Unified Addresses with
+ *   a transparent or Orchard receiver.
+ */
+class ZecAddressCodec extends recipient_1.AddressCodec {
+    constructor(coinName, wasmName, unifiedRecipientPreference = 'transparent') {
+        super(coinName, wasmName);
+        this.zcashNetworkName = wasmName;
+        this.unifiedRecipientPreference = unifiedRecipientPreference;
+    }
+    /**
+     * Whether `address` is a valid Zcash address for this coin's network.
+     *
+     * Mirrors the pre-codec `Zec.isValidAddress` logic exactly: the address is
+     * valid iff it has a usable transparent receiver (an ordinary transparent
+     * address, or a UA carrying a transparent receiver) or an Orchard receiver
+     * (a UA carrying one).
+     */
+    isValidAddress(address) {
+        return (wasm_utxo_1.zcashAddress.hasTransparentReceiver(address, this.wasmName) ||
+            wasm_utxo_1.zcashAddress.hasOrchardReceiver(address, this.wasmName));
+    }
+    /**
+     * Resolve `address` to the bytes this codec's unified-recipient preference pays to.
+     *
+     * - `'transparent'` (default) resolves the scriptPubKey: an ordinary
+     *   transparent address decodes to its own script, and a UA with a
+     *   transparent receiver decodes to that receiver's script. A UA without a
+     *   transparent receiver (e.g. Orchard-only) throws, since a shielded
+     *   output has no script.
+     * - `'shielded'` resolves the raw Orchard (Ironwood) receiver — the
+     *   43-byte diversifier + `pk_d` — of a UA carrying one. Any other address
+     *   (plain transparent, transparent-only UA, malformed, wrong network)
+     *   throws, since it has no Orchard receiver to resolve.
+     */
+    decode(address) {
+        if (this.unifiedRecipientPreference !== 'shielded') {
+            return wasm_utxo_1.zcashAddress.toTransparentReceiverWithCoin(address, this.wasmName);
+        }
+        // The raw Orchard receiver exists only for a Unified Address carrying one; anything else
+        // (plain transparent address, transparent-only UA, malformed, wrong network) throws.
+        let unified;
+        try {
+            unified = wasm_utxo_1.fixedScriptWallet.ZcashUnifiedAddress.parse(address, this.zcashNetworkName);
+        }
+        catch {
+            throw new Error(`address ${address} is not a valid address for network ${this.zcashNetworkName}`);
+        }
+        if (!unified?.hasOrchardReceiver) {
+            throw new Error(`address ${address} has no Orchard receiver to resolve as shielded`);
+        }
+        return wasm_utxo_1.zcashAddress.toShieldedReceiverWithCoin(address, this.wasmName);
+    }
+    /** Change addresses are always transparent wallet addresses. */
+    decodeChangeAddress(address) {
+        return wasm_utxo_1.zcashAddress.toTransparentReceiverWithCoin(address, this.wasmName);
+    }
+    isMatchingScript(output) {
+        const address = output.address;
+        if (address === undefined || address === null) {
+            return true;
+        }
+        if (recipient_1.AddressCodec.isScriptRecipient(address)) {
+            return super.isMatchingScript(output);
+        }
+        const matchesOutput = (decode) => {
+            try {
+                return Buffer.from(decode()).equals(Buffer.from(output.script));
+            }
+            catch {
+                return false;
+            }
+        };
+        const isShielded = output.isShielded;
+        if (isShielded === true) {
+            return matchesOutput(() => wasm_utxo_1.zcashAddress.toShieldedReceiverWithCoin(address, this.wasmName));
+        }
+        if (isShielded === false) {
+            return matchesOutput(() => wasm_utxo_1.zcashAddress.toTransparentReceiverWithCoin(address, this.wasmName));
+        }
+        return (matchesOutput(() => wasm_utxo_1.zcashAddress.toTransparentReceiverWithCoin(address, this.wasmName)) ||
+            matchesOutput(() => wasm_utxo_1.zcashAddress.toShieldedReceiverWithCoin(address, this.wasmName)));
+    }
+    /** Preserve a shielded output's original UA only after validating it against the raw script. */
+    toExtendedAddressFormat(script, address) {
+        if (address !== undefined && !this.isMatchingScript({ address, script })) {
+            throw new Error(`address ${address} does not match the output script`);
+        }
+        return address ?? super.toExtendedAddressFormat(script);
+    }
+}
+exports.ZecAddressCodec = ZecAddressCodec;
+/**
+ * Whether `address` is a well-formed ZIP-316 Unified Address for `network`
+ * with an Orchard receiver. BitGo only supports Orchard, so a UA without one
+ * (e.g. Sapling- or transparent-only) is not considered valid here.
+ */
+function isShieldedZcashAddress(address, network) {
+    try {
+        return wasm_utxo_1.fixedScriptWallet.ZcashUnifiedAddress.parse(address, network).hasOrchardReceiver;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Classify a Zcash address string as transparent or shielded, validating it in
+ * the process. Returns undefined if the address is neither a valid transparent
+ * address nor a well-formed ZIP-316 Unified Address for `network`.
+ */
+function getZcashAddressKind(address, network) {
+    // ZcashNetworkName also permits 'zcash'/'zcashTest', which toOutputScriptWithCoin
+    // doesn't accept (it takes a CoinName, i.e. 'zec'/'tzec'). Skip straight to the
+    // shielded check for those rather than relying on an unsafe cast + caught throw.
+    if ((0, wasm_utxo_1.isCoinName)(network)) {
+        try {
+            wasm_utxo_1.address.toOutputScriptWithCoin(address, network);
+            return 'transparent';
+        }
+        catch {
+            // not a valid transparent address; fall through to shielded check
+        }
+    }
+    return isShieldedZcashAddress(address, network) ? 'shielded' : undefined;
+}
+/**
+ * Standalone counterpart to `Zec.isValidAddress`, parameterized by `network`
+ * instead of requiring a coin instance. Accepts transparent addresses and
+ * shielded ZIP-316 Unified Addresses.
+ *
+ * Not structurally identical to `Zec.isValidAddress`: the base class also
+ * round-trips the parsed script through each known encoding format (see
+ * `AbstractUtxoCoin.isValidAddress`), whereas this only calls
+ * `toOutputScriptWithCoin` once via `getZcashAddressKind`. They agree in
+ * practice since zec/tzec have no alternate transparent-address encoding to
+ * round-trip against, but that's not guaranteed to remain true.
+ */
+function isValidZcashAddress(address, network) {
+    return getZcashAddressKind(address, network) !== undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"address.js","sourceRoot":"","sources":["../../../../../src/impl/zec/address.ts"],"names":[],"mappings":"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","sourcesContent":["import { address as wasmAddress, fixedScriptWallet, isCoinName, zcashAddress } from '@bitgo/wasm-utxo';\nimport type { UnifiedRecipientPreference } from '@bitgo-beta/sdk-core';\n\nimport { AddressCodec } from '../../transaction/recipient';\nimport { UtxoCoinName, WasmUtxoCoinName } from '../../names';\n\nimport type { ZecAddressCodecOutput } from './types';\n\nexport type ZcashAddressKind = 'transparent' | 'shielded';\n\n/**\n * Address codec for Zcash coins ('zec'/'tzec') that understands ZIP-316\n * Unified Addresses in addition to ordinary transparent addresses.\n *\n * - `decode` resolves the bytes a recipient pays to (see its doc): by default\n *   the transparent scriptPubKey; with `unifiedRecipientPreference: 'shielded'`\n *   the raw Orchard/Ironwood receiver of a Unified Address.\n * - `encode`/`toExtendedAddressFormat` are unchanged: scripts can only be\n *   written back out as transparent addresses.\n * - `isValidAddress` accepts transparent addresses and Unified Addresses with\n *   a transparent or Orchard receiver.\n */\nexport class ZecAddressCodec extends AddressCodec {\n  /** The Zcash network name for wasm calls — 'zec' or 'tzec'. */\n  private readonly zcashNetworkName: fixedScriptWallet.ZcashNetworkName;\n  /** How Unified Address recipients resolve when this codec decodes them. */\n  private readonly unifiedRecipientPreference: UnifiedRecipientPreference;\n\n  constructor(\n    coinName: UtxoCoinName,\n    wasmName: WasmUtxoCoinName,\n    unifiedRecipientPreference: UnifiedRecipientPreference = 'transparent'\n  ) {\n    super(coinName, wasmName);\n    this.zcashNetworkName = wasmName as fixedScriptWallet.ZcashNetworkName;\n    this.unifiedRecipientPreference = unifiedRecipientPreference;\n  }\n\n  /**\n   * Whether `address` is a valid Zcash address for this coin's network.\n   *\n   * Mirrors the pre-codec `Zec.isValidAddress` logic exactly: the address is\n   * valid iff it has a usable transparent receiver (an ordinary transparent\n   * address, or a UA carrying a transparent receiver) or an Orchard receiver\n   * (a UA carrying one).\n   */\n  override isValidAddress(address: string): boolean {\n    return (\n      zcashAddress.hasTransparentReceiver(address, this.wasmName) ||\n      zcashAddress.hasOrchardReceiver(address, this.wasmName)\n    );\n  }\n\n  /**\n   * Resolve `address` to the bytes this codec's unified-recipient preference pays to.\n   *\n   * - `'transparent'` (default) resolves the scriptPubKey: an ordinary\n   *   transparent address decodes to its own script, and a UA with a\n   *   transparent receiver decodes to that receiver's script. A UA without a\n   *   transparent receiver (e.g. Orchard-only) throws, since a shielded\n   *   output has no script.\n   * - `'shielded'` resolves the raw Orchard (Ironwood) receiver — the\n   *   43-byte diversifier + `pk_d` — of a UA carrying one. Any other address\n   *   (plain transparent, transparent-only UA, malformed, wrong network)\n   *   throws, since it has no Orchard receiver to resolve.\n   */\n  override decode(address: string): Uint8Array {\n    if (this.unifiedRecipientPreference !== 'shielded') {\n      return zcashAddress.toTransparentReceiverWithCoin(address, this.wasmName);\n    }\n    // The raw Orchard receiver exists only for a Unified Address carrying one; anything else\n    // (plain transparent address, transparent-only UA, malformed, wrong network) throws.\n    let unified: fixedScriptWallet.ZcashUnifiedAddress | undefined;\n    try {\n      unified = fixedScriptWallet.ZcashUnifiedAddress.parse(address, this.zcashNetworkName);\n    } catch {\n      throw new Error(`address ${address} is not a valid address for network ${this.zcashNetworkName}`);\n    }\n    if (!unified?.hasOrchardReceiver) {\n      throw new Error(`address ${address} has no Orchard receiver to resolve as shielded`);\n    }\n    return zcashAddress.toShieldedReceiverWithCoin(address, this.wasmName);\n  }\n\n  /** Change addresses are always transparent wallet addresses. */\n  override decodeChangeAddress(address: string): Uint8Array {\n    return zcashAddress.toTransparentReceiverWithCoin(address, this.wasmName);\n  }\n  override isMatchingScript(output: ZecAddressCodecOutput): boolean {\n    const address = output.address;\n    if (address === undefined || address === null) {\n      return true;\n    }\n    if (AddressCodec.isScriptRecipient(address)) {\n      return super.isMatchingScript(output);\n    }\n\n    const matchesOutput = (decode: () => Uint8Array): boolean => {\n      try {\n        return Buffer.from(decode()).equals(Buffer.from(output.script));\n      } catch {\n        return false;\n      }\n    };\n    const isShielded = output.isShielded;\n    if (isShielded === true) {\n      return matchesOutput(() => zcashAddress.toShieldedReceiverWithCoin(address, this.wasmName));\n    }\n    if (isShielded === false) {\n      return matchesOutput(() => zcashAddress.toTransparentReceiverWithCoin(address, this.wasmName));\n    }\n    return (\n      matchesOutput(() => zcashAddress.toTransparentReceiverWithCoin(address, this.wasmName)) ||\n      matchesOutput(() => zcashAddress.toShieldedReceiverWithCoin(address, this.wasmName))\n    );\n  }\n\n  /** Preserve a shielded output's original UA only after validating it against the raw script. */\n  override toExtendedAddressFormat(script: Buffer, address?: string): string {\n    if (address !== undefined && !this.isMatchingScript({ address, script })) {\n      throw new Error(`address ${address} does not match the output script`);\n    }\n    return address ?? super.toExtendedAddressFormat(script);\n  }\n}\n\n/**\n * Whether `address` is a well-formed ZIP-316 Unified Address for `network`\n * with an Orchard receiver. BitGo only supports Orchard, so a UA without one\n * (e.g. Sapling- or transparent-only) is not considered valid here.\n */\nexport function isShieldedZcashAddress(address: string, network: fixedScriptWallet.ZcashNetworkName): boolean {\n  try {\n    return fixedScriptWallet.ZcashUnifiedAddress.parse(address, network).hasOrchardReceiver;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Classify a Zcash address string as transparent or shielded, validating it in\n * the process. Returns undefined if the address is neither a valid transparent\n * address nor a well-formed ZIP-316 Unified Address for `network`.\n */\nexport function getZcashAddressKind(\n  address: string,\n  network: fixedScriptWallet.ZcashNetworkName\n): ZcashAddressKind | undefined {\n  // ZcashNetworkName also permits 'zcash'/'zcashTest', which toOutputScriptWithCoin\n  // doesn't accept (it takes a CoinName, i.e. 'zec'/'tzec'). Skip straight to the\n  // shielded check for those rather than relying on an unsafe cast + caught throw.\n  if (isCoinName(network)) {\n    try {\n      wasmAddress.toOutputScriptWithCoin(address, network);\n      return 'transparent';\n    } catch {\n      // not a valid transparent address; fall through to shielded check\n    }\n  }\n  return isShieldedZcashAddress(address, network) ? 'shielded' : undefined;\n}\n\n/**\n * Standalone counterpart to `Zec.isValidAddress`, parameterized by `network`\n * instead of requiring a coin instance. Accepts transparent addresses and\n * shielded ZIP-316 Unified Addresses.\n *\n * Not structurally identical to `Zec.isValidAddress`: the base class also\n * round-trips the parsed script through each known encoding format (see\n * `AbstractUtxoCoin.isValidAddress`), whereas this only calls\n * `toOutputScriptWithCoin` once via `getZcashAddressKind`. They agree in\n * practice since zec/tzec have no alternate transparent-address encoding to\n * round-trip against, but that's not guaranteed to remain true.\n */\nexport function isValidZcashAddress(address: string, network: fixedScriptWallet.ZcashNetworkName): boolean {\n  return getZcashAddressKind(address, network) !== undefined;\n}\n"]}

package/dist/cjs/src/impl/zec/index.d.ts

@@ -0,0 +1,7 @@
+export * from './zec';
+export * from './tzec';
+export * from './shieldedAddress';
+export * from './address';
+export * from './recipients';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/src/impl/zec/index.d.ts.map

@@ -0,0 +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,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}

package/dist/cjs/src/impl/zec/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./zec"), exports);
+__exportStar(require("./tzec"), exports);
+__exportStar(require("./shieldedAddress"), exports);
+__exportStar(require("./address"), exports);
+__exportStar(require("./recipients"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvaW1wbC96ZWMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdDQUFzQjtBQUN0Qix5Q0FBdUI7QUFDdkIsb0RBQWtDO0FBQ2xDLDRDQUEwQjtBQUMxQiwrQ0FBNkI7QUFDN0IsMENBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi96ZWMnO1xuZXhwb3J0ICogZnJvbSAnLi90emVjJztcbmV4cG9ydCAqIGZyb20gJy4vc2hpZWxkZWRBZGRyZXNzJztcbmV4cG9ydCAqIGZyb20gJy4vYWRkcmVzcyc7XG5leHBvcnQgKiBmcm9tICcuL3JlY2lwaWVudHMnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG4iXX0=

package/dist/cjs/src/impl/zec/recipients.d.ts

@@ -0,0 +1,86 @@
+import { fixedScriptWallet } from '@bitgo/wasm-utxo';
+import type { UnifiedRecipientPreference } from '@bitgo-beta/sdk-core';
+import type { AddressCodec } from '../../transaction/recipient';
+import { ZcashCoinName } from './types';
+/**
+ * How a recipient parsed from a Zcash PSBT is spent.
+ *
+ * The decode-side counterpart of utxo-core's `buildTransaction/zcash.ts` `ZcashDestination` on
+ * the build side: a shielded recipient is an Orchard/Ironwood output stored in the v6 (Ironwood)
+ * PSBT's orchard PCZT, and everything else is an ordinary transparent output. A transparent
+ * output resolved from a Unified Address carries that original UA (`zcashUnifiedTransparent`), a
+ * plain address does not.
+ */
+export type PsbtRecipientDestination = {
+    kind: 'zcashShielded';
+    /**
+     * The Unified Address the output was addressed to — the original multi-receiver UA the
+     * client passed when the PSBT stores one verbatim, otherwise a re-encoded single-receiver
+     * Orchard UA.
+     */
+    unifiedAddress: string;
+} | {
+    kind: 'zcashUnifiedTransparent';
+    /** The original Unified Address the transparent receiver was resolved from. */
+    unifiedAddress: string;
+} | {
+    kind: 'transparent';
+};
+/** A recipient resolved from a decoded Zcash PSBT's external outputs. */
+export interface PsbtRecipient {
+    /** Amount in satoshis. */
+    amount: bigint;
+    /**
+     * The recipient address. For a shielded output this is the Unified Address the output was
+     * addressed to — the original multi-receiver UA when the PSBT stores one verbatim, otherwise a
+     * re-encoded single-receiver Orchard UA. For a transparent output it is the original Unified
+     * Address when one was stored, else the decoded transparent address.
+     */
+    address: string;
+    /**
+     * Raw receiver bytes: the 43-byte Orchard/Ironwood receiver for a shielded output, the
+     * scriptPubKey for a transparent one.
+     */
+    script: Uint8Array;
+    /**
+     * The original Unified Address the client supplied for this recipient, when the PSBT stores
+     * one: the v6 (Ironwood) PCZT for a shielded output, the transparent-output proprietary
+     * key-value map for a v4 transparent output. `undefined` when the recipient was built from a
+     * plain address.
+     */
+    unifiedAddress?: string;
+    destination: PsbtRecipientDestination;
+}
+/**
+ * Resolve the recipient list of a decoded Zcash PSBT (v4 Sapling-shaped or v6 Ironwood).
+ *
+ * Mirrors the recipient resolution of wallet-platform's utxo-core `buildTransaction` in the
+ * decode direction: every non-wallet output with a resolvable address is a recipient. A
+ * shielded output parses with `isShielded: true`, its `script` being the raw 43-byte receiver;
+ * when the build stored the client's original Unified Address (the v6 PCZT for shielded
+ * outputs, the transparent-output proprietary key-value map for v4), both the parsed address
+ * and `unifiedAddress` report it verbatim. Opaque outputs with no address (e.g. OP_RETURN) are
+ * skipped, as they carry no recipient.
+ */
+export declare function resolvePsbtRecipients(psbt: fixedScriptWallet.ZcashBitGoPsbt, walletKeys: fixedScriptWallet.RootWalletKeys, addressCodec: AddressCodec): PsbtRecipient[];
+/**
+ * Infer the Unified-Address recipient preference for a Zcash transaction when the caller did
+ * not pass one — the counterpart of wallet-platform's utxo-core `buildTransaction`
+ * `classifyRecipientShieldedness`.
+ *
+ * A recipient that resolves to a transparent output — an ordinary transparent address, or a
+ * Unified Address carrying a transparent receiver — is classified `'transparent'`; a Unified
+ * Address carrying only an Orchard/Ironwood receiver is classified `'shielded'`. A mix of
+ * shielded and transparent recipients is rejected. An address that is neither a transparent
+ * address nor a Unified Address propagates the Unified-Address parse error — it is not
+ * silently defaulted to `'transparent'`.
+ *
+ * @returns `'shielded'` when every recipient resolves shielded, `undefined` when every
+ *   recipient resolves transparent (the build's default). The `'transparent'` arm of the
+ *   return type exists so callers can pass the explicit preference through unchanged; this
+ *   function itself never returns `'transparent'`.
+ */
+export declare function getUnifiedRecipientPreference(name: ZcashCoinName, recipients: {
+    address: string | undefined;
+}[]): UnifiedRecipientPreference | undefined;
+//# sourceMappingURL=recipients.d.ts.map

package/dist/cjs/src/impl/zec/recipients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipients.d.ts","sourceRoot":"","sources":["../../../../../src/impl/zec/recipients.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAgB,MAAM,kBAAkB,CAAC;AACnE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAGvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC;;;;;;;;GAQG;AACH,MAAM,MAAM,wBAAwB,GAChC;IACE,IAAI,EAAE,eAAe,CAAC;IACtB;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;CACxB,GACD;IACE,IAAI,EAAE,yBAAyB,CAAC;IAChC,+EAA+E;IAC/E,cAAc,EAAE,MAAM,CAAC;CACxB,GACD;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC;AAE5B,yEAAyE;AACzE,MAAM,WAAW,aAAa;IAC5B,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,MAAM,EAAE,UAAU,CAAC;IACnB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,wBAAwB,CAAC;CACvC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,iBAAiB,CAAC,cAAc,EACtC,UAAU,EAAE,iBAAiB,CAAC,cAAc,EAC5C,YAAY,EAAE,YAAY,GACzB,aAAa,EAAE,CAoCjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,aAAa,EACnB,UAAU,EAAE;IAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,EAAE,GAC5C,0BAA0B,GAAG,SAAS,CA0BxC"}

package/dist/cjs/src/impl/zec/recipients.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePsbtRecipients = resolvePsbtRecipients;
+exports.getUnifiedRecipientPreference = getUnifiedRecipientPreference;
+const wasm_utxo_1 = require("@bitgo/wasm-utxo");
+const replayProtection_1 = require("../../transaction/fixedScript/replayProtection");
+/**
+ * Resolve the recipient list of a decoded Zcash PSBT (v4 Sapling-shaped or v6 Ironwood).
+ *
+ * Mirrors the recipient resolution of wallet-platform's utxo-core `buildTransaction` in the
+ * decode direction: every non-wallet output with a resolvable address is a recipient. A
+ * shielded output parses with `isShielded: true`, its `script` being the raw 43-byte receiver;
+ * when the build stored the client's original Unified Address (the v6 PCZT for shielded
+ * outputs, the transparent-output proprietary key-value map for v4), both the parsed address
+ * and `unifiedAddress` report it verbatim. Opaque outputs with no address (e.g. OP_RETURN) are
+ * skipped, as they carry no recipient.
+ */
+function resolvePsbtRecipients(psbt, walletKeys, addressCodec) {
+    const parsed = psbt.parseTransactionWithWalletKeys(walletKeys, {
+        replayProtection: { publicKeys: (0, replayProtection_1.getReplayProtectionPubkeys)('zec') },
+    });
+    const recipients = [];
+    parsed.outputs.forEach((output, i) => {
+        // Wallet-owned (change) outputs.
+        if (output.scriptId !== null) {
+            return;
+        }
+        // Opaque outputs (e.g. OP_RETURN) carry no recipient address.
+        if (output.address === null) {
+            return;
+        }
+        // The raw parsed receiver/script is authoritative; proprietary Unified Address metadata
+        // must match it before it is exposed to callers.
+        if (!addressCodec.isMatchingScript(output)) {
+            throw new Error(`Output ${i} address ${output.address} does not match its raw recipient`);
+        }
+        // The original client-passed Unified Address, stored verbatim in the PSBT's key-value
+        // transparent-output proprietary map for a v4 transparent output.
+        const unifiedAddress = output.isShielded ? output.address : psbt.transparentOutputUnifiedAddress(i) ?? undefined;
+        recipients.push({
+            amount: output.value,
+            address: output.address,
+            script: output.script,
+            unifiedAddress,
+            destination: output.isShielded
+                ? { kind: 'zcashShielded', unifiedAddress: output.address }
+                : unifiedAddress
+                    ? { kind: 'zcashUnifiedTransparent', unifiedAddress }
+                    : { kind: 'transparent' },
+        });
+    });
+    return recipients;
+}
+/**
+ * Infer the Unified-Address recipient preference for a Zcash transaction when the caller did
+ * not pass one — the counterpart of wallet-platform's utxo-core `buildTransaction`
+ * `classifyRecipientShieldedness`.
+ *
+ * A recipient that resolves to a transparent output — an ordinary transparent address, or a
+ * Unified Address carrying a transparent receiver — is classified `'transparent'`; a Unified
+ * Address carrying only an Orchard/Ironwood receiver is classified `'shielded'`. A mix of
+ * shielded and transparent recipients is rejected. An address that is neither a transparent
+ * address nor a Unified Address propagates the Unified-Address parse error — it is not
+ * silently defaulted to `'transparent'`.
+ *
+ * @returns `'shielded'` when every recipient resolves shielded, `undefined` when every
+ *   recipient resolves transparent (the build's default). The `'transparent'` arm of the
+ *   return type exists so callers can pass the explicit preference through unchanged; this
+ *   function itself never returns `'transparent'`.
+ */
+function getUnifiedRecipientPreference(name, recipients) {
+    const shieldedness = recipients.map((recipient) => {
+        if (recipient.address === undefined) {
+            // Raw script inherently transparent.
+            return 'transparent';
+        }
+        // Ordinary transparent address, or a Unified Address carrying a transparent receiver:
+        // resolves transparently either way (the build's default when no preference is given).
+        if (wasm_utxo_1.zcashAddress.hasTransparentReceiver(recipient.address, name)) {
+            return 'transparent';
+        }
+        // A shielded (Orchard/Ironwood-only) Unified Address is the only remaining resolvable
+        // form. An address that is none of the above propagates the parse error instead of
+        // assuming a default.
+        const unified = wasm_utxo_1.fixedScriptWallet.ZcashUnifiedAddress.parse(recipient.address, name);
+        if (unified.hasOrchardReceiver) {
+            return 'shielded';
+        }
+        throw new Error(`address ${recipient.address} carries no transparent or Orchard receiver`);
+    });
+    const hasShielded = shieldedness.includes('shielded');
+    const hasTransparent = shieldedness.includes('transparent');
+    if (hasShielded && hasTransparent) {
+        throw new Error('Mixed shielded and transparent recipients are not supported');
+    }
+    return hasShielded ? 'shielded' : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recipients.js","sourceRoot":"","sources":["../../../../../src/impl/zec/recipients.ts"],"names":[],"mappings":"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","sourcesContent":["import { fixedScriptWallet, zcashAddress } from '@bitgo/wasm-utxo';\nimport type { UnifiedRecipientPreference } from '@bitgo-beta/sdk-core';\n\nimport { getReplayProtectionPubkeys } from '../../transaction/fixedScript/replayProtection';\nimport type { AddressCodec } from '../../transaction/recipient';\n\nimport { ZcashCoinName } from './types';\n\n/**\n * How a recipient parsed from a Zcash PSBT is spent.\n *\n * The decode-side counterpart of utxo-core's `buildTransaction/zcash.ts` `ZcashDestination` on\n * the build side: a shielded recipient is an Orchard/Ironwood output stored in the v6 (Ironwood)\n * PSBT's orchard PCZT, and everything else is an ordinary transparent output. A transparent\n * output resolved from a Unified Address carries that original UA (`zcashUnifiedTransparent`), a\n * plain address does not.\n */\nexport type PsbtRecipientDestination =\n  | {\n      kind: 'zcashShielded';\n      /**\n       * The Unified Address the output was addressed to — the original multi-receiver UA the\n       * client passed when the PSBT stores one verbatim, otherwise a re-encoded single-receiver\n       * Orchard UA.\n       */\n      unifiedAddress: string;\n    }\n  | {\n      kind: 'zcashUnifiedTransparent';\n      /** The original Unified Address the transparent receiver was resolved from. */\n      unifiedAddress: string;\n    }\n  | { kind: 'transparent' };\n\n/** A recipient resolved from a decoded Zcash PSBT's external outputs. */\nexport interface PsbtRecipient {\n  /** Amount in satoshis. */\n  amount: bigint;\n  /**\n   * The recipient address. For a shielded output this is the Unified Address the output was\n   * addressed to — the original multi-receiver UA when the PSBT stores one verbatim, otherwise a\n   * re-encoded single-receiver Orchard UA. For a transparent output it is the original Unified\n   * Address when one was stored, else the decoded transparent address.\n   */\n  address: string;\n  /**\n   * Raw receiver bytes: the 43-byte Orchard/Ironwood receiver for a shielded output, the\n   * scriptPubKey for a transparent one.\n   */\n  script: Uint8Array;\n  /**\n   * The original Unified Address the client supplied for this recipient, when the PSBT stores\n   * one: the v6 (Ironwood) PCZT for a shielded output, the transparent-output proprietary\n   * key-value map for a v4 transparent output. `undefined` when the recipient was built from a\n   * plain address.\n   */\n  unifiedAddress?: string;\n  destination: PsbtRecipientDestination;\n}\n\n/**\n * Resolve the recipient list of a decoded Zcash PSBT (v4 Sapling-shaped or v6 Ironwood).\n *\n * Mirrors the recipient resolution of wallet-platform's utxo-core `buildTransaction` in the\n * decode direction: every non-wallet output with a resolvable address is a recipient. A\n * shielded output parses with `isShielded: true`, its `script` being the raw 43-byte receiver;\n * when the build stored the client's original Unified Address (the v6 PCZT for shielded\n * outputs, the transparent-output proprietary key-value map for v4), both the parsed address\n * and `unifiedAddress` report it verbatim. Opaque outputs with no address (e.g. OP_RETURN) are\n * skipped, as they carry no recipient.\n */\nexport function resolvePsbtRecipients(\n  psbt: fixedScriptWallet.ZcashBitGoPsbt,\n  walletKeys: fixedScriptWallet.RootWalletKeys,\n  addressCodec: AddressCodec\n): PsbtRecipient[] {\n  const parsed = psbt.parseTransactionWithWalletKeys(walletKeys, {\n    replayProtection: { publicKeys: getReplayProtectionPubkeys('zec') },\n  });\n\n  const recipients: PsbtRecipient[] = [];\n  parsed.outputs.forEach((output, i) => {\n    // Wallet-owned (change) outputs.\n    if (output.scriptId !== null) {\n      return;\n    }\n    // Opaque outputs (e.g. OP_RETURN) carry no recipient address.\n    if (output.address === null) {\n      return;\n    }\n    // The raw parsed receiver/script is authoritative; proprietary Unified Address metadata\n    // must match it before it is exposed to callers.\n    if (!addressCodec.isMatchingScript(output)) {\n      throw new Error(`Output ${i} address ${output.address} does not match its raw recipient`);\n    }\n    // The original client-passed Unified Address, stored verbatim in the PSBT's key-value\n    // transparent-output proprietary map for a v4 transparent output.\n    const unifiedAddress = output.isShielded ? output.address : psbt.transparentOutputUnifiedAddress(i) ?? undefined;\n    recipients.push({\n      amount: output.value,\n      address: output.address,\n      script: output.script,\n      unifiedAddress,\n      destination: output.isShielded\n        ? { kind: 'zcashShielded', unifiedAddress: output.address }\n        : unifiedAddress\n        ? { kind: 'zcashUnifiedTransparent', unifiedAddress }\n        : { kind: 'transparent' },\n    });\n  });\n  return recipients;\n}\n\n/**\n * Infer the Unified-Address recipient preference for a Zcash transaction when the caller did\n * not pass one — the counterpart of wallet-platform's utxo-core `buildTransaction`\n * `classifyRecipientShieldedness`.\n *\n * A recipient that resolves to a transparent output — an ordinary transparent address, or a\n * Unified Address carrying a transparent receiver — is classified `'transparent'`; a Unified\n * Address carrying only an Orchard/Ironwood receiver is classified `'shielded'`. A mix of\n * shielded and transparent recipients is rejected. An address that is neither a transparent\n * address nor a Unified Address propagates the Unified-Address parse error — it is not\n * silently defaulted to `'transparent'`.\n *\n * @returns `'shielded'` when every recipient resolves shielded, `undefined` when every\n *   recipient resolves transparent (the build's default). The `'transparent'` arm of the\n *   return type exists so callers can pass the explicit preference through unchanged; this\n *   function itself never returns `'transparent'`.\n */\nexport function getUnifiedRecipientPreference(\n  name: ZcashCoinName,\n  recipients: { address: string | undefined }[]\n): UnifiedRecipientPreference | undefined {\n  const shieldedness = recipients.map((recipient) => {\n    if (recipient.address === undefined) {\n      // Raw script inherently transparent.\n      return 'transparent' as const;\n    }\n    // Ordinary transparent address, or a Unified Address carrying a transparent receiver:\n    // resolves transparently either way (the build's default when no preference is given).\n    if (zcashAddress.hasTransparentReceiver(recipient.address, name)) {\n      return 'transparent' as const;\n    }\n    // A shielded (Orchard/Ironwood-only) Unified Address is the only remaining resolvable\n    // form. An address that is none of the above propagates the parse error instead of\n    // assuming a default.\n    const unified = fixedScriptWallet.ZcashUnifiedAddress.parse(recipient.address, name);\n    if (unified.hasOrchardReceiver) {\n      return 'shielded' as const;\n    }\n    throw new Error(`address ${recipient.address} carries no transparent or Orchard receiver`);\n  });\n  const hasShielded = shieldedness.includes('shielded');\n  const hasTransparent = shieldedness.includes('transparent');\n  if (hasShielded && hasTransparent) {\n    throw new Error('Mixed shielded and transparent recipients are not supported');\n  }\n  return hasShielded ? 'shielded' : undefined;\n}\n"]}

package/dist/cjs/src/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/cjs/src/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/cjs/src/impl/zec/shieldedAddress.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertShieldedWalletAddress = assertShieldedWalletAddress;
+const wasm_utxo_1 = require("@bitgo/wasm-utxo");
+const sdk_core_1 = require("@bitgo-beta/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`
+ */
+function assertShieldedWalletAddress(coinName, params) {
+    const shielded = params.coinSpecific?.shielded;
+    if (!shielded?.diversifier || !shielded.pkD) {
+        throw new sdk_core_1.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 sdk_core_1.UnexpectedAddressError(`address validation failure: invalid diversifier length ${diversifier.length}`);
+    }
+    if (pkD.length !== 32) {
+        throw new sdk_core_1.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 = wasm_utxo_1.fixedScriptWallet.ZcashUnifiedAddress.parse(params.address, network);
+    }
+    catch (e) {
+        throw new sdk_core_1.UnexpectedAddressError(`address validation failure: not a valid unified address: ${params.address}`);
+    }
+    const orchard = ua.orchardReceiver;
+    if (!orchard || orchard.length !== 43) {
+        throw new sdk_core_1.UnexpectedAddressError('address validation failure: unified address carries no Orchard receiver');
+    }
+    const expectedReceiver = Buffer.concat([diversifier, pkD]);
+    if (!Buffer.from(orchard).equals(expectedReceiver)) {
+        throw new sdk_core_1.UnexpectedAddressError('address validation failure: unified address Orchard receiver does not match shielded coinSpecific');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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