feat(tron): add stake support (freeze and vote)

TICKET: SC-1632

Author: abhijit0943

modules/sdk-coin-trx/src/lib/enum.ts

@@ -14,6 +14,14 @@ export enum ContractType {
    * This is a smart contract type.
    */
   TriggerSmartContract,
+  /**
+   * This is the contract for freezeBuilder
+   */
+  FreezeBalanceV2,
+  /**
+   * This is the contract for voting for witnesses
+   */
+  VoteWitness,
 }
 
 export enum PermissionType {

modules/sdk-coin-trx/src/lib/freezeBuilder.ts

@@ -0,0 +1,101 @@
+import { InvalidTransactionError, TransactionType } from '@bitgo/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+
+/**
+ * Valid resource types for Tron freezing
+ */
+export enum FreezeResource {
+  BANDWIDTH = 'BANDWIDTH',
+  ENERGY = 'ENERGY',
+}
+
+export class FreezeBuilder extends TransactionBuilder {
+  /** @inheritdoc */
+  protected get transactionType(): TransactionType {
+    return TransactionType.StakingActivate;
+  }
+
+  /** Override to initialize this builder from a raw transaction */
+  initBuilder(rawTransaction: string | any): void {
+    this.transaction = this.fromImplementation(rawTransaction);
+    // Explicitly set the transaction type after initialization
+    this.transaction.setTransactionType(this.transactionType);
+  }
+
+  validateTransaction(transaction: any): void {
+    if (transaction && typeof transaction.toJson === 'function') {
+      super.validateTransaction(transaction);
+      // Get the raw transaction data from the Transaction object
+      const rawTx = transaction.toJson();
+      this.validateFreezeTransaction(rawTx);
+    } else {
+      // If it's already a raw transaction object, validate it directly
+      this.validateFreezeTransaction(transaction);
+    }
+  }
+
+  /**
+   * Validates if the transaction is a valid freeze transaction
+   * @param transaction The transaction to validate
+   * @throws {InvalidTransactionError} when the transaction is invalid
+   */
+  private validateFreezeTransaction(transaction: any): void {
+    if (
+      !transaction ||
+      !transaction.raw_data ||
+      !transaction.raw_data.contract ||
+      transaction.raw_data.contract.length === 0
+    ) {
+      throw new InvalidTransactionError('Invalid transaction: missing or empty contract array');
+    }
+
+    const contract = transaction.raw_data.contract[0];
+
+    // Validate contract type
+    if (contract.type !== 'FreezeBalanceV2Contract') {
+      throw new InvalidTransactionError(
+        `Invalid freeze transaction: expected contract type FreezeBalanceV2Contract but got ${contract.type}`
+      );
+    }
+
+    // Validate parameter value
+    if (!contract.parameter || !contract.parameter.value) {
+      throw new InvalidTransactionError('Invalid freeze transaction: missing parameter value');
+    }
+
+    const value = contract.parameter.value;
+
+    // Validate resource
+    if (!Object.values(FreezeResource).includes(value.resource)) {
+      throw new InvalidTransactionError(
+        `Invalid freeze transaction: resource must be ${Object.values(FreezeResource).join(' or ')}, got ${
+          value.resource
+        }`
+      );
+    }
+
+    // Validate frozen_balance
+    if (!value.frozen_balance || value.frozen_balance <= 0) {
+      throw new InvalidTransactionError('Invalid freeze transaction: frozen_balance must be positive');
+    }
+
+    // Validate owner_address
+    if (!value.owner_address || typeof value.owner_address !== 'string' || value.owner_address.length === 0) {
+      throw new InvalidTransactionError('Invalid freeze transaction: missing or invalid owner_address');
+    }
+  }
+
+  /**
+   * Check if the transaction is a valid freeze transaction
+   * @param transaction Transaction to check
+   * @returns True if the transaction is a valid freeze transaction
+   */
+  canSign(transaction: any): boolean {
+    try {
+      this.validateFreezeTransaction(transaction);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+}

modules/sdk-coin-trx/src/lib/iface.ts

@@ -42,7 +42,12 @@ export interface RawData {
   ref_block_hash: string;
   fee_limit?: number;
   contractType?: ContractType;
-  contract: TransferContract[] | AccountPermissionUpdateContract[] | TriggerSmartContract[];
+  contract:
+    | TransferContract[]
+    | AccountPermissionUpdateContract[]
+    | TriggerSmartContract[]
+    | FreezeBalanceV2Contract[]
+    | VoteWitnessContract[];
 }
 
 export interface Value {
@@ -117,3 +122,60 @@ export interface AccountInfo {
   active_permission: [{ keys: [PermissionKey] }];
   trc20: [Record<string, string>];
 }
+
+/**
+ * Freeze balance contract value fields
+ */
+export interface FreezeBalanceValueFields {
+  resource: string;
+  frozen_balance: number;
+  owner_address: string;
+}
+
+/**
+ * Freeze balance contract value interface
+ */
+export interface FreezeBalanceValue {
+  type_url?: string;
+  value: FreezeBalanceValueFields;
+}
+
+/**
+ * Freeze balance v2 contract interface
+ */
+export interface FreezeBalanceV2Contract {
+  parameter: FreezeBalanceValue;
+  type?: string;
+}
+
+/**
+ * Vote data in a vote transaction
+ */
+export interface VoteData {
+  vote_address: string;
+  vote_count: number;
+}
+
+/**
+ * Vote transaction value fields
+ */
+export interface VoteValueFields {
+  owner_address: string;
+  votes: VoteData[];
+}
+
+/**
+ * Vote contract value interface
+ */
+export interface VoteValue {
+  type_url?: string;
+  value: VoteValueFields;
+}
+
+/**
+ * Vote witness contract interface
+ */
+export interface VoteWitnessContract {
+  parameter: VoteValue;
+  type?: string;
+}

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

@@ -17,7 +17,15 @@ import {
   tokenMainnetContractAddresses,
   tokenTestnetContractAddresses,
 } from './utils';
-import { ContractEntry, RawData, TransactionReceipt, TransferContract, TriggerSmartContract } from './iface';
+import {
+  ContractEntry,
+  FreezeBalanceV2Contract,
+  RawData,
+  TransactionReceipt,
+  TransferContract,
+  TriggerSmartContract,
+  VoteWitnessContract,
+} from './iface';
 
 /**
  * Tron transaction model.
@@ -126,6 +134,34 @@ export class Transaction extends BaseTransaction {
           value: '0',
         };
         break;
+      case ContractType.FreezeBalanceV2:
+        this._type = TransactionType.StakingActivate;
+        const freezeValue = (rawData.contract[0] as FreezeBalanceV2Contract).parameter.value;
+        output = {
+          address: freezeValue.owner_address,
+          value: freezeValue.frozen_balance.toString(),
+        };
+        input = {
+          address: freezeValue.owner_address,
+          value: freezeValue.frozen_balance.toString(),
+        };
+        break;
+      case ContractType.VoteWitness:
+        this._type = TransactionType.StakingVote;
+        const voteValues = (rawData.contract[0] as VoteWitnessContract).parameter.value;
+
+        // Calculate total vote count
+        const totalVoteCount = voteValues.votes.reduce((sum, vote) => sum + vote.vote_count, 0);
+
+        output = {
+          address: voteValues.owner_address,
+          value: totalVoteCount.toString(),
+        };
+        input = {
+          address: voteValues.owner_address,
+          value: totalVoteCount.toString(),
+        };
+        break;
       default:
         throw new ParseTransactionError('Unsupported contract type');
     }