feat(sdk-coin-trx): 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/freezeBalanceTxBuilder.ts

@@ -0,0 +1,98 @@
+import { InvalidTransactionError, TransactionType } from '@bitgo/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction';
+import { TransactionReceipt } from './iface';
+import { TronResource } from './resourcesTypes';
+
+interface RawFreezeContract {
+  parameter: {
+    value: {
+      resource?: string;
+      frozen_balance?: number;
+      owner_address?: string;
+    };
+  };
+  type: string;
+}
+
+export class FreezeBalanceTxBuilder extends TransactionBuilder {
+  /** @inheritdoc */
+  protected get transactionType(): TransactionType {
+    return TransactionType.StakingActivate;
+  }
+
+  initBuilder(rawTransaction: TransactionReceipt | string): void {
+    this.transaction = this.fromImplementation(rawTransaction);
+    this.transaction.setTransactionType(this.transactionType);
+  }
+
+  validateTransaction(transaction: Transaction | TransactionReceipt): void {
+    if (transaction && typeof (transaction as Transaction).toJson === 'function') {
+      super.validateTransaction(transaction as Transaction);
+      const rawTx = (transaction as Transaction).toJson();
+      this.validateFreezeTransaction(rawTx);
+    } else {
+      this.validateFreezeTransaction(transaction as TransactionReceipt);
+    }
+  }
+
+  /**
+   * Validates if the transaction is a valid freeze transaction
+   * @param {TransactionReceipt} transaction - The transaction to validate
+   * @throws {InvalidTransactionError} when the transaction is invalid
+   */
+  private validateFreezeTransaction(transaction: TransactionReceipt): void {
+    if (!transaction?.raw_data?.contract?.length) {
+      throw new InvalidTransactionError('Invalid transaction: missing or empty contract array');
+    }
+
+    const contract = transaction.raw_data.contract[0] as RawFreezeContract;
+
+    // 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?.value) {
+      throw new InvalidTransactionError('Invalid freeze transaction: missing parameter value');
+    }
+
+    const value = contract.parameter.value;
+
+    // Validate resource - Using TronResource instead of FreezeResource
+    if (!Object.values(TronResource).includes(value.resource as TronResource)) {
+      throw new InvalidTransactionError(
+        `Invalid freeze transaction: resource must be ${Object.values(TronResource).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 {TransactionReceipt} transaction - The transaction to check
+   * @returns True if the transaction is a valid freeze transaction
+   */
+  canSign(transaction: TransactionReceipt): boolean {
+    try {
+      this.validateFreezeTransaction(transaction);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+}

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

@@ -1,5 +1,6 @@
 import { Entry } from '@bitgo/sdk-core';
 import { ContractType, PermissionType } from './enum';
+import { TronResource } from './resourcesTypes';
 
 export interface Account {
   publicKey: string;
@@ -42,7 +43,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 +123,81 @@ 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;
+}
+
+export interface FreezeBalanceContractParameter {
+  parameter: {
+    value: {
+      resource: TronResource;
+      frozen_balance: number;
+      owner_address: string;
+    };
+  };
+}
+
+/**
+ * Vote data in a vote transaction
+ */
+export interface VoteWitnessData {
+  vote_address: string;
+  vote_count: number;
+}
+
+/**
+ * Vote transaction value fields
+ */
+export interface VoteWitnessValueFields {
+  owner_address: string;
+  votes: VoteWitnessData[];
+}
+
+/**
+ * Vote contract value interface
+ */
+export interface VoteWitnessValue {
+  type_url?: string;
+  value: VoteWitnessValueFields;
+}
+
+/**
+ * Vote witness contract interface
+ */
+export interface VoteWitnessContract {
+  parameter: VoteWitnessValue;
+  type?: string;
+}
+export interface VoteWitnessContractParameter {
+  parameter: {
+    value: {
+      owner_address: string;
+      votes: Array<{
+        vote_address: string;
+        vote_count: number;
+      }>;
+    };
+  };
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Valid resource types for Tron freezing and unfreezing
+ */
+export enum TronResource {
+  BANDWIDTH = 'BANDWIDTH',
+  ENERGY = 'ENERGY',
+}

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');
     }