@bitgo-beta/sdk-coin-eth 4.4.1-beta.19 → 4.4.1-beta.1900

package/dist/src/erc7984Token.js

@@ -0,0 +1,459 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Erc7984Token = void 0;
+const statics_1 = require("@bitgo-beta/statics");
+const abstract_eth_1 = require("@bitgo-beta/abstract-eth");
+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(Erc7984Token.coinNames[tokenConfig.network]);
+        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 (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);
+    }
+    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;
+        }
+    }
+    /**
+     * 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 { BitGoBase, CoinConstructor, MPCAlgorithm, NamedCoinConstructor } from '@bitgo-beta/sdk-core';\n\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  VerifyEthTransactionOptions,\n  aclMulticallMethodId,\n  callFromParentMethodId,\n} from '@bitgo-beta/abstract-eth';\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(Erc7984Token.coinNames[tokenConfig.network]);\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 (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  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   * 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"]}