feat(sdk-coin-tempo): add tests for TIP-20 transaction builder

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

@@ -65,11 +65,7 @@ export class Tip20Transaction extends BaseTransaction {
    * @private
    */
   private encodeCallsAsTuples(): any[] {
-    return this.txRequest.calls.map((call) => [
-      call.to,
-      call.value ? ethers.utils.hexlify(call.value) : '0x',
-      call.data,
-    ]);
+    return this.txRequest.calls.map((call) => [call.to, this.bigintToHex(call.value), call.data]);
   }
 
   /**
@@ -81,6 +77,20 @@ export class Tip20Transaction extends BaseTransaction {
     return (this.txRequest.accessList ?? []).map((item: any) => [item.address, item.storageKeys || []]);
   }
 
+  /**
+   * Convert bigint to hex string for RLP encoding
+   * @param value bigint value to convert
+   * @returns Hex string
+   * @private
+   */
+  private bigintToHex(value: bigint): string {
+    if (value === 0n) {
+      return '0x';
+    }
+    const hex = value.toString(16);
+    return '0x' + (hex.length % 2 ? '0' : '') + hex;
+  }
+
   /**
    * Build base RLP data array per Tempo EIP-7702 specification
    * @param callsTuples Encoded calls
@@ -91,9 +101,9 @@ export class Tip20Transaction extends BaseTransaction {
   private buildBaseRlpData(callsTuples: any[], accessTuples: any[]): any[] {
     return [
       ethers.utils.hexlify(this.txRequest.chainId),
-      this.txRequest.maxPriorityFeePerGas ? ethers.utils.hexlify(this.txRequest.maxPriorityFeePerGas.toString()) : '0x',
-      ethers.utils.hexlify(this.txRequest.maxFeePerGas.toString()),
-      ethers.utils.hexlify(this.txRequest.gas.toString()),
+      this.txRequest.maxPriorityFeePerGas ? this.bigintToHex(this.txRequest.maxPriorityFeePerGas) : '0x',
+      this.bigintToHex(this.txRequest.maxFeePerGas),
+      this.bigintToHex(this.txRequest.gas),
       callsTuples,
       accessTuples,
       '0x', // nonceKey (reserved for 2D nonce system)

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

@@ -46,9 +46,13 @@ export class Tip20TransactionBuilder extends AbstractTransactionBuilder {
   }
 
   /**
-   * Build the transaction from configured TIP-20 operations and transaction parameters
+   * Validate the transaction has all required fields for Tempo AA transactions.
+   * Overrides parent class validation since AA transactions use a different model
+   * (operations-based rather than single contract address).
+   *
+   * @throws BuildTransactionError if validation fails
    */
-  protected async buildImplementation(): Promise<BaseTransaction> {
+  validateTransaction(): void {
     if (this.operations.length === 0) {
       throw new BuildTransactionError('At least one operation is required to build a transaction');
     }
@@ -68,6 +72,29 @@ export class Tip20TransactionBuilder extends AbstractTransactionBuilder {
     if (this._maxPriorityFeePerGas === undefined) {
       throw new BuildTransactionError('maxPriorityFeePerGas is required to build a transaction');
     }
+  }
+
+  /**
+   * Build the transaction from configured TIP-20 operations and transaction parameters.
+   */
+  protected async buildImplementation(): Promise<BaseTransaction> {
+    if (
+      this._nonce === undefined ||
+      this._gas === undefined ||
+      this._maxFeePerGas === undefined ||
+      this._maxPriorityFeePerGas === undefined
+    ) {
+      throw new BuildTransactionError('Transaction validation failed: missing required fields');
+    }
+
+    this.fee({
+      fee: this._maxFeePerGas.toString(),
+      gasLimit: this._gas.toString(),
+      eip1559: {
+        maxFeePerGas: this._maxFeePerGas.toString(),
+        maxPriorityFeePerGas: this._maxPriorityFeePerGas.toString(),
+      },
+    });
 
     const calls = this.operations.map((op) => this.operationToCall(op));
 

modules/sdk-coin-tempo/test/integration/tip20.ts

@@ -1,121 +1,213 @@
+/**
+ * TIP-20 Integration Tests
+ *
+ * End-to-end flows for TIP-20 token transactions on Tempo using testnet token addresses.
+ */
+
+import assert from 'assert';
 import { describe, it } from 'mocha';
+import { ethers } from 'ethers';
+import { coins } from '@bitgo/statics';
 import { Tip20TransactionBuilder } from '../../src/lib/transactionBuilder';
+import { Tip20Transaction } from '../../src/lib/transaction';
 import { Address } from '../../src/lib/types';
-import { coins } from '@bitgo/statics';
+import { AA_TRANSACTION_TYPE, TEMPO_CHAIN_IDS } from '../../src/lib/constants';
+import { TESTNET_TOKENS, TX_PARAMS, SIGNATURE_TEST_DATA, TEST_RECIPIENT_ADDRESS } from '../resources/tempo';
 
 const mockCoinConfig = coins.get('ttempo');
 
+const ALPHA_USD_TOKEN = TESTNET_TOKENS.alphaUSD.address as Address;
+const BETA_USD_TOKEN = TESTNET_TOKENS.betaUSD.address as Address;
+const THETA_USD_TOKEN = TESTNET_TOKENS.thetaUSD.address as Address;
+const RECEIVER_ADDRESS = TEST_RECIPIENT_ADDRESS as Address;
+
 describe('TIP-20 Integration Tests', () => {
-  const ALPHA_USD_TOKEN = '0x...' as Address;
-  const BETA_USD_TOKEN = '0x...' as Address;
-  const THETA_USD_TOKEN = '0x...' as Address;
-  const RECEIVER_ADDRESS = '0x...' as Address;
+  describe('Single Transfer', () => {
+    it('should build and serialize single TIP-20 transfer', async () => {
+      const builder = new Tip20TransactionBuilder(mockCoinConfig);
 
-  describe.skip('Single Transfer', () => {
-    it('should build single TIP-20 transfer without memo', async () => {
+      builder
+        .addOperation({
+          token: ALPHA_USD_TOKEN,
+          to: RECEIVER_ADDRESS,
+          amount: '1',
+          memo: '1',
+        })
+        .feeToken(ALPHA_USD_TOKEN)
+        .nonce(0)
+        .gas(TX_PARAMS.defaultGas)
+        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)
+        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);
+
+      const tx = (await builder.build()) as Tip20Transaction;
+
+      assert.ok(tx instanceof Tip20Transaction);
+      assert.strictEqual(tx.getOperationCount(), 1);
+      assert.strictEqual(tx.isBatch(), false);
+      assert.strictEqual(tx.getOperations()[0].memo, '1');
+
+      const serialized = await tx.serialize();
+      assert.ok(serialized.startsWith(AA_TRANSACTION_TYPE));
+    });
+  });
+
+  describe('Batch Transfer', () => {
+    it('should build multi-token batch transfer', async () => {
       const builder = new Tip20TransactionBuilder(mockCoinConfig);
-      builder.addOperation({
-        token: ALPHA_USD_TOKEN,
-        to: RECEIVER_ADDRESS,
-        amount: '1.0',
-      });
-      builder.feeToken(ALPHA_USD_TOKEN);
-      // TODO: const tx = await builder.build();
+
+      builder
+        .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '15', memo: '1' })
+        .addOperation({ token: BETA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '20', memo: '2' })
+        .addOperation({ token: THETA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '7', memo: '3' })
+        .feeToken(BETA_USD_TOKEN)
+        .nonce(10)
+        .gas(400000n)
+        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)
+        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);
+
+      const tx = (await builder.build()) as Tip20Transaction;
+
+      assert.strictEqual(tx.getOperationCount(), 3);
+      assert.strictEqual(tx.isBatch(), true);
+      assert.strictEqual(tx.getFeeToken(), BETA_USD_TOKEN);
+
+      const operations = tx.getOperations();
+      assert.strictEqual(operations[0].token, ALPHA_USD_TOKEN);
+      assert.strictEqual(operations[1].token, BETA_USD_TOKEN);
+      assert.strictEqual(operations[2].token, THETA_USD_TOKEN);
+    });
+  });
+
+  describe('Transaction Signing', () => {
+    it('should produce unsigned transaction with correct RLP structure', async () => {
+      const builder = new Tip20TransactionBuilder(mockCoinConfig);
+
+      builder
+        .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })
+        .feeToken(ALPHA_USD_TOKEN)
+        .nonce(0)
+        .gas(TX_PARAMS.defaultGas)
+        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)
+        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);
+
+      const tx = (await builder.build()) as Tip20Transaction;
+      const unsignedHex = await tx.serialize();
+
+      assert.ok(unsignedHex.startsWith(AA_TRANSACTION_TYPE));
+      assert.strictEqual(tx.getSignature(), undefined);
+
+      // Verify RLP structure (13 fields for unsigned)
+      const rlpPart = '0x' + unsignedHex.slice(4);
+      const decoded = ethers.utils.RLP.decode(rlpPart);
+      assert.strictEqual(decoded.length, 13);
     });
 
-    it('should build single TIP-20 transfer with memo', async () => {
+    it('should apply signature and produce broadcast format', async () => {
       const builder = new Tip20TransactionBuilder(mockCoinConfig);
-      builder.addOperation({
-        token: ALPHA_USD_TOKEN,
-        to: RECEIVER_ADDRESS,
-        amount: '1.0',
-        memo: '12345',
-      });
-      builder.feeToken(ALPHA_USD_TOKEN);
-      // TODO: const tx = await builder.build();
+
+      builder
+        .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })
+        .feeToken(ALPHA_USD_TOKEN)
+        .nonce(0)
+        .gas(TX_PARAMS.defaultGas)
+        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)
+        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);
+
+      const tx = (await builder.build()) as Tip20Transaction;
+      tx.setSignature(SIGNATURE_TEST_DATA.validSignature);
+
+      const signedHex = await tx.toBroadcastFormat();
+
+      // Verify it includes signature (14 fields)
+      assert.ok(signedHex.startsWith(AA_TRANSACTION_TYPE));
+      const rlpPart = '0x' + signedHex.slice(4);
+      const decoded = ethers.utils.RLP.decode(rlpPart);
+      assert.strictEqual(decoded.length, 14);
+
+      const storedSig = tx.getSignature();
+      assert.ok(storedSig);
+      assert.strictEqual(storedSig?.r, SIGNATURE_TEST_DATA.validSignature.r);
     });
   });
 
