feat(sdk-coin-ton): add support for recovery for ton

TICKET: WIN-5046

Author: Chinmay-Sharma1

modules/sdk-coin-ton/src/lib/utils.ts

@@ -87,6 +87,36 @@ export class Utils implements BaseUtils {
   }
 }
 
+const DUMMY_PRIVATE_KEY = '43e8594854cb53947c4a1a2fab926af11e123f6251dcd5bd0dfb100604186430'; // This dummy private key is used only for fee estimation
+
+/**
+ * Function to estimate the fee for a transaction.
+ * This function uses the dummy private key exclusively for fee estimation.
+ * @param wallet - The wallet instance.
+ * @param toAddress - The destination address.
+ * @param amount - The amount to transfer.
+ * @param seqno - The sequence number for the transaction.
+ * @returns The estimated fee for the transaction.
+ */
+
+export async function getFeeEstimate(wallet: any, toAddress: string, amount: string, seqno: number): Promise<any> {
+  try {
+    const secretKey = TonWeb.utils.stringToBytes(DUMMY_PRIVATE_KEY);
+    const feeEstimate = await wallet.methods
+      .transfer({
+        secretKey,
+        toAddress,
+        amount,
+        seqno,
+        sendMode: 1,
+      })
+      .estimateFee();
+    return feeEstimate;
+  } catch (error) {
+    throw new Error(`Failed to estimate fee: ${error.message}`);
+  }
+}
+
 const utils = new Utils();
 
 export default utils;

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

@@ -14,13 +14,27 @@ import {
   TransactionExplanation,
   TssVerifyAddressOptions,
   VerifyTransactionOptions,
+  EDDSAMethodTypes,
+  MPCRecoveryOptions,
+  MPCTx,
+  MPCUnsignedTx,
+  RecoveryTxRequest,
+  OvcInput,
+  OvcOutput,
+  Environments,
+  MPCSweepTxs,
+  PublicKey,
+  MPCTxs,
+  MPCSweepRecoveryOptions,
 } from '@bitgo/sdk-core';
 import { BaseCoin as StaticsBaseCoin, coins } from '@bitgo/statics';
 import { KeyPair as TonKeyPair } from './lib/keyPair';
 import BigNumber from 'bignumber.js';
 import * as _ from 'lodash';
-import { Transaction, TransactionBuilderFactory, Utils } from './lib';
+import { Transaction, TransactionBuilderFactory, Utils, TransferBuilder } from './lib';
 import TonWeb from 'tonweb';
+import { getDerivationPath } from '@bitgo/sdk-lib-mpc';
+import { getFeeEstimate } from './lib/utils';
 
 export interface TonParseTransactionOptions extends ParseTransactionOptions {
   txHex: string;
@@ -240,4 +254,240 @@ export class Ton extends BaseCoin {
       throw new Error('Invalid transaction');
     }
   }
