feat(sdk-coin-vet): add flush token tx builder

COIN-4742
TICKET: COIN-4742

Author: gianchandania

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

@@ -131,7 +131,7 @@ export class AddressInitializationTransaction extends Transaction {
       this.gas = typeof body.gas === 'number' ? body.gas : Number(body.gas) || 0;
       this.dependsOn = body.dependsOn || null;
       this.nonce = typeof body.nonce === 'number' ? body.nonce : Number(body.nonce) || 0;
-      // Set recipients from clauses
+      // Set data from clauses
       this.contract = body.clauses[0]?.to || '0x0';
       this.transactionData = body.clauses[0]?.data || '0x0';
 

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

@@ -1,24 +1,25 @@
-import { TransactionType } from '@bitgo/sdk-core';
+import { TransactionType, InvalidTransactionError } from '@bitgo/sdk-core';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { Transaction as VetTransaction, Secp256k1 } from '@vechain/sdk-core';
 
 import { Transaction } from './transaction';
 import { VetTransactionData } from '../iface';
 
 export class FlushTokenTransaction extends Transaction {
-  private _forwarderAddress: string;
+  private _forwarderVersion: number;
   private _tokenAddress: string;
 
   constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
     this._type = TransactionType.FlushTokens;
   }
 
-  get forwarderAddress(): string {
-    return this._forwarderAddress;
+  get forwarderVersion(): number {
+    return this._forwarderVersion;
   }
 
-  set forwarderAddress(address: string) {
-    this._forwarderAddress = address;
+  set forwarderVersion(forwarderVersion: number) {
+    this._forwarderVersion = forwarderVersion;
   }
 
   get tokenAddress(): string {
@@ -59,4 +60,48 @@ export class FlushTokenTransaction extends Transaction {
     };
     return json;
   }
+
+  /** @inheritdoc */
+  fromDeserializedSignedTransaction(signedTx: VetTransaction): void {
+    try {
+      if (!signedTx || !signedTx.body) {
+        throw new InvalidTransactionError('Invalid transaction: missing transaction body');
+      }
+
+      // Store the raw transaction
+      this.rawTransaction = signedTx;
+
+      // Set transaction body properties
+      const body = signedTx.body;
+      this.chainTag = typeof body.chainTag === 'number' ? body.chainTag : 0;
+      this.blockRef = body.blockRef || '0x0';
+      this.expiration = typeof body.expiration === 'number' ? body.expiration : 64;
+      this.clauses = body.clauses || [];
+      this.gasPriceCoef = typeof body.gasPriceCoef === 'number' ? body.gasPriceCoef : 128;
+      this.gas = typeof body.gas === 'number' ? body.gas : Number(body.gas) || 0;
+      this.dependsOn = body.dependsOn || null;
+      this.nonce = typeof body.nonce === 'number' ? body.nonce : Number(body.nonce) || 0;
+      // Set data from clauses
+      this.contract = body.clauses[0]?.to || '0x0';
+      this.transactionData = body.clauses[0]?.data || '0x0';
+
+      // Set sender address
+      if (signedTx.origin) {
+        this.sender = signedTx.origin.toString().toLowerCase();
+      }
+
+      // Set signatures if present
+      if (signedTx.signature) {
+        // First signature is sender's signature
+        this.senderSignature = Buffer.from(signedTx.signature.slice(0, Secp256k1.SIGNATURE_LENGTH));
+
+        // If there's additional signature data, it's the fee payer's signature
+        if (signedTx.signature.length > Secp256k1.SIGNATURE_LENGTH) {
+          this.feePayerSignature = Buffer.from(signedTx.signature.slice(Secp256k1.SIGNATURE_LENGTH));
+        }
+      }
+    } catch (e) {
+      throw new InvalidTransactionError(`Failed to deserialize transaction: ${e.message}`);
+    }
+  }
 }

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

@@ -175,15 +175,4 @@ export class AddressInitializationBuilder extends TransactionBuilder {
     const args = EthereumAbi.rawEncode(createForwarderTypes, createForwarderParams);
     return addHexPrefix(Buffer.concat([method, args]).toString('hex'));
   }
-
-  /** @inheritdoc */
-  protected fromImplementation(rawTransaction: string): Transaction {
-    const tx = new AddressInitializationTransaction(this._coinConfig);
-    this.validateRawTransaction(rawTransaction);
-
-    tx.fromRawTransaction(rawTransaction);
-    this.initBuilder(tx);
-    this.validateTransaction(tx);
-    return this.transaction;
-  }
 }

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

@@ -1,9 +1,11 @@
+import assert from 'assert';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { TransactionType } from '@bitgo/sdk-core';
-import { decodeFlushTokensData } from '@bitgo/abstract-eth';
+import { decodeFlushTokensData, flushTokensData } from '@bitgo/abstract-eth';
 import { TransactionClause } from '@vechain/sdk-core';
 
 import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from '../transaction/transaction';
 import { FlushTokenTransaction } from '../transaction/flushTokenTransaction';
 import utils from '../utils';
 
@@ -27,16 +29,16 @@ export class FlushTokenTransactionBuilder extends TransactionBuilder {
   }
 
   /**
-   * Gets the address initialization transaction instance.
+   * Gets the flush token transaction instance.
    *
-   * @returns {FlushTokenTransaction} The address initialization transaction
+   * @returns {FlushTokenTransaction} The flush token transaction
    */
   get flushTokenTransaction(): FlushTokenTransaction {
     return this._transaction as FlushTokenTransaction;
   }
 
   /**
-   * Gets the transaction type for address initialization.
+   * Gets the transaction type for flush token.
    *
    * @returns {TransactionType} The transaction type
    */
@@ -45,7 +47,7 @@ export class FlushTokenTransactionBuilder extends TransactionBuilder {
   }
 
   /**
-   * Validates the transaction clauses for address initialization.
+   * Validates the transaction clauses for flush token transaction.
    * @param {TransactionClause[]} clauses - The transaction clauses to validate.
    * @returns {boolean} - Returns true if the clauses are valid, false otherwise.
    */
@@ -61,7 +63,7 @@ export class FlushTokenTransactionBuilder extends TransactionBuilder {
         return false;
       }
 
-      // For address init transactions, value must be exactly '0x0'
+      // For address init transactions, value must be exactly 0
       if (clause.value !== 0) {
         return false;
       }
@@ -79,10 +81,10 @@ export class FlushTokenTransactionBuilder extends TransactionBuilder {
   }
 
   /**
-   * Sets the base address for this forwarder init tx.
+   * Sets the token address for this token flush tx.
    *
-   * @param {string} address - The base address to be set for the forwarder address
-   * @returns {AddressInitializationBuilder} This transaction builder
+   * @param {string} address - The token address to be set for the token flush transaction
+   * @returns {FlushTokenTransaction} This transaction builder
    */
   tokenAddress(address: string): this {
     this.validateAddress({ address });
@@ -91,59 +93,38 @@ export class FlushTokenTransactionBuilder extends TransactionBuilder {
   }
 
   /** @inheritdoc */
-  validateTransaction(transaction?: AddressInitializationTransaction): void {
+  validateTransaction(transaction?: FlushTokenTransaction): void {
     if (!transaction) {
       throw new Error('transaction not defined');
     }
     assert(transaction.contract, 'Contract address is required');
-    assert(transaction.baseAddress, 'Base address is required');
-    assert(transaction.feeAddress, 'Fee address is required');
-    assert(transaction.salt, 'Salt is required');
-    assert(transaction.initCode, 'Init code is required');
+    assert(transaction.tokenAddress, 'Token address is required');
 
     this.validateAddress({ address: transaction.contract });
-    this.validateAddress({ address: transaction.baseAddress });
-    this.validateAddress({ address: transaction.feeAddress });
-    if (!utils.isValidHex(transaction.salt, 64)) {
-      throw new Error('Invalid salt');
-    }
+    this.validateAddress({ address: transaction.tokenAddress });
   }
 
   /** @inheritdoc */
   protected async buildImplementation(): Promise<Transaction> {
-    const transactionData = this.getAddressInitializationData();
+    const transactionData = this.getFlushTokenTransactionData();
     this.transaction.type = this.transactionType;
-    this.addressInitializationTransaction.transactionData = transactionData;
-    await this.addressInitializationTransaction.build();
+    this.flushTokenTransaction.transactionData = transactionData;
+    await this.flushTokenTransaction.build();
     return this.transaction;
   }
 
   /**
-   * Generates the transaction data for address initialization by encoding the createForwarder method call.
+   * Generates the transaction data for flush token transaction
    *
    * @private
    * @returns {string} The encoded transaction data as a hex string
    */
-  private getAddressInitializationData(): string {
-    const saltBuffer = setLengthLeft(toBuffer(this.addressInitializationTransaction.salt), 32);
-    const { createForwarderParams, createForwarderTypes } = getCreateForwarderParamsAndTypes(
-      this.addressInitializationTransaction.baseAddress,
-      saltBuffer,
-      this.addressInitializationTransaction.feeAddress
+  private getFlushTokenTransactionData(): string {
+    const flushTokenData = flushTokensData(
+      this.flushTokenTransaction.contract,
+      this.flushTokenTransaction.tokenAddress,
+      this.flushTokenTransaction.forwarderVersion
     );
-    const method = EthereumAbi.methodID('createForwarder', createForwarderTypes);
-    const args = EthereumAbi.rawEncode(createForwarderTypes, createForwarderParams);
-    return addHexPrefix(Buffer.concat([method, args]).toString('hex'));
-  }
-
-  /** @inheritdoc */
-  protected fromImplementation(rawTransaction: string): Transaction {
-    const tx = new AddressInitializationTransaction(this._coinConfig);
-    this.validateRawTransaction(rawTransaction);
-
-    tx.fromRawTransaction(rawTransaction);
-    this.initBuilder(tx);
-    this.validateTransaction(tx);
-    return this.transaction;
+    return flushTokenData;
   }
 }

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

@@ -180,4 +180,11 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
   validateKey(key: BaseKey): void {
     throw new Error('Method not implemented.');
   }
+
+  /** @inheritdoc */
+  protected fromImplementation(rawTransaction: string): Transaction {
+    this.validateRawTransaction(rawTransaction);
+    this.transaction.fromRawTransaction(rawTransaction);
+    return this.transaction;
+  }
 }

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

@@ -4,9 +4,11 @@ import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { TransactionBuilder } from './transactionBuilder/transactionBuilder';
 import { TransferBuilder } from './transactionBuilder/transferBuilder';
 import { AddressInitializationBuilder } from './transactionBuilder/addressInitializationBuilder';
+import { FlushTokenTransactionBuilder } from './transactionBuilder/flushTokenTransactionBuilder';
 import { Transaction } from './transaction/transaction';
 import utils from './utils';
 import { AddressInitializationTransaction } from './transaction/addressInitializationTransaction';
+import { FlushTokenTransaction } from './transaction/flushTokenTransaction';
 
 export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
   constructor(_coinConfig: Readonly<CoinConfig>) {
@@ -27,6 +29,10 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
           const addressInitializationTx = new AddressInitializationTransaction(this._coinConfig);
           addressInitializationTx.fromDeserializedSignedTransaction(signedTx);
           return this.getAddressInitialisationBuilder(addressInitializationTx);
+        case TransactionType.FlushTokens:
+          const flushTokenTx = new FlushTokenTransaction(this._coinConfig);
+          flushTokenTx.fromDeserializedSignedTransaction(signedTx);
+          return this.getFlushTokenTransactionBuilder(flushTokenTx);
         default:
           throw new InvalidTransactionError('Invalid transaction type');
       }
@@ -44,6 +50,10 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
     return this.initializeBuilder(tx, new AddressInitializationBuilder(this._coinConfig));
   }
 
+  getFlushTokenTransactionBuilder(tx?: FlushTokenTransaction): FlushTokenTransactionBuilder {
+    return this.initializeBuilder(tx, new FlushTokenTransactionBuilder(this._coinConfig));
+  }
+
   /** @inheritdoc */
   getWalletInitializationBuilder(): void {
     throw new Error('Method not implemented.');

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

@@ -1,5 +1,5 @@
 import { BaseUtils, TransactionType } from '@bitgo/sdk-core';
-import { v4CreateForwarderMethodId } from '@bitgo/abstract-eth';
+import { v4CreateForwarderMethodId, flushForwarderTokensMethodIdV4 } from '@bitgo/abstract-eth';
 import { VET_ADDRESS_LENGTH, VET_BLOCK_ID_LENGTH, VET_TRANSACTION_ID_LENGTH } from './constants';
 import { KeyPair } from './keyPair';
 import { HexUInt, Transaction, TransactionClause } from '@vechain/sdk-core';
@@ -62,6 +62,8 @@ export class Utils implements BaseUtils {
       return TransactionType.Send;
     } else if (clauses[0].data.startsWith(v4CreateForwarderMethodId)) {
       return TransactionType.AddressInitialization;
+    } else if (clauses[0].data.startsWith(flushForwarderTokensMethodIdV4)) {
+      return TransactionType.FlushTokens;
     } else {
       return TransactionType.SendToken;
     }