feat(sdk-coin-bsc): added support for mpcv2 in recovery

TICKET: WIN-4618

Author: shashankms288

modules/abstract-eth/src/abstractEthLikeNewCoins.ts

@@ -253,6 +253,7 @@ export type RecoverOptions = {
   intendedChain?: string;
   common?: EthLikeCommon.default;
   derivationSeed?: string;
+  apiKey?: string;
 } & TSSRecoverOptions;
 
 export type GetBatchExecutionInfoRT = {
@@ -531,12 +532,15 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
    * @param {String} address - the ETHLike address
    * @returns {BigNumber} address balance
    */
-  async queryAddressBalance(address: string): Promise<any> {
-    const result = await this.recoveryBlockchainExplorerQuery({
-      module: 'account',
-      action: 'balance',
-      address: address,
-    });
+  async queryAddressBalance(address: string, apiKey?: string): Promise<any> {
+    const result = await this.recoveryBlockchainExplorerQuery(
+      {
+        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}`);
@@ -837,15 +841,18 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
    * @param {string} address
    * @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({
-      module: 'account',
-      action: 'txlist',
-      address,
-    });
+    const result = await this.recoveryBlockchainExplorerQuery(
+      {
+        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));
     }
@@ -1932,7 +1939,7 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
     }
   }
 
-  private async getGasValues(params: RecoverOptions): Promise<{ gasLimit: number; gasPrice: Buffer }> {
+  protected async getGasValues(params: RecoverOptions): Promise<{ gasLimit: number; gasPrice: Buffer }> {
     const gasLimit = new optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit));
     const gasPrice = params.eip1559
       ? new optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)
@@ -2152,9 +2159,9 @@ 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);
+  protected async buildTssRecoveryTxn(baseAddress: string, gasPrice: any, gasLimit: any, params: RecoverOptions) {
+    const nonce = await this.getAddressNonce(baseAddress, params.apiKey);
+    const txAmount = await this.validateBalanceAndGetTxAmount(baseAddress, gasPrice, gasLimit, params.apiKey);
     const recipients = [
       {
         address: params.recoveryDestination,
@@ -2183,8 +2190,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)) {
@@ -2198,7 +2205,7 @@ export abstract class AbstractEthLikeNewCoins extends AbstractEthLikeCoin {
     return txAmount;
   }
 
-  async recoveryBlockchainExplorerQuery(query: Record<string, string>): Promise<any> {
+  async recoveryBlockchainExplorerQuery(query: Record<string, string>, apiKey?: string): Promise<any> {
     throw new Error('method not implemented');
   }
 

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

@@ -1,11 +1,29 @@
-import { BaseCoin, BitGoBase, common, MPCAlgorithm, MultisigType, multisigTypes } from '@bitgo/sdk-core';
+import {
+  BaseCoin,
+  BitGoBase,
+  common,
+  Ecdsa,
+  MPCAlgorithm,
+  MultisigType,
+  multisigTypes,
+  UnsignedTransactionTss,
+} from '@bitgo/sdk-core';
 import { BaseCoin as StaticsBaseCoin, coins } from '@bitgo/statics';
 import {
   AbstractEthLikeNewCoins,
+  KeyPair,
   recoveryBlockchainExplorerQuery,
-  VerifyEthTransactionOptions,
+  ReplayProtectionOptions,
+  UnsignedSweepTxMPCv2,
+  RecoverOptions,
+  OfflineVaultTxInfo,
+  ETHTransactionType,
+  Transaction as EthTransaction,
+  optionalDeps,
 } from '@bitgo/abstract-eth';
 import { TransactionBuilder } from './lib';
+import { getDerivationPath } from '@bitgo/sdk-lib-mpc';
+import EthereumCommon from '@ethereumjs/common';
 
 export class Bsc extends AbstractEthLikeNewCoins {
   protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {
@@ -16,6 +34,180 @@ export class Bsc extends AbstractEthLikeNewCoins {
     return new Bsc(bitgo, staticsCoin);
   }
 
+  /**
+   * Builds an unsigned sweep transaction for TSS specific to BSC
+   * This implementation ensures that only legacy transactions are supported for BSC.
+   * @param params - Recovery options
+   * @returns {Promise<OfflineVaultTxInfo | UnsignedSweepTxMPCv2>}
+   */
+  protected async buildUnsignedSweepTxnTSS(params: RecoverOptions): Promise<OfflineVaultTxInfo | UnsignedSweepTxMPCv2> {
+    const bscParams: RecoverOptions = { ...params };
+
+    if (!bscParams.replayProtectionOptions) {
+      bscParams.replayProtectionOptions = {
+        chain: this.getChain().includes('t') ? '97' : '56',
+        hardfork: 'petersburg',
+      };
+    } else if (!bscParams.replayProtectionOptions.hardfork) {
+      bscParams.replayProtectionOptions.hardfork = 'petersburg';
+    }
+
+    if (!bscParams.gasLimit || !bscParams.gasPrice) {
+      throw new Error('gasLimit and gasPrice are required for BSC legacy transactions');
+    }
+
+    if (!bscParams.backupKey) {
+      throw new Error('backupKey is required for TSS recovery');
+    }
+    if (!bscParams.recoveryDestination) {
+      throw new Error('Recipient address (recoveryDestination) is required for TSS recovery');
+    }
+
+    const { gasLimit, gasPrice } = await this.getGasValues(params);
+
+    const derivationPath = bscParams.derivationSeed ? getDerivationPath(bscParams.derivationSeed) : 'm/0';
+    const MPC = new Ecdsa();
+    const derivedCommonKeyChain = MPC.deriveUnhardened(bscParams.backupKey as string, derivationPath);
+    const backupKeyPair = new KeyPair({ pub: derivedCommonKeyChain.slice(0, 66) });
+    const baseAddress = backupKeyPair.getAddress();
+
+    const { txInfo, tx, nonce } = await this.buildTssRecoveryTxn(baseAddress, gasPrice, gasLimit, bscParams);
+
+    return this.buildTxRequestForOfflineVaultMPCv2bsc(
+      txInfo,
+      tx,
+      derivationPath,
+      nonce,
+      gasPrice,
+      gasLimit,
+      bscParams.replayProtectionOptions,
+      derivedCommonKeyChain
+    );
+  }
+  /**
+   * This transforms the unsigned transaction information into a format the BitGo offline vault expects
+   * Specific to BSC which only supports legacy transactions
+   * @param {any} txInfo
+   * @param {any} tx
+   * @param {string} derivationPath
+   * @param {number} nonce
+   * @param {string} gasPrice
+   * @param {string} gasLimit
+   * @param {undefined} _eip1559Params
+   * @param {ReplayProtectionOptions} replayProtectionOptions
+   * @param {string} commonKeyChain
+   * @returns {UnsignedSweepTxMPCv2}
+   */
+  private buildTxRequestForOfflineVaultMPCv2bsc(
+    txInfo: any,
+    tx: any,
+    derivationPath: string,
+    nonce: any,
+    gasPrice: Buffer,
+    gasLimit: number,
+    replayProtectionOptions: ReplayProtectionOptions | undefined,
+    commonKeyChain: string
+  ): OfflineVaultTxInfo | UnsignedSweepTxMPCv2 {
+    if (!tx.to) {
+      throw new Error('BSC tx must have a `to` address');
+    }
+
+    console.log('tx', tx);
+    const fee = gasLimit * Number(optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed());
+    const txNonce = tx.nonce;
+    const txGasPrice = tx.gasPrice;
+    const txGasLimit = tx.gasLimit;
+    const txTo = tx.to ? tx.to.toBuffer() : Buffer.alloc(0);
+    const txValue = tx.value;
+    const txData = tx.data && tx.data.length > 0 ? tx.data : Buffer.alloc(0);
+    const txFrom = tx.from ? tx.from.toBuffer() : Buffer.alloc(0);
+
+    const txChainId = this.getChain().includes('t') ? 97 : 56;
+
+    let signableHex: string;
+    let serializedTxHex: string;
+
+    try {
+      const txDataObj = {
+        nonce: txNonce,
+        gasPrice: txGasPrice,
+        gasLimit: txGasLimit,
+        to: txTo,
+        value: txValue,
+        data: txData,
+        chainId: txChainId.toString(),
+        _type: ETHTransactionType.LEGACY,
+        from: txFrom,
+      };
+
+      const common = EthereumCommon.forCustomChain(
+        'mainnet',
+        {
+          name: 'bsc',
+          networkId: txChainId,
+          chainId: txChainId,
+        },
+        'petersburg'
+      );
+
+      const bscTx = new EthTransaction(coins.get(this.getChain()), common, txDataObj);
+      const serializedTx = bscTx.toBroadcastFormat();
+      // Remove '0x' prefix if present
+      serializedTxHex = serializedTx.startsWith('0x') ? serializedTx.slice(2) : serializedTx;
+      signableHex = serializedTxHex;
+    } catch (e) {
+      throw new Error(`Failed to encode transaction: ${e.message}`);
+    }
+
+    if (!replayProtectionOptions) {
+      replayProtectionOptions = {
+        chain: txChainId.toString(),
+        hardfork: 'petersburg',
+      };
+    } else if (!replayProtectionOptions.chain) {
+      replayProtectionOptions.chain = txChainId.toString();
+    }
+
+    const unsignedTx: UnsignedTransactionTss = {
+      serializedTxHex: serializedTxHex,
+      signableHex: signableHex,
+      derivationPath: derivationPath,
+      feeInfo: {
+        fee: fee,
+        feeString: fee.toString(),
+      },
+      parsedTx: {
+        spendAmount: txInfo.recipient.amount,
+        outputs: [
+          {
+            coinName: this.getChain(),
+            address: txInfo.recipient.address,
+            valueString: txInfo.recipient.amount,
+          },
+        ],
+      },
+      coinSpecific: {
+        commonKeyChain: commonKeyChain,
+      },
+      replayProtectionOptions: replayProtectionOptions,
+    };
+
+    return {
+      txRequests: [
+        {
+          walletCoin: this.getChain(),
+          transactions: [
+            {
+              unsignedTx: unsignedTx,
+              nonce: nonce,
+              signatureShares: [],
+            },
+          ],
+        },
+      ],
+    };
+  }
+
   protected getTransactionBuilder(): TransactionBuilder {
     return new TransactionBuilder(coins.get(this.getBaseChain()));
   }
@@ -40,8 +232,11 @@ 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;
+  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);
   }
@@ -55,7 +250,7 @@ export class Bsc extends AbstractEthLikeNewCoins {
    * @param {Wallet} params.wallet - Wallet object to obtain keys to verify against
    * @returns {boolean}
    */
-  async verifyTssTransaction(params: VerifyEthTransactionOptions): Promise<boolean> {
+  async verifyTssTransaction(params: { txParams: any; txPrebuild: any; wallet: any }): Promise<boolean> {
     const { txParams, txPrebuild, wallet } = params;
     if (
       !txParams?.recipients &&

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

@@ -1,11 +1,12 @@
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
-import { BuildTransactionError, TransactionType } from '@bitgo/sdk-core';
+import { BuildTransactionError, PublicKey, TransactionType } from '@bitgo/sdk-core';
 import { TransactionBuilder as AbstractTransactionBuilder, Transaction } from '@bitgo/abstract-eth';
 import { getCommon } from './utils';
 import { TransferBuilder } from './transferBuilder';
 
 export class TransactionBuilder extends AbstractTransactionBuilder {
   protected _transfer: TransferBuilder;
+  private _signatures: { publicKey: string; signature: string }[] = [];
 
   constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
@@ -23,4 +24,13 @@ export class TransactionBuilder extends AbstractTransactionBuilder {
     }
     return this._transfer;
   }
+  /**
+   * Add a signature to the transaction
+   * @param publicKey - The public key associated with the signature
+   * @param signature - The signature to add
+   */
+  addSignature(publicKey: PublicKey, signature: Buffer): void {
+    // Method updated
+    this._signatures.push({ publicKey: publicKey.toString(), signature: signature.toString('hex') });
+  }
 }