@bitgo-beta/sdk-coin-eth 4.4.1-beta.20 → 4.4.1-beta.2000

package/dist/src/erc721Token.js

@@ -0,0 +1,334 @@
+"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.Erc721Token = void 0;
+/**
+ * @prettier
+ */
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const bignumber_js_1 = require("bignumber.js");
+const statics_1 = require("@bitgo-beta/statics");
+const secp256k1_1 = require("@bitgo-beta/secp256k1");
+const _ = __importStar(require("lodash"));
+const eth_1 = require("./eth");
+const lib_1 = require("./lib");
+class Erc721Token extends eth_1.Eth {
+    constructor(bitgo, tokenConfig) {
+        const staticsCoin = statics_1.coins.get(Erc721Token.coinNames[tokenConfig.network]);
+        super(bitgo, staticsCoin);
+        this.tokenConfig = tokenConfig;
+        this.sendMethodName = 'sendMultiSigToken';
+    }
+    static createTokenConstructor(config) {
+        return (bitgo) => new Erc721Token(bitgo, config);
+    }
+    static createTokenConstructors(tokenConfigs = [...statics_1.tokens.bitcoin.eth.nfts, ...statics_1.tokens.testnet.eth.nfts]) {
+        const tokensCtors = [];
+        for (const token of tokenConfigs) {
+            const tokenConstructor = Erc721Token.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 'ERC721 Token';
+    }
+    getBaseFactor() {
+        return Math.pow(10, this.tokenConfig.decimalPlaces);
+    }
+    /**
+     * Flag for sending value of 0
+     * @returns {boolean} True if okay to send 0 value, false otherwise
+     */
+    valuelessTransferAllowed() {
+        return false;
+    }
+    /**
+     * Flag for sending data along with transactions
+     * @returns {boolean} True if okay to send tx data (ETH), false otherwise
+     */
+    transactionDataAllowed() {
+        return false;
+    }
+    /** @inheritDoc */
+    supportsTss() {
+        return true;
+    }
+    /** @inheritDoc */
+    getMPCAlgorithm() {
+        return 'ecdsa';
+    }
+    getTransactionBuilder() {
+        return new lib_1.TransactionBuilder(statics_1.coins.get(this.getBaseChain()));
+    }
+    /**
+     * Builds a token recovery transaction without BitGo
+     * @param params
+     * @param params.userKey {String} [encrypted] xprv
+     * @param params.backupKey {String} [encrypted] xprv or xpub if the xprv is held by a KRS providers
+     * @param params.walletPassphrase {String} used to decrypt userKey and backupKey
+     * @param params.walletContractAddress {String} the ETH address of the wallet contract
+     * @param params.recoveryDestination {String} target address to send recovered funds to
+     * @param params.krsProvider {String} necessary if backup key is held by KRS
+     */
+    async recover(params) {
+        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 });
+        }
+        // Clean up whitespace from entered values
+        const userKey = params.userKey.replace(/\s/g, '');
+        const backupKey = params.backupKey.replace(/\s/g, '');
+        // Set new eth tx fees (default to using platform values if none are provided)
+        const gasPrice = params.eip1559
+            ? new eth_1.optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)
+            : new eth_1.optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice));
+        const gasLimit = new eth_1.optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit));
+        // Decrypt private keys from KeyCard values
+        let userPrv;
+        if (!userKey.startsWith('xpub') && !userKey.startsWith('xprv')) {
+            try {
+                userPrv = await this.bitgo.decrypt({
+                    input: userKey,
+                    password: params.walletPassphrase,
+                });
+            }
+            catch (e) {
+                throw new Error(`Error decrypting user keychain: ${e.message}`);
+            }
+        }
+        let backupKeyAddress;
+        let backupSigningKey;
+        if (isKrsRecovery || isUnsignedSweep) {
+            const backupHDNode = secp256k1_1.bip32.fromBase58(backupKey);
+            backupSigningKey = backupHDNode.publicKey;
+            backupKeyAddress = `0x${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${eth_1.optionalDeps.ethUtil.privateToAddress(backupSigningKey).toString('hex')}`;
+        }
+        // Get nonce for backup key (should be 0)
+        let backupKeyNonce = 0;
+        const result = await this.recoveryBlockchainExplorerQuery({
+            chainid: this.getChainId().toString(),
+            module: 'account',
+            action: 'txlist',
+            address: backupKeyAddress,
+        }, params.apiKey);
+        const backupKeyTxList = result.result;
+        if (backupKeyTxList.length > 0) {
+            // Calculate last nonce used
+            const outgoingTxs = backupKeyTxList.filter((tx) => tx.from === backupKeyAddress);
+            backupKeyNonce = outgoingTxs.length;
+        }
+        // get balance of backup key and make sure we can afford gas
+        const backupKeyBalance = await this.queryAddressBalance(backupKeyAddress, params.apiKey);
+        if (backupKeyBalance.lt(gasPrice.mul(gasLimit))) {
+            throw new Error(`Backup key address ${backupKeyAddress} has balance ${backupKeyBalance.toString(10)}. This address must have a balance of at least 0.01 ETH to perform recoveries`);
+        }
+        // get token balance of wallet
+        const txAmount = await this.queryAddressTokenBalance(this.tokenContractAddress, params.walletContractAddress, params.apiKey);
+        if (new bignumber_js_1.BigNumber(txAmount).isLessThanOrEqualTo(0)) {
+            throw new Error('Wallet does not have enough funds to recover');
+        }
+        // build recipients object
+        const recipients = [
+            {
+                address: params.recoveryDestination,
+                amount: txAmount.toString(10),
+            },
+        ];
+        // Get sequence ID using contract call
+        const sequenceId = await this.querySequenceId(params.walletContractAddress, params.apiKey);
+        let operationHash, signature;
+        if (!isUnsignedSweep) {
+            // Get operation hash and sign it
+            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,
+            signature: signature,
+            gasLimit: gasLimit.toString(10),
+            tokenContractAddress: this.tokenContractAddress,
+        };
+        // calculate send data
+        const sendMethodArgs = this.getSendMethodArgs(txInfo);
+        const methodSignature = eth_1.optionalDeps.ethAbi.methodID(this.sendMethodName, _.map(sendMethodArgs, 'type'));
+        const encodedArgs = 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: eth_1.optionalDeps.ethUtil.bufferToHex(tx.hash()),
+            tx: tx.serialize().toString('hex'),
+        };
+        if (isKrsRecovery) {
+            signedTx.backupKey = backupKey;
+            signedTx.coin = 'erc721';
+        }
+        return signedTx;
+    }
+    getOperation(recipient, expireTime, contractSequenceId) {
+        return [
+            ['string', 'address', 'uint', 'address', 'uint', 'uint'],
+            [
+                'ERC721',
+                new eth_1.optionalDeps.ethUtil.BN(eth_1.optionalDeps.ethUtil.stripHexPrefix(recipient.address), 16),
+                recipient.amount,
+                new eth_1.optionalDeps.ethUtil.BN(eth_1.optionalDeps.ethUtil.stripHexPrefix(this.tokenContractAddress), 16),
+                expireTime,
+                contractSequenceId,
+            ],
+        ];
+    }
+    getSendMethodArgs(txInfo) {
+        // Method signature is
+        // sendMultiSigToken(address toAddress, uint value, address tokenContractAddress, uint expireTime, uint sequenceId, bytes signature)
+        return [
+            {
+                name: 'toAddress',
+                type: 'address',
+                value: txInfo.recipient.address,
+            },
+            {
+                name: 'value',
+                type: 'uint',
+                value: txInfo.recipient.amount,
+            },
+            {
+                name: 'tokenContractAddress',
+                type: 'address',
+                value: this.tokenContractAddress,
+            },
+            {
+                name: 'expireTime',
+                type: 'uint',
+                value: txInfo.expireTime,
+            },
+            {
+                name: 'sequenceId',
+                type: 'uint',
+                value: txInfo.contractSequenceId,
+            },
+            {
+                name: 'signature',
+                type: 'bytes',
+                value: eth_1.optionalDeps.ethUtil.toBuffer(eth_1.optionalDeps.ethUtil.addHexPrefix(txInfo.signature)),
+            },
+        ];
+    }
+    verifyCoin(txPrebuild) {
+        return txPrebuild.coin === this.tokenConfig.coin && txPrebuild.token === this.tokenConfig.type;
+    }
+}
+exports.Erc721Token = Erc721Token;
+Erc721Token.coinNames = {
+    Mainnet: 'eth',
+    Testnet: 'hteth',
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"erc721Token.js","sourceRoot":"","sources":["../../src/erc721Token.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport {\n  BitGoBase,\n  CoinConstructor,\n  Util,\n  checkKrsProvider,\n  getIsKrsRecovery,\n  getIsUnsignedSweep,\n  MPCAlgorithm,\n  NamedCoinConstructor,\n} from '@bitgo-beta/sdk-core';\nimport { BigNumber } from 'bignumber.js';\n\nimport { coins, EthLikeTokenConfig, tokens } from '@bitgo-beta/statics';\nimport { CoinNames } from '@bitgo-beta/abstract-eth';\nimport { bip32 } from '@bitgo-beta/secp256k1';\nimport * as _ from 'lodash';\n\nimport { Eth, RecoverOptions, RecoveryInfo, optionalDeps, TransactionPrebuild } from './eth';\nimport { TransactionBuilder } from './lib';\n\nexport { EthLikeTokenConfig };\nexport class Erc721Token extends Eth {\n  public readonly tokenConfig: EthLikeTokenConfig;\n  protected readonly sendMethodName: 'sendMultiSig' | 'sendMultiSigToken';\n  static coinNames: CoinNames = {\n    Mainnet: 'eth',\n    Testnet: 'hteth',\n  };\n\n  constructor(bitgo: BitGoBase, tokenConfig: EthLikeTokenConfig) {\n    const staticsCoin = coins.get(Erc721Token.coinNames[tokenConfig.network]);\n    super(bitgo, staticsCoin);\n    this.tokenConfig = tokenConfig;\n    this.sendMethodName = 'sendMultiSigToken';\n  }\n\n  static createTokenConstructor(config: EthLikeTokenConfig): CoinConstructor {\n    return (bitgo: BitGoBase) => new Erc721Token(bitgo, config);\n  }\n\n  static createTokenConstructors(\n    tokenConfigs: EthLikeTokenConfig[] = [...tokens.bitcoin.eth.nfts, ...tokens.testnet.eth.nfts]\n  ): NamedCoinConstructor[] {\n    const tokensCtors: NamedCoinConstructor[] = [];\n    for (const token of tokenConfigs) {\n      const tokenConstructor = Erc721Token.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() {\n    return this.tokenConfig.type;\n  }\n\n  get name() {\n    return this.tokenConfig.name;\n  }\n\n  get coin() {\n    return this.tokenConfig.coin;\n  }\n\n  get network() {\n    return this.tokenConfig.network;\n  }\n\n  get tokenContractAddress() {\n    return this.tokenConfig.tokenContractAddress;\n  }\n\n  get decimalPlaces() {\n    return this.tokenConfig.decimalPlaces;\n  }\n\n  getChain() {\n    return this.tokenConfig.type;\n  }\n\n  getFullName() {\n    return 'ERC721 Token';\n  }\n\n  getBaseFactor() {\n    return Math.pow(10, this.tokenConfig.decimalPlaces);\n  }\n\n  /**\n   * Flag for sending value of 0\n   * @returns {boolean} True if okay to send 0 value, false otherwise\n   */\n  valuelessTransferAllowed() {\n    return false;\n  }\n\n  /**\n   * Flag for sending data along with transactions\n   * @returns {boolean} True if okay to send tx data (ETH), false otherwise\n   */\n  transactionDataAllowed() {\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  /**\n   * Builds a token recovery transaction without BitGo\n   * @param params\n   * @param params.userKey {String} [encrypted] xprv\n   * @param params.backupKey {String} [encrypted] xprv or xpub if the xprv is held by a KRS providers\n   * @param params.walletPassphrase {String} used to decrypt userKey and backupKey\n   * @param params.walletContractAddress {String} the ETH address of the wallet contract\n   * @param params.recoveryDestination {String} target address to send recovered funds to\n   * @param params.krsProvider {String} necessary if backup key is held by KRS\n   */\n  async recover(params: RecoverOptions): Promise<RecoveryInfo> {\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    // Clean up whitespace from entered values\n    const userKey = params.userKey.replace(/\\s/g, '');\n    const backupKey = params.backupKey.replace(/\\s/g, '');\n\n    // Set new eth tx fees (default to using platform values if none are provided)\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    // Decrypt private keys from KeyCard values\n    let userPrv;\n    if (!userKey.startsWith('xpub') && !userKey.startsWith('xprv')) {\n      try {\n        userPrv = await this.bitgo.decrypt({\n          input: userKey,\n          password: params.walletPassphrase,\n        });\n      } catch (e) {\n        throw new Error(`Error decrypting user keychain: ${e.message}`);\n      }\n    }\n\n    let backupKeyAddress;\n    let backupSigningKey;\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;\n\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.message}`);\n      }\n\n      const backupHDNode = bip32.fromBase58(backupPrv);\n      backupSigningKey = backupHDNode.privateKey;\n      backupKeyAddress = `0x${optionalDeps.ethUtil.privateToAddress(backupSigningKey).toString('hex')}`;\n    }\n\n    // Get nonce for backup key (should be 0)\n    let backupKeyNonce = 0;\n\n    const result = await this.recoveryBlockchainExplorerQuery(\n      {\n        chainid: this.getChainId().toString(),\n        module: 'account',\n        action: 'txlist',\n        address: backupKeyAddress,\n      },\n      params.apiKey\n    );\n    const backupKeyTxList = result.result;\n    if (backupKeyTxList.length > 0) {\n      // Calculate last nonce used\n      const outgoingTxs = backupKeyTxList.filter((tx) => tx.from === backupKeyAddress);\n      backupKeyNonce = outgoingTxs.length;\n    }\n\n    // get balance of backup key and make sure we can afford gas\n    const backupKeyBalance = await this.queryAddressBalance(backupKeyAddress, params.apiKey);\n\n    if (backupKeyBalance.lt(gasPrice.mul(gasLimit))) {\n      throw new Error(\n        `Backup key address ${backupKeyAddress} has balance ${backupKeyBalance.toString(\n          10\n        )}. This address must have a balance of at least 0.01 ETH to perform recoveries`\n      );\n    }\n\n    // get token balance of wallet\n    const txAmount = await this.queryAddressTokenBalance(\n      this.tokenContractAddress,\n      params.walletContractAddress,\n      params.apiKey\n    );\n    if (new BigNumber(txAmount).isLessThanOrEqualTo(0)) {\n      throw new Error('Wallet does not have enough funds to recover');\n    }\n\n    // build recipients object\n    const recipients = [\n      {\n        address: params.recoveryDestination,\n        amount: txAmount.toString(10),\n      },\n    ];\n\n    // Get sequence ID using contract call\n    const sequenceId = await this.querySequenceId(params.walletContractAddress, params.apiKey);\n\n    let operationHash, signature;\n    if (!isUnsignedSweep) {\n      // Get operation hash and sign it\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      signature: signature,\n      gasLimit: gasLimit.toString(10),\n      tokenContractAddress: this.tokenContractAddress,\n    };\n\n    // calculate send data\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 = 'erc721';\n    }\n\n    return signedTx;\n  }\n\n  getOperation(recipient, expireTime, contractSequenceId) {\n    return [\n      ['string', 'address', 'uint', 'address', 'uint', 'uint'],\n      [\n        'ERC721',\n        new optionalDeps.ethUtil.BN(optionalDeps.ethUtil.stripHexPrefix(recipient.address), 16),\n        recipient.amount,\n        new optionalDeps.ethUtil.BN(optionalDeps.ethUtil.stripHexPrefix(this.tokenContractAddress), 16),\n        expireTime,\n        contractSequenceId,\n      ],\n    ];\n  }\n\n  getSendMethodArgs(txInfo) {\n    // Method signature is\n    // sendMultiSigToken(address toAddress, uint value, address tokenContractAddress, uint expireTime, uint sequenceId, bytes signature)\n    return [\n      {\n        name: 'toAddress',\n        type: 'address',\n        value: txInfo.recipient.address,\n      },\n      {\n        name: 'value',\n        type: 'uint',\n        value: txInfo.recipient.amount,\n      },\n      {\n        name: 'tokenContractAddress',\n        type: 'address',\n        value: this.tokenContractAddress,\n      },\n      {\n        name: 'expireTime',\n        type: 'uint',\n        value: txInfo.expireTime,\n      },\n      {\n        name: 'sequenceId',\n        type: 'uint',\n        value: txInfo.contractSequenceId,\n      },\n      {\n        name: 'signature',\n        type: 'bytes',\n        value: optionalDeps.ethUtil.toBuffer(optionalDeps.ethUtil.addHexPrefix(txInfo.signature)),\n      },\n    ];\n  }\n\n  verifyCoin(txPrebuild: TransactionPrebuild): boolean {\n    return txPrebuild.coin === this.tokenConfig.coin && txPrebuild.token === this.tokenConfig.type;\n  }\n}\n"]}