-  describe.skip('Batch Transfer', () => {
-    it('should build batch transfer with multiple memos', async () => {
+  describe('Fee Token Selection', () => {
+    it('should pay fees with different token than transfer', async () => {
       const builder = new Tip20TransactionBuilder(mockCoinConfig);
+
       builder
-        .addOperation({
-          token: ALPHA_USD_TOKEN,
-          to: RECEIVER_ADDRESS,
-          amount: '0.5',
-          memo: '1001',
-        })
-        .addOperation({
-          token: ALPHA_USD_TOKEN,
-          to: RECEIVER_ADDRESS,
-          amount: '0.3',
-          memo: '1002',
-        })
-        .addOperation({
-          token: ALPHA_USD_TOKEN,
-          to: RECEIVER_ADDRESS,
-          amount: '0.2',
-          memo: '1003',
-        });
-      builder.feeToken(ALPHA_USD_TOKEN);
-      // TODO: const tx = await builder.build();
+        .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })
+        .feeToken(BETA_USD_TOKEN)
+        .nonce(0)
+        .gas(TX_PARAMS.defaultGas)
+        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)
+        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);
+
+      const tx = (await builder.build()) as Tip20Transaction;
+
+      assert.strictEqual(tx.getOperations()[0].token, ALPHA_USD_TOKEN);
+      assert.strictEqual(tx.getFeeToken(), BETA_USD_TOKEN);
     });
 
-    it('should build multi-token batch transfer', async () => {
+    it('should build transaction without explicit fee token', async () => {
       const builder = new Tip20TransactionBuilder(mockCoinConfig);
+
       builder
-        .addOperation({
-          token: ALPHA_USD_TOKEN,
-          to: RECEIVER_ADDRESS,
-          amount: '1.5',
-          memo: '2001',
-        })
-        .addOperation({
-          token: BETA_USD_TOKEN,
-          to: RECEIVER_ADDRESS,
-          amount: '2.0',
-          memo: '2002',
-        })
-        .addOperation({
-          token: THETA_USD_TOKEN,
-          to: RECEIVER_ADDRESS,
-          amount: '0.75',
-          memo: '2003',
-        });
-      builder.feeToken(BETA_USD_TOKEN);
-      // TODO: const tx = await builder.build();
+        .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })
+        .nonce(0)
+        .gas(TX_PARAMS.defaultGas)
+        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)
+        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);
+
+      const tx = (await builder.build()) as Tip20Transaction;
+
+      assert.strictEqual(tx.getFeeToken(), undefined);
+      const serialized = await tx.serialize();
+      assert.ok(serialized.startsWith(AA_TRANSACTION_TYPE));
     });
   });
 
