Merge pull request #7137 from BitGo/SC-3324-1

fix: invalid id error for vechain staking txns

Author: raksha-r7

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

@@ -374,7 +374,11 @@ export class Transaction extends BaseTransaction {
     if (
       this.type === TransactionType.Send ||
       this.type === TransactionType.SendToken ||
-      this.type === TransactionType.SendNFT
+      this.type === TransactionType.SendNFT ||
+      this.type === TransactionType.ContractCall ||
+      this.type === TransactionType.StakingUnlock ||
+      this.type === TransactionType.StakingWithdraw ||
+      this.type === TransactionType.StakingClaim
     ) {
       transactionBody.reserved = {
         features: 1, // mark transaction as delegated i.e. will use gas payer

modules/sdk-coin-vet/test/resources/vet.ts

@@ -16,7 +16,7 @@ export const STAKING_TRANSACTION =
 
 export const STAKING_LEVEL_ID = 8;
 export const STAKING_AUTORENEW = true;
-export const STAKING_CONTRACT_ADDRESS = '0x1856c533ac2d94340aaa8544d35a5c1d4a21dee7';
+export const STAKING_CONTRACT_ADDRESS = '0x1ec1d168574603ec35b9d229843b7c2b44bcb770';
 
 export const VALID_TOKEN_SIGNABLE_PAYLOAD =
   'f8762788014ead140e77bbc140f85ef85c940000000000000000000000000000456e6572677980b844a9059cbb000000000000000000000000e59f1cea4e0fef511e3d0f4eec44adf19c4cbeec000000000000000000000000000000000000000000000000016345785d8a000081808252088082faf8c101';

modules/sdk-coin-vet/test/transactionBuilder/stakingTransaction.ts

@@ -143,17 +143,6 @@ describe('VET Staking Transaction', function () {
       stakingTx.clauses[0].data.should.equal(expectedData);
     });
 
-    it('should throw error when stakingContractABI is missing', async function () {
-      const txBuilder = createBasicTxBuilder();
-      txBuilder.stakingContractAddress(stakingContractAddress);
-      txBuilder.amountToStake(amountToStake);
-      txBuilder.levelId(levelId);
-      // Not setting stakingContractABI
-
-      // Should fail when trying to build without ABI
-      await txBuilder.build().should.be.rejectedWith('Staking contract ABI is required');
-    });
-
     it('should build transaction with undefined sender but include it in inputs', async function () {
       const txBuilder = factory.getStakingBuilder();
       txBuilder.stakingContractAddress(stakingContractAddress);

modules/sdk-coin-vet/test/unit/stakingFlowE2E.ts

@@ -0,0 +1,233 @@
+import should from 'should';
+import { coins } from '@bitgo/statics';
+import { TransactionType } from '@bitgo/sdk-core';
+import { TransactionBuilderFactory, StakingTransaction } from '../../src/lib';
+import * as testData from '../resources/vet';
+
+describe('VET Staking Flow - End-to-End Test', function () {
+  const coinConfig = coins.get('tvet');
+  const factory = new TransactionBuilderFactory(coinConfig);
+
+  // Test data
+  const stakingContractAddress = testData.STAKING_CONTRACT_ADDRESS;
+  const amountToStake = '1000000000000000000'; // 1 VET in wei
+  const amountToStakeHex = '0xde0b6b3a7640000'; // Same amount in hex
+  const levelId = testData.STAKING_LEVEL_ID;
+  const autorenew = testData.STAKING_AUTORENEW;
+  const senderAddress = '0x9378c12BD7502A11F770a5C1F223c959B2805dA9';
+  const feePayerAddress = '0xdc9fef0b84a0ccf3f1bd4b84e41743e3e051a083';
+
+  // Mock signatures for testing (these would come from actual signing in real scenario)
+  const mockSenderSignature = Buffer.from(testData.senderSig, 'hex');
+  const mockFeePayerSignature = Buffer.from(testData.feePayerSig, 'hex');
+
+  describe('Complete Staking Transaction Flow', function () {
+    it('should build, sign, and serialize a complete staking transaction with fee delegation', async function () {
+      // Step 1: Build the staking transaction
+      const stakingBuilder = factory.getStakingBuilder();
+
+      stakingBuilder
+        .stakingContractAddress(stakingContractAddress)
+        .amountToStake(amountToStake)
+        .levelId(levelId)
+        .sender(senderAddress)
+        .chainTag(0x27) // Testnet chain tag
+        .blockRef('0x014ead140e77bbc1')
+        .expiration(64)
+        .gas(100000)
+        .gasPriceCoef(128)
+        .nonce('12345');
+
+      stakingBuilder.addFeePayerAddress(feePayerAddress);
+
+      const unsignedTx = await stakingBuilder.build();
+      should.exist(unsignedTx);
+      unsignedTx.should.be.instanceof(StakingTransaction);
+
+      const stakingTx = unsignedTx as StakingTransaction;
+
+      // Verify transaction structure
+      stakingTx.type.should.equal(TransactionType.ContractCall);
+      stakingTx.stakingContractAddress.should.equal(stakingContractAddress);
+      stakingTx.amountToStake.should.equal(amountToStake);
+      stakingTx.levelId.should.equal(levelId);
+      stakingTx.autorenew.should.equal(autorenew);
+
+      should.exist(stakingTx.rawTransaction);
+      should.exist(stakingTx.rawTransaction.body);
+
+      // This is the critical test - ensure reserved.features = 1 for ContractCall type
+      should.exist(stakingTx.rawTransaction.body.reserved);
+      stakingTx.rawTransaction.body.reserved!.should.have.property('features', 1);
+
+      // Step 3: Add sender signature
+      stakingTx.addSenderSignature(mockSenderSignature);
+      should.exist(stakingTx.senderSignature);
+      Buffer.from(stakingTx.senderSignature!).should.eql(mockSenderSignature);
+
+      // Step 4: Add fee payer signature
+      stakingTx.addFeePayerSignature(mockFeePayerSignature);
+      should.exist(stakingTx.feePayerSignature);
+      Buffer.from(stakingTx.feePayerSignature!).should.eql(mockFeePayerSignature);
+
+      // Step 5: Generate transaction ID
+
+      // This should NOT throw "not signed transaction: id unavailable" error anymore
+      const transactionId = stakingTx.id;
+      should.exist(transactionId);
+      transactionId.should.not.equal('UNAVAILABLE');
+
+      // Step 6: Serialize the fully signed transaction
+      const serializedTx = stakingTx.toBroadcastFormat();
+      should.exist(serializedTx);
+      serializedTx.should.be.type('string');
+      serializedTx.should.startWith('0x');
+
+      // Step 7: Verify transaction can be deserialized
+      const deserializedBuilder = factory.from(serializedTx);
+      const deserializedTx = deserializedBuilder.transaction as StakingTransaction;
+
+      deserializedTx.should.be.instanceof(StakingTransaction);
+      deserializedTx.stakingContractAddress.should.equal(stakingContractAddress);
+      // Amount is stored in hex format in deserialized transaction
+      deserializedTx.amountToStake.should.equal(amountToStakeHex);
+      deserializedTx.levelId.should.equal(levelId);
+      deserializedTx.autorenew.should.equal(autorenew);
+
+      // Step 8: Verify toJson output
+      const jsonOutput = stakingTx.toJson();
+      should.exist(jsonOutput);
+      jsonOutput.should.have.property('id', transactionId);
+      jsonOutput.should.have.property('stakingContractAddress', stakingContractAddress);
+      // JSON output keeps decimal format for amounts
+      jsonOutput.should.have.property('amountToStake', amountToStake);
+      jsonOutput.should.have.property('nftTokenId', levelId);
+      jsonOutput.should.have.property('autorenew', autorenew);
+    });
+
+    it('should handle signature combination in the correct order', async function () {
+      // This test specifically validates the signature combination flow that was failing
+      const stakingBuilder = factory.getStakingBuilder();
+
+      stakingBuilder
+        .stakingContractAddress(stakingContractAddress)
+        .amountToStake(amountToStake)
+        .levelId(levelId)
+        .sender(senderAddress)
+        .chainTag(0x27)
+        .blockRef('0x014ead140e77bbc1')
+        .expiration(64)
+        .gas(100000)
+        .gasPriceCoef(128)
+        .nonce('12345');
+
+      stakingBuilder.addFeePayerAddress(feePayerAddress);
+
+      const tx = (await stakingBuilder.build()) as StakingTransaction;
+
+      // Test 1: Only sender signature - should generate half-signed transaction
+      tx.addSenderSignature(mockSenderSignature);
+
+      // Test 2: Add fee payer signature - should generate fully signed transaction
+      tx.addFeePayerSignature(mockFeePayerSignature);
+
+      // Should be able to get transaction ID with both signatures
+      const fullSignedId = tx.id;
+      should.exist(fullSignedId);
+      fullSignedId.should.not.equal('UNAVAILABLE');
+
+      // The ID should be consistent
+      fullSignedId.should.be.type('string');
+      fullSignedId.length.should.be.greaterThan(10);
+    });
+
+    it('should properly set transaction type for fee delegation validation', async function () {
+      // This test ensures our fix for TransactionType.ContractCall is working
+      const stakingBuilder = factory.getStakingBuilder();
+
+      stakingBuilder
+        .stakingContractAddress(stakingContractAddress)
+        .amountToStake(amountToStake)
+        .levelId(levelId)
+        .sender(senderAddress)
+        .chainTag(0x27)
+        .blockRef('0x014ead140e77bbc1')
+        .expiration(64)
+        .gas(100000)
+        .gasPriceCoef(128)
+        .nonce('12345');
+
+      stakingBuilder.addFeePayerAddress(feePayerAddress);
+
+      const tx = (await stakingBuilder.build()) as StakingTransaction;
+
+      // Verify the transaction type is ContractCall
+      tx.type.should.equal(TransactionType.ContractCall);
+
+      // Verify fee delegation is enabled via reserved.features = 1
+      const rawTxBody = tx.rawTransaction.body;
+      should.exist(rawTxBody.reserved);
+      rawTxBody.reserved!.should.have.property('features', 1);
+
+      // This proves that ContractCall transactions now get fee delegation support
+    });
+
+    it('should work with pre-built signed transaction from test data', async function () {
+      // Test using the actual signed transaction from our test data
+      const txBuilder = factory.from(testData.STAKING_TRANSACTION);
+      const tx = txBuilder.transaction as StakingTransaction;
+
+      // Should be able to get ID without throwing errors
+      const txId = tx.id;
+      should.exist(txId);
+      txId.should.not.equal('UNAVAILABLE');
+
+      // Verify all staking properties are preserved
+      // Note: The test data uses a different contract address in the transaction
+      // The actual contract address from the parsed transaction is 0x1856c533ac2d94340aaa8544d35a5c1d4a21dee7
+      tx.stakingContractAddress.should.equal('0x1856c533ac2d94340aaa8544d35a5c1d4a21dee7');
+      tx.levelId.should.equal(testData.STAKING_LEVEL_ID);
+      tx.autorenew.should.equal(testData.STAKING_AUTORENEW);
+    });
+  });
+
+  describe('Fee Delegation Flag Tests', function () {
+    it('should set fee delegation for all staking-related transaction types', async function () {
+      const testTypes = [
+        { type: TransactionType.ContractCall, name: 'Staking' },
+        { type: TransactionType.StakingUnlock, name: 'Exit Delegation' },
+        { type: TransactionType.StakingWithdraw, name: 'Burn NFT' },
+        { type: TransactionType.StakingClaim, name: 'Claim Rewards' },
+      ];
+
+      for (const testCase of testTypes) {
+        const stakingBuilder = factory.getStakingBuilder();
+        stakingBuilder
+          .stakingContractAddress(stakingContractAddress)
+          .amountToStake(amountToStake)
+          .levelId(levelId)
+          .sender(senderAddress)
+          .chainTag(0x27)
+          .blockRef('0x014ead140e77bbc1')
+          .expiration(64)
+          .gas(100000)
+          .gasPriceCoef(128)
+          .nonce('12345');
+
+        stakingBuilder.addFeePayerAddress(feePayerAddress);
+
+        // Manually set the transaction type to test different types
+        const tx = (await stakingBuilder.build()) as StakingTransaction;
+        (tx as any)._type = testCase.type;
+
+        // Rebuild the raw transaction to test fee delegation flag
+        await (tx as any).buildRawTransaction();
+
+        // Verify fee delegation is set for all types
+        const rawTxBody = tx.rawTransaction.body;
+        should.exist(rawTxBody.reserved);
+        rawTxBody.reserved!.should.have.property('features', 1);
+      }
+    });
+  });
+});