package/dist/src/erc7984Token.d.ts

@@ -0,0 +1,187 @@
+/**
+ * @prettier
+ */
+import { BitGoBase, CoinConstructor, MPCAlgorithm, NamedCoinConstructor } from '@bitgo-beta/sdk-core';
+import { Erc7984TokenConfig } from '@bitgo-beta/statics';
+import { CoinNames, DecryptionDelegationBuilder, RecoverOptions, RecoveryInfo, OfflineVaultTxInfo, VerifyEthTransactionOptions } from '@bitgo-beta/abstract-eth';
+import { Eth } from './eth';
+import { TransactionBuilder } from './lib';
+export { Erc7984TokenConfig };
+export declare class Erc7984Token extends Eth {
+    readonly tokenConfig: Erc7984TokenConfig;
+    protected readonly sendMethodName: 'sendMultiSig' | 'sendMultiSigToken';
+    static coinNames: CoinNames;
+    constructor(bitgo: BitGoBase, tokenConfig: Erc7984TokenConfig);
+    static createTokenConstructor(config: Erc7984TokenConfig): CoinConstructor;
+    static createTokenConstructors(tokenConfigs?: Erc7984TokenConfig[]): NamedCoinConstructor[];
+    get type(): string;
+    get name(): string;
+    get coin(): string;
+    get network(): string;
+    get tokenContractAddress(): string;
+    get decimalPlaces(): number;
+    getChain(): string;
+    getFullName(): string;
+    getBaseFactor(): number;
+    /**
+     * Flag for sending value of 0.
+     * ERC-7984 confidential transfers always carry an encrypted amount; zero-value sends are not meaningful.
+     */
+    valuelessTransferAllowed(): boolean;
+    /**
+     * 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(): boolean;
+    /** @inheritDoc */
+    supportsTss(): boolean;
+    /** @inheritDoc */
+    getMPCAlgorithm(): MPCAlgorithm;
+    protected getTransactionBuilder(): TransactionBuilder;
+    /** @inheritDoc */
+    verifyTransaction(params: VerifyEthTransactionOptions): Promise<boolean>;
+    private isConsolidationTransaction;
+    /**
+     * 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.
+     */
+    private verifyWrapTransaction;
+    /**
+     * 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.
+     */
+    private verifyUnwrapTransaction;
+    /**
+     * 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(...), ...)
+     */
+    private verifyFinalizeUnwrapTransaction;
+    private getWalletBaseAddress;
+    /**
+     * 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))
+     */
+    private verifyConfidentialConsolidation;
+    /**
+     * 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.
+     */
+    private verifyConfidentialTransfer;
+    private static isPositiveIntegerString;
+    /**
+     * 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.
+     */
+    private verifyEnableTokenTransaction;
+    /**
+     * 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?: number): number;
+    /**
+     * 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).
+     */
+    queryConfidentialBalance(walletAddress: string, apiKey?: string): Promise<string>;
+    /**
+     * 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), ...)
+     */
+    recover(params: RecoverOptions): Promise<RecoveryInfo | OfflineVaultTxInfo>;
+    /**
+     * 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(): DecryptionDelegationBuilder;
+}
+//# sourceMappingURL=erc7984Token.d.ts.map

package/dist/src/erc7984Token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc7984Token.d.ts","sourceRoot":"","sources":["../../src/erc7984Token.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EACL,SAAS,EACT,eAAe,EAIf,YAAY,EACZ,oBAAoB,EAErB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAS,kBAAkB,EAA2B,MAAM,qBAAqB,CAAC;AACzF,OAAO,EACL,SAAS,EACT,2BAA2B,EAU3B,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,2BAA2B,EAY5B,MAAM,0BAA0B,CAAC;AAIlC,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAC5B,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAE3C,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAE9B,qBAAa,YAAa,SAAQ,GAAG;IACnC,SAAgB,WAAW,EAAE,kBAAkB,CAAC;IAChD,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,cAAc,GAAG,mBAAmB,CAAC;IACxE,MAAM,CAAC,SAAS,EAAE,SAAS,CAGzB;gBAEU,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,kBAAkB;IAU7D,MAAM,CAAC,sBAAsB,CAAC,MAAM,EAAE,kBAAkB,GAAG,eAAe;IAI1E,MAAM,CAAC,uBAAuB,CAC5B,YAAY,GAAE,kBAAkB,EAG/B,GACA,oBAAoB,EAAE;IAUzB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,oBAAoB,IAAI,MAAM,CAEjC;IAED,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,QAAQ,IAAI,MAAM;IAIlB,WAAW,IAAI,MAAM;IAIrB,aAAa,IAAI,MAAM;IAIvB;;;OAGG;IACH,wBAAwB,IAAI,OAAO;IAInC;;;;;;OAMG;IACH,sBAAsB,IAAI,OAAO;IAIjC,kBAAkB;IAClB,WAAW,IAAI,OAAO;IAItB,kBAAkB;IAClB,eAAe,IAAI,YAAY;IAI/B,SAAS,CAAC,qBAAqB,IAAI,kBAAkB;IAIrD,kBAAkB;IACZ,iBAAiB,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,OAAO,CAAC;IAmB9E,OAAO,CAAC,0BAA0B;IAclC;;;;;;;;;;;;;OAaG;YACW,qBAAqB;IAqFnC;;;;;;;;;;;;OAYG;YACW,uBAAuB;IA8ErC;;;;;;;;;;OAUG;YACW,+BAA+B;IAiF7C,OAAO,CAAC,oBAAoB;IAS5B;;;;;;;;;;OAUG;YACW,+BAA+B;IA+E7C;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;YACW,0BAA0B;IAuIxC,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAItC;;;;;;;;OAQG;YACW,4BAA4B;IAqH1C;;;;OAIG;IACH,WAAW,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM;IAO1C;;;;;;;;OAQG;IACG,wBAAwB,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA+BvF;;;;;;;;;;OAUG;IACG,OAAO,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,GAAG,kBAAkB,CAAC;IA2LjF;;;;;;;;;;;;;;;;OAgBG;IACH,8BAA8B,IAAI,2BAA2B;CAG9D"}