feat: recover function for vet recovery

Ticket: COIN-6042

Author: at31416

modules/bitgo/test/v2/lib/recovery-nocks.ts

@@ -416,6 +416,96 @@ module.exports.nockEthLikeRecovery = function (bitgo, nockData = nockEthData) {
   });
 };
 
+module.exports.nockVetRecovery = function (bitgo) {
+  // nock for account balance
+  const url = Environments[bitgo.getEnv()].vetNodeUrl;
+  nock(url).get('/accounts/0x88c2ab227908d39f6afdb85203dca3e937bb77af').reply(200, {
+    balance: '0x8ac7230489e80000',
+    energy: '0x5969b539627800',
+    hasCode: false,
+  });
+
+  nock(url).get('/blocks/best').reply(200, {
+    number: 23107826,
+    id: '0x016098f2a6779c3ad2bb52ef0a3f57c770af55a77bfa1b2837266f752118ad8d',
+    size: 368,
+    parentID: '0x016098f1acffb0125ffeca9b3e2491d31574d14b55a15e912e45e8081e063e0e',
+    timestamp: 1761116630,
+    gasLimit: 40000000,
+    beneficiary: '0xae99cb89767a09d53e589a40cb4016974aba4b94',
+    gasUsed: 0,
+    totalScore: 218523577,
+    txsRoot: '0x45b0cfc220ceec5b7c1c62c4d4193d38e4eba48e8815729ce75f9c0ab0e4c1c0',
+    txsFeatures: 1,
+    stateRoot: '0x7a5e7b3b8b89958e7fdd5e14acbc79dbc419672e84d02376a43b3beebe555e33',
+    receiptsRoot: '0x45b0cfc220ceec5b7c1c62c4d4193d38e4eba48e8815729ce75f9c0ab0e4c1c0',
+    com: true,
+    signer: '0xae99cb89767a09d53e589a40cb4016974aba4b94',
+    isTrunk: true,
+    isFinalized: false,
+    baseFeePerGas: '0x9184e72a000',
+    transactions: [],
+  });
+
+  nock(url)
+    .post('/accounts/*', {
+      clauses: [
+        {
+          to: '0xac05da78464520aa7c9d4c19bd7a440b111b3054',
+          value: '10000000000000000000',
+          data: '0x',
+        },
+      ],
+      caller: '0x88c2ab227908d39f6afdb85203dca3e937bb77af',
+    })
+    .reply(200, [
+      {
+        data: '0x',
+        events: [],
+        transfers: [
+          {
+            sender: '0x880ff4718587d678e78fc7803b3634bd12ecf019',
+            recipient: '0xac05da78464520aa7c9d4c19bd7a440b111b3054',
+            amount: '0x8ac7230489e80000',
+          },
+        ],
+        gasUsed: 0,
+        reverted: false,
+        vmError: '',
+      },
+    ]);
+  // nock for vtho balance for gas
+  nock(url)
+    .post('/accounts/*', {
+      clauses: [
+        {
+          to: '0x0000000000000000000000000000456E65726779',
+          value: '0x0',
+          data: '0x70a0823100000000000000000000000088c2ab227908d39f6afdb85203dca3e937bb77af',
+        },
+      ],
+    })
+    .reply(200, [
+      {
+        data: '0x000000000000000000000000000000000000000000000007e982789f8fe0cf0a',
+        events: [],
+        transfers: [],
+        gasUsed: 870,
+        reverted: false,
+        vmError: '',
+      },
+    ]);
+
+  nock(url)
+    .post('/transactions', {
+      raw: /^0x[0-9a-f]+$/i,
+    })
+    .reply(200, {
+      id: '0x' + 'a'.repeat(64), // A fake transaction ID
+      reverted: false,
+    });
+};
+
 module.exports.nockEtherscanRateLimitError = function () {
   const response = {
     status: '0',

modules/bitgo/test/v2/unit/recovery.ts

@@ -1457,4 +1457,75 @@ describe('Recovery:', function () {
       (output.txRequests[0].transactions[0].unsignedTx.parsedTx as { outputs: any[] }).should.have.property('outputs');
     });
   });
