@bitgo-beta/sdk-coin-tempo 1.0.1-beta.31 → 1.0.1-beta.310

package/dist/src/tempo.js

@@ -1,130 +1,501 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+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.Tempo = void 0;
+/**
+ * @prettier
+ */
+const abstract_eth_1 = require("@bitgo-beta/abstract-eth");
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
-const keyPair_1 = require("./lib/keyPair");
-const utils_1 = __importDefault(require("./lib/utils"));
-class Tempo extends sdk_core_1.BaseCoin {
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const statics_1 = require("@bitgo-beta/statics");
+const ethers_1 = require("ethers");
+const lib_1 = require("./lib");
+const utils_1 = require("./lib/utils");
+const constants_1 = require("./lib/constants");
+const url = __importStar(require("url"));
+const querystring = __importStar(require("querystring"));
+class Tempo extends abstract_eth_1.AbstractEthLikeNewCoins {
     constructor(bitgo, staticsCoin) {
-        super(bitgo);
-        if (!staticsCoin) {
-            throw new Error('missing required constructor parameter staticsCoin');
-        }
-        this._staticsCoin = staticsCoin;
+        super(bitgo, staticsCoin);
     }
+    /**
+     * Factory method to create Tempo instance
+     */
     static createInstance(bitgo, staticsCoin) {
         return new Tempo(bitgo, staticsCoin);
     }
     /**
-     * Factor between the coin's base unit and its smallest subdivision
+     * Get the chain identifier
      */
-    getBaseFactor() {
-        return 1e18;
-    }
     getChain() {
-        return 'tempo';
-    }
-    getFamily() {
-        return 'tempo';
+        return this._staticsCoin?.name || 'tempo';
     }
+    /**
+     * Get the full chain name
+     */
     getFullName() {
         return 'Tempo';
     }
+    /** @inheritdoc */
+    getBaseFactor() {
+        return 1e6;
+    }
     /**
-     * Flag for sending value of 0
-     * @returns {boolean} True if okay to send 0 value, false otherwise
+     * Check if value-less transfers are allowed
+     * EVM-based chains allow zero-value transfers for smart contract interactions
      */
     valuelessTransferAllowed() {
-        return false;
+        return true;
+    }
+    /**
+     * Check if TSS is supported
+     */
+    supportsTss() {
+        return true;
     }
     /**
-     * Checks if this is a valid base58 or hex address
-     * @param address
+     * Get the MPC algorithm (ECDSA for EVM chains)
+     */
+    getMPCAlgorithm() {
+        return 'ecdsa';
+    }
+    /**
+     * Evaluates whether an address string is valid for Tempo
+     * Supports addresses with optional memoId query parameter (e.g., 0x...?memoId=123)
+     * @param address - The address to validate
+     * @returns true if address is valid
      */
     isValidAddress(address) {
-        return utils_1.default.isValidAddress(address);
+        if (typeof address !== 'string') {
+            return false;
+        }
+        try {
+            const { baseAddress } = this.getAddressDetails(address);
+            return abstract_eth_1.optionalDeps.ethUtil.isValidAddress(abstract_eth_1.optionalDeps.ethUtil.addHexPrefix(baseAddress));
+        }
+        catch (e) {
+            return false;
+        }
     }
     /**
-     * Generate ed25519 key pair
-     *
-     * @param seed
-     * @returns {Object} object with generated pub, prv
+     * Parse address into base address and optional memoId
+     * Throws InvalidAddressError for invalid address formats
+     * @param address - Address string, potentially with ?memoId=X suffix
+     * @returns Object containing address, baseAddress, and memoId (null if not present)
+     * @throws InvalidAddressError if address format is invalid
      */
-    generateKeyPair(seed) {
-        const keyPair = seed ? new keyPair_1.KeyPair({ seed }) : new keyPair_1.KeyPair();
-        const keys = keyPair.getKeys();
-        if (!keys.prv) {
-            throw new Error('Missing prv in key generation.');
+    getAddressDetails(address) {
+        if (typeof address !== 'string') {
+            throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}`);
+        }
+        const destinationDetails = url.parse(address);
+        const baseAddress = destinationDetails.pathname || '';
+        // No query string - just a plain address
+        if (destinationDetails.pathname === address) {
+            return {
+                address,
+                baseAddress: address,
+                memoId: null,
+            };
+        }
+        // Has query string - must contain memoId
+        if (!destinationDetails.query) {
+            throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}`);
+        }
+        const queryDetails = querystring.parse(destinationDetails.query);
+        // Query string must contain memoId
+        if (!queryDetails.memoId) {
+            throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}, unknown query parameters`);
+        }
+        // Only one memoId allowed
+        if (Array.isArray(queryDetails.memoId)) {
+            throw new sdk_core_1.InvalidAddressError(`memoId may only be given at most once, but found ${queryDetails.memoId.length} instances in address ${address}`);
+        }
+        // Reject if there are other query parameters besides memoId
+        const queryKeys = Object.keys(queryDetails);
+        if (queryKeys.length !== 1) {
+            throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}, only memoId query parameter is allowed`);
+        }
+        // Validate memoId format
+        if (!this.isValidMemoId(queryDetails.memoId)) {
+            throw new sdk_core_1.InvalidMemoIdError(`invalid address: '${address}', memoId is not valid`);
         }
         return {
-            pub: keys.pub,
-            prv: keys.prv,
+            address,
+            baseAddress,
+            memoId: queryDetails.memoId,
         };
     }
     /**
-     * Return boolean indicating whether input is valid public key for the coin.
-     *
-     * @param {String} pub the pub to be checked
-     * @returns {Boolean} is it valid?
+     * Validate that a memoId is a valid non-negative integer string
+     * @param memoId - The memoId to validate
+     * @returns true if valid
+     */
+    isValidMemoId(memoId) {
+        return (0, utils_1.isValidMemoId)(memoId);
+    }
+    /**
+     * Tempo uses memoId-based addresses rather than forwarder contracts.
+     * Verify that the address belongs to this wallet by checking that the
+     * base (EVM) portion matches the wallet's base address.
+     */
+    async isWalletAddress(params) {
+        const { address, baseAddress } = params;
+        const rootAddress = params.rootAddress;
+        if (!address) {
+            throw new sdk_core_1.InvalidAddressError('address is required');
+        }
+        if (!this.isValidAddress(address)) {
+            throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}`);
+        }
+        const { baseAddress: addressBase } = this.getAddressDetails(address);
+        const walletBaseAddress = baseAddress || rootAddress;
+        if (!walletBaseAddress) {
+            throw new sdk_core_1.InvalidAddressError('baseAddress or rootAddress is required for verification');
+        }
+        const { baseAddress: walletBase } = this.getAddressDetails(walletBaseAddress);
+        if (addressBase.toLowerCase() !== walletBase.toLowerCase()) {
+            throw new sdk_core_1.UnexpectedAddressError(`address validation failure: expected ${walletBase} but got ${addressBase}`);
+        }
+        return true;
+    }
+    /**
+     * Parse a serialised Tempo transaction and return its operations as SDK outputs.
+     * @inheritdoc
      */
-    isValidPub(pub) {
-        return utils_1.default.isValidPublicKey(pub);
+    async parseTransaction(params) {
+        const txHex = (params.txHex || params.halfSigned?.txHex);
+        if (!txHex) {
+            return {};
+        }
+        if (!(0, utils_1.isTip20Transaction)(txHex)) {
+            return {};
+        }
+        const txBuilder = this.getTransactionBuilder();
+        txBuilder.from(txHex);
+        const tx = (await txBuilder.build());
+        return {
+            inputs: tx.inputs.map((input) => ({
+                address: input.address,
+                amount: input.value,
+                coin: this.getChain(),
+            })),
+            outputs: tx.outputs.map((output) => ({
+                address: output.address,
+                amount: output.value,
+                coin: this.getChain(),
+            })),
+        };
     }
     /**
-     * Verify that a transaction prebuild complies with the original intention
-     * @param params
-     * @param params.txPrebuild
-     * @param params.txParams
-     * @returns {boolean}
+     * Verify that a Tempo transaction matches the intended recipients and amounts.
+     * @inheritdoc
      */
     async verifyTransaction(params) {
-        // TODO: Implement transaction verification
-        return false;
+        const { txParams, txPrebuild } = params;
+        if (!txPrebuild?.txHex) {
+            return true;
+        }
+        // signableHex may arrive without the 0x prefix (e.g. from the TSS signing flow).
+        const txHex = txPrebuild.txHex.startsWith('0x') ? txPrebuild.txHex : '0x' + txPrebuild.txHex;
+        if (!(0, utils_1.isTip20Transaction)(txHex)) {
+            throw new Error(`Invalid Tempo transaction hex: expected a 0x76 TIP-20 transaction`);
+        }
+        const txBuilder = this.getTransactionBuilder();
+        txBuilder.from(txHex);
+        const tx = (await txBuilder.build());
+        const operations = tx.getOperations();
+        const rawCalls = tx.getRawCalls();
+        // If the caller specified explicit recipients, verify they match the transaction.
+        // A transaction is either all token transfer operations OR a single raw contract call — never mixed.
+        const recipients = txParams?.recipients;
+        if (recipients && recipients.length > 0) {
+            if (rawCalls.length > 0) {
+                // Contract call transaction — single raw call, single recipient with data
+                if (rawCalls.length !== recipients.length) {
+                    throw new Error(`Transaction has ${rawCalls.length} call(s) but ${recipients.length} recipient(s) were requested`);
+                }
+                for (let i = 0; i < rawCalls.length; i++) {
+                    const rawCall = rawCalls[i];
+                    const recipient = recipients[i];
+                    if (rawCall.to.toLowerCase() !== recipient.address.split('?')[0].toLowerCase()) {
+                        throw new Error(`Raw call ${i} address mismatch: expected ${recipient.address}, got ${rawCall.to}`);
+                    }
+                    if (!recipient.data || rawCall.data.toLowerCase() !== recipient.data.toLowerCase()) {
+                        throw new Error(`Raw call ${i} calldata mismatch`);
+                    }
+                }
+            }
+            else {
+                // Token transfer transaction — operations matched 1-to-1 against recipients
+                if (operations.length !== recipients.length) {
+                    throw new Error(`Transaction has ${operations.length} operation(s) but ${recipients.length} recipient(s) were requested`);
+                }
+                for (let i = 0; i < operations.length; i++) {
+                    const op = operations[i];
+                    const recipient = recipients[i];
+                    const recipientBaseAddress = recipient.address.split('?')[0];
+                    if (op.to.toLowerCase() !== recipientBaseAddress.toLowerCase()) {
+                        throw new Error(`Operation ${i} recipient mismatch: expected ${recipient.address}, got ${op.to}`);
+                    }
+                    const opAmountBaseUnits = (0, utils_1.amountToTip20Units)(op.amount).toString();
+                    if (opAmountBaseUnits !== recipient.amount.toString()) {
+                        throw new Error(`Operation ${i} amount mismatch: expected ${recipient.amount}, got ${opAmountBaseUnits}`);
+                    }
+                }
+            }
+        }
+        // Verify fee token if specified
+        if (txParams?.feeToken) {
+            const txFeeToken = tx.getFeeToken();
+            if (txFeeToken?.toLowerCase() !== txParams.feeToken.toLowerCase()) {
+                throw new Error(`Fee token mismatch: expected ${txParams.feeToken}, got ${txFeeToken || 'none'}`);
+            }
+        }
+        return true;
     }
     /**
-     * Check if address is a wallet address
-     * @param params
+     * Set coin-specific fields in the intent for Tempo TSS transactions.
+     * Ensures feeToken is properly wired through the intent for Tempo transactions.
+     * @param intent - The populated intent to modify
+     * @param params - The parameters containing feeToken
      */
-    async isWalletAddress(params) {
-        // TODO: Implement address verification
-        return false;
+    setCoinSpecificFieldsInIntent(intent, params) {
+        if (params.feeToken) {
+            intent.feeOptions = intent.feeOptions
+                ? { ...intent.feeOptions, feeToken: params.feeToken }
+                : { feeToken: params.feeToken };
+        }
     }
     /**
-     * Audit a decrypted private key for security purposes
-     * @param params
+     * Query the Tempo Alchemy RPC for recovery balance/nonce information.
+     * Routes through queryTempoRpc using the URL from environments.ts.
      */
-    async auditDecryptedKey(params) {
-        // TODO: Implement key auditing logic if needed
-        // This method is typically used for security compliance
-        return Promise.resolve();
+    async recoveryBlockchainExplorerQuery(query, apiKey) {
+        const evmConfig = sdk_core_1.common.Environments[this.bitgo.getEnv()].evm;
+        const coinFamily = this.getFamily();
+        if (!evmConfig || !(coinFamily in evmConfig)) {
+            throw new Error(`env config missing for ${coinFamily} in ${this.bitgo.getEnv()}`);
+        }
+        const token = apiKey || evmConfig[coinFamily].apiToken;
+        const rpcUrl = evmConfig[coinFamily].baseUrl;
+        return this.queryTempoRpc(query, rpcUrl, token);
     }
     /**
-     * Parse a transaction from the raw transaction hex
-     * @param params
+     * Translates Etherscan-style recovery queries into Tempo Alchemy JSON-RPC calls.
+     *
+     * Supported:
+     *   account/balance      → returns { result: '0' } (no native coin on Tempo)
+     *   account/tokenbalance → eth_call (balanceOf selector 0x70a08231) → { result: decimalString }
+     *   account/txlist       → eth_getTransactionCount → { nonce: number }
      */
-    async parseTransaction(params) {
-        // TODO: Implement transaction parsing
-        return {};
+    async queryTempoRpc(query, rpcUrl, apiKey) {
+        const endpoint = apiKey ? `${rpcUrl}${apiKey}` : rpcUrl;
+        const { module, action, address, contractaddress, tag } = query;
+        let method;
+        let params;
+        if (module === 'account' && action === 'balance') {
+            return { result: '0' };
+        }
+        else if (module === 'account' && action === 'tokenbalance') {
+            const paddedAddr = (address ?? '').replace(/^0x/, '').padStart(64, '0');
+            method = 'eth_call';
+            params = [{ to: contractaddress, data: '0x70a08231' + paddedAddr }, tag ?? 'latest'];
+        }
+        else if (module === 'account' && action === 'txlist') {
+            method = 'eth_getTransactionCount';
+            params = [address, 'latest'];
+        }
+        else {
+            throw new Error(`queryTempoRpc: unsupported module=${module} action=${action}`);
+        }
+        const res = await fetch(endpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ jsonrpc: '2.0', method, params, id: 1 }),
+        });
+        if (!res.ok) {
+            throw new Error(`Could not reach Tempo RPC endpoint (HTTP ${res.status})`);
+        }
+        const body = (await res.json());
+        if (body.error) {
+            throw new Error(`Tempo RPC error: ${body.error.message}`);
+        }
+        if (module === 'account' && action === 'txlist') {
+            return { nonce: parseInt(body.result, 16) };
+        }
+        try {
+            return { result: BigInt(body.result).toString() };
+        }
+        catch {
+            return { result: '0' };
+        }
     }
     /**
-     * Explain a transaction
-     * @param params
+     * Shared helper: queries the token balance, computes sweep amount, and builds
+     * an unsigned TIP-20 transfer transaction. Used by both recovery paths.
+     *
+     * - tokenContractAddress: the token to sweep (defaults to pathUSD)
+     * - feeToken: always pathUSD
+     * - If sweeping pathUSD itself, reserves gasLimit × maxFeePerGas / 10^12 pathUSD units for fees.
      */
-    async explainTransaction(params) {
-        // TODO: Implement transaction explanation
-        return {};
+    async buildTempoSweepTx(walletAddress, params) {
+        if (!params.tokenContractAddress) {
+            throw new Error('tokenContractAddress is required for sweep');
+        }
+        const tokenAddress = params.tokenContractAddress;
+        const pathUsdTokenName = this.getChain() === constants_1.MAINNET_COIN ? constants_1.PATH_USD_TOKEN_MAINNET : constants_1.PATH_USD_TOKEN_TESTNET;
+        const pathUsdAddress = statics_1.coins.get(pathUsdTokenName).contractAddress;
+        const rawBalance = await this.queryAddressTokenBalance(tokenAddress, walletAddress, params.apiKey);
+        const balance = BigInt(rawBalance.toString());
+        const isPathUsd = tokenAddress.toLowerCase() === pathUsdAddress.toLowerCase();
+        const gasLimitBig = BigInt(params.gasLimit ?? 700000);
+        const maxFeePerGasBig = BigInt(params.eip1559?.maxFeePerGas ?? 20000000000);
+        // 75% buffer on top of gasLimit × maxFeePerGas to cover actual on-chain gas variance
+        const gasMarginUnits = (gasLimitBig * maxFeePerGasBig * 175n) / (10n ** 12n * 100n);
+        const sweepAmount = isPathUsd ? balance - gasMarginUnits : balance;
+        if (sweepAmount <= 0n) {
+            throw new Error(`Insufficient balance in ${tokenAddress}: ${balance} units (minimum required: ${isPathUsd ? gasMarginUnits + 1n : 1n})`);
+        }
+        const sweepAmountHuman = (0, utils_1.tip20UnitsToAmount)(sweepAmount);
+        const nonce = await this.getAddressNonce(walletAddress, params.apiKey);
+        const txBuilder = this.getTransactionBuilder();
+        txBuilder
+            .addOperation({ token: tokenAddress, to: params.recoveryDestination, amount: sweepAmountHuman })
+            .feeToken(pathUsdAddress)
+            .nonce(nonce)
+            .gas(gasLimitBig)
+            .maxFeePerGas(maxFeePerGasBig)
+            .maxPriorityFeePerGas(BigInt(params.eip1559?.maxPriorityFeePerGas ?? 10000000000));
+        const tx = (await txBuilder.build());
+        return { tx, nonce, sweepAmount, gasMarginUnits };
+    }
+    /**
+     * Overrides the base-class recoverTSS to use TIP-20 transactions instead of standard ETH.
+     *
+     * Two paths:
+     *   - Unsigned sweep (plain public key shares): delegates to buildUnsignedSweepTxnTSS
+     *   - Signed sweep (encrypted keys + passphrase): builds and signs a TIP-20 tx via MPC
+     */
+    async recoverTSS(params) {
+        this.validateRecoveryParams(params);
+        const userKey = params.userKey.replace(/\s/g, '');
+        const backupKey = params.backupKey.replace(/\s/g, '');
+        if ((0, sdk_core_1.getIsUnsignedSweep)({ userKey, backupKey, isTss: params.isTss })) {
+            return this.buildUnsignedSweepTxnTSS(params);
+        }
+        // Signed sweep: decrypt MPC v2 key shares
+        const { userKeyShare, backupKeyShare, commonKeyChain } = await sdk_core_1.ECDSAUtils.getMpcV2RecoveryKeyShares(userKey, backupKey, params.walletPassphrase);
+        const MPC = new sdk_core_1.Ecdsa();
+        const derivedCommonKeyChain = MPC.deriveUnhardened(commonKeyChain, 'm/0');
+        const backupKeyPair = new abstract_eth_1.KeyPair({ pub: derivedCommonKeyChain.slice(0, 66) });
+        const baseAddress = backupKeyPair.getAddress();
+        const { tx: unsignedTx } = await this.buildTempoSweepTx(baseAddress, params);
+        const serializedHex = await unsignedTx.serialize();
+        // Hash the unsigned 0x76 tx — matches Tip20TransactionBuilder's own signing logic
+        const msgHashHex = ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.arrayify(serializedHex));
+        const messageHash = Buffer.from(msgHashHex.replace('0x', ''), 'hex');
+        const signature = await sdk_core_1.ECDSAUtils.signRecoveryMpcV2(messageHash, userKeyShare, backupKeyShare, commonKeyChain);
+        // ECDSAMethodTypes.Signature.r/s are 64-char hex WITHOUT 0x prefix
+        unsignedTx.setSignature({
+            r: `0x${signature.r}`,
+            s: `0x${signature.s}`,
+            yParity: signature.recid,
+        });
+        const signedHex = await unsignedTx.serialize();
+        const txId = ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.arrayify(signedHex));
+        return { id: txId, tx: signedHex };
+    }
+    /**
+     * Builds an unsigned TIP-20 sweep transaction for the offline vault (unsigned sweep path).
+     * Called by recoverTSS when plain public key shares are provided.
+     */
+    async buildUnsignedSweepTxnTSS(params) {
+        const backupKey = params.backupKey.replace(/\s/g, '');
+        const derivationPath = params.derivationSeed ? (0, sdk_lib_mpc_1.getDerivationPath)(params.derivationSeed) : 'm/0';
+        const MPC = new sdk_core_1.Ecdsa();
+        const derivedCommonKeyChain = MPC.deriveUnhardened(backupKey, derivationPath);
+        const backupKeyPair = new abstract_eth_1.KeyPair({ pub: derivedCommonKeyChain.slice(0, 66) });
+        const baseAddress = backupKeyPair.getAddress();
+        const { tx, nonce, sweepAmount, gasMarginUnits } = await this.buildTempoSweepTx(baseAddress, params);
+        const serializedHex = await tx.serialize();
+        const serializedTxHex = serializedHex.replace('0x', '');
+        const signableHex = ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.arrayify(serializedHex)).replace('0x', '');
+        return {
+            txRequests: [
+                {
+                    walletCoin: this.getChain(),
+                    transactions: [
+                        {
+                            unsignedTx: {
+                                serializedTxHex,
+                                signableHex,
+                                derivationPath,
+                                feeInfo: {
+                                    fee: Number(gasMarginUnits),
+                                    feeString: (0, utils_1.tip20UnitsToAmount)(gasMarginUnits),
+                                },
+                                parsedTx: {
+                                    spendAmount: (0, utils_1.tip20UnitsToAmount)(sweepAmount),
+                                    outputs: [
+                                        {
+                                            coinName: this.getChain(),
+                                            address: params.recoveryDestination,
+                                            valueString: (0, utils_1.tip20UnitsToAmount)(sweepAmount),
+                                        },
+                                    ],
+                                },
+                                coinSpecific: { commonKeyChain: backupKey },
+                                eip1559: params.eip1559,
+                                replayProtectionOptions: params.replayProtectionOptions,
+                            },
+                            nonce,
+                            signatureShares: [],
+                        },
+                    ],
+                },
+            ],
+        };
     }
     /**
-     * Sign a transaction
-     * @param params
+     * Get transaction builder for Tempo.
      */
-    async signTransaction(params) {
-        // TODO: Implement transaction signing
-        return {};
+    getTransactionBuilder(common) {
+        return new lib_1.Tip20TransactionBuilder(statics_1.coins.get(this.getBaseChain()));
     }
 }
 exports.Tempo = Tempo;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tempo.js","sourceRoot":"","sources":["../../src/tempo.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport {\n  AbstractEthLikeNewCoins,\n  RecoverOptions,\n  OfflineVaultTxInfo,\n  UnsignedSweepTxMPCv2,\n  RecoveryInfo,\n  TransactionBuilder,\n  VerifyEthTransactionOptions,\n  VerifyEthAddressOptions,\n  TssVerifyEthAddressOptions,\n  optionalDeps,\n  KeyPair,\n} from '@bitgo-beta/abstract-eth';\nimport type * as EthLikeCommon from '@ethereumjs/common';\nimport {\n  BaseCoin,\n  BitGoBase,\n  InvalidAddressError,\n  InvalidMemoIdError,\n  MPCAlgorithm,\n  ParseTransactionOptions,\n  ParsedTransaction,\n  UnexpectedAddressError,\n  PopulatedIntent,\n  PrebuildTransactionWithIntentOptions,\n  common,\n  Ecdsa,\n  ECDSAUtils,\n  getIsUnsignedSweep,\n} from '@bitgo-beta/sdk-core';\nimport { getDerivationPath } from '@bitgo-beta/sdk-lib-mpc';\nimport { BaseCoin as StaticsBaseCoin, coins } from '@bitgo-beta/statics';\nimport { ethers } from 'ethers';\nimport { Tip20Transaction, Tip20TransactionBuilder } from './lib';\nimport {\n  amountToTip20Units,\n  tip20UnitsToAmount,\n  isTip20Transaction,\n  isValidMemoId as isValidMemoIdUtil,\n} from './lib/utils';\nimport { MAINNET_COIN, PATH_USD_TOKEN_MAINNET, PATH_USD_TOKEN_TESTNET } from './lib/constants';\nimport * as url from 'url';\nimport * as querystring from 'querystring';\n\nexport class Tempo extends AbstractEthLikeNewCoins {\n  protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo, staticsCoin);\n  }\n\n  /**\n   * Factory method to create Tempo instance\n   */\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Tempo(bitgo, staticsCoin);\n  }\n\n  /**\n   * Get the chain identifier\n   */\n  getChain(): string {\n    return this._staticsCoin?.name || 'tempo';\n  }\n\n  /**\n   * Get the full chain name\n   */\n  getFullName(): string {\n    return 'Tempo';\n  }\n\n  /** @inheritdoc */\n  getBaseFactor(): number {\n    return 1e6;\n  }\n\n  /**\n   * Check if value-less transfers are allowed\n   * EVM-based chains allow zero-value transfers for smart contract interactions\n   */\n  valuelessTransferAllowed(): boolean {\n    return true;\n  }\n\n  /**\n   * Check if TSS is supported\n   */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /**\n   * Get the MPC algorithm (ECDSA for EVM chains)\n   */\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'ecdsa';\n  }\n\n  /**\n   * Evaluates whether an address string is valid for Tempo\n   * Supports addresses with optional memoId query parameter (e.g., 0x...?memoId=123)\n   * @param address - The address to validate\n   * @returns true if address is valid\n   */\n  isValidAddress(address: string): boolean {\n    if (typeof address !== 'string') {\n      return false;\n    }\n\n    try {\n      const { baseAddress } = this.getAddressDetails(address);\n      return optionalDeps.ethUtil.isValidAddress(optionalDeps.ethUtil.addHexPrefix(baseAddress));\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Parse address into base address and optional memoId\n   * Throws InvalidAddressError for invalid address formats\n   * @param address - Address string, potentially with ?memoId=X suffix\n   * @returns Object containing address, baseAddress, and memoId (null if not present)\n   * @throws InvalidAddressError if address format is invalid\n   */\n  getAddressDetails(address: string): { address: string; baseAddress: string; memoId: string | null } {\n    if (typeof address !== 'string') {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    const destinationDetails = url.parse(address);\n    const baseAddress = destinationDetails.pathname || '';\n\n    // No query string - just a plain address\n    if (destinationDetails.pathname === address) {\n      return {\n        address,\n        baseAddress: address,\n        memoId: null,\n      };\n    }\n\n    // Has query string - must contain memoId\n    if (!destinationDetails.query) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    const queryDetails = querystring.parse(destinationDetails.query);\n\n    // Query string must contain memoId\n    if (!queryDetails.memoId) {\n      throw new InvalidAddressError(`invalid address: ${address}, unknown query parameters`);\n    }\n\n    // Only one memoId allowed\n    if (Array.isArray(queryDetails.memoId)) {\n      throw new InvalidAddressError(\n        `memoId may only be given at most once, but found ${queryDetails.memoId.length} instances in address ${address}`\n      );\n    }\n\n    // Reject if there are other query parameters besides memoId\n    const queryKeys = Object.keys(queryDetails);\n    if (queryKeys.length !== 1) {\n      throw new InvalidAddressError(`invalid address: ${address}, only memoId query parameter is allowed`);\n    }\n\n    // Validate memoId format\n    if (!this.isValidMemoId(queryDetails.memoId)) {\n      throw new InvalidMemoIdError(`invalid address: '${address}', memoId is not valid`);\n    }\n\n    return {\n      address,\n      baseAddress,\n      memoId: queryDetails.memoId,\n    };\n  }\n\n  /**\n   * Validate that a memoId is a valid non-negative integer string\n   * @param memoId - The memoId to validate\n   * @returns true if valid\n   */\n  isValidMemoId(memoId: string): boolean {\n    return isValidMemoIdUtil(memoId);\n  }\n\n  /**\n   * Tempo uses memoId-based addresses rather than forwarder contracts.\n   * Verify that the address belongs to this wallet by checking that the\n   * base (EVM) portion matches the wallet's base address.\n   */\n  async isWalletAddress(params: VerifyEthAddressOptions | TssVerifyEthAddressOptions): Promise<boolean> {\n    const { address, baseAddress } = params;\n    const rootAddress = (params as unknown as Record<string, unknown>).rootAddress as string | undefined;\n\n    if (!address) {\n      throw new InvalidAddressError('address is required');\n    }\n\n    if (!this.isValidAddress(address)) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    const { baseAddress: addressBase } = this.getAddressDetails(address);\n\n    const walletBaseAddress = baseAddress || rootAddress;\n    if (!walletBaseAddress) {\n      throw new InvalidAddressError('baseAddress or rootAddress is required for verification');\n    }\n\n    const { baseAddress: walletBase } = this.getAddressDetails(walletBaseAddress);\n\n    if (addressBase.toLowerCase() !== walletBase.toLowerCase()) {\n      throw new UnexpectedAddressError(`address validation failure: expected ${walletBase} but got ${addressBase}`);\n    }\n\n    return true;\n  }\n\n  /**\n   * Parse a serialised Tempo transaction and return its operations as SDK outputs.\n   * @inheritdoc\n   */\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    const txHex = (params.txHex || (params as any).halfSigned?.txHex) as string | undefined;\n    if (!txHex) {\n      return {};\n    }\n    if (!isTip20Transaction(txHex)) {\n      return {};\n    }\n    const txBuilder = this.getTransactionBuilder();\n    txBuilder.from(txHex);\n    const tx = (await txBuilder.build()) as Tip20Transaction;\n    return {\n      inputs: tx.inputs.map((input) => ({\n        address: input.address,\n        amount: input.value,\n        coin: this.getChain(),\n      })),\n      outputs: tx.outputs.map((output) => ({\n        address: output.address,\n        amount: output.value,\n        coin: this.getChain(),\n      })),\n    };\n  }\n\n  /**\n   * Verify that a Tempo transaction matches the intended recipients and amounts.\n   * @inheritdoc\n   */\n  async verifyTransaction(params: VerifyEthTransactionOptions): Promise<boolean> {\n    const { txParams, txPrebuild } = params;\n\n    if (!txPrebuild?.txHex) {\n      return true;\n    }\n\n    // signableHex may arrive without the 0x prefix (e.g. from the TSS signing flow).\n    const txHex = txPrebuild.txHex.startsWith('0x') ? txPrebuild.txHex : '0x' + txPrebuild.txHex;\n    if (!isTip20Transaction(txHex)) {\n      throw new Error(`Invalid Tempo transaction hex: expected a 0x76 TIP-20 transaction`);\n    }\n\n    const txBuilder = this.getTransactionBuilder();\n    txBuilder.from(txHex);\n    const tx = (await txBuilder.build()) as Tip20Transaction;\n    const operations = tx.getOperations();\n    const rawCalls = tx.getRawCalls();\n\n    // If the caller specified explicit recipients, verify they match the transaction.\n    // A transaction is either all token transfer operations OR a single raw contract call — never mixed.\n    const recipients = txParams?.recipients;\n    if (recipients && recipients.length > 0) {\n      if (rawCalls.length > 0) {\n        // Contract call transaction — single raw call, single recipient with data\n        if (rawCalls.length !== recipients.length) {\n          throw new Error(\n            `Transaction has ${rawCalls.length} call(s) but ${recipients.length} recipient(s) were requested`\n          );\n        }\n        for (let i = 0; i < rawCalls.length; i++) {\n          const rawCall = rawCalls[i];\n          const recipient = recipients[i];\n          if (rawCall.to.toLowerCase() !== recipient.address.split('?')[0].toLowerCase()) {\n            throw new Error(`Raw call ${i} address mismatch: expected ${recipient.address}, got ${rawCall.to}`);\n          }\n          if (!recipient.data || rawCall.data.toLowerCase() !== recipient.data.toLowerCase()) {\n            throw new Error(`Raw call ${i} calldata mismatch`);\n          }\n        }\n      } else {\n        // Token transfer transaction — operations matched 1-to-1 against recipients\n        if (operations.length !== recipients.length) {\n          throw new Error(\n            `Transaction has ${operations.length} operation(s) but ${recipients.length} recipient(s) were requested`\n          );\n        }\n        for (let i = 0; i < operations.length; i++) {\n          const op = operations[i];\n          const recipient = recipients[i];\n          const recipientBaseAddress = recipient.address.split('?')[0];\n          if (op.to.toLowerCase() !== recipientBaseAddress.toLowerCase()) {\n            throw new Error(`Operation ${i} recipient mismatch: expected ${recipient.address}, got ${op.to}`);\n          }\n          const opAmountBaseUnits = amountToTip20Units(op.amount).toString();\n          if (opAmountBaseUnits !== recipient.amount.toString()) {\n            throw new Error(`Operation ${i} amount mismatch: expected ${recipient.amount}, got ${opAmountBaseUnits}`);\n          }\n        }\n      }\n    }\n\n    // Verify fee token if specified\n    if (txParams?.feeToken) {\n      const txFeeToken = tx.getFeeToken();\n      if (txFeeToken?.toLowerCase() !== txParams.feeToken.toLowerCase()) {\n        throw new Error(`Fee token mismatch: expected ${txParams.feeToken}, got ${txFeeToken || 'none'}`);\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Set coin-specific fields in the intent for Tempo TSS transactions.\n   * Ensures feeToken is properly wired through the intent for Tempo transactions.\n   * @param intent - The populated intent to modify\n   * @param params - The parameters containing feeToken\n   */\n  setCoinSpecificFieldsInIntent(intent: PopulatedIntent, params: PrebuildTransactionWithIntentOptions): void {\n    if (params.feeToken) {\n      intent.feeOptions = intent.feeOptions\n        ? { ...intent.feeOptions, feeToken: params.feeToken }\n        : { feeToken: params.feeToken };\n    }\n  }\n\n  /**\n   * Query the Tempo Alchemy RPC for recovery balance/nonce information.\n   * Routes through queryTempoRpc using the URL from environments.ts.\n   */\n  async recoveryBlockchainExplorerQuery(\n    query: Record<string, string>,\n    apiKey?: string\n  ): Promise<Record<string, unknown>> {\n    const evmConfig = common.Environments[this.bitgo.getEnv()].evm;\n    const coinFamily = this.getFamily();\n    if (!evmConfig || !(coinFamily in evmConfig)) {\n      throw new Error(`env config missing for ${coinFamily} in ${this.bitgo.getEnv()}`);\n    }\n    const token = apiKey || evmConfig[coinFamily].apiToken;\n    const rpcUrl = evmConfig[coinFamily].baseUrl;\n    return this.queryTempoRpc(query, rpcUrl, token);\n  }\n\n  /**\n   * Translates Etherscan-style recovery queries into Tempo Alchemy JSON-RPC calls.\n   *\n   * Supported:\n   *   account/balance      → returns { result: '0' } (no native coin on Tempo)\n   *   account/tokenbalance → eth_call (balanceOf selector 0x70a08231) → { result: decimalString }\n   *   account/txlist       → eth_getTransactionCount → { nonce: number }\n   */\n  private async queryTempoRpc(\n    query: Record<string, string>,\n    rpcUrl: string,\n    apiKey?: string\n  ): Promise<Record<string, unknown>> {\n    const endpoint = apiKey ? `${rpcUrl}${apiKey}` : rpcUrl;\n    const { module, action, address, contractaddress, tag } = query;\n\n    let method: string;\n    let params: unknown[];\n\n    if (module === 'account' && action === 'balance') {\n      return { result: '0' };\n    } else if (module === 'account' && action === 'tokenbalance') {\n      const paddedAddr = (address ?? '').replace(/^0x/, '').padStart(64, '0');\n      method = 'eth_call';\n      params = [{ to: contractaddress, data: '0x70a08231' + paddedAddr }, tag ?? 'latest'];\n    } else if (module === 'account' && action === 'txlist') {\n      method = 'eth_getTransactionCount';\n      params = [address, 'latest'];\n    } else {\n      throw new Error(`queryTempoRpc: unsupported module=${module} action=${action}`);\n    }\n\n    const res = await fetch(endpoint, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json' },\n      body: JSON.stringify({ jsonrpc: '2.0', method, params, id: 1 }),\n    });\n\n    if (!res.ok) {\n      throw new Error(`Could not reach Tempo RPC endpoint (HTTP ${res.status})`);\n    }\n\n    const body = (await res.json()) as { result?: unknown; error?: { message: string } };\n    if (body.error) {\n      throw new Error(`Tempo RPC error: ${body.error.message}`);\n    }\n\n    if (module === 'account' && action === 'txlist') {\n      return { nonce: parseInt(body.result as string, 16) };\n    }\n\n    try {\n      return { result: BigInt(body.result as string).toString() };\n    } catch {\n      return { result: '0' };\n    }\n  }\n\n  /**\n   * Shared helper: queries the token balance, computes sweep amount, and builds\n   * an unsigned TIP-20 transfer transaction. Used by both recovery paths.\n   *\n   * - tokenContractAddress: the token to sweep (defaults to pathUSD)\n   * - feeToken: always pathUSD\n   * - If sweeping pathUSD itself, reserves gasLimit × maxFeePerGas / 10^12 pathUSD units for fees.\n   */\n  private async buildTempoSweepTx(\n    walletAddress: string,\n    params: RecoverOptions\n  ): Promise<{ tx: Tip20Transaction; nonce: number; sweepAmount: bigint; gasMarginUnits: bigint }> {\n    if (!params.tokenContractAddress) {\n      throw new Error('tokenContractAddress is required for sweep');\n    }\n    const tokenAddress = params.tokenContractAddress;\n\n    const pathUsdTokenName = this.getChain() === MAINNET_COIN ? PATH_USD_TOKEN_MAINNET : PATH_USD_TOKEN_TESTNET;\n    const pathUsdAddress = (coins.get(pathUsdTokenName) as unknown as { contractAddress: string }).contractAddress;\n\n    const rawBalance = await this.queryAddressTokenBalance(tokenAddress, walletAddress, params.apiKey);\n    const balance = BigInt(rawBalance.toString());\n\n    const isPathUsd = tokenAddress.toLowerCase() === pathUsdAddress.toLowerCase();\n    const gasLimitBig = BigInt(params.gasLimit ?? 700_000);\n    const maxFeePerGasBig = BigInt(params.eip1559?.maxFeePerGas ?? 20_000_000_000);\n    // 75% buffer on top of gasLimit × maxFeePerGas to cover actual on-chain gas variance\n    const gasMarginUnits = (gasLimitBig * maxFeePerGasBig * 175n) / (10n ** 12n * 100n);\n    const sweepAmount = isPathUsd ? balance - gasMarginUnits : balance;\n\n    if (sweepAmount <= 0n) {\n      throw new Error(\n        `Insufficient balance in ${tokenAddress}: ${balance} units (minimum required: ${\n          isPathUsd ? gasMarginUnits + 1n : 1n\n        })`\n      );\n    }\n\n    const sweepAmountHuman = tip20UnitsToAmount(sweepAmount);\n    const nonce = await this.getAddressNonce(walletAddress, params.apiKey);\n\n    const txBuilder = this.getTransactionBuilder() as unknown as Tip20TransactionBuilder;\n    txBuilder\n      .addOperation({ token: tokenAddress, to: params.recoveryDestination, amount: sweepAmountHuman })\n      .feeToken(pathUsdAddress)\n      .nonce(nonce)\n      .gas(gasLimitBig)\n      .maxFeePerGas(maxFeePerGasBig)\n      .maxPriorityFeePerGas(BigInt(params.eip1559?.maxPriorityFeePerGas ?? 10_000_000_000));\n\n    const tx = (await txBuilder.build()) as Tip20Transaction;\n    return { tx, nonce, sweepAmount, gasMarginUnits };\n  }\n\n  /**\n   * Overrides the base-class recoverTSS to use TIP-20 transactions instead of standard ETH.\n   *\n   * Two paths:\n   *   - Unsigned sweep (plain public key shares): delegates to buildUnsignedSweepTxnTSS\n   *   - Signed sweep (encrypted keys + passphrase): builds and signs a TIP-20 tx via MPC\n   */\n  protected async recoverTSS(\n    params: RecoverOptions\n  ): Promise<RecoveryInfo | OfflineVaultTxInfo | UnsignedSweepTxMPCv2> {\n    this.validateRecoveryParams(params);\n    const userKey = params.userKey.replace(/\\s/g, '');\n    const backupKey = params.backupKey.replace(/\\s/g, '');\n\n    if (getIsUnsignedSweep({ userKey, backupKey, isTss: params.isTss })) {\n      return this.buildUnsignedSweepTxnTSS(params);\n    }\n\n    // Signed sweep: decrypt MPC v2 key shares\n    const { userKeyShare, backupKeyShare, commonKeyChain } = await ECDSAUtils.getMpcV2RecoveryKeyShares(\n      userKey,\n      backupKey,\n      params.walletPassphrase\n    );\n\n    const MPC = new Ecdsa();\n    const derivedCommonKeyChain = MPC.deriveUnhardened(commonKeyChain, 'm/0');\n    const backupKeyPair = new KeyPair({ pub: derivedCommonKeyChain.slice(0, 66) });\n    const baseAddress = backupKeyPair.getAddress();\n\n    const { tx: unsignedTx } = await this.buildTempoSweepTx(baseAddress, params);\n    const serializedHex = await unsignedTx.serialize();\n\n    // Hash the unsigned 0x76 tx — matches Tip20TransactionBuilder's own signing logic\n    const msgHashHex = ethers.utils.keccak256(ethers.utils.arrayify(serializedHex));\n    const messageHash = Buffer.from(msgHashHex.replace('0x', ''), 'hex');\n\n    const signature = await ECDSAUtils.signRecoveryMpcV2(messageHash, userKeyShare, backupKeyShare, commonKeyChain);\n\n    // ECDSAMethodTypes.Signature.r/s are 64-char hex WITHOUT 0x prefix\n    unsignedTx.setSignature({\n      r: `0x${signature.r}`,\n      s: `0x${signature.s}`,\n      yParity: signature.recid,\n    });\n\n    const signedHex = await unsignedTx.serialize();\n    const txId = ethers.utils.keccak256(ethers.utils.arrayify(signedHex));\n    return { id: txId, tx: signedHex };\n  }\n\n  /**\n   * Builds an unsigned TIP-20 sweep transaction for the offline vault (unsigned sweep path).\n   * Called by recoverTSS when plain public key shares are provided.\n   */\n  protected async buildUnsignedSweepTxnTSS(params: RecoverOptions): Promise<OfflineVaultTxInfo | UnsignedSweepTxMPCv2> {\n    const backupKey = params.backupKey.replace(/\\s/g, '');\n    const derivationPath = params.derivationSeed ? getDerivationPath(params.derivationSeed) : 'm/0';\n    const MPC = new Ecdsa();\n    const derivedCommonKeyChain = MPC.deriveUnhardened(backupKey, derivationPath);\n    const backupKeyPair = new KeyPair({ pub: derivedCommonKeyChain.slice(0, 66) });\n    const baseAddress = backupKeyPair.getAddress();\n\n    const { tx, nonce, sweepAmount, gasMarginUnits } = await this.buildTempoSweepTx(baseAddress, params);\n    const serializedHex = await tx.serialize();\n    const serializedTxHex = serializedHex.replace('0x', '');\n    const signableHex = ethers.utils.keccak256(ethers.utils.arrayify(serializedHex)).replace('0x', '');\n\n    return {\n      txRequests: [\n        {\n          walletCoin: this.getChain(),\n          transactions: [\n            {\n              unsignedTx: {\n                serializedTxHex,\n                signableHex,\n                derivationPath,\n                feeInfo: {\n                  fee: Number(gasMarginUnits),\n                  feeString: tip20UnitsToAmount(gasMarginUnits),\n                },\n                parsedTx: {\n                  spendAmount: tip20UnitsToAmount(sweepAmount),\n                  outputs: [\n                    {\n                      coinName: this.getChain(),\n                      address: params.recoveryDestination,\n                      valueString: tip20UnitsToAmount(sweepAmount),\n                    },\n                  ],\n                },\n                coinSpecific: { commonKeyChain: backupKey },\n                eip1559: params.eip1559,\n                replayProtectionOptions: params.replayProtectionOptions,\n              },\n              nonce,\n              signatureShares: [],\n            },\n          ],\n        },\n      ],\n    };\n  }\n\n  /**\n   * Get transaction builder for Tempo.\n   */\n  protected getTransactionBuilder(common?: EthLikeCommon.default): TransactionBuilder {\n    return new Tip20TransactionBuilder(coins.get(this.getBaseChain())) as unknown as TransactionBuilder;\n  }\n}\n"]}