feat(abstract-eth): add recover consolidation for eth

ticket: WIN-5700

Author: abhi-bitgo

modules/abstract-eth/src/abstractEthLikeNewCoins.ts

@@ -19,6 +19,7 @@ import {
   IWallet,
   KeyPair,
   MPCSweepRecoveryOptions,
+  MPCSweepTxs,
   MPCTx,
   MPCTxs,
   ParsedTransaction,
@@ -55,7 +56,7 @@ import { BigNumber } from 'bignumber.js';
 import BN from 'bn.js';
 import { randomBytes } from 'crypto';
 import debugLib from 'debug';
-import { addHexPrefix, stripHexPrefix } from 'ethereumjs-util';
+import { addHexPrefix, stripHexPrefix, bufferToHex, setLengthLeft, toBuffer } from 'ethereumjs-util';
 import Keccak from 'keccak';
 import _ from 'lodash';
 import secp256k1 from 'secp256k1';
@@ -68,6 +69,7 @@ import {
   ERC721TransferBuilder,
   getBufferedByteCode,
   getCommon,
+  getCreateForwarderParamsAndTypes,
   getProxyInitcode,
   getRawDecoded,
   getToken,
@@ -359,6 +361,33 @@ interface EthAddressCoinSpecifics extends AddressCoinSpecific {
   salt?: string;
 }
 
+export const DEFAULT_SCAN_FACTOR = 20;
+export interface EthConsolidationRecoveryOptions {
+  coinName: string;
+  walletContractAddress?: string;
+  apiKey: string;
+  isTss: boolean;
+  userKey: string;
+  backupKey: string;
+  walletPassphrase?: string;
+  recoveryDestination: string;
+  krsProvider?: string;
+  gasPrice?: number;
+  gasLimit?: number;
+  eip1559?: EIP1559;
+  replayProtectionOptions?: ReplayProtectionOptions;
+  bitgoFeeAddress?: string;
+  bitgoDestinationAddress?: string;
+  tokenContractAddress?: string;
+  intendedChain?: string;
+  common?: EthLikeCommon.default;
+  derivationSeed?: string;
+  bitgoKey: string;
+  startingScanIndex: number;
+  endingScanIndex: number;
+  ignoreAddressTypes?: unknown;
+}
+
 export interface VerifyEthAddressOptions extends BaseVerifyAddressOptions {
   baseAddress: string;
   coinSpecific: EthAddressCoinSpecifics;
@@ -1181,6 +1210,144 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
     return this.recoverEthLike(params);
   }
 
+  generateForwarderAddress(
+    baseAddress: string,
+    feeAddress: string,
+    forwarderFactoryAddress: string,
+    forwarderImplementationAddress: string,
+    index: number
+  ): string {
+    const salt = addHexPrefix(index.toString(16));
+    const saltBuffer = setLengthLeft(toBuffer(salt), 32);
+
+    const { createForwarderParams, createForwarderTypes } = getCreateForwarderParamsAndTypes(
+      baseAddress,
+      saltBuffer,
+      feeAddress
+    );
+
+    const calculationSalt = bufferToHex(optionalDeps.ethAbi.soliditySHA3(createForwarderTypes, createForwarderParams));
+
+    const initCode = getProxyInitcode(forwarderImplementationAddress);
+    return calculateForwarderV1Address(forwarderFactoryAddress, calculationSalt, initCode);
+  }
+
+  deriveAddressFromPublicKey(publicKey: string): string {
+    const keyPair = new KeyPairLib({ pub: publicKey });
+    const address = keyPair.getAddress();
+    return address;
+  }
+
+  getConsolidationAddress(params: EthConsolidationRecoveryOptions, index: number): string {
+    if (params.walletContractAddress && params.bitgoFeeAddress) {
+      const ethNetwork = this.getNetwork();
+      const forwarderFactoryAddress = ethNetwork?.walletV4ForwarderFactoryAddress as string;
+      const forwarderImplementationAddress = ethNetwork?.walletV4ForwarderImplementationAddress as string;
+      try {
+        return this.generateForwarderAddress(
+          params.walletContractAddress,
+          params.bitgoFeeAddress,
+          forwarderFactoryAddress,
+          forwarderImplementationAddress,
+          index
+        );
+      } catch (e) {
+        console.log(`Failed to generate forwarder address: ${e.message}`);
+      }
+    }
+
+    if (params.userKey) {
+      try {
+        return this.deriveAddressFromPublicKey(params.userKey);
+      } catch (e) {
+        console.log(`Failed to generate derived address: ${e.message}`);
+      }
+    }
+    throw new Error(
+      'Unable to generate consolidation address. Check that wallet contract address, fee address, or user key is valid.'
+    );
+  }
+
+  async recoverConsolidations(params: EthConsolidationRecoveryOptions): Promise<Record<string, unknown> | undefined> {
+    const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;
+    const startIdx = params.startingScanIndex || 1;
+    const endIdx = params.endingScanIndex || startIdx + DEFAULT_SCAN_FACTOR;
+
+    if (!params.walletContractAddress || params.walletContractAddress === '') {
+      throw new Error(`Invalid wallet contract address ${params.walletContractAddress}`);
+    }
+
+    if (!params.bitgoFeeAddress || params.bitgoFeeAddress === '') {
+      throw new Error(`Invalid fee address ${params.bitgoFeeAddress}`);
+    }
+
+    if (startIdx < 1 || endIdx <= startIdx || endIdx - startIdx > 10 * DEFAULT_SCAN_FACTOR) {
+      throw new Error(
+        `Invalid starting or ending index to scan for addresses. startingScanIndex: ${startIdx}, endingScanIndex: ${endIdx}.`
+      );
+    }
+
+    const consolidationTransactions: any[] = [];
+    let lastScanIndex = startIdx;
+
+    for (let i = startIdx; i < endIdx; i++) {
+      const consolidationAddress = this.getConsolidationAddress(params, i);
+
+      const recoverParams = {
+        apiKey: params.apiKey,
+        backupKey: params.backupKey,
+        gasLimit: params.gasLimit,
+        recoveryDestination: params.recoveryDestination,
+        userKey: params.userKey,
+        walletContractAddress: consolidationAddress,
+        derivationSeed: '',
+        isTss: params.isTss,
+        eip1559: {
+          maxFeePerGas: params.eip1559?.maxFeePerGas || 20,
+          maxPriorityFeePerGas: params.eip1559?.maxPriorityFeePerGas || 200000,
+        },
+        replayProtectionOptions: {
+          chain: params.replayProtectionOptions?.chain || 0,
+          hardfork: params.replayProtectionOptions?.hardfork || 'london',
+        },
+        bitgoKey: '',
+        ignoreAddressTypes: [],
+      };
+
+      let recoveryTransaction;
+      try {
+        recoveryTransaction = await this.recover(recoverParams);
+      } catch (e) {
+        if (
+          e.message === 'Did not find address with funds to recover' ||
+          e.message === 'Did not find token account to recover tokens, please check token account' ||
+          e.message === 'Not enough token funds to recover'
+        ) {
+          lastScanIndex = i;
+          continue;
+        }
+        throw e;
+      }
+
+      if (isUnsignedSweep) {
+        consolidationTransactions.push((recoveryTransaction as MPCSweepTxs).txRequests[0]);
+      } else {
+        consolidationTransactions.push(recoveryTransaction);
+      }
+
+      lastScanIndex = i;
+    }
+
+    if (consolidationTransactions.length === 0) {
+      throw new Error(
+        `Did not find an address with sufficient funds to recover. Please start the next scan at address index ${
+          lastScanIndex + 1
+        }.`
+      );
+    }
+    return { transactions: consolidationTransactions, lastScanIndex };
+  }
+
   /**
    * Builds a funds recovery transaction without BitGo for non-TSS transaction
    * @param params

modules/statics/src/networks.ts

@@ -120,6 +120,8 @@ export interface EthereumNetwork extends AccountNetwork {
   readonly forwarderImplementationAddress?: string;
   readonly nativeCoinOperationHashPrefix?: string;
   readonly tokenOperationHashPrefix?: string;
+  readonly walletV4ForwarderFactoryAddress?: string;
+  readonly walletV4ForwarderImplementationAddress?: string;
 }
 
 export interface TronNetwork extends AccountNetwork {
@@ -544,6 +546,8 @@ class Ethereum extends Mainnet implements EthereumNetwork {
   forwarderImplementationAddress = '0x059ffafdc6ef594230de44f824e2bd0a51ca5ded';
   nativeCoinOperationHashPrefix = 'ETHER';
   tokenOperationHashPrefix = 'ERC20';
+  walletV4ForwarderFactoryAddress = '0x37996e762fa8b671869740c79eb33f625b3bf92a';
+  walletV4ForwarderImplementationAddress = '0xd5fe1c1f216b775dfd30638fa7164d41321ef79b';
 }
 
 class Ethereum2 extends Mainnet implements AccountNetwork {
@@ -615,6 +619,8 @@ class Holesky extends Testnet implements EthereumNetwork {
   forwarderImplementationAddress = '0x059ffafdc6ef594230de44f824e2bd0a51ca5ded';
   nativeCoinOperationHashPrefix = 'ETHER';
   tokenOperationHashPrefix = 'ERC20';
+  walletV4ForwarderFactoryAddress = '0x37996e762fa8b671869740c79eb33f625b3bf92a';
+  walletV4ForwarderImplementationAddress = '0xd5fe1c1f216b775dfd30638fa7164d41321ef79b';
 }
 
 class Hoodi extends Testnet implements EthereumNetwork {