feat(root): enable passing apiKey for recovery on eth likes

Ticket: WP-5348

Author: mohammadalfaiyazbitgo

modules/abstract-eth/src/abstractEthLikeNewCoins.ts

@@ -253,6 +253,7 @@ export type RecoverOptions = {
   intendedChain?: string;
   common?: EthLikeCommon.default;
   derivationSeed?: string;
+  apiKey?: string; // optional API key to use instead of the one from the environment
 } & TSSRecoverOptions;
 
 export type GetBatchExecutionInfoRT = {
@@ -529,15 +530,19 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
   /**
    * Query explorer for the balance of an address
    * @param {String} address - the ETHLike address
+   * @param {String} apiKey - optional API key to use instead of the one from the environment
    * @returns {BigNumber} address balance
    */
-  async queryAddressBalance(address: string): Promise<any> {
-    const result = await this.recoveryBlockchainExplorerQuery({
-      chainid: this.getChainId().toString(),
-      module: 'account',
-      action: 'balance',
-      address: address,
-    });
+  async queryAddressBalance(address: string, apiKey?: string): Promise<any> {
+    const result = await this.recoveryBlockchainExplorerQuery(
+      {
+        chainid: this.getChainId().toString(),
+        module: 'account',
+        action: 'balance',
+        address: address,
+      },
+      apiKey
+    );
     // throw if the result does not exist or the result is not a valid number
     if (!result || !result.result || isNaN(result.result)) {
       throw new Error(`Could not obtain address balance for ${address} from the explorer, got: ${result.result}`);
@@ -627,21 +632,25 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
   /**
    * Queries the contract (via explorer API) for the next sequence ID
    * @param {String} address - address of the contract
+   * @param {String} apiKey - optional API key to use instead of the one from the environment
    * @returns {Promise<Number>} sequence ID
    */
-  async querySequenceId(address: string): Promise<number> {
+  async querySequenceId(address: string, apiKey?: string): Promise<number> {
     // Get sequence ID using contract call
     const sequenceIdMethodSignature = optionalDeps.ethAbi.methodID('getNextSequenceId', []);
     const sequenceIdArgs = optionalDeps.ethAbi.rawEncode([], []);
     const sequenceIdData = Buffer.concat([sequenceIdMethodSignature, sequenceIdArgs]).toString('hex');
-    const result = await this.recoveryBlockchainExplorerQuery({
-      chainid: this.getChainId().toString(),
-      module: 'proxy',
-      action: 'eth_call',
-      to: address,
-      data: sequenceIdData,
-      tag: 'latest',
-    });
+    const result = await this.recoveryBlockchainExplorerQuery(
+      {
+        chainid: this.getChainId().toString(),
+        module: 'proxy',
+        action: 'eth_call',
+        to: address,
+        data: sequenceIdData,
+        tag: 'latest',
+      },
+      apiKey
+    );
     if (!result || !result.result) {
       throw new Error('Could not obtain sequence ID from explorer, got: ' + result.result);
     }
@@ -837,18 +846,22 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
   /**
    * Queries public block explorer to get the next ETHLike coin's nonce that should be used for the given ETH address
    * @param {string} address
+   * @param {string} apiKey - optional API key to use instead of the one from the environment
    * @returns {Promise<number>}
    */
-  async getAddressNonce(address: string): Promise<number> {
+  async getAddressNonce(address: string, apiKey?: string): Promise<number> {
     // Get nonce for backup key (should be 0)
     let nonce = 0;
 
-    const result = await this.recoveryBlockchainExplorerQuery({
-      chainid: this.getChainId().toString(),
-      module: 'account',
-      action: 'txlist',
-      address,
-    });
+    const result = await this.recoveryBlockchainExplorerQuery(
+      {
+        chainid: this.getChainId().toString(),
+        module: 'account',
+        action: 'txlist',
+        address,
+      },
+      apiKey
+    );
     if (!result || !Array.isArray(result.result)) {
       throw new Error('Unable to find next nonce from Etherscan, got: ' + JSON.stringify(result));
     }
@@ -1630,24 +1643,32 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
    * Query explorer for the balance of an address for a token
    * @param {string} tokenContractAddress - address where the token smart contract is hosted
    * @param {string} walletContractAddress - address of the wallet
+   * @param {string} apiKey - optional API key to use instead of the one from the environment
    * @returns {BigNumber} token balaance in base units
    */
-  async queryAddressTokenBalance(tokenContractAddress: string, walletContractAddress: string): Promise<any> {
+  async queryAddressTokenBalance(
+    tokenContractAddress: string,
+    walletContractAddress: string,
+    apiKey?: string
+  ): Promise<any> {
     if (!optionalDeps.ethUtil.isValidAddress(tokenContractAddress)) {
       throw new Error('cannot get balance for invalid token address');
     }
     if (!optionalDeps.ethUtil.isValidAddress(walletContractAddress)) {
       throw new Error('cannot get token balance for invalid wallet address');
     }
 
-    const result = await this.recoveryBlockchainExplorerQuery({
-      chainid: this.getChainId().toString(),
-      module: 'account',
-      action: 'tokenbalance',
-      contractaddress: tokenContractAddress,
-      address: walletContractAddress,
-      tag: 'latest',
-    });
+    const result = await this.recoveryBlockchainExplorerQuery(
+      {
+        chainid: this.getChainId().toString(),
+        module: 'account',
+        action: 'tokenbalance',
+        contractaddress: tokenContractAddress,
+        address: walletContractAddress,
+        tag: 'latest',
+      },
+      apiKey
+    );
     // throw if the result does not exist or the result is not a valid number
     if (!result || !result.result || isNaN(result.result)) {
       throw new Error(
@@ -2164,8 +2185,8 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
   }
 
   private async buildTssRecoveryTxn(baseAddress: string, gasPrice: any, gasLimit: any, params: RecoverOptions) {
-    const nonce = await this.getAddressNonce(baseAddress);
-    const txAmount = await this.validateBalanceAndGetTxAmount(baseAddress, gasPrice, gasLimit);
+    const nonce = await this.getAddressNonce(baseAddress, params.apiKey);
+    const txAmount = await this.validateBalanceAndGetTxAmount(baseAddress, gasPrice, gasLimit, params.apiKey);
     const recipients = [
       {
         address: params.recoveryDestination,
@@ -2194,8 +2215,8 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
     return { txInfo, tx, nonce };
   }
 
-  async validateBalanceAndGetTxAmount(baseAddress: string, gasPrice: BN, gasLimit: BN) {
-    const baseAddressBalance = await this.queryAddressBalance(baseAddress);
+  async validateBalanceAndGetTxAmount(baseAddress: string, gasPrice: BN, gasLimit: BN, apiKey?: string) {
+    const baseAddressBalance = await this.queryAddressBalance(baseAddress, apiKey);
     const totalGasNeeded = gasPrice.mul(gasLimit);
     const weiToGwei = new BN(10 ** 9);
     if (baseAddressBalance.lt(totalGasNeeded)) {
@@ -2209,7 +2230,13 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
     return txAmount;
   }
 
-  async recoveryBlockchainExplorerQuery(query: Record<string, string>): Promise<any> {
+  /**
+   * Make a query to blockchain explorer for information such as balance, token balance, solidity calls
+   * @param query {Object} key-value pairs of parameters to append after /api
+   * @param apiKey {string} optional API key to use instead of the one from the environment
+   * @returns {Object} response from the blockchain explorer
+   */
+  async recoveryBlockchainExplorerQuery(query: Record<string, string>, apiKey?: string): Promise<any> {
     throw new Error('method not implemented');
   }
 
@@ -2782,14 +2809,19 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
 
   /**
    * Fetch the gas price from the explorer
+   * @param {string} wrongChainCoin - the coin that we're getting gas price for
+   * @param {string} apiKey - optional API key to use instead of the one from the environment
    */
-  async getGasPriceFromExternalAPI(wrongChainCoin: string): Promise<BN> {
+  async getGasPriceFromExternalAPI(wrongChainCoin: string, apiKey?: string): Promise<BN> {
     try {
-      const res = await this.recoveryBlockchainExplorerQuery({
-        chainid: this.getChainId().toString(),
-        module: 'proxy',
-        action: 'eth_gasPrice',
-      });
+      const res = await this.recoveryBlockchainExplorerQuery(
+        {
+          chainid: this.getChainId().toString(),
+          module: 'proxy',
+          action: 'eth_gasPrice',
+        },
+        apiKey
+      );
       const gasPrice = new BN(res.result.slice(2), 16);
       console.log(` Got gas price: ${gasPrice}`);
       return gasPrice;
@@ -2804,17 +2836,27 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
    * @param from
    * @param to
    * @param data
+   * @param {string} apiKey - optional API key to use instead of the one from the environment
    */
-  async getGasLimitFromExternalAPI(intendedChain: string, from: string, to: string, data: string): Promise<BN> {
+  async getGasLimitFromExternalAPI(
+    intendedChain: string,
+    from: string,
+    to: string,
+    data: string,
+    apiKey?: string
+  ): Promise<BN> {
     try {
-      const res = await this.recoveryBlockchainExplorerQuery({
-        chainid: this.getChainId().toString(),
-        module: 'proxy',
-        action: 'eth_estimateGas',
-        from,
-        to,
-        data,
-      });
+      const res = await this.recoveryBlockchainExplorerQuery(
+        {
+          chainid: this.getChainId().toString(),
+          module: 'proxy',
+          action: 'eth_estimateGas',
+          from,
+          to,
+          data,
+        },
+        apiKey
+      );
       const gasLimit = new BN(res.result.slice(2), 16);
       console.log(`Got gas limit: ${gasLimit}`);
       return gasLimit;

modules/sdk-coin-arbeth/src/arbeth.ts

@@ -35,10 +35,14 @@ export class Arbeth extends AbstractEthLikeNewCoins {
   /**
    * Make a query to Arbiscan for information such as balance, token balance, solidity calls
    * @param {Object} query key-value pairs of parameters to append after /api
+   * @param {string} apiKey optional API key to use instead of the one from the environment
    * @returns {Promise<Object>} response from Arbiscan
    */
-  async recoveryBlockchainExplorerQuery(query: Record<string, string>): Promise<Record<string, unknown>> {
-    const apiToken = common.Environments[this.bitgo.getEnv()].arbiscanApiToken;
+  async recoveryBlockchainExplorerQuery(
+    query: Record<string, string>,
+    apiKey?: string
+  ): Promise<Record<string, unknown>> {
+    const apiToken = apiKey || common.Environments[this.bitgo.getEnv()].arbiscanApiToken;
     const explorerUrl = common.Environments[this.bitgo.getEnv()].arbiscanBaseUrl;
     return await recoveryBlockchainExplorerQuery(query, explorerUrl as string, apiToken);
   }

modules/sdk-coin-avaxc/src/avaxc.ts

@@ -307,9 +307,10 @@ export class AvaxC extends AbstractEthLikeNewCoins {
   /**
    * Make a query to avax.network for information such as balance, token balance, solidity calls
    * @param {Object} query — key-value pairs of parameters to append after /api
+   * @param {string} apiKey - optional API key to use instead of the one from the environment
    * @returns {Promise<Object>} response from avax.network
    */
-  async recoveryBlockchainExplorerQuery(query: Record<string, any>): Promise<any> {
+  async recoveryBlockchainExplorerQuery(query: Record<string, any>, apiKey?: string): Promise<any> {
     const response = await request
       .post(common.Environments[this.bitgo.getEnv()].avaxcNetworkBaseUrl + '/ext/bc/C/rpc')
       .send(query);

modules/sdk-coin-bsc/src/bsc.ts

@@ -40,8 +40,17 @@ export class Bsc extends AbstractEthLikeNewCoins {
     return 'ecdsa';
   }
 
-  async recoveryBlockchainExplorerQuery(query: Record<string, string>): Promise<Record<string, unknown>> {
-    const apiToken = common.Environments[this.bitgo.getEnv()].bscscanApiToken;
+  /**
+   * Make a query to BSCScan for information such as balance, token balance, solidity calls
+   * @param {Object} query key-value pairs of parameters to append after /api
+   * @param {string} apiKey optional API key to use instead of the one from the environment
+   * @returns {Promise<Object>} response from BSCScan
+   */
+  async recoveryBlockchainExplorerQuery(
+    query: Record<string, string>,
+    apiKey?: string
+  ): Promise<Record<string, unknown>> {
+    const apiToken = apiKey || common.Environments[this.bitgo.getEnv()].bscscanApiToken;
     const explorerUrl = common.Environments[this.bitgo.getEnv()].bscscanBaseUrl;
     return await recoveryBlockchainExplorerQuery(query, explorerUrl as string, apiToken);
   }

modules/sdk-coin-coredao/src/coredao.ts

@@ -39,8 +39,17 @@ export class Coredao extends AbstractEthLikeNewCoins {
     return 'ecdsa';
   }
 
-  async recoveryBlockchainExplorerQuery(query: Record<string, string>): Promise<Record<string, unknown>> {
-    const apiToken = common.Environments[this.bitgo.getEnv()].coredaoExplorerApiToken;
+  /**
+   * Make a query to Coredao explorer for information such as balance, token balance, solidity calls
+   * @param {Object} query key-value pairs of parameters to append after /api
+   * @param {string} apiKey optional API key to use instead of the one from the environment
+   * @returns {Promise<Object>} response from Coredao explorer
+   */
+  async recoveryBlockchainExplorerQuery(
+    query: Record<string, string>,
+    apiKey?: string
+  ): Promise<Record<string, unknown>> {
+    const apiToken = apiKey || common.Environments[this.bitgo.getEnv()].coredaoExplorerApiToken;
     const explorerUrl = common.Environments[this.bitgo.getEnv()].coredaoExplorerBaseUrl;
     return await recoveryBlockchainExplorerQuery(query, explorerUrl as string, apiToken);
   }

modules/sdk-coin-eth/src/erc20Token.ts

@@ -207,12 +207,15 @@ export class Erc20Token extends Eth {
     // 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,
-    });
+    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
@@ -221,7 +224,7 @@ export class Erc20Token extends Eth {
     }
 
     // get balance of backup key and make sure we can afford gas
-    const backupKeyBalance = await this.queryAddressBalance(backupKeyAddress);
+    const backupKeyBalance = await this.queryAddressBalance(backupKeyAddress, params.apiKey);
 
     if (backupKeyBalance.lt(gasPrice.mul(gasLimit))) {
       throw new Error(
@@ -232,7 +235,11 @@ export class Erc20Token extends Eth {
     }
 
     // get token balance of wallet
-    const txAmount = await this.queryAddressTokenBalance(this.tokenContractAddress, params.walletContractAddress);
+    const txAmount = await this.queryAddressTokenBalance(
+      this.tokenContractAddress,
+      params.walletContractAddress,
+      params.apiKey
+    );
     if (new BigNumber(txAmount).isLessThanOrEqualTo(0)) {
       throw new Error('Wallet does not have enough funds to recover');
     }
@@ -246,7 +253,7 @@ export class Erc20Token extends Eth {
     ];
 
     // Get sequence ID using contract call
-    const sequenceId = await this.querySequenceId(params.walletContractAddress);
+    const sequenceId = await this.querySequenceId(params.walletContractAddress, params.apiKey);
 
     let operationHash, signature;
     if (!isUnsignedSweep) {
@@ -288,7 +295,17 @@ export class Erc20Token extends Eth {
     });
 
     if (isUnsignedSweep) {
-      return this.formatForOfflineVault(txInfo, tx, userKey, backupKey, gasPrice, gasLimit, params.eip1559) as any;
+      return this.formatForOfflineVault(
+        txInfo,
+        tx,
+        userKey,
+        backupKey,
+        gasPrice,
+        gasLimit,
+        params.eip1559,
+        params.replayProtectionOptions,
+        params.apiKey
+      ) as any;
     }
 
     if (!isKrsRecovery) {