+
+  protected getPublicNodeUrl(): string {
+    return Environments[this.bitgo.getEnv()].tonNodeUrl;
+  }
+
+  private getBuilder(): TransactionBuilderFactory {
+    return new TransactionBuilderFactory(coins.get(this.getChain()));
+  }
+
+  async recover(params: MPCRecoveryOptions): Promise<MPCTx | MPCSweepTxs> {
+    if (!params.bitgoKey) {
+      throw new Error('missing bitgoKey');
+    }
+    if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {
+      throw new Error('invalid recoveryDestination');
+    }
+    if (!params.apiKey) {
+      throw new Error('missing apiKey');
+    }
+    const bitgoKey = params.bitgoKey.replace(/\s/g, '');
+    const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;
+
+    // Build the transaction
+    const tonweb = new TonWeb(new TonWeb.HttpProvider(this.getPublicNodeUrl(), { apiKey: params.apiKey }));
+    const MPC = await EDDSAMethods.getInitializedMpcInstance();
+
+    const index = params.index || 0;
+    const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;
+    const accountId = MPC.deriveUnhardened(bitgoKey, currPath).slice(0, 64);
+    const senderAddr = await Utils.default.getAddressFromPublicKey(accountId);
+    const balance = await tonweb.getBalance(senderAddr);
+    if (new BigNumber(balance).isEqualTo(0)) {
+      throw Error('Did not find address with funds to recover');
+    }
+
+    const WalletClass = tonweb.wallet.all['v4R2'];
+    const wallet = new WalletClass(tonweb.provider, {
+      publicKey: tonweb.utils.hexToBytes(accountId),
+      wc: 0,
+    });
+    let seqno = await wallet.methods.seqno().call();
+    if (seqno === null) {
+      seqno = 0;
+    }
+
+    const feeEstimate = await getFeeEstimate(wallet, params.recoveryDestination, balance, seqno as number);
+
+    const totalFeeEstimate = Math.round(
+      (feeEstimate.source_fees.in_fwd_fee +
+        feeEstimate.source_fees.storage_fee +
+        feeEstimate.source_fees.gas_fee +
+        feeEstimate.source_fees.fwd_fee) *
+        1.5
+    );
+
+    if (new BigNumber(totalFeeEstimate).gt(balance)) {
+      throw Error('Did not find address with funds to recover');
+    }
+
+    const factory = this.getBuilder();
+    const expireAt = Math.floor(Date.now() / 1e3) + 60 * 60 * 24 * 7; // 7 days
+
+    const txBuilder = factory
+      .getTransferBuilder()
+      .sender(senderAddr)
+      .sequenceNumber(seqno as number)
+      .publicKey(accountId)
+      .expireTime(expireAt);
+
+    (txBuilder as TransferBuilder).send({
+      address: params.recoveryDestination,
+      amount: new BigNumber(balance).minus(new BigNumber(totalFeeEstimate)).toString(),
+    });
+
+    const unsignedTransaction = await txBuilder.build();
+
+    if (!isUnsignedSweep) {
+      if (!params.userKey) {
+        throw new Error('missing userKey');
+      }
+      if (!params.backupKey) {
+        throw new Error('missing backupKey');
+      }
+      if (!params.walletPassphrase) {
+        throw new Error('missing wallet passphrase');
+      }
+
+      // Clean up whitespace from entered values
+      const userKey = params.userKey.replace(/\s/g, '');
+      const backupKey = params.backupKey.replace(/\s/g, '');
+
+      let userPrv;
+
+      try {
+        userPrv = this.bitgo.decrypt({
+          input: userKey,
+          password: params.walletPassphrase,
+        });
+      } catch (e) {
+        throw new Error(`Error decrypting user keychain: ${e.message}`);
+      }
+      const userSigningMaterial = JSON.parse(userPrv) as EDDSAMethodTypes.UserSigningMaterial;
+
+      let backupPrv;
+      try {
+        backupPrv = this.bitgo.decrypt({
+          input: backupKey,
+          password: params.walletPassphrase,
+        });
+      } catch (e) {
+        throw new Error(`Error decrypting backup keychain: ${e.message}`);
+      }
+      const backupSigningMaterial = JSON.parse(backupPrv) as EDDSAMethodTypes.BackupSigningMaterial;
+
+      const signatureHex = await EDDSAMethods.getTSSSignature(
+        userSigningMaterial,
+        backupSigningMaterial,
+        currPath,
+        unsignedTransaction
+      );
+
+      const publicKeyObj = { pub: senderAddr };
+      txBuilder.addSignature(publicKeyObj as PublicKey, signatureHex);
+    }
+
+    const completedTransaction = await txBuilder.build();
+    const serializedTx = completedTransaction.toBroadcastFormat();
+    const walletCoin = this.getChain();
+
+    const inputs: OvcInput[] = [];
+    for (const input of completedTransaction.inputs) {
+      inputs.push({
+        address: input.address,
+        valueString: input.value,
+        value: new BigNumber(input.value).toNumber(),
+      });
+    }
+    const outputs: OvcOutput[] = [];
+    for (const output of completedTransaction.outputs) {
+      outputs.push({
+        address: output.address,
+        valueString: output.value,
+        coinName: output.coin,
+      });
+    }
+    const spendAmount = completedTransaction.inputs.length === 1 ? completedTransaction.inputs[0].value : 0;
+    const parsedTx = { inputs: inputs, outputs: outputs, spendAmount: spendAmount, type: '' };
+    const feeInfo = { fee: totalFeeEstimate, feeString: totalFeeEstimate.toString() };
+    const coinSpecific = { commonKeychain: bitgoKey };
+    if (isUnsignedSweep) {
+      const transaction: MPCTx = {
+        serializedTx: serializedTx,
+        scanIndex: index,
+        coin: walletCoin,
+        signableHex: completedTransaction.signablePayload.toString('hex'),
+        derivationPath: currPath,
+        parsedTx: parsedTx,
+        feeInfo: feeInfo,
+        coinSpecific: coinSpecific,
+      };
+      const unsignedTx: MPCUnsignedTx = { unsignedTx: transaction, signatureShares: [] };
+      const transactions: MPCUnsignedTx[] = [unsignedTx];
+      const txRequest: RecoveryTxRequest = {
+        transactions: transactions,
+        walletCoin: walletCoin,
+      };
+      const txRequests: MPCSweepTxs = { txRequests: [txRequest] };
+      return txRequests;
+    }
+
+    const transaction: MPCTx = {
+      serializedTx: serializedTx,
+      scanIndex: index,
+    };
+    return transaction;
+  }
+
+  /**
+   * Creates funds sweep recovery transaction(s) without BitGo
+   *
+   * @param {MPCSweepRecoveryOptions} params parameters needed to combine the signatures
+   * and transactions to create broadcastable transactions
+   *
+   * @returns {MPCTxs} array of the serialized transaction hex strings and indices
+   * of the addresses being swept
+   */
+  async createBroadcastableSweepTransaction(params: MPCSweepRecoveryOptions): Promise<MPCTxs> {
+    const req = params.signatureShares;
+    const broadcastableTransactions: MPCTx[] = [];
+    let lastScanIndex = 0;
+
+    for (let i = 0; i < req.length; i++) {
+      const MPC = await EDDSAMethods.getInitializedMpcInstance();
+      const transaction = req[i].txRequest.transactions[0].unsignedTx;
+      if (!req[i].ovc || !req[i].ovc[0].eddsaSignature) {
+        throw new Error('Missing signature(s)');
+      }
+      const signature = req[i].ovc[0].eddsaSignature;
+      if (!transaction.signableHex) {
+        throw new Error('Missing signable hex');
+      }
+      const messageBuffer = Buffer.from(transaction.signableHex!, 'hex');
+      const result = MPC.verify(messageBuffer, signature);
+      if (!result) {
+        throw new Error('Invalid signature');
+      }
+      const signatureHex = Buffer.concat([Buffer.from(signature.R, 'hex'), Buffer.from(signature.sigma, 'hex')]);
+      const txBuilder = this.getBuilder().from(transaction.serializedTx as string);
+      if (!transaction.coinSpecific?.commonKeychain) {
+        throw new Error('Missing common keychain');
+      }
+      const commonKeychain = transaction.coinSpecific!.commonKeychain! as string;
+      if (!transaction.derivationPath) {
+        throw new Error('Missing derivation path');
+      }
+      const derivationPath = transaction.derivationPath as string;
+      const accountId = MPC.deriveUnhardened(commonKeychain, derivationPath).slice(0, 64);
+      const tonKeyPair = new TonKeyPair({ pub: accountId });
+
+      // add combined signature from ovc
+      txBuilder.addSignature({ pub: tonKeyPair.getKeys().pub }, signatureHex);
+      const signedTransaction = await txBuilder.build();
+      const serializedTx = signedTransaction.toBroadcastFormat();
+
+      broadcastableTransactions.push({
+        serializedTx: serializedTx,
+        scanIndex: transaction.scanIndex,
+      });
+
+      if (i === req.length - 1 && transaction.coinSpecific!.lastScanIndex) {
+        lastScanIndex = transaction.coinSpecific!.lastScanIndex as number;
+      }
+    }
+
+    return { transactions: broadcastableTransactions, lastScanIndex };
+  }
 }