-  describe.skip('Transaction Signing', () => {
-    it('should sign and serialize transaction', async () => {
+  describe('Transaction JSON', () => {
+    it('should produce complete JSON representation', async () => {
       const builder = new Tip20TransactionBuilder(mockCoinConfig);
-      builder.addOperation({
-        token: ALPHA_USD_TOKEN,
-        to: RECEIVER_ADDRESS,
-        amount: '1.0',
-        memo: '9999',
-      });
-      builder.feeToken(ALPHA_USD_TOKEN);
-      // TODO: Implement signing with ethers.js Wallet
-      // TODO: const tx = await builder.build();
-      // TODO: tx.setSignature(signature);
-      // TODO: const serialized = await tx.toBroadcastFormat();
+
+      builder
+        .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '123456', memo: '5' })
+        .feeToken(BETA_USD_TOKEN)
+        .nonce(42)
+        .gas(150000n)
+        .maxFeePerGas(3000000000n)
+        .maxPriorityFeePerGas(1500000000n);
+
+      const tx = (await builder.build()) as Tip20Transaction;
+      const json = tx.toJson();
+
+      assert.strictEqual(json.type, AA_TRANSACTION_TYPE);
+      assert.strictEqual(json.chainId, TEMPO_CHAIN_IDS.TESTNET);
+      assert.strictEqual(json.nonce, 42);
+      assert.strictEqual(json.gas, '150000');
+      assert.strictEqual(json.feeToken, BETA_USD_TOKEN);
+
+      const ops = json.operations as any[];
+      assert.strictEqual(ops[0].token, ALPHA_USD_TOKEN);
+      assert.strictEqual(ops[0].amount, '123456');
+      assert.strictEqual(ops[0].memo, '5');
     });
   });
 
-  describe.skip('Fee Token Selection', () => {
-    it('should pay fees with different token than transfer', async () => {
+  describe('canBroadcast Check', () => {
+    it('should return true for valid transaction', async () => {
       const builder = new Tip20TransactionBuilder(mockCoinConfig);
-      builder.addOperation({
-        token: ALPHA_USD_TOKEN,
-        to: RECEIVER_ADDRESS,
-        amount: '1.0',
-        memo: '5555',
-      });
-      builder.feeToken(BETA_USD_TOKEN);
-      // TODO: const tx = await builder.build();
+
+      builder
+        .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })
+        .feeToken(ALPHA_USD_TOKEN)
+        .nonce(0)
+        .gas(TX_PARAMS.defaultGas)
+        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)
+        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);
+
+      const tx = (await builder.build()) as Tip20Transaction;
+      assert.strictEqual(tx.canBroadcast(), true);
     });
   });
 });