+
+  describe('RecoverVet', function () {
+    beforeEach(() => {
+      nock.cleanAll();
+    });
+    let recoveryParams;
+
+    it('should construct a recovery tx with MPCv2 TSS', async function () {
+      recoveryNocks.nockVetRecovery(bitgo);
+      const basecoin = bitgo.coin('tvet');
+      const baseAddress = ethLikeDKLSKeycard.senderAddress;
+      recoveryParams = {
+        userKey: ethLikeDKLSKeycard.userKey,
+        backupKey: ethLikeDKLSKeycard.backupKey,
+        walletContractAddress: baseAddress,
+        recoveryDestination: ethLikeDKLSKeycard.destinationAddress,
+        walletPassphrase: ethLikeDKLSKeycard.walletPassphrase,
+        isTss: true,
+      };
+
+      const recovery = await basecoin.recover(recoveryParams);
+
+      should.exist(recovery);
+      recovery.should.have.property('id');
+      recovery.should.have.property('tx');
+    });
+
+    // it('should construct an unsigned sweep tx with TSS', async function () {
+    //   recoveryNocks.nockEthLikeRecovery(bitgo, nockUnsignedSweepTSSData);
+    //
+    //   const basecoin = bitgo.coin('hteth');
+    //
+    //   const userKey =
+    //     '0234eb39b22fed523ece7c78da29ba1f1de5b64a6e48013e0914de793bc1df0570e779de04758732734d97e54b782c8b336283811af6a2c57bd81438798e1c2446';
+    //   const backupKey =
+    //     '0234eb39b22fed523ece7c78da29ba1f1de5b64a6e48013e0914de793bc1df0570e779de04758732734d97e54b782c8b336283811af6a2c57bd81438798e1c2446';
+    //
+    //   recoveryParams = {
+    //     userKey: userKey,
+    //     backupKey: backupKey,
+    //     walletContractAddress: '0xe7406dc43d13f698fb41a345c7783d39a4c2d191',
+    //     recoveryDestination: '0xac05da78464520aa7c9d4c19bd7a440b111b3054',
+    //     walletPassphrase: TestBitGo.V2.TEST_RECOVERY_PASSCODE,
+    //     isTss: true,
+    //     gasPrice: '20000000000',
+    //     gasLimit: '500000',
+    //     replayProtectionOptions: {
+    //       chain: 42,
+    //       hardfork: 'london',
+    //     },
+    //   };
+    //
+    //   const transaction = await basecoin.recover(recoveryParams);
+    //   should.exist(transaction);
+    //   const output = transaction as unknown as UnsignedSweepTxMPCv2;
+    //   output.should.have.property('txRequests');
+    //   output.txRequests.should.have.length(1);
+    //   output.txRequests[0].should.have.property('transactions');
+    //   output.txRequests[0].transactions.should.have.length(1);
+    //   output.txRequests[0].should.have.property('walletCoin');
+    //   output.txRequests[0].transactions[0].should.have.property('unsignedTx');
+    //   output.txRequests[0].transactions[0].unsignedTx.should.have.property('serializedTxHex');
+    //   output.txRequests[0].transactions[0].unsignedTx.should.have.property('signableHex');
+    //   output.txRequests[0].transactions[0].unsignedTx.should.have.property('derivationPath');
+    //   output.txRequests[0].transactions[0].unsignedTx.should.have.property('feeInfo');
+    //   output.txRequests[0].transactions[0].unsignedTx.should.have.property('parsedTx');
+    //   const parsedTx = output.txRequests[0].transactions[0].unsignedTx.parsedTx as { spendAmount: string };
+    //   parsedTx.should.have.property('spendAmount');
+    //   (output.txRequests[0].transactions[0].unsignedTx.parsedTx as { outputs: any[] }).should.have.property('outputs');
+    // });
+  });
 });

modules/sdk-coin-vet/src/lib/constants.ts

@@ -15,3 +15,9 @@ export const STARGATE_DELEGATION_ADDRESS = '0x4cb1c9ef05b529c093371264fab2c93cc6
 
 export const STARGATE_NFT_ADDRESS_TESTNET = '0x1ec1d168574603ec35b9d229843b7c2b44bcb770';
 export const STARGATE_DELEGATION_ADDRESS_TESTNET = '0x7240e3bc0d26431512d5b67dbd26d199205bffe8';
+
+export const AVG_GAS_UNITS = '21000';
+export const EXPIRATION = 400;
+export const GAS_PRICE_COEF = '128';
+export const GAS_UNIT_PRICE = '10000000000000'; // vechain has fixed gas unit price of 10^13 wei
+export const COEF_DIVISOR = '255';

modules/sdk-coin-vet/src/lib/transaction/transaction.ts

@@ -32,6 +32,7 @@ export class Transaction extends BaseTransaction {
   private _senderSignature: Buffer | null;
   private _feePayerAddress: string;
   private _feePayerSignature: Buffer | null;
+  private _isRecovery: boolean;
 
   constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
@@ -47,6 +48,7 @@ export class Transaction extends BaseTransaction {
     this._recipients = [];
     this._senderSignature = null;
     this._feePayerSignature = null;
+    this._isRecovery = false;
   }
 
   public get id(): string {
@@ -198,6 +200,14 @@ export class Transaction extends BaseTransaction {
     this._transactionData = transactionData;
   }
 
+  get isRecovery(): boolean {
+    return this._isRecovery;
+  }
+
+  set isRecovery(isRecovery: boolean) {
+    this._isRecovery = isRecovery;
+  }
+
   /**
    * Get all signatures associated with this transaction
    * Required by BaseTransaction
@@ -337,6 +347,9 @@ export class Transaction extends BaseTransaction {
       if (halfSignedTransaction.signature) {
         this._rawTransaction = halfSignedTransaction;
         this._sender = halfSignedTransaction.origin.toString().toLowerCase();
+        if (this.isRecovery) {
+          this._id = halfSignedTransaction.id.toString();
+        }
       } else {
         return;
       }
@@ -372,7 +385,7 @@ export class Transaction extends BaseTransaction {
     };
 
     if (
-      this.type === TransactionType.Send ||
+      (this.type === TransactionType.Send && !this.isRecovery) ||
       this.type === TransactionType.SendToken ||
       this.type === TransactionType.SendNFT ||
       this.type === TransactionType.ContractCall ||

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

@@ -45,6 +45,11 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
     return this;
   }
 
+  isRecovery(isRecovery: boolean): this {
+    this._transaction.isRecovery = isRecovery;
+    return this;
+  }
+
   /**
    * Sets the sender of this transaction.
    *

modules/sdk-coin-vet/src/lib/types.ts

@@ -15,3 +15,22 @@ export interface ClaimRewardsData {
   claimBaseRewards?: boolean;
   claimStakingRewards?: boolean;
 }
+
+export type RecoverOptions = {
+  userKey: string;
+  backupKey: string;
+  walletPassphrase?: string;
+  walletContractAddress: string; // use this as walletBaseAddress for TSS
+  recoveryDestination: string;
+  isUnsignedSweep?: boolean; // specify if this is an unsigned recovery
+};
+
+export interface RecoveryTransaction {
+  id: string;
+  tx: string;
+}
+
+export interface UnsignedSweepRecoveryTransaction {
+  txHex: string;
+  coin: string;
+}