@bitgo-beta/sdk-coin-eth 4.4.1-beta.202 → 4.4.1-beta.2021

package/dist/src/erc7984Token.js

@@ -0,0 +1,946 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Erc7984Token = void 0;
+/**
+ * @prettier
+ */
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const statics_1 = require("@bitgo-beta/statics");
+const abstract_eth_1 = require("@bitgo-beta/abstract-eth");
+const secp256k1_1 = require("@bitgo-beta/secp256k1");
+const _ = __importStar(require("lodash"));
+const eth_1 = require("./eth");
+const lib_1 = require("./lib");
+class Erc7984Token extends eth_1.Eth {
+    constructor(bitgo, tokenConfig) {
+        const staticsCoin = statics_1.coins.get(tokenConfig.coin);
+        super(bitgo, staticsCoin);
+        this.tokenConfig = tokenConfig;
+        // ERC7984 confidential transfers use sendMultiSig (not sendMultiSigToken) because
+        // the calldata parameter is required to carry confidentialTransfer(recipient, encryptedHandle, inputProof).
+        // sendMultiSigToken has no data parameter and cannot carry inner calldata.
+        this.sendMethodName = 'sendMultiSig';
+    }
+    static createTokenConstructor(config) {
+        return (bitgo) => new Erc7984Token(bitgo, config);
+    }
+    static createTokenConstructors(tokenConfigs = [
+        ...statics_1.tokens.bitcoin.eth.confidentialTokens,
+        ...statics_1.tokens.testnet.eth.confidentialTokens,
+    ]) {
+        const tokensCtors = [];
+        for (const token of tokenConfigs) {
+            const tokenConstructor = Erc7984Token.createTokenConstructor(token);
+            tokensCtors.push({ name: token.type, coinConstructor: tokenConstructor });
+            tokensCtors.push({ name: token.tokenContractAddress, coinConstructor: tokenConstructor });
+        }
+        return tokensCtors;
+    }
+    get type() {
+        return this.tokenConfig.type;
+    }
+    get name() {
+        return this.tokenConfig.name;
+    }
+    get coin() {
+        return this.tokenConfig.coin;
+    }
+    get network() {
+        return this.tokenConfig.network;
+    }
+    get tokenContractAddress() {
+        return this.tokenConfig.tokenContractAddress;
+    }
+    get decimalPlaces() {
+        return this.tokenConfig.decimalPlaces;
+    }
+    getChain() {
+        return this.tokenConfig.type;
+    }
+    getFullName() {
+        return 'ERC7984 Confidential Token';
+    }
+    getBaseFactor() {
+        return Math.pow(10, this.tokenConfig.decimalPlaces);
+    }
+    /**
+     * Flag for sending value of 0.
+     * ERC-7984 confidential transfers always carry an encrypted amount; zero-value sends are not meaningful.
+     */
+    valuelessTransferAllowed() {
+        return false;
+    }
+    /**
+     * Flag for sending data along with transactions via the standard token-send API.
+     * Returns false because ERC-7984 sends use confidentialTransfer() calldata built
+     * by WP, not an arbitrary data field on the send params.
+     * Note: this does not prevent calldata-based flows like getDelegationBuilder(),
+     * which bypass the token-send path entirely.
+     */
+    transactionDataAllowed() {
+        return false;
+    }
+    /** @inheritDoc */
+    supportsTss() {
+        return true;
+    }
+    /** @inheritDoc */
+    getMPCAlgorithm() {
+        return 'ecdsa';
+    }
+    getTransactionBuilder() {
+        return new lib_1.TransactionBuilder(statics_1.coins.get(this.getBaseChain()));
+    }
+    /** @inheritDoc */
+    async verifyTransaction(params) {
+        if (params.txParams?.type === 'enabletoken') {
+            return this.verifyEnableTokenTransaction(params);
+        }
+        if (params.txParams?.type === 'wrap') {
+            return this.verifyWrapTransaction(params);
+        }
+        if (params.txParams?.type === 'unwrap') {
+            return this.verifyUnwrapTransaction(params);
+        }
+        if (params.txParams?.type === 'finalizeUnwrap') {
+            return this.verifyFinalizeUnwrapTransaction(params);
+        }
+        if (this.isConsolidationTransaction(params)) {
+            return this.verifyConfidentialConsolidation(params);
+        }
+        return this.verifyConfidentialTransfer(params);
+    }
+    isConsolidationTransaction(params) {
+        const { txParams, txPrebuild, verification } = params;
+        return !!(verification?.consolidationToBaseAddress ||
+            txPrebuild?.consolidateId ||
+            txParams?.type === 'consolidate' ||
+            // TSS signing path: resolveEffectiveTxParams sets type from intent.intentType which is
+            // 'consolidateToken' for ERC-7984 token consolidations. txPrebuild has only txHex
+            // (no consolidateId) in this path.
+            txParams?.type === 'consolidateToken' ||
+            txParams?.prebuildTx?.consolidateId);
+    }
+    /**
+     * Verifies WrapERC7984 (shield) transactions.
+     *
+     * TSS / direct shape:
+     *   tx.to   = wrapper contract
+     *   tx.data = wrap(baseAddress, amount)
+     *
+     * Multisig shape:
+     *   tx.to   = wallet contract
+     *   tx.data = sendMultiSig(wrapper, 0, wrap(baseAddress, amount), ...)
+     *
+     * Checks: wrapper address, self-directed `to` == base, amount > 0, amount matches
+     * recipients, and amount × rate fits uint64 when statics rate is present.
+     */
+    async verifyWrapTransaction(params) {
+        const { txParams, txPrebuild, wallet } = params;
+        if (!txPrebuild?.txHex) {
+            throw new Error('verifyWrapTransaction: missing txHex in txPrebuild');
+        }
+        const txBuilder = this.getTransactionBuilder();
+        txBuilder.from(txPrebuild.txHex);
+        const tx = await txBuilder.build();
+        const txJson = tx.toJson();
+        let wrapperAddress;
+        let wrapCalldata;
+        try {
+            if (txJson.data.toLowerCase().startsWith(abstract_eth_1.sendMultisigMethodId.toLowerCase())) {
+                const decoded = (0, abstract_eth_1.decodeTransferData)(txJson.data);
+                wrapperAddress = decoded.to;
+                wrapCalldata = decoded.data;
+                if (decoded.amount !== '0') {
+                    throw new Error(`expected sendMultiSig value 0 but got ${decoded.amount}`);
+                }
+            }
+            else if (txJson.data.toLowerCase().startsWith(abstract_eth_1.wrapMethodId.toLowerCase())) {
+                wrapperAddress = txJson.to;
+                wrapCalldata = txJson.data;
+            }
+            else {
+                throw new Error(`unexpected method ID ${txJson.data.slice(0, 10)}`);
+            }
+        }
+        catch (e) {
+            throw new Error(`verifyWrapTransaction: failed to decode wrap calldata — ${e.message}`);
+        }
+        if (wrapperAddress.toLowerCase() !== this.tokenContractAddress.toLowerCase()) {
+            throw new Error(`verifyWrapTransaction: wrapper address mismatch — ` +
+                `expected ${this.tokenContractAddress}, got ${wrapperAddress}`);
+        }
+        let to;
+        let amount;
+        try {
+            ({ to, amount } = (0, abstract_eth_1.decodeWrapCalldata)(wrapCalldata));
+        }
+        catch (e) {
+            throw new Error(`verifyWrapTransaction: invalid wrap inner calldata — ${e.message}`);
+        }
+        if (!Erc7984Token.isPositiveIntegerString(amount)) {
+            throw new Error(`verifyWrapTransaction: amount must be a positive integer string, got '${amount}'`);
+        }
+        const baseAddress = this.getWalletBaseAddress(wallet);
+        if (!baseAddress) {
+            throw new Error('verifyWrapTransaction: unable to determine wallet base address');
+        }
+        if (to.toLowerCase() !== baseAddress.toLowerCase()) {
+            throw new Error(`verifyWrapTransaction: wrap recipient must equal wallet base address — expected ${baseAddress}, got ${to}`);
+        }
+        const expectedAmount = txParams?.recipients?.[0]?.amount ?? txPrebuild.buildParams?.recipients?.[0]?.amount;
+        if (expectedAmount !== undefined && String(expectedAmount) !== amount) {
+            throw new Error(`verifyWrapTransaction: amount mismatch — calldata has '${amount}' but params have '${expectedAmount}'`);
+        }
+        const rate = this.tokenConfig.rate;
+        if (rate !== undefined) {
+            try {
+                (0, abstract_eth_1.assertAmountTimesRateFitsUint64)(amount, rate);
+            }
+            catch (e) {
+                throw new Error(`verifyWrapTransaction: ${e.message}`);
+            }
+        }
+        if (txJson.value !== undefined && txJson.value !== '0' && txJson.value !== 0) {
+            throw new Error(`verifyWrapTransaction: expected transaction value 0 but got ${txJson.value}`);
+        }
+        return true;
+    }
+    /**
+     * Verifies UnwrapERC7984 (unshield phase-1) transactions.
+     *
+     * TSS / direct shape:
+     *   tx.to   = wrapper contract
+     *   tx.data = unwrap(base, base, encryptedAmount, inputProof)
+     *
+     * Multisig shape:
+     *   tx.to   = wallet contract
+     *   tx.data = sendMultiSig(wrapper, 0, unwrap(base, base, ...), ...)
+     *
+     * v1 is self-directed only: from == to == wallet base address.
+     */
+    async verifyUnwrapTransaction(params) {
+        const { txPrebuild, wallet } = params;
+        if (!txPrebuild?.txHex) {
+            throw new Error('verifyUnwrapTransaction: missing txHex in txPrebuild');
+        }
+        const txBuilder = this.getTransactionBuilder();
+        txBuilder.from(txPrebuild.txHex);
+        const tx = await txBuilder.build();
+        const txJson = tx.toJson();
+        let wrapperAddress;
+        let unwrapCalldata;
+        try {
+            if (txJson.data.toLowerCase().startsWith(abstract_eth_1.sendMultisigMethodId.toLowerCase())) {
+                const decoded = (0, abstract_eth_1.decodeTransferData)(txJson.data);
+                wrapperAddress = decoded.to;
+                unwrapCalldata = decoded.data;
+                if (decoded.amount !== '0') {
+                    throw new Error(`expected sendMultiSig value 0 but got ${decoded.amount}`);
+                }
+            }
+            else if (txJson.data.toLowerCase().startsWith(abstract_eth_1.unwrapMethodId.toLowerCase())) {
+                wrapperAddress = txJson.to;
+                unwrapCalldata = txJson.data;
+            }
+            else {
+                throw new Error(`unexpected method ID ${txJson.data.slice(0, 10)}`);
+            }
+        }
+        catch (e) {
+            throw new Error(`verifyUnwrapTransaction: failed to decode unwrap calldata — ${e.message}`);
+        }
+        if (wrapperAddress.toLowerCase() !== this.tokenContractAddress.toLowerCase()) {
+            throw new Error(`verifyUnwrapTransaction: wrapper address mismatch — expected ${this.tokenContractAddress}, got ${wrapperAddress}`);
+        }
+        let from;
+        let to;
+        let encryptedAmount;
+        let inputProof;
+        try {
+            ({ from, to, encryptedAmount, inputProof } = (0, abstract_eth_1.decodeUnwrapCalldata)(unwrapCalldata));
+        }
+        catch (e) {
+            throw new Error(`verifyUnwrapTransaction: invalid unwrap inner calldata — ${e.message}`);
+        }
+        const baseAddress = this.getWalletBaseAddress(wallet);
+        if (!baseAddress) {
+            throw new Error('verifyUnwrapTransaction: unable to determine wallet base address');
+        }
+        if (from.toLowerCase() !== baseAddress.toLowerCase()) {
+            throw new Error(`verifyUnwrapTransaction: unwrap from must equal wallet base address — expected ${baseAddress}, got ${from}`);
+        }
+        if (to.toLowerCase() !== baseAddress.toLowerCase()) {
+            throw new Error(`verifyUnwrapTransaction: unwrap to must equal wallet base address — expected ${baseAddress}, got ${to}`);
+        }
+        if (!encryptedAmount || encryptedAmount === '0x' || /^0x0+$/.test(encryptedAmount)) {
+            throw new Error('verifyUnwrapTransaction: encryptedAmount is missing or empty');
+        }
+        if (!inputProof || inputProof === '0x') {
+            throw new Error('verifyUnwrapTransaction: inputProof is missing or empty');
+        }
+        if (txJson.value !== undefined && txJson.value !== '0' && txJson.value !== 0) {
+            throw new Error(`verifyUnwrapTransaction: expected transaction value 0 but got ${txJson.value}`);
+        }
+        return true;
+    }
+    /**
+     * Verifies FinalizeUnwrapERC7984 (unshield phase-2) transactions.
+     *
+     * TSS / direct shape:
+     *   tx.to   = wrapper contract
+     *   tx.data = finalizeUnwrap(requestId, cleartextAmount, decryptionProof)
+     *
+     * Multisig shape:
+     *   tx.to   = wallet contract
+     *   tx.data = sendMultiSig(wrapper, 0, finalizeUnwrap(...), ...)
+     */
+    async verifyFinalizeUnwrapTransaction(params) {
+        const { txParams, txPrebuild } = params;
+        if (!txPrebuild?.txHex) {
+            throw new Error('verifyFinalizeUnwrapTransaction: missing txHex in txPrebuild');
+        }
+        const txBuilder = this.getTransactionBuilder();
+        txBuilder.from(txPrebuild.txHex);
+        const tx = await txBuilder.build();
+        const txJson = tx.toJson();
+        let wrapperAddress;
+        let finalizeCalldata;
+        try {
+            if (txJson.data.toLowerCase().startsWith(abstract_eth_1.sendMultisigMethodId.toLowerCase())) {
+                const decoded = (0, abstract_eth_1.decodeTransferData)(txJson.data);
+                wrapperAddress = decoded.to;
+                finalizeCalldata = decoded.data;
+                if (decoded.amount !== '0') {
+                    throw new Error(`expected sendMultiSig value 0 but got ${decoded.amount}`);
+                }
+            }
+            else if (txJson.data.toLowerCase().startsWith(abstract_eth_1.finalizeUnwrapMethodId.toLowerCase())) {
+                wrapperAddress = txJson.to;
+                finalizeCalldata = txJson.data;
+            }
+            else {
+                throw new Error(`unexpected method ID ${txJson.data.slice(0, 10)}`);
+            }
+        }
+        catch (e) {
+            throw new Error(`verifyFinalizeUnwrapTransaction: failed to decode finalizeUnwrap calldata — ${e.message}`);
+        }
+        if (wrapperAddress.toLowerCase() !== this.tokenContractAddress.toLowerCase()) {
+            throw new Error(`verifyFinalizeUnwrapTransaction: wrapper address mismatch — expected ${this.tokenContractAddress}, got ${wrapperAddress}`);
+        }
+        let requestId;
+        let cleartextAmount;
+        let decryptionProof;
+        try {
+            ({ requestId, cleartextAmount, decryptionProof } = (0, abstract_eth_1.decodeFinalizeUnwrapCalldata)(finalizeCalldata));
+        }
+        catch (e) {
+            throw new Error(`verifyFinalizeUnwrapTransaction: invalid finalizeUnwrap inner calldata — ${e.message}`);
+        }
+        if (!requestId || requestId === '0x' || /^0x0+$/.test(requestId)) {
+            throw new Error('verifyFinalizeUnwrapTransaction: requestId is missing or empty');
+        }
+        if (!Erc7984Token.isPositiveIntegerString(cleartextAmount)) {
+            throw new Error(`verifyFinalizeUnwrapTransaction: cleartextAmount must be a positive integer string, got '${cleartextAmount}'`);
+        }
+        if (BigInt(cleartextAmount) > abstract_eth_1.UINT64_MAX) {
+            throw new Error('verifyFinalizeUnwrapTransaction: cleartextAmount exceeds uint64');
+        }
+        if (!decryptionProof || decryptionProof === '0x') {
+            throw new Error('verifyFinalizeUnwrapTransaction: decryptionProof is missing or empty');
+        }
+        const expectedAmount = txParams?.recipients?.[0]?.amount ?? txPrebuild.buildParams?.recipients?.[0]?.amount;
+        if (expectedAmount !== undefined && String(expectedAmount) !== cleartextAmount) {
+            throw new Error(`verifyFinalizeUnwrapTransaction: amount mismatch — calldata has '${cleartextAmount}' but params have '${expectedAmount}'`);
+        }
+        if (txJson.value !== undefined && txJson.value !== '0' && txJson.value !== 0) {
+            throw new Error(`verifyFinalizeUnwrapTransaction: expected transaction value 0 but got ${txJson.value}`);
+        }
+        return true;
+    }
+    getWalletBaseAddress(wallet) {
+        if (!wallet) {
+            return undefined;
+        }
+        const coinSpecific = typeof wallet.coinSpecific === 'function' ? wallet.coinSpecific() : wallet.coinSpecific;
+        const ethCoinSpecific = coinSpecific;
+        return ethCoinSpecific?.baseAddress ?? ethCoinSpecific?.rootAddress;
+    }
+    /**
+     * Verifies ERC-7984 forwarder consolidation (flush) transactions.
+     *
+     * Multisig shape:
+     *   tx.to   = wallet contract
+     *   tx.data = sendMultiSig(forwarder, 0, callFromParent(token, 0, confidentialTransferNoProof(base, handle)), ...)
+     *
+     * TSS / direct shape:
+     *   tx.to   = forwarder contract
+     *   tx.data = callFromParent(token, 0, confidentialTransferNoProof(base, handle))
+     */
+    async verifyConfidentialConsolidation(params) {
+        const { txParams, txPrebuild, wallet } = params;
+        if (!txPrebuild?.txHex) {
+            if (!txPrebuild?.consolidateId && !txParams?.prebuildTx?.consolidateId) {
+                throw new Error('verifyConfidentialConsolidation: missing consolidateId');
+            }
+            return true;
+        }
+        const txBuilder = this.getTransactionBuilder();
+        txBuilder.from(txPrebuild.txHex);
+        const tx = await txBuilder.build();
+        const txJson = tx.toJson();
+        let tokenContractAddress;
+        let parentAddress;
+        let encryptedHandle;
+        let forwarderAddress;
+        try {
+            if (txJson.data.startsWith(abstract_eth_1.sendMultisigMethodId)) {
+                const decoded = (0, abstract_eth_1.decodeSendMultiSigFlushERC7984Data)(txJson.data);
+                forwarderAddress = decoded.forwarderAddress;
+                tokenContractAddress = decoded.tokenContractAddress;
+                parentAddress = decoded.parentAddress;
+                encryptedHandle = decoded.encryptedHandle;
+            }
+            else if (txJson.data.startsWith(abstract_eth_1.callFromParentMethodId)) {
+                const decoded = (0, abstract_eth_1.decodeFlushERC7984ForwarderTokenCalldata)(txJson.data);
+                tokenContractAddress = decoded.tokenContractAddress;
+                parentAddress = decoded.parentAddress;
+                encryptedHandle = decoded.encryptedHandle;
+                forwarderAddress = txJson.to;
+            }
+            else {
+                throw new Error(`unexpected method ID ${txJson.data.slice(0, 10)}`);
+            }
+        }
+        catch (e) {
+            throw new Error(`verifyConfidentialConsolidation: failed to decode consolidation calldata — ${e.message}`);
+        }
+        if (tokenContractAddress.toLowerCase() !== this.tokenContractAddress.toLowerCase()) {
+            throw new Error(`verifyConfidentialConsolidation: token contract address mismatch — ` +
+                `expected ${this.tokenContractAddress}, got ${tokenContractAddress}`);
+        }
+        const baseAddress = this.getWalletBaseAddress(wallet);
+        if (!baseAddress) {
+            throw new Error('verifyConfidentialConsolidation: unable to determine wallet base address');
+        }
+        if (parentAddress.toLowerCase() !== baseAddress.toLowerCase()) {
+            throw new Error(`verifyConfidentialConsolidation: parent address mismatch — expected ${baseAddress}, got ${parentAddress}`);
+        }
+        if (!encryptedHandle || encryptedHandle === '0x') {
+            throw new Error('verifyConfidentialConsolidation: encryptedHandle is missing or empty in transaction calldata');
+        }
+        const expectedForwarder = txPrebuild.recipients?.[0]?.address ??
+            txPrebuild.txInfo?.recipients?.[0]?.address ??
+            txParams?.recipients?.[0]?.address;
+        if (forwarderAddress && expectedForwarder) {
+            if (forwarderAddress.toLowerCase() !== expectedForwarder.toLowerCase()) {
+                throw new Error(`verifyConfidentialConsolidation: forwarder address mismatch — ` +
+                    `expected ${expectedForwarder}, got ${forwarderAddress}`);
+            }
+        }
+        return true;
+    }
+    /**
+     * Verifies a confidential token transfer (SendERC7984) transaction.
+     *
+     * With txHex — two on-chain shapes are supported:
+     *
+     *   sendMultiSig-wrapped (multisig / smart-contract wallet):
+     *     tx.to   = wallet contract
+     *     tx.data = sendMultiSig(tokenAddr, 0, confidentialTransfer(recipient, handle, proof), ...)
+     *     Token contract address is decoded from the sendMultiSig inner calldata.
+     *
+     *   Direct call (hot / TSS EOA wallet):
+     *     tx.to   = token contract
+     *     tx.data = confidentialTransfer(recipient, handle, proof)
+     *     Token contract address is taken from tx.to.
+     *
+     *   For both shapes the verifier checks:
+     *     1. Token contract address matches this coin's tokenContractAddress.
+     *     2. Decoded recipient matches txParams.recipients[0].address or buildParams.recipients[0].address.
+     *     3. encryptedHandle and inputProof are structurally present (non-empty).
+     *     4. txParams.recipients[0].amount is a positive integer and matches buildParams when both present.
+     *
+     * Without txHex (first-signer / pre-signing path):
+     *  1. Requires exactly one recipient in txParams.
+     *  2. Validates txParams.recipients[0].address is a valid Ethereum address.
+     *  3. Validates txParams.recipients[0].amount is a positive integer.
+     *  4. Cross-checks address and amount against buildParams when the server has stored the intent.
+     */
+    async verifyConfidentialTransfer(params) {
+        const { txParams, txPrebuild } = params;
+        if (!txPrebuild?.txHex) {
+            // No raw tx available (multisig first-signer path).
+            // Validate ERC7984-specific invariants from txParams and buildParams.
+            const recipients = txParams?.recipients;
+            if (!recipients || recipients.length === 0) {
+                throw new Error('verifyConfidentialTransfer: recipients must contain at least one entry');
+            }
+            if (recipients.length !== 1) {
+                throw new Error(`verifyConfidentialTransfer: confidential transfers support exactly 1 recipient, got ${recipients.length}`);
+            }
+            const recipient = recipients[0];
+            if (!recipient.address || !this.isValidAddress(recipient.address)) {
+                throw new Error(`verifyConfidentialTransfer: recipient address is missing or invalid: ${recipient.address}`);
+            }
+            const amountStr = String(recipient.amount);
+            if (!Erc7984Token.isPositiveIntegerString(amountStr)) {
+                throw new Error(`verifyConfidentialTransfer: amount must be a positive integer string in base units, got '${amountStr}'`);
+            }
+            // Cross-check against buildParams when the server has already stored the intent
+            const buildParamsRecipient = txPrebuild?.buildParams?.recipients?.[0];
+            if (buildParamsRecipient?.address !== undefined) {
+                if (recipient.address.toLowerCase() !== buildParamsRecipient.address.toLowerCase()) {
+                    throw new Error(`verifyConfidentialTransfer: recipient address mismatch — ` +
+                        `txParams has '${recipient.address}' but buildParams has '${buildParamsRecipient.address}'`);
+                }
+            }
+            const buildParamsAmount = buildParamsRecipient?.amount;
+            if (buildParamsAmount !== undefined && buildParamsAmount !== amountStr) {
+                throw new Error(`verifyConfidentialTransfer: amount mismatch — txParams has '${amountStr}' but buildParams has '${buildParamsAmount}'`);
+            }
+            return true;
+        }
+        // Parse and decode the raw transaction
+        const txBuilder = this.getTransactionBuilder();
+        txBuilder.from(txPrebuild.txHex);
+        const tx = await txBuilder.build();
+        const txJson = tx.toJson();
+        let toAddress;
+        let tokenContractAddress;
+        let encryptedHandle;
+        let inputProof;
+        try {
+            if (txJson.data.startsWith(abstract_eth_1.sendMultisigMethodId)) {
+                // sendMultiSig-wrapped path: smart-contract wallet relays the confidentialTransfer call.
+                // Token contract address is encoded inside the sendMultiSig calldata.
+                const decoded = (0, abstract_eth_1.decodeConfidentialTransferData)(txJson.data);
+                toAddress = decoded.toAddress;
+                tokenContractAddress = decoded.tokenContractAddress;
+                encryptedHandle = decoded.encryptedHandle;
+                inputProof = decoded.inputProof;
+            }
+            else if (txJson.data.startsWith(abstract_eth_1.confidentialTransferWithProofMethodId)) {
+                // Direct call path: hot/TSS EOA wallet calls the token contract directly.
+                // The transaction's `to` field is the token contract address.
+                if (!txJson.to) {
+                    throw new Error('direct confidentialTransfer call is missing transaction to address');
+                }
+                const decoded = (0, abstract_eth_1.decodeDirectConfidentialTransferCalldata)(txJson.data);
+                toAddress = decoded.toAddress;
+                tokenContractAddress = txJson.to;
+                encryptedHandle = decoded.encryptedHandle;
+                inputProof = decoded.inputProof;
+            }
+            else {
+                throw new Error(`unexpected method ID ${txJson.data.slice(0, 10)}`);
+            }
+        }
+        catch (e) {
+            throw new Error(`verifyConfidentialTransfer: failed to decode confidential transfer calldata — ${e.message}`);
+        }
+        // 1. Token contract address must match this coin
+        if (tokenContractAddress.toLowerCase() !== this.tokenContractAddress.toLowerCase()) {
+            throw new Error(`verifyConfidentialTransfer: token contract address mismatch — ` +
+                `expected ${this.tokenContractAddress}, got ${tokenContractAddress}`);
+        }
+        // 2. Recipient address must match txParams.recipients[0] or buildParams.recipients[0]
+        const expectedRecipient = txParams?.recipients?.[0]?.address ?? txPrebuild.buildParams?.recipients?.[0]?.address;
+        if (!expectedRecipient) {
+            throw new Error('verifyConfidentialTransfer: missing expected recipient (provide txParams.recipients or txPrebuild.buildParams.recipients)');
+        }
+        if (toAddress.toLowerCase() !== expectedRecipient.toLowerCase()) {
+            throw new Error(`verifyConfidentialTransfer: recipient address mismatch — ` + `expected ${expectedRecipient}, got ${toAddress}`);
+        }
+        // 3. encryptedHandle must be a non-trivial hex value (not bare '0x')
+        if (!encryptedHandle || encryptedHandle === '0x') {
+            throw new Error('verifyConfidentialTransfer: encryptedHandle is missing or empty in transaction calldata');
+        }
+        // 4. inputProof must be a non-trivial hex value
+        if (!inputProof || inputProof === '0x') {
+            throw new Error('verifyConfidentialTransfer: inputProof is missing or empty in transaction calldata');
+        }
+        // 5. Verify plaintext intent: txParams amount must be valid and consistent with buildParams
+        const rawTxParamsAmount = txParams?.recipients?.[0]?.amount;
+        if (rawTxParamsAmount !== undefined) {
+            const txParamsAmount = String(rawTxParamsAmount);
+            if (!Erc7984Token.isPositiveIntegerString(txParamsAmount)) {
+                throw new Error(`verifyConfidentialTransfer: amount must be a positive integer string in base units, got '${txParamsAmount}'`);
+            }
+            const buildParamsAmount = txPrebuild.buildParams?.recipients?.[0]?.amount;
+            if (buildParamsAmount !== undefined && txParamsAmount !== buildParamsAmount) {
+                throw new Error(`verifyConfidentialTransfer: amount mismatch — txParams has '${txParamsAmount}' but buildParams has '${buildParamsAmount}'`);
+            }
+        }
+        return true;
+    }
+    static isPositiveIntegerString(value) {
+        return /^\d+$/.test(value) && BigInt(value) > 0n;
+    }
+    /**
+     * Verifies a token enablement transaction for ERC-7984 decryption delegation.
+     *
+     * TSS path: decodes the raw tx and verifies it calls the ACL contract with
+     * calldata that covers all requested token contract addresses.
+     *
+     * Multisig path: verifies the buildParams recipients carry the correct tokenNames
+     * and zero amounts.
+     */
+    async verifyEnableTokenTransaction(params) {
+        const { txParams, txPrebuild, walletType } = params;
+        if (walletType === 'tss') {
+            // TSS path: full raw-tx decode
+            const enableTokens = txParams.enableTokens;
+            if (!enableTokens || enableTokens.length === 0) {
+                throw new Error('verifyEnableTokenTransaction: enableTokens must be non-empty for TSS path');
+            }
+            if (!txPrebuild.txHex) {
+                throw new Error('verifyEnableTokenTransaction: missing txHex in txPrebuild');
+            }
+            // Resolve requested token names → contract addresses
+            const requestedAddresses = enableTokens.map((t) => {
+                const tokenCoin = this.bitgo.coin(t.name);
+                return tokenCoin.tokenContractAddress.toLowerCase();
+            });
+            // Parse the raw transaction
+            const txBuilder = this.getTransactionBuilder();
+            txBuilder.from(txPrebuild.txHex);
+            const tx = await txBuilder.build();
+            const txJson = tx.toJson();
+            // Verify transaction targets the correct contract based on calldata shape
+            const network = this.getNetwork();
+            const aclContractAddress = network?.zamaAclContractAddress;
+            if (!aclContractAddress) {
+                throw new Error('verifyEnableTokenTransaction: zamaAclContractAddress not configured for this network');
+            }
+            if (!txJson.to) {
+                throw new Error('verifyEnableTokenTransaction: transaction is missing recipient address');
+            }
+            // Inspect calldata method ID to distinguish root wallet from forwarder wallet:
+            //   aclMulticallMethodId   → root wallet: to = ACL contract directly
+            //   callFromParentMethodId → forwarder wallet: to = forwarder, ACL address is inside calldata
+            const calldataMethodId = txJson.data.slice(0, 10);
+            if (calldataMethodId === abstract_eth_1.aclMulticallMethodId) {
+                // Root wallet (base address): tx calls the ACL contract directly
+                if (txJson.to.toLowerCase() !== aclContractAddress.toLowerCase()) {
+                    throw new Error(`verifyEnableTokenTransaction: transaction target ${txJson.to} does not match ACL contract ${aclContractAddress}`);
+                }
+            }
+            else if (calldataMethodId === abstract_eth_1.callFromParentMethodId) {
+                // Forwarder wallet: tx calls the forwarder, which calls the ACL via callFromParent.
+                // The forwarder address is wallet-specific and cannot be statically verified here;
+                // token address correctness is still verified below via calldata decoding.
+            }
+            else {
+                throw new Error(`verifyEnableTokenTransaction: unrecognised calldata method ID ${calldataMethodId}; expected multicall or callFromParent`);
+            }
+            // Verify value is 0
+            if (txJson.value !== '0') {
+                throw new Error(`verifyEnableTokenTransaction: expected transaction value 0 but got ${txJson.value}`);
+            }
+            // Decode token addresses from calldata and verify all requested tokens are present
+            const decodedAddresses = (0, abstract_eth_1.decodeTokenAddressesFromDelegationCalldata)(txJson.data);
+            for (const requested of requestedAddresses) {
+                if (!decodedAddresses.includes(requested)) {
+                    throw new Error(`verifyEnableTokenTransaction: requested token ${requested} not found in delegation calldata`);
+                }
+            }
+            return true;
+        }
+        else {
+            // Multisig path: buildParams-level check
+            const recipients = txPrebuild.buildParams?.recipients;
+            if (!recipients || recipients.length === 0) {
+                throw new Error('verifyEnableTokenTransaction: missing buildParams.recipients for multisig path');
+            }
+            // Determine requested token names from txParams
+            const requestedTokenNames = [];
+            if (txParams.enableTokens && txParams.enableTokens.length > 0) {
+                requestedTokenNames.push(...txParams.enableTokens.map((t) => t.name));
+            }
+            else if (txParams.recipients && txParams.recipients.length > 0) {
+                requestedTokenNames.push(...txParams.recipients.map((r) => r.tokenName).filter(Boolean));
+            }
+            // Verify all recipients have tokenName and amount = '0'
+            for (const recipient of recipients) {
+                if (!recipient.tokenName) {
+                    throw new Error('verifyEnableTokenTransaction: recipient is missing tokenName in buildParams');
+                }
+                if (recipient.amount !== '0') {
+                    throw new Error(`verifyEnableTokenTransaction: expected amount 0 for token enablement but got ${recipient.amount}`);
+                }
+            }
+            // Verify requested token names are present in recipients
+            if (requestedTokenNames.length > 0) {
+                const recipientTokenNames = recipients.map((r) => r.tokenName);
+                for (const requested of requestedTokenNames) {
+                    if (!recipientTokenNames.includes(requested)) {
+                        throw new Error(`verifyEnableTokenTransaction: requested token ${requested} not found in buildParams recipients`);
+                    }
+                }
+            }
+            return true;
+        }
+    }
+    /**
+     * Override gas limit for ERC-7984 confidential token recovery.
+     * Actual on-chain usage is ~506-530k gas based on testnet results.
+     * Default: 800,000 (comfortable buffer over observed usage).
+     */
+    setGasLimit(userGasLimit) {
+        if (!userGasLimit) {
+            return 800000;
+        }
+        return super.setGasLimit(userGasLimit);
+    }
+    /**
+     * Queries the encrypted balance handle for a wallet address via eth_call to the
+     * token contract's confidentialBalanceOf(address) function.
+     *
+     * @param walletAddress - the wallet contract address to query balance for
+     * @param apiKey - optional Etherscan API key
+     * @returns bytes32 encrypted handle (0x-prefixed, 66 chars).
+     *   Note: handles are always non-zero even for zero balances (encrypted domain).
+     */
+    async queryConfidentialBalance(walletAddress, apiKey) {
+        const methodSignature = abstract_eth_1.optionalDeps.ethAbi.methodID('confidentialBalanceOf', ['address']);
+        const encodedArgs = abstract_eth_1.optionalDeps.ethAbi.rawEncode(['address'], [walletAddress]);
+        const calldata = Buffer.concat([methodSignature, encodedArgs]).toString('hex');
+        const result = await this.recoveryBlockchainExplorerQuery({
+            chainid: this.getChainId().toString(),
+            module: 'proxy',
+            action: 'eth_call',
+            to: this.tokenContractAddress,
+            data: calldata,
+            tag: 'latest',
+        }, apiKey);
+        if (!result || !result.result) {
+            throw new Error(`Could not obtain confidential balance for ${walletAddress} from token ${this.tokenContractAddress}`);
+        }
+        const handle = result.result;
+        if (!handle.startsWith('0x') || handle.length !== 66) {
+            throw new Error(`Unexpected confidentialBalanceOf response format: ${handle}`);
+        }
+        return handle;
+    }
+    /**
+     * Builds a non-BitGo recovery transaction for ERC-7984 confidential tokens.
+     *
+     * Uses the no-proof handle sweep: confidentialTransfer(recipient, handle) with 2 args.
+     * No FHE decryption or proof generation is needed — the wallet transfers its entire
+     * encrypted balance handle without knowing the plaintext amount.
+     *
+     * The outer transaction shape is:
+     *   tx.to   = walletContractAddress
+     *   tx.data = sendMultiSig(tokenContractAddr, 0, confidentialTransfer(recoveryDest, handle), ...)
+     */
+    async recover(params) {
+        if (params.isTss === true) {
+            throw new Error('ERC-7984 TSS recovery is not yet supported');
+        }
+        if (_.isUndefined(params.userKey)) {
+            throw new Error('missing userKey');
+        }
+        if (_.isUndefined(params.backupKey)) {
+            throw new Error('missing backupKey');
+        }
+        if (_.isUndefined(params.walletPassphrase) && !params.userKey.startsWith('xpub')) {
+            throw new Error('missing wallet passphrase');
+        }
+        if (_.isUndefined(params.walletContractAddress) || !this.isValidAddress(params.walletContractAddress)) {
+            throw new Error('invalid walletContractAddress');
+        }
+        if (_.isUndefined(params.recoveryDestination) || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('invalid recoveryDestination');
+        }
+        const isKrsRecovery = (0, sdk_core_1.getIsKrsRecovery)(params);
+        const isUnsignedSweep = (0, sdk_core_1.getIsUnsignedSweep)(params);
+        if (isKrsRecovery) {
+            (0, sdk_core_1.checkKrsProvider)(this, params.krsProvider, { checkCoinFamilySupport: false });
+        }
+        let userKey = params.userKey.replace(/\s/g, '');
+        const backupKey = params.backupKey.replace(/\s/g, '');
+        const gasPrice = params.eip1559
+            ? new abstract_eth_1.optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)
+            : new abstract_eth_1.optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice));
+        const gasLimit = new abstract_eth_1.optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit));
+        let userPrv;
+        if (!isUnsignedSweep) {
+            if (!userKey.startsWith('xpub') && !userKey.startsWith('xprv')) {
+                try {
+                    userKey = await this.bitgo.decrypt({
+                        input: userKey,
+                        password: params.walletPassphrase,
+                    });
+                }
+                catch (e) {
+                    throw new Error(`Error decrypting user keychain: ${e.message}`);
+                }
+            }
+            userPrv = userKey;
+        }
+        let backupKeyAddress;
+        let backupSigningKey;
+        if (isKrsRecovery || isUnsignedSweep) {
+            const backupHDNode = secp256k1_1.bip32.fromBase58(backupKey);
+            backupSigningKey = backupHDNode.publicKey;
+            backupKeyAddress = `0x${abstract_eth_1.optionalDeps.ethUtil.publicToAddress(backupSigningKey, true).toString('hex')}`;
+        }
+        else {
+            let backupPrv;
+            try {
+                backupPrv = await this.bitgo.decrypt({
+                    input: backupKey,
+                    password: params.walletPassphrase,
+                });
+            }
+            catch (e) {
+                throw new Error(`Error decrypting backup keychain: ${e.message}`);
+            }
+            const backupHDNode = secp256k1_1.bip32.fromBase58(backupPrv);
+            backupSigningKey = backupHDNode.privateKey;
+            backupKeyAddress = `0x${abstract_eth_1.optionalDeps.ethUtil.privateToAddress(backupSigningKey).toString('hex')}`;
+        }
+        const backupKeyNonce = await this.getAddressNonce(backupKeyAddress, params.apiKey);
+        const backupKeyBalance = await this.queryAddressBalance(backupKeyAddress, params.apiKey);
+        const totalGasNeeded = gasPrice.mul(gasLimit);
+        const weiToGwei = 10 ** 9;
+        if (backupKeyBalance.lt(totalGasNeeded)) {
+            throw new Error(`Backup key address ${backupKeyAddress} has balance ${(backupKeyBalance / weiToGwei).toString()} Gwei.` +
+                `This address must have a balance of at least ${(totalGasNeeded / weiToGwei).toString()}` +
+                ` Gwei to perform recoveries. Try sending some ETH to this address then retry.`);
+        }
+        // Get the encrypted balance handle (auto-query or user-provided)
+        let encryptedHandle;
+        if (params.encryptedHandle) {
+            encryptedHandle = params.encryptedHandle;
+        }
+        else {
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            encryptedHandle = await this.queryConfidentialBalance(params.walletContractAddress, params.apiKey);
+        }
+        // Note: encrypted handles are always non-zero even for zero balances (encrypted domain).
+        // The transfer will execute but move 0 tokens if the wallet is empty.
+        // Build the inner calldata: confidentialTransfer(recoveryDestination, handle)
+        const innerCalldata = (0, abstract_eth_1.buildConfidentialTransferByHandleCalldata)(params.recoveryDestination, encryptedHandle);
+        // For sendMultiSig: recipient is the token contract, amount is 0, data carries the confidentialTransfer calldata
+        const recipients = [
+            {
+                address: this.tokenContractAddress,
+                amount: '0',
+                data: abstract_eth_1.optionalDeps.ethUtil.stripHexPrefix(innerCalldata),
+            },
+        ];
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const sequenceId = await this.querySequenceId(params.walletContractAddress, params.apiKey);
+        let operationHash;
+        let signature;
+        if (!isUnsignedSweep) {
+            operationHash = this.getOperationSha3ForExecuteAndConfirm(recipients, this.getDefaultExpireTime(), sequenceId);
+            signature = sdk_core_1.Util.ethSignMsgHash(operationHash, sdk_core_1.Util.xprvToEthPrivateKey(userPrv));
+            try {
+                sdk_core_1.Util.ecRecoverEthAddress(operationHash, signature);
+            }
+            catch (e) {
+                throw new Error('Invalid signature');
+            }
+        }
+        const txInfo = {
+            recipient: recipients[0],
+            expireTime: this.getDefaultExpireTime(),
+            contractSequenceId: sequenceId,
+            operationHash: operationHash,
+            signature: signature ?? '',
+            gasLimit: gasLimit.toString(10),
+        };
+        const sendMethodArgs = this.getSendMethodArgs(txInfo);
+        const methodSignature = abstract_eth_1.optionalDeps.ethAbi.methodID(this.sendMethodName, _.map(sendMethodArgs, 'type'));
+        const encodedArgs = abstract_eth_1.optionalDeps.ethAbi.rawEncode(_.map(sendMethodArgs, 'type'), _.map(sendMethodArgs, 'value'));
+        const sendData = Buffer.concat([methodSignature, encodedArgs]);
+        let tx = eth_1.Eth.buildTransaction({
+            to: params.walletContractAddress,
+            nonce: backupKeyNonce,
+            value: 0,
+            gasPrice: gasPrice,
+            gasLimit: gasLimit,
+            data: sendData,
+            eip1559: params.eip1559,
+            replayProtectionOptions: params.replayProtectionOptions,
+        });
+        if (isUnsignedSweep) {
+            return this.formatForOfflineVault(txInfo, tx, userKey, backupKey, gasPrice, gasLimit, params.eip1559, params.replayProtectionOptions, params.apiKey);
+        }
+        if (!isKrsRecovery) {
+            tx = tx.sign(backupSigningKey);
+        }
+        const signedTx = {
+            id: abstract_eth_1.optionalDeps.ethUtil.bufferToHex(tx.hash()),
+            tx: tx.serialize().toString('hex'),
+        };
+        if (isKrsRecovery) {
+            signedTx.backupKey = backupKey;
+            signedTx.coin = this.getChain();
+        }
+        return signedTx;
+    }
+    /**
+     * Returns a DecryptionDelegationBuilder for constructing Zama ACL decryption
+     * delegation transactions.
+     *
+     * The builder produces a DecryptionDelegationTxRequest {to, data, value} that is
+     * wallet-type-agnostic — WP routes it to the correct signing path:
+     * - MPC: submit as a raw TSS transaction
+     * - Multisig: wrap in sendMultiSig(walletContract, to, 0, data, ...)
+     *
+     * Example:
+     *   const req = coin.getDecryptionDelegationBuilder().build({
+     *     aclContractAddress: '0xf0Ff...',
+     *     delegateAddress:    enterpriseViewingKey,
+     *     tokenContractAddresses: [tokenAddress],
+     *     expiryTimestamp:    Math.floor(Date.now() / 1000) + 365 * 86400,
+     *   });
+     */
+    getDecryptionDelegationBuilder() {
+        return new abstract_eth_1.DecryptionDelegationBuilder();
+    }
+}
+exports.Erc7984Token = Erc7984Token;
+Erc7984Token.coinNames = {
+    Mainnet: 'eth',
+    Testnet: 'hteth',
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"erc7984Token.js","sourceRoot":"","sources":["../../src/erc7984Token.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport {\n  BitGoBase,\n  CoinConstructor,\n  checkKrsProvider,\n  getIsKrsRecovery,\n  getIsUnsignedSweep,\n  MPCAlgorithm,\n  NamedCoinConstructor,\n  Util,\n} from '@bitgo-beta/sdk-core';\nimport { coins, Erc7984TokenConfig, EthereumNetwork, tokens } from '@bitgo-beta/statics';\nimport {\n  CoinNames,\n  DecryptionDelegationBuilder,\n  decodeTokenAddressesFromDelegationCalldata,\n  decodeConfidentialTransferData,\n  decodeDirectConfidentialTransferCalldata,\n  decodeFlushERC7984ForwarderTokenCalldata,\n  decodeSendMultiSigFlushERC7984Data,\n  sendMultisigMethodId,\n  confidentialTransferWithProofMethodId,\n  buildConfidentialTransferByHandleCalldata,\n  optionalDeps,\n  RecoverOptions,\n  RecoveryInfo,\n  OfflineVaultTxInfo,\n  VerifyEthTransactionOptions,\n  aclMulticallMethodId,\n  callFromParentMethodId,\n  decodeWrapCalldata,\n  wrapMethodId,\n  assertAmountTimesRateFitsUint64,\n  decodeUnwrapCalldata,\n  unwrapMethodId,\n  decodeFinalizeUnwrapCalldata,\n  finalizeUnwrapMethodId,\n  UINT64_MAX,\n  decodeTransferData,\n} from '@bitgo-beta/abstract-eth';\nimport { bip32 } from '@bitgo-beta/secp256k1';\nimport * as _ from 'lodash';\n\nimport { Eth } from './eth';\nimport { TransactionBuilder } from './lib';\n\nexport { Erc7984TokenConfig };\n\nexport class Erc7984Token extends Eth {\n  public readonly tokenConfig: Erc7984TokenConfig;\n  protected readonly sendMethodName: 'sendMultiSig' | 'sendMultiSigToken';\n  static coinNames: CoinNames = {\n    Mainnet: 'eth',\n    Testnet: 'hteth',\n  };\n\n  constructor(bitgo: BitGoBase, tokenConfig: Erc7984TokenConfig) {\n    const staticsCoin = coins.get(tokenConfig.coin);\n    super(bitgo, staticsCoin);\n    this.tokenConfig = tokenConfig;\n    // ERC7984 confidential transfers use sendMultiSig (not sendMultiSigToken) because\n    // the calldata parameter is required to carry confidentialTransfer(recipient, encryptedHandle, inputProof).\n    // sendMultiSigToken has no data parameter and cannot carry inner calldata.\n    this.sendMethodName = 'sendMultiSig';\n  }\n\n  static createTokenConstructor(config: Erc7984TokenConfig): CoinConstructor {\n    return (bitgo: BitGoBase) => new Erc7984Token(bitgo, config);\n  }\n\n  static createTokenConstructors(\n    tokenConfigs: Erc7984TokenConfig[] = [\n      ...tokens.bitcoin.eth.confidentialTokens,\n      ...tokens.testnet.eth.confidentialTokens,\n    ]\n  ): NamedCoinConstructor[] {\n    const tokensCtors: NamedCoinConstructor[] = [];\n    for (const token of tokenConfigs) {\n      const tokenConstructor = Erc7984Token.createTokenConstructor(token);\n      tokensCtors.push({ name: token.type, coinConstructor: tokenConstructor });\n      tokensCtors.push({ name: token.tokenContractAddress, coinConstructor: tokenConstructor });\n    }\n    return tokensCtors;\n  }\n\n  get type(): string {\n    return this.tokenConfig.type;\n  }\n\n  get name(): string {\n    return this.tokenConfig.name;\n  }\n\n  get coin(): string {\n    return this.tokenConfig.coin;\n  }\n\n  get network(): string {\n    return this.tokenConfig.network;\n  }\n\n  get tokenContractAddress(): string {\n    return this.tokenConfig.tokenContractAddress;\n  }\n\n  get decimalPlaces(): number {\n    return this.tokenConfig.decimalPlaces;\n  }\n\n  getChain(): string {\n    return this.tokenConfig.type;\n  }\n\n  getFullName(): string {\n    return 'ERC7984 Confidential Token';\n  }\n\n  getBaseFactor(): number {\n    return Math.pow(10, this.tokenConfig.decimalPlaces);\n  }\n\n  /**\n   * Flag for sending value of 0.\n   * ERC-7984 confidential transfers always carry an encrypted amount; zero-value sends are not meaningful.\n   */\n  valuelessTransferAllowed(): boolean {\n    return false;\n  }\n\n  /**\n   * Flag for sending data along with transactions via the standard token-send API.\n   * Returns false because ERC-7984 sends use confidentialTransfer() calldata built\n   * by WP, not an arbitrary data field on the send params.\n   * Note: this does not prevent calldata-based flows like getDelegationBuilder(),\n   * which bypass the token-send path entirely.\n   */\n  transactionDataAllowed(): boolean {\n    return false;\n  }\n\n  /** @inheritDoc */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** @inheritDoc */\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'ecdsa';\n  }\n\n  protected getTransactionBuilder(): TransactionBuilder {\n    return new TransactionBuilder(coins.get(this.getBaseChain()));\n  }\n\n  /** @inheritDoc */\n  async verifyTransaction(params: VerifyEthTransactionOptions): Promise<boolean> {\n    if (params.txParams?.type === 'enabletoken') {\n      return this.verifyEnableTokenTransaction(params);\n    }\n    if (params.txParams?.type === 'wrap') {\n      return this.verifyWrapTransaction(params);\n    }\n    if (params.txParams?.type === 'unwrap') {\n      return this.verifyUnwrapTransaction(params);\n    }\n    if (params.txParams?.type === 'finalizeUnwrap') {\n      return this.verifyFinalizeUnwrapTransaction(params);\n    }\n    if (this.isConsolidationTransaction(params)) {\n      return this.verifyConfidentialConsolidation(params);\n    }\n    return this.verifyConfidentialTransfer(params);\n  }\n\n  private isConsolidationTransaction(params: VerifyEthTransactionOptions): boolean {\n    const { txParams, txPrebuild, verification } = params;\n    return !!(\n      verification?.consolidationToBaseAddress ||\n      txPrebuild?.consolidateId ||\n      txParams?.type === 'consolidate' ||\n      // TSS signing path: resolveEffectiveTxParams sets type from intent.intentType which is\n      // 'consolidateToken' for ERC-7984 token consolidations. txPrebuild has only txHex\n      // (no consolidateId) in this path.\n      txParams?.type === 'consolidateToken' ||\n      txParams?.prebuildTx?.consolidateId\n    );\n  }\n\n  /**\n   * Verifies WrapERC7984 (shield) transactions.\n   *\n   * TSS / direct shape:\n   *   tx.to   = wrapper contract\n   *   tx.data = wrap(baseAddress, amount)\n   *\n   * Multisig shape:\n   *   tx.to   = wallet contract\n   *   tx.data = sendMultiSig(wrapper, 0, wrap(baseAddress, amount), ...)\n   *\n   * Checks: wrapper address, self-directed `to` == base, amount > 0, amount matches\n   * recipients, and amount × rate fits uint64 when statics rate is present.\n   */\n  private async verifyWrapTransaction(params: VerifyEthTransactionOptions): Promise<boolean> {\n    const { txParams, txPrebuild, wallet } = params;\n\n    if (!txPrebuild?.txHex) {\n      throw new Error('verifyWrapTransaction: missing txHex in txPrebuild');\n    }\n\n    const txBuilder = this.getTransactionBuilder();\n    txBuilder.from(txPrebuild.txHex);\n    const tx = await txBuilder.build();\n    const txJson = tx.toJson();\n\n    let wrapperAddress: string;\n    let wrapCalldata: string;\n\n    try {\n      if (txJson.data.toLowerCase().startsWith(sendMultisigMethodId.toLowerCase())) {\n        const decoded = decodeTransferData(txJson.data);\n        wrapperAddress = decoded.to;\n        wrapCalldata = decoded.data as string;\n        if (decoded.amount !== '0') {\n          throw new Error(`expected sendMultiSig value 0 but got ${decoded.amount}`);\n        }\n      } else if (txJson.data.toLowerCase().startsWith(wrapMethodId.toLowerCase())) {\n        wrapperAddress = txJson.to as string;\n        wrapCalldata = txJson.data;\n      } else {\n        throw new Error(`unexpected method ID ${txJson.data.slice(0, 10)}`);\n      }\n    } catch (e) {\n      throw new Error(`verifyWrapTransaction: failed to decode wrap calldata — ${(e as Error).message}`);\n    }\n\n    if (wrapperAddress.toLowerCase() !== this.tokenContractAddress.toLowerCase()) {\n      throw new Error(\n        `verifyWrapTransaction: wrapper address mismatch — ` +\n          `expected ${this.tokenContractAddress}, got ${wrapperAddress}`\n      );\n    }\n\n    let to: string;\n    let amount: string;\n    try {\n      ({ to, amount } = decodeWrapCalldata(wrapCalldata));\n    } catch (e) {\n      throw new Error(`verifyWrapTransaction: invalid wrap inner calldata — ${(e as Error).message}`);\n    }\n\n    if (!Erc7984Token.isPositiveIntegerString(amount)) {\n      throw new Error(`verifyWrapTransaction: amount must be a positive integer string, got '${amount}'`);\n    }\n\n    const baseAddress = this.getWalletBaseAddress(wallet);\n    if (!baseAddress) {\n      throw new Error('verifyWrapTransaction: unable to determine wallet base address');\n    }\n    if (to.toLowerCase() !== baseAddress.toLowerCase()) {\n      throw new Error(\n        `verifyWrapTransaction: wrap recipient must equal wallet base address — expected ${baseAddress}, got ${to}`\n      );\n    }\n\n    const expectedAmount = txParams?.recipients?.[0]?.amount ?? txPrebuild.buildParams?.recipients?.[0]?.amount;\n    if (expectedAmount !== undefined && String(expectedAmount) !== amount) {\n      throw new Error(\n        `verifyWrapTransaction: amount mismatch — calldata has '${amount}' but params have '${expectedAmount}'`\n      );\n    }\n\n    const rate = this.tokenConfig.rate;\n    if (rate !== undefined) {\n      try {\n        assertAmountTimesRateFitsUint64(amount, rate);\n      } catch (e) {\n        throw new Error(`verifyWrapTransaction: ${(e as Error).message}`);\n      }\n    }\n\n    if (txJson.value !== undefined && txJson.value !== '0' && txJson.value !== 0) {\n      throw new Error(`verifyWrapTransaction: expected transaction value 0 but got ${txJson.value}`);\n    }\n\n    return true;\n  }\n\n  /**\n   * Verifies UnwrapERC7984 (unshield phase-1) transactions.\n   *\n   * TSS / direct shape:\n   *   tx.to   = wrapper contract\n   *   tx.data = unwrap(base, base, encryptedAmount, inputProof)\n   *\n   * Multisig shape:\n   *   tx.to   = wallet contract\n   *   tx.data = sendMultiSig(wrapper, 0, unwrap(base, base, ...), ...)\n   *\n   * v1 is self-directed only: from == to == wallet base address.\n   */\n  private async verifyUnwrapTransaction(params: VerifyEthTransactionOptions): Promise<boolean> {\n    const { txPrebuild, wallet } = params;\n\n    if (!txPrebuild?.txHex) {\n      throw new Error('verifyUnwrapTransaction: missing txHex in txPrebuild');\n    }\n\n    const txBuilder = this.getTransactionBuilder();\n    txBuilder.from(txPrebuild.txHex);\n    const tx = await txBuilder.build();\n    const txJson = tx.toJson();\n\n    let wrapperAddress: string;\n    let unwrapCalldata: string;\n\n    try {\n      if (txJson.data.toLowerCase().startsWith(sendMultisigMethodId.toLowerCase())) {\n        const decoded = decodeTransferData(txJson.data);\n        wrapperAddress = decoded.to;\n        unwrapCalldata = decoded.data as string;\n        if (decoded.amount !== '0') {\n          throw new Error(`expected sendMultiSig value 0 but got ${decoded.amount}`);\n        }\n      } else if (txJson.data.toLowerCase().startsWith(unwrapMethodId.toLowerCase())) {\n        wrapperAddress = txJson.to as string;\n        unwrapCalldata = txJson.data;\n      } else {\n        throw new Error(`unexpected method ID ${txJson.data.slice(0, 10)}`);\n      }\n    } catch (e) {\n      throw new Error(`verifyUnwrapTransaction: failed to decode unwrap calldata — ${(e as Error).message}`);\n    }\n\n    if (wrapperAddress.toLowerCase() !== this.tokenContractAddress.toLowerCase()) {\n      throw new Error(\n        `verifyUnwrapTransaction: wrapper address mismatch — expected ${this.tokenContractAddress}, got ${wrapperAddress}`\n      );\n    }\n\n    let from: string;\n    let to: string;\n    let encryptedAmount: string;\n    let inputProof: string;\n    try {\n      ({ from, to, encryptedAmount, inputProof } = decodeUnwrapCalldata(unwrapCalldata));\n    } catch (e) {\n      throw new Error(`verifyUnwrapTransaction: invalid unwrap inner calldata — ${(e as Error).message}`);\n    }\n\n    const baseAddress = this.getWalletBaseAddress(wallet);\n    if (!baseAddress) {\n      throw new Error('verifyUnwrapTransaction: unable to determine wallet base address');\n    }\n    if (from.toLowerCase() !== baseAddress.toLowerCase()) {\n      throw new Error(\n        `verifyUnwrapTransaction: unwrap from must equal wallet base address — expected ${baseAddress}, got ${from}`\n      );\n    }\n    if (to.toLowerCase() !== baseAddress.toLowerCase()) {\n      throw new Error(\n        `verifyUnwrapTransaction: unwrap to must equal wallet base address — expected ${baseAddress}, got ${to}`\n      );\n    }\n\n    if (!encryptedAmount || encryptedAmount === '0x' || /^0x0+$/.test(encryptedAmount)) {\n      throw new Error('verifyUnwrapTransaction: encryptedAmount is missing or empty');\n    }\n    if (!inputProof || inputProof === '0x') {\n      throw new Error('verifyUnwrapTransaction: inputProof is missing or empty');\n    }\n\n    if (txJson.value !== undefined && txJson.value !== '0' && txJson.value !== 0) {\n      throw new Error(`verifyUnwrapTransaction: expected transaction value 0 but got ${txJson.value}`);\n    }\n\n    return true;\n  }\n\n  /**\n   * Verifies FinalizeUnwrapERC7984 (unshield phase-2) transactions.\n   *\n   * TSS / direct shape:\n   *   tx.to   = wrapper contract\n   *   tx.data = finalizeUnwrap(requestId, cleartextAmount, decryptionProof)\n   *\n   * Multisig shape:\n   *   tx.to   = wallet contract\n   *   tx.data = sendMultiSig(wrapper, 0, finalizeUnwrap(...), ...)\n   */\n  private async verifyFinalizeUnwrapTransaction(params: VerifyEthTransactionOptions): Promise<boolean> {\n    const { txParams, txPrebuild } = params;\n\n    if (!txPrebuild?.txHex) {\n      throw new Error('verifyFinalizeUnwrapTransaction: missing txHex in txPrebuild');\n    }\n\n    const txBuilder = this.getTransactionBuilder();\n    txBuilder.from(txPrebuild.txHex);\n    const tx = await txBuilder.build();\n    const txJson = tx.toJson();\n\n    let wrapperAddress: string;\n    let finalizeCalldata: string;\n\n    try {\n      if (txJson.data.toLowerCase().startsWith(sendMultisigMethodId.toLowerCase())) {\n        const decoded = decodeTransferData(txJson.data);\n        wrapperAddress = decoded.to;\n        finalizeCalldata = decoded.data as string;\n        if (decoded.amount !== '0') {\n          throw new Error(`expected sendMultiSig value 0 but got ${decoded.amount}`);\n        }\n      } else if (txJson.data.toLowerCase().startsWith(finalizeUnwrapMethodId.toLowerCase())) {\n        wrapperAddress = txJson.to as string;\n        finalizeCalldata = txJson.data;\n      } else {\n        throw new Error(`unexpected method ID ${txJson.data.slice(0, 10)}`);\n      }\n    } catch (e) {\n      throw new Error(\n        `verifyFinalizeUnwrapTransaction: failed to decode finalizeUnwrap calldata — ${(e as Error).message}`\n      );\n    }\n\n    if (wrapperAddress.toLowerCase() !== this.tokenContractAddress.toLowerCase()) {\n      throw new Error(\n        `verifyFinalizeUnwrapTransaction: wrapper address mismatch — expected ${this.tokenContractAddress}, got ${wrapperAddress}`\n      );\n    }\n\n    let requestId: string;\n    let cleartextAmount: string;\n    let decryptionProof: string;\n    try {\n      ({ requestId, cleartextAmount, decryptionProof } = decodeFinalizeUnwrapCalldata(finalizeCalldata));\n    } catch (e) {\n      throw new Error(\n        `verifyFinalizeUnwrapTransaction: invalid finalizeUnwrap inner calldata — ${(e as Error).message}`\n      );\n    }\n\n    if (!requestId || requestId === '0x' || /^0x0+$/.test(requestId)) {\n      throw new Error('verifyFinalizeUnwrapTransaction: requestId is missing or empty');\n    }\n    if (!Erc7984Token.isPositiveIntegerString(cleartextAmount)) {\n      throw new Error(\n        `verifyFinalizeUnwrapTransaction: cleartextAmount must be a positive integer string, got '${cleartextAmount}'`\n      );\n    }\n    if (BigInt(cleartextAmount) > UINT64_MAX) {\n      throw new Error('verifyFinalizeUnwrapTransaction: cleartextAmount exceeds uint64');\n    }\n    if (!decryptionProof || decryptionProof === '0x') {\n      throw new Error('verifyFinalizeUnwrapTransaction: decryptionProof is missing or empty');\n    }\n\n    const expectedAmount = txParams?.recipients?.[0]?.amount ?? txPrebuild.buildParams?.recipients?.[0]?.amount;\n    if (expectedAmount !== undefined && String(expectedAmount) !== cleartextAmount) {\n      throw new Error(\n        `verifyFinalizeUnwrapTransaction: amount mismatch — calldata has '${cleartextAmount}' but params have '${expectedAmount}'`\n      );\n    }\n\n    if (txJson.value !== undefined && txJson.value !== '0' && txJson.value !== 0) {\n      throw new Error(`verifyFinalizeUnwrapTransaction: expected transaction value 0 but got ${txJson.value}`);\n    }\n\n    return true;\n  }\n\n  private getWalletBaseAddress(wallet: VerifyEthTransactionOptions['wallet']): string | undefined {\n    if (!wallet) {\n      return undefined;\n    }\n    const coinSpecific = typeof wallet.coinSpecific === 'function' ? wallet.coinSpecific() : wallet.coinSpecific;\n    const ethCoinSpecific = coinSpecific as { baseAddress?: string; rootAddress?: string } | undefined;\n    return ethCoinSpecific?.baseAddress ?? ethCoinSpecific?.rootAddress;\n  }\n\n  /**\n   * Verifies ERC-7984 forwarder consolidation (flush) transactions.\n   *\n   * Multisig shape:\n   *   tx.to   = wallet contract\n   *   tx.data = sendMultiSig(forwarder, 0, callFromParent(token, 0, confidentialTransferNoProof(base, handle)), ...)\n   *\n   * TSS / direct shape:\n   *   tx.to   = forwarder contract\n   *   tx.data = callFromParent(token, 0, confidentialTransferNoProof(base, handle))\n   */\n  private async verifyConfidentialConsolidation(params: VerifyEthTransactionOptions): Promise<boolean> {\n    const { txParams, txPrebuild, wallet } = params;\n\n    if (!txPrebuild?.txHex) {\n      if (!txPrebuild?.consolidateId && !txParams?.prebuildTx?.consolidateId) {\n        throw new Error('verifyConfidentialConsolidation: missing consolidateId');\n      }\n      return true;\n    }\n\n    const txBuilder = this.getTransactionBuilder();\n    txBuilder.from(txPrebuild.txHex);\n    const tx = await txBuilder.build();\n    const txJson = tx.toJson();\n\n    let tokenContractAddress: string;\n    let parentAddress: string;\n    let encryptedHandle: string;\n    let forwarderAddress: string | undefined;\n\n    try {\n      if (txJson.data.startsWith(sendMultisigMethodId)) {\n        const decoded = decodeSendMultiSigFlushERC7984Data(txJson.data);\n        forwarderAddress = decoded.forwarderAddress;\n        tokenContractAddress = decoded.tokenContractAddress;\n        parentAddress = decoded.parentAddress;\n        encryptedHandle = decoded.encryptedHandle;\n      } else if (txJson.data.startsWith(callFromParentMethodId)) {\n        const decoded = decodeFlushERC7984ForwarderTokenCalldata(txJson.data);\n        tokenContractAddress = decoded.tokenContractAddress;\n        parentAddress = decoded.parentAddress;\n        encryptedHandle = decoded.encryptedHandle;\n        forwarderAddress = txJson.to;\n      } else {\n        throw new Error(`unexpected method ID ${txJson.data.slice(0, 10)}`);\n      }\n    } catch (e) {\n      throw new Error(\n        `verifyConfidentialConsolidation: failed to decode consolidation calldata — ${(e as Error).message}`\n      );\n    }\n\n    if (tokenContractAddress.toLowerCase() !== this.tokenContractAddress.toLowerCase()) {\n      throw new Error(\n        `verifyConfidentialConsolidation: token contract address mismatch — ` +\n          `expected ${this.tokenContractAddress}, got ${tokenContractAddress}`\n      );\n    }\n\n    const baseAddress = this.getWalletBaseAddress(wallet);\n    if (!baseAddress) {\n      throw new Error('verifyConfidentialConsolidation: unable to determine wallet base address');\n    }\n    if (parentAddress.toLowerCase() !== baseAddress.toLowerCase()) {\n      throw new Error(\n        `verifyConfidentialConsolidation: parent address mismatch — expected ${baseAddress}, got ${parentAddress}`\n      );\n    }\n\n    if (!encryptedHandle || encryptedHandle === '0x') {\n      throw new Error('verifyConfidentialConsolidation: encryptedHandle is missing or empty in transaction calldata');\n    }\n\n    const expectedForwarder =\n      txPrebuild.recipients?.[0]?.address ??\n      txPrebuild.txInfo?.recipients?.[0]?.address ??\n      txParams?.recipients?.[0]?.address;\n    if (forwarderAddress && expectedForwarder) {\n      if (forwarderAddress.toLowerCase() !== expectedForwarder.toLowerCase()) {\n        throw new Error(\n          `verifyConfidentialConsolidation: forwarder address mismatch — ` +\n            `expected ${expectedForwarder}, got ${forwarderAddress}`\n        );\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Verifies a confidential token transfer (SendERC7984) transaction.\n   *\n   * With txHex — two on-chain shapes are supported:\n   *\n   *   sendMultiSig-wrapped (multisig / smart-contract wallet):\n   *     tx.to   = wallet contract\n   *     tx.data = sendMultiSig(tokenAddr, 0, confidentialTransfer(recipient, handle, proof), ...)\n   *     Token contract address is decoded from the sendMultiSig inner calldata.\n   *\n   *   Direct call (hot / TSS EOA wallet):\n   *     tx.to   = token contract\n   *     tx.data = confidentialTransfer(recipient, handle, proof)\n   *     Token contract address is taken from tx.to.\n   *\n   *   For both shapes the verifier checks:\n   *     1. Token contract address matches this coin's tokenContractAddress.\n   *     2. Decoded recipient matches txParams.recipients[0].address or buildParams.recipients[0].address.\n   *     3. encryptedHandle and inputProof are structurally present (non-empty).\n   *     4. txParams.recipients[0].amount is a positive integer and matches buildParams when both present.\n   *\n   * Without txHex (first-signer / pre-signing path):\n   *  1. Requires exactly one recipient in txParams.\n   *  2. Validates txParams.recipients[0].address is a valid Ethereum address.\n   *  3. Validates txParams.recipients[0].amount is a positive integer.\n   *  4. Cross-checks address and amount against buildParams when the server has stored the intent.\n   */\n  private async verifyConfidentialTransfer(params: VerifyEthTransactionOptions): Promise<boolean> {\n    const { txParams, txPrebuild } = params;\n\n    if (!txPrebuild?.txHex) {\n      // No raw tx available (multisig first-signer path).\n      // Validate ERC7984-specific invariants from txParams and buildParams.\n      const recipients = txParams?.recipients;\n      if (!recipients || recipients.length === 0) {\n        throw new Error('verifyConfidentialTransfer: recipients must contain at least one entry');\n      }\n      if (recipients.length !== 1) {\n        throw new Error(\n          `verifyConfidentialTransfer: confidential transfers support exactly 1 recipient, got ${recipients.length}`\n        );\n      }\n      const recipient = recipients[0];\n      if (!recipient.address || !this.isValidAddress(recipient.address)) {\n        throw new Error(`verifyConfidentialTransfer: recipient address is missing or invalid: ${recipient.address}`);\n      }\n      const amountStr = String(recipient.amount);\n      if (!Erc7984Token.isPositiveIntegerString(amountStr)) {\n        throw new Error(\n          `verifyConfidentialTransfer: amount must be a positive integer string in base units, got '${amountStr}'`\n        );\n      }\n      // Cross-check against buildParams when the server has already stored the intent\n      const buildParamsRecipient = txPrebuild?.buildParams?.recipients?.[0];\n      if (buildParamsRecipient?.address !== undefined) {\n        if (recipient.address.toLowerCase() !== buildParamsRecipient.address.toLowerCase()) {\n          throw new Error(\n            `verifyConfidentialTransfer: recipient address mismatch — ` +\n              `txParams has '${recipient.address}' but buildParams has '${buildParamsRecipient.address}'`\n          );\n        }\n      }\n      const buildParamsAmount = buildParamsRecipient?.amount;\n      if (buildParamsAmount !== undefined && buildParamsAmount !== amountStr) {\n        throw new Error(\n          `verifyConfidentialTransfer: amount mismatch — txParams has '${amountStr}' but buildParams has '${buildParamsAmount}'`\n        );\n      }\n      return true;\n    }\n\n    // Parse and decode the raw transaction\n    const txBuilder = this.getTransactionBuilder();\n    txBuilder.from(txPrebuild.txHex);\n    const tx = await txBuilder.build();\n    const txJson = tx.toJson();\n\n    let toAddress: string;\n    let tokenContractAddress: string;\n    let encryptedHandle: string;\n    let inputProof: string;\n\n    try {\n      if (txJson.data.startsWith(sendMultisigMethodId)) {\n        // sendMultiSig-wrapped path: smart-contract wallet relays the confidentialTransfer call.\n        // Token contract address is encoded inside the sendMultiSig calldata.\n        const decoded = decodeConfidentialTransferData(txJson.data);\n        toAddress = decoded.toAddress;\n        tokenContractAddress = decoded.tokenContractAddress;\n        encryptedHandle = decoded.encryptedHandle;\n        inputProof = decoded.inputProof;\n      } else if (txJson.data.startsWith(confidentialTransferWithProofMethodId)) {\n        // Direct call path: hot/TSS EOA wallet calls the token contract directly.\n        // The transaction's `to` field is the token contract address.\n        if (!txJson.to) {\n          throw new Error('direct confidentialTransfer call is missing transaction to address');\n        }\n        const decoded = decodeDirectConfidentialTransferCalldata(txJson.data);\n        toAddress = decoded.toAddress;\n        tokenContractAddress = txJson.to;\n        encryptedHandle = decoded.encryptedHandle;\n        inputProof = decoded.inputProof;\n      } else {\n        throw new Error(`unexpected method ID ${txJson.data.slice(0, 10)}`);\n      }\n    } catch (e) {\n      throw new Error(\n        `verifyConfidentialTransfer: failed to decode confidential transfer calldata — ${(e as Error).message}`\n      );\n    }\n\n    // 1. Token contract address must match this coin\n    if (tokenContractAddress.toLowerCase() !== this.tokenContractAddress.toLowerCase()) {\n      throw new Error(\n        `verifyConfidentialTransfer: token contract address mismatch — ` +\n          `expected ${this.tokenContractAddress}, got ${tokenContractAddress}`\n      );\n    }\n\n    // 2. Recipient address must match txParams.recipients[0] or buildParams.recipients[0]\n    const expectedRecipient = txParams?.recipients?.[0]?.address ?? txPrebuild.buildParams?.recipients?.[0]?.address;\n    if (!expectedRecipient) {\n      throw new Error(\n        'verifyConfidentialTransfer: missing expected recipient (provide txParams.recipients or txPrebuild.buildParams.recipients)'\n      );\n    }\n    if (toAddress.toLowerCase() !== expectedRecipient.toLowerCase()) {\n      throw new Error(\n        `verifyConfidentialTransfer: recipient address mismatch — ` + `expected ${expectedRecipient}, got ${toAddress}`\n      );\n    }\n\n    // 3. encryptedHandle must be a non-trivial hex value (not bare '0x')\n    if (!encryptedHandle || encryptedHandle === '0x') {\n      throw new Error('verifyConfidentialTransfer: encryptedHandle is missing or empty in transaction calldata');\n    }\n\n    // 4. inputProof must be a non-trivial hex value\n    if (!inputProof || inputProof === '0x') {\n      throw new Error('verifyConfidentialTransfer: inputProof is missing or empty in transaction calldata');\n    }\n\n    // 5. Verify plaintext intent: txParams amount must be valid and consistent with buildParams\n    const rawTxParamsAmount = txParams?.recipients?.[0]?.amount;\n    if (rawTxParamsAmount !== undefined) {\n      const txParamsAmount = String(rawTxParamsAmount);\n      if (!Erc7984Token.isPositiveIntegerString(txParamsAmount)) {\n        throw new Error(\n          `verifyConfidentialTransfer: amount must be a positive integer string in base units, got '${txParamsAmount}'`\n        );\n      }\n      const buildParamsAmount = txPrebuild.buildParams?.recipients?.[0]?.amount;\n      if (buildParamsAmount !== undefined && txParamsAmount !== buildParamsAmount) {\n        throw new Error(\n          `verifyConfidentialTransfer: amount mismatch — txParams has '${txParamsAmount}' but buildParams has '${buildParamsAmount}'`\n        );\n      }\n    }\n\n    return true;\n  }\n\n  private static isPositiveIntegerString(value: string): boolean {\n    return /^\\d+$/.test(value) && BigInt(value) > 0n;\n  }\n\n  /**\n   * Verifies a token enablement transaction for ERC-7984 decryption delegation.\n   *\n   * TSS path: decodes the raw tx and verifies it calls the ACL contract with\n   * calldata that covers all requested token contract addresses.\n   *\n   * Multisig path: verifies the buildParams recipients carry the correct tokenNames\n   * and zero amounts.\n   */\n  private async verifyEnableTokenTransaction(params: VerifyEthTransactionOptions): Promise<boolean> {\n    const { txParams, txPrebuild, walletType } = params;\n\n    if (walletType === 'tss') {\n      // TSS path: full raw-tx decode\n      const enableTokens = txParams.enableTokens;\n      if (!enableTokens || enableTokens.length === 0) {\n        throw new Error('verifyEnableTokenTransaction: enableTokens must be non-empty for TSS path');\n      }\n      if (!txPrebuild.txHex) {\n        throw new Error('verifyEnableTokenTransaction: missing txHex in txPrebuild');\n      }\n\n      // Resolve requested token names → contract addresses\n      const requestedAddresses = enableTokens.map((t) => {\n        const tokenCoin = this.bitgo.coin(t.name) as Erc7984Token;\n        return tokenCoin.tokenContractAddress.toLowerCase();\n      });\n\n      // Parse the raw transaction\n      const txBuilder = this.getTransactionBuilder();\n      txBuilder.from(txPrebuild.txHex);\n      const tx = await txBuilder.build();\n      const txJson = tx.toJson();\n\n      // Verify transaction targets the correct contract based on calldata shape\n      const network = this.getNetwork() as EthereumNetwork;\n      const aclContractAddress = network?.zamaAclContractAddress;\n      if (!aclContractAddress) {\n        throw new Error('verifyEnableTokenTransaction: zamaAclContractAddress not configured for this network');\n      }\n      if (!txJson.to) {\n        throw new Error('verifyEnableTokenTransaction: transaction is missing recipient address');\n      }\n\n      // Inspect calldata method ID to distinguish root wallet from forwarder wallet:\n      //   aclMulticallMethodId   → root wallet: to = ACL contract directly\n      //   callFromParentMethodId → forwarder wallet: to = forwarder, ACL address is inside calldata\n      const calldataMethodId = txJson.data.slice(0, 10);\n      if (calldataMethodId === aclMulticallMethodId) {\n        // Root wallet (base address): tx calls the ACL contract directly\n        if (txJson.to.toLowerCase() !== aclContractAddress.toLowerCase()) {\n          throw new Error(\n            `verifyEnableTokenTransaction: transaction target ${txJson.to} does not match ACL contract ${aclContractAddress}`\n          );\n        }\n      } else if (calldataMethodId === callFromParentMethodId) {\n        // Forwarder wallet: tx calls the forwarder, which calls the ACL via callFromParent.\n        // The forwarder address is wallet-specific and cannot be statically verified here;\n        // token address correctness is still verified below via calldata decoding.\n      } else {\n        throw new Error(\n          `verifyEnableTokenTransaction: unrecognised calldata method ID ${calldataMethodId}; expected multicall or callFromParent`\n        );\n      }\n\n      // Verify value is 0\n      if (txJson.value !== '0') {\n        throw new Error(`verifyEnableTokenTransaction: expected transaction value 0 but got ${txJson.value}`);\n      }\n\n      // Decode token addresses from calldata and verify all requested tokens are present\n      const decodedAddresses = decodeTokenAddressesFromDelegationCalldata(txJson.data);\n      for (const requested of requestedAddresses) {\n        if (!decodedAddresses.includes(requested)) {\n          throw new Error(\n            `verifyEnableTokenTransaction: requested token ${requested} not found in delegation calldata`\n          );\n        }\n      }\n\n      return true;\n    } else {\n      // Multisig path: buildParams-level check\n      const recipients = txPrebuild.buildParams?.recipients as\n        | Array<{ tokenName?: string; amount?: string }>\n        | undefined;\n      if (!recipients || recipients.length === 0) {\n        throw new Error('verifyEnableTokenTransaction: missing buildParams.recipients for multisig path');\n      }\n\n      // Determine requested token names from txParams\n      const requestedTokenNames: string[] = [];\n      if (txParams.enableTokens && txParams.enableTokens.length > 0) {\n        requestedTokenNames.push(...txParams.enableTokens.map((t) => t.name));\n      } else if (txParams.recipients && txParams.recipients.length > 0) {\n        requestedTokenNames.push(...txParams.recipients.map((r: any) => r.tokenName).filter(Boolean));\n      }\n\n      // Verify all recipients have tokenName and amount = '0'\n      for (const recipient of recipients) {\n        if (!recipient.tokenName) {\n          throw new Error('verifyEnableTokenTransaction: recipient is missing tokenName in buildParams');\n        }\n        if (recipient.amount !== '0') {\n          throw new Error(\n            `verifyEnableTokenTransaction: expected amount 0 for token enablement but got ${recipient.amount}`\n          );\n        }\n      }\n\n      // Verify requested token names are present in recipients\n      if (requestedTokenNames.length > 0) {\n        const recipientTokenNames = recipients.map((r) => r.tokenName);\n        for (const requested of requestedTokenNames) {\n          if (!recipientTokenNames.includes(requested)) {\n            throw new Error(\n              `verifyEnableTokenTransaction: requested token ${requested} not found in buildParams recipients`\n            );\n          }\n        }\n      }\n\n      return true;\n    }\n  }\n\n  /**\n   * Override gas limit for ERC-7984 confidential token recovery.\n   * Actual on-chain usage is ~506-530k gas based on testnet results.\n   * Default: 800,000 (comfortable buffer over observed usage).\n   */\n  setGasLimit(userGasLimit?: number): number {\n    if (!userGasLimit) {\n      return 800000;\n    }\n    return super.setGasLimit(userGasLimit);\n  }\n\n  /**\n   * Queries the encrypted balance handle for a wallet address via eth_call to the\n   * token contract's confidentialBalanceOf(address) function.\n   *\n   * @param walletAddress - the wallet contract address to query balance for\n   * @param apiKey - optional Etherscan API key\n   * @returns bytes32 encrypted handle (0x-prefixed, 66 chars).\n   *   Note: handles are always non-zero even for zero balances (encrypted domain).\n   */\n  async queryConfidentialBalance(walletAddress: string, apiKey?: string): Promise<string> {\n    const methodSignature = optionalDeps.ethAbi.methodID('confidentialBalanceOf', ['address']);\n    const encodedArgs = optionalDeps.ethAbi.rawEncode(['address'], [walletAddress]);\n    const calldata = Buffer.concat([methodSignature, encodedArgs]).toString('hex');\n\n    const result = await this.recoveryBlockchainExplorerQuery(\n      {\n        chainid: this.getChainId().toString(),\n        module: 'proxy',\n        action: 'eth_call',\n        to: this.tokenContractAddress,\n        data: calldata,\n        tag: 'latest',\n      },\n      apiKey\n    );\n\n    if (!result || !result.result) {\n      throw new Error(\n        `Could not obtain confidential balance for ${walletAddress} from token ${this.tokenContractAddress}`\n      );\n    }\n\n    const handle = result.result as string;\n    if (!handle.startsWith('0x') || handle.length !== 66) {\n      throw new Error(`Unexpected confidentialBalanceOf response format: ${handle}`);\n    }\n\n    return handle;\n  }\n\n  /**\n   * Builds a non-BitGo recovery transaction for ERC-7984 confidential tokens.\n   *\n   * Uses the no-proof handle sweep: confidentialTransfer(recipient, handle) with 2 args.\n   * No FHE decryption or proof generation is needed — the wallet transfers its entire\n   * encrypted balance handle without knowing the plaintext amount.\n   *\n   * The outer transaction shape is:\n   *   tx.to   = walletContractAddress\n   *   tx.data = sendMultiSig(tokenContractAddr, 0, confidentialTransfer(recoveryDest, handle), ...)\n   */\n  async recover(params: RecoverOptions): Promise<RecoveryInfo | OfflineVaultTxInfo> {\n    if (params.isTss === true) {\n      throw new Error('ERC-7984 TSS recovery is not yet supported');\n    }\n\n    if (_.isUndefined(params.userKey)) {\n      throw new Error('missing userKey');\n    }\n\n    if (_.isUndefined(params.backupKey)) {\n      throw new Error('missing backupKey');\n    }\n\n    if (_.isUndefined(params.walletPassphrase) && !params.userKey.startsWith('xpub')) {\n      throw new Error('missing wallet passphrase');\n    }\n\n    if (_.isUndefined(params.walletContractAddress) || !this.isValidAddress(params.walletContractAddress)) {\n      throw new Error('invalid walletContractAddress');\n    }\n\n    if (_.isUndefined(params.recoveryDestination) || !this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('invalid recoveryDestination');\n    }\n\n    const isKrsRecovery = getIsKrsRecovery(params);\n    const isUnsignedSweep = getIsUnsignedSweep(params);\n\n    if (isKrsRecovery) {\n      checkKrsProvider(this, params.krsProvider, { checkCoinFamilySupport: false });\n    }\n\n    let userKey = params.userKey.replace(/\\s/g, '');\n    const backupKey = params.backupKey.replace(/\\s/g, '');\n\n    const gasPrice = params.eip1559\n      ? new optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)\n      : new optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice));\n    const gasLimit = new optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit));\n\n    let userPrv: string | undefined;\n    if (!isUnsignedSweep) {\n      if (!userKey.startsWith('xpub') && !userKey.startsWith('xprv')) {\n        try {\n          userKey = await this.bitgo.decrypt({\n            input: userKey,\n            password: params.walletPassphrase,\n          });\n        } catch (e) {\n          throw new Error(`Error decrypting user keychain: ${(e as Error).message}`);\n        }\n      }\n      userPrv = userKey;\n    }\n\n    let backupKeyAddress: string;\n    let backupSigningKey: Buffer;\n\n    if (isKrsRecovery || isUnsignedSweep) {\n      const backupHDNode = bip32.fromBase58(backupKey);\n      backupSigningKey = backupHDNode.publicKey;\n      backupKeyAddress = `0x${optionalDeps.ethUtil.publicToAddress(backupSigningKey, true).toString('hex')}`;\n    } else {\n      let backupPrv: string;\n      try {\n        backupPrv = await this.bitgo.decrypt({\n          input: backupKey,\n          password: params.walletPassphrase,\n        });\n      } catch (e) {\n        throw new Error(`Error decrypting backup keychain: ${(e as Error).message}`);\n      }\n\n      const backupHDNode = bip32.fromBase58(backupPrv);\n      backupSigningKey = backupHDNode.privateKey as Buffer;\n      backupKeyAddress = `0x${optionalDeps.ethUtil.privateToAddress(backupSigningKey).toString('hex')}`;\n    }\n\n    const backupKeyNonce = await this.getAddressNonce(backupKeyAddress, params.apiKey);\n\n    const backupKeyBalance = await this.queryAddressBalance(backupKeyAddress, params.apiKey);\n    const totalGasNeeded = gasPrice.mul(gasLimit);\n    const weiToGwei = 10 ** 9;\n    if (backupKeyBalance.lt(totalGasNeeded)) {\n      throw new Error(\n        `Backup key address ${backupKeyAddress} has balance ${(backupKeyBalance / weiToGwei).toString()} Gwei.` +\n          `This address must have a balance of at least ${(totalGasNeeded / weiToGwei).toString()}` +\n          ` Gwei to perform recoveries. Try sending some ETH to this address then retry.`\n      );\n    }\n\n    // Get the encrypted balance handle (auto-query or user-provided)\n    let encryptedHandle: string;\n    if (params.encryptedHandle) {\n      encryptedHandle = params.encryptedHandle;\n    } else {\n      await new Promise((resolve) => setTimeout(resolve, 1000));\n      encryptedHandle = await this.queryConfidentialBalance(params.walletContractAddress, params.apiKey);\n    }\n\n    // Note: encrypted handles are always non-zero even for zero balances (encrypted domain).\n    // The transfer will execute but move 0 tokens if the wallet is empty.\n\n    // Build the inner calldata: confidentialTransfer(recoveryDestination, handle)\n    const innerCalldata = buildConfidentialTransferByHandleCalldata(params.recoveryDestination, encryptedHandle);\n\n    // For sendMultiSig: recipient is the token contract, amount is 0, data carries the confidentialTransfer calldata\n    const recipients = [\n      {\n        address: this.tokenContractAddress,\n        amount: '0',\n        data: optionalDeps.ethUtil.stripHexPrefix(innerCalldata),\n      },\n    ];\n\n    await new Promise((resolve) => setTimeout(resolve, 1000));\n    const sequenceId = await this.querySequenceId(params.walletContractAddress, params.apiKey);\n\n    let operationHash: string | undefined;\n    let signature: string | undefined;\n    if (!isUnsignedSweep) {\n      operationHash = this.getOperationSha3ForExecuteAndConfirm(recipients, this.getDefaultExpireTime(), sequenceId);\n      signature = Util.ethSignMsgHash(operationHash, Util.xprvToEthPrivateKey(userPrv!));\n\n      try {\n        Util.ecRecoverEthAddress(operationHash, signature);\n      } catch (e) {\n        throw new Error('Invalid signature');\n      }\n    }\n\n    const txInfo = {\n      recipient: recipients[0],\n      expireTime: this.getDefaultExpireTime(),\n      contractSequenceId: sequenceId,\n      operationHash: operationHash,\n      signature: signature ?? '',\n      gasLimit: gasLimit.toString(10),\n    };\n\n    const sendMethodArgs = this.getSendMethodArgs(txInfo);\n    const methodSignature = optionalDeps.ethAbi.methodID(this.sendMethodName, _.map(sendMethodArgs, 'type'));\n    const encodedArgs = optionalDeps.ethAbi.rawEncode(_.map(sendMethodArgs, 'type'), _.map(sendMethodArgs, 'value'));\n    const sendData = Buffer.concat([methodSignature, encodedArgs]);\n\n    let tx = Eth.buildTransaction({\n      to: params.walletContractAddress,\n      nonce: backupKeyNonce,\n      value: 0,\n      gasPrice: gasPrice,\n      gasLimit: gasLimit,\n      data: sendData,\n      eip1559: params.eip1559,\n      replayProtectionOptions: params.replayProtectionOptions,\n    });\n\n    if (isUnsignedSweep) {\n      return this.formatForOfflineVault(\n        txInfo,\n        tx,\n        userKey,\n        backupKey,\n        gasPrice,\n        gasLimit,\n        params.eip1559,\n        params.replayProtectionOptions,\n        params.apiKey\n      ) as any;\n    }\n\n    if (!isKrsRecovery) {\n      tx = tx.sign(backupSigningKey);\n    }\n\n    const signedTx: RecoveryInfo = {\n      id: optionalDeps.ethUtil.bufferToHex(tx.hash()),\n      tx: tx.serialize().toString('hex'),\n    };\n\n    if (isKrsRecovery) {\n      signedTx.backupKey = backupKey;\n      signedTx.coin = this.getChain();\n    }\n\n    return signedTx;\n  }\n\n  /**\n   * Returns a DecryptionDelegationBuilder for constructing Zama ACL decryption\n   * delegation transactions.\n   *\n   * The builder produces a DecryptionDelegationTxRequest {to, data, value} that is\n   * wallet-type-agnostic — WP routes it to the correct signing path:\n   * - MPC: submit as a raw TSS transaction\n   * - Multisig: wrap in sendMultiSig(walletContract, to, 0, data, ...)\n   *\n   * Example:\n   *   const req = coin.getDecryptionDelegationBuilder().build({\n   *     aclContractAddress: '0xf0Ff...',\n   *     delegateAddress:    enterpriseViewingKey,\n   *     tokenContractAddresses: [tokenAddress],\n   *     expiryTimestamp:    Math.floor(Date.now() / 1000) + 365 * 86400,\n   *   });\n   */\n  getDecryptionDelegationBuilder(): DecryptionDelegationBuilder {\n    return new DecryptionDelegationBuilder();\n  }\n}\n"]}