@bitgo-beta/sdk-coin-tempo 1.0.1-beta.31 → 1.0.1-beta.310

package/dist/test/unit/transactionBuilder.js

@@ -0,0 +1,858 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const mocha_1 = require("mocha");
+const ethers_1 = require("ethers");
+const transactionBuilder_1 = require("../../src/lib/transactionBuilder");
+const transaction_1 = require("../../src/lib/transaction");
+const utils_1 = require("../../src/lib/utils");
+const constants_1 = require("../../src/lib/constants");
+const statics_1 = require("@bitgo-beta/statics");
+const ttempo_1 = require("../../src/ttempo");
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const tempo_1 = require("../resources/tempo");
+const mockCoinConfig = statics_1.coins.get('ttempo');
+(0, mocha_1.describe)('TIP-20 Utilities', () => {
+    (0, mocha_1.describe)('amountToTip20Units', () => {
+        (0, mocha_1.it)('should convert decimal amount to 6-decimal units', () => {
+            assert_1.default.strictEqual((0, utils_1.amountToTip20Units)('1.5'), 1500000n);
+            assert_1.default.strictEqual((0, utils_1.amountToTip20Units)('100'), 100000000n);
+            assert_1.default.strictEqual((0, utils_1.amountToTip20Units)('0.000001'), 1n);
+        });
+        (0, mocha_1.it)('should throw error for invalid amount', () => {
+            assert_1.default.throws(() => (0, utils_1.amountToTip20Units)('invalid'), /Invalid amount format/);
+        });
+    });
+    (0, mocha_1.describe)('tip20UnitsToAmount', () => {
+        (0, mocha_1.it)('should convert 6-decimal units to human-readable amount', () => {
+            assert_1.default.strictEqual((0, utils_1.tip20UnitsToAmount)(1500000n), '1.5');
+            assert_1.default.strictEqual((0, utils_1.tip20UnitsToAmount)(100000000n), '100.0');
+            assert_1.default.strictEqual((0, utils_1.tip20UnitsToAmount)(1n), '0.000001');
+        });
+    });
+    (0, mocha_1.describe)('stringToBytes32', () => {
+        (0, mocha_1.it)('should convert string to bytes32', () => {
+            const result = (0, utils_1.stringToBytes32)('12345');
+            assert_1.default.strictEqual(result.length, 66);
+            assert_1.default.ok(result.startsWith('0x'));
+        });
+        (0, mocha_1.it)('should throw error for string longer than 32 bytes', () => {
+            assert_1.default.throws(() => (0, utils_1.stringToBytes32)('a'.repeat(33)), /Memo too long/);
+        });
+    });
+    (0, mocha_1.describe)('encodeTip20TransferWithMemo', () => {
+        (0, mocha_1.it)('should encode transferWithMemo call', () => {
+            const to = ethers_1.ethers.utils.getAddress('0x742d35cc6634c0532925a3b844bc9e7595f0beb1');
+            const encoded = (0, utils_1.encodeTip20TransferWithMemo)(to, 1500000n, '12345');
+            assert_1.default.ok(encoded.startsWith('0x'));
+            assert_1.default.ok(encoded.length > 10);
+        });
+    });
+    (0, mocha_1.describe)('isValidTip20Amount', () => {
+        (0, mocha_1.it)('should validate amounts correctly', () => {
+            assert_1.default.strictEqual((0, utils_1.isValidTip20Amount)('1.5'), true);
+            assert_1.default.strictEqual((0, utils_1.isValidTip20Amount)('invalid'), false);
+            assert_1.default.strictEqual((0, utils_1.isValidTip20Amount)('-5'), false);
+        });
+    });
+});
+(0, mocha_1.describe)('TIP-20 Transaction Builder', () => {
+    const mockToken = ethers_1.ethers.utils.getAddress('0x1234567890123456789012345678901234567890');
+    const mockRecipient = ethers_1.ethers.utils.getAddress('0x742d35cc6634c0532925a3b844bc9e7595f0beb1');
+    const mockFeeToken = ethers_1.ethers.utils.getAddress('0xabcdefabcdefabcdefabcdefabcdefabcdefabcd');
+    (0, mocha_1.describe)('addOperation', () => {
+        (0, mocha_1.it)('should add operation with and without memo', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder.addOperation({ token: mockToken, to: mockRecipient, amount: '100' });
+            builder.addOperation({ token: mockToken, to: mockRecipient, amount: '50', memo: '1' });
+            const operations = builder.getOperations();
+            assert_1.default.strictEqual(operations.length, 2);
+            assert_1.default.strictEqual(operations[0].memo, undefined);
+            assert_1.default.strictEqual(operations[1].memo, '1');
+        });
+        (0, mocha_1.it)('should throw error for invalid addresses', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            assert_1.default.throws(() => builder.addOperation({ token: '0xinvalid', to: mockRecipient, amount: '100' }), /Invalid token address/);
+            assert_1.default.throws(() => builder.addOperation({ token: mockToken, to: '0xinvalid', amount: '100' }), /Invalid recipient address/);
+        });
+        (0, mocha_1.it)('should throw error for invalid amount', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            assert_1.default.throws(() => builder.addOperation({ token: mockToken, to: mockRecipient, amount: 'invalid-amount' }), /Invalid amount/);
+        });
+        (0, mocha_1.it)('should throw error for invalid (non-numeric) memo', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            assert_1.default.throws(() => builder.addOperation({ token: mockToken, to: mockRecipient, amount: '100', memo: 'INV-001' }), /Invalid memo/);
+        });
+    });
+    (0, mocha_1.describe)('feeToken', () => {
+        (0, mocha_1.it)('should set and get fee token', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder.feeToken(mockFeeToken);
+            assert_1.default.strictEqual(builder.getFeeToken(), mockFeeToken);
+        });
+        (0, mocha_1.it)('should throw error for invalid fee token address', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            assert_1.default.throws(() => builder.feeToken('invalid-address'), /Invalid fee token address/);
+        });
+    });
+    (0, mocha_1.describe)('Transaction parameters', () => {
+        (0, mocha_1.it)('should set nonce, gas, maxFeePerGas, and maxPriorityFeePerGas', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder.nonce(42).gas(500000n).maxFeePerGas(1000000000n).maxPriorityFeePerGas(500000000n);
+            assert_1.default.strictEqual(builder._nonce, 42);
+            assert_1.default.strictEqual(builder._gas, 500000n);
+            assert_1.default.strictEqual(builder._maxFeePerGas, 1000000000n);
+            assert_1.default.strictEqual(builder._maxPriorityFeePerGas, 500000000n);
+        });
+        (0, mocha_1.it)('should throw error for invalid nonce and gas', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            assert_1.default.throws(() => builder.nonce(-1), /Invalid nonce/);
+            assert_1.default.throws(() => builder.gas(0n), /Invalid gas limit/);
+        });
+    });
+    (0, mocha_1.describe)('Method chaining', () => {
+        (0, mocha_1.it)('should support fluent interface', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            const result = builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '100', memo: '5' })
+                .feeToken(mockFeeToken)
+                .nonce(10)
+                .gas(400000n)
+                .maxFeePerGas(2000000000n)
+                .maxPriorityFeePerGas(1000000000n);
+            assert_1.default.strictEqual(result, builder);
+        });
+    });
+});
+(0, mocha_1.describe)('TIP-20 Constants', () => {
+    (0, mocha_1.it)('should have correct decimal places', () => {
+        assert_1.default.strictEqual(constants_1.TIP20_DECIMALS, 6);
+    });
+});
+(0, mocha_1.describe)('TIP-20 Transaction Build', () => {
+    const mockToken = ethers_1.ethers.utils.getAddress(tempo_1.TESTNET_TOKENS.alphaUSD.address);
+    const mockRecipient = ethers_1.ethers.utils.getAddress(tempo_1.TEST_RECIPIENT_ADDRESS);
+    const mockFeeToken = ethers_1.ethers.utils.getAddress(tempo_1.TESTNET_TOKENS.betaUSD.address);
+    (0, mocha_1.describe)('Build Transaction', () => {
+        (0, mocha_1.it)('should build single-operation transaction', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '100', memo: '1' })
+                .feeToken(mockFeeToken)
+                .nonce(0)
+                .gas(100000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            assert_1.default.ok(tx instanceof transaction_1.Tip20Transaction);
+            assert_1.default.strictEqual(tx.getOperationCount(), 1);
+            assert_1.default.strictEqual(tx.getFeeToken(), mockFeeToken);
+        });
+        (0, mocha_1.it)('should build batch transaction with multiple operations', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: tempo_1.TESTNET_TOKENS.alphaUSD.address, to: mockRecipient, amount: '10', memo: '1' })
+                .addOperation({ token: tempo_1.TESTNET_TOKENS.betaUSD.address, to: mockRecipient, amount: '20', memo: '2' })
+                .addOperation({ token: tempo_1.TESTNET_TOKENS.thetaUSD.address, to: mockRecipient, amount: '30', memo: '3' })
+                .feeToken(mockFeeToken)
+                .nonce(42)
+                .gas(300000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            assert_1.default.ok(tx instanceof transaction_1.Tip20Transaction);
+            assert_1.default.strictEqual(tx.getOperationCount(), 3);
+            assert_1.default.strictEqual(tx.isBatch(), true);
+        });
+        (0, mocha_1.it)('should build transaction without fee token', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '50' })
+                .nonce(1)
+                .gas(100000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            assert_1.default.ok(tx instanceof transaction_1.Tip20Transaction);
+            assert_1.default.strictEqual(tx.getFeeToken(), undefined);
+        });
+    });
+    (0, mocha_1.describe)('Build Validation Errors', () => {
+        (0, mocha_1.it)('should throw error when no operations added', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder.nonce(0).gas(100000n).maxFeePerGas(1000000000n).maxPriorityFeePerGas(500000000n);
+            await assert_1.default.rejects(async () => await builder.build(), /At least one operation or raw call is required/);
+        });
+        (0, mocha_1.it)('should throw error when nonce not set', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })
+                .gas(100000n)
+                .maxFeePerGas(1000000000n)
+                .maxPriorityFeePerGas(500000000n);
+            await assert_1.default.rejects(async () => await builder.build(), tempo_1.ERROR_MESSAGES.missingNonce);
+        });
+        (0, mocha_1.it)('should throw error when gas not set', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })
+                .nonce(0)
+                .maxFeePerGas(1000000000n)
+                .maxPriorityFeePerGas(500000000n);
+            await assert_1.default.rejects(async () => await builder.build(), tempo_1.ERROR_MESSAGES.missingGas);
+        });
+        (0, mocha_1.it)('should throw error when maxFeePerGas not set', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })
+                .nonce(0)
+                .gas(100000n)
+                .maxPriorityFeePerGas(500000000n);
+            await assert_1.default.rejects(async () => await builder.build(), tempo_1.ERROR_MESSAGES.missingMaxFeePerGas);
+        });
+        (0, mocha_1.it)('should throw error when maxPriorityFeePerGas not set', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })
+                .nonce(0)
+                .gas(100000n)
+                .maxFeePerGas(1000000000n);
+            await assert_1.default.rejects(async () => await builder.build(), tempo_1.ERROR_MESSAGES.missingMaxPriorityFeePerGas);
+        });
+    });
+    (0, mocha_1.describe)('Round-Trip: Build -> Serialize -> Operations Check', () => {
+        (0, mocha_1.it)('should preserve operation data through build', async () => {
+            const operations = [{ token: mockToken, to: mockRecipient, amount: '123', memo: '1' }];
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation(operations[0])
+                .feeToken(mockFeeToken)
+                .nonce(10)
+                .gas(150000n)
+                .maxFeePerGas(2000000000n)
+                .maxPriorityFeePerGas(1000000000n);
+            const tx = (await builder.build());
+            const txOps = tx.getOperations();
+            assert_1.default.strictEqual(txOps.length, 1);
+            assert_1.default.strictEqual(txOps[0].token, operations[0].token);
+            assert_1.default.strictEqual(txOps[0].to, operations[0].to);
+            assert_1.default.strictEqual(txOps[0].amount, operations[0].amount);
+            assert_1.default.strictEqual(txOps[0].memo, operations[0].memo);
+        });
+    });
+    (0, mocha_1.describe)('Build -> Serialize -> Sign Flow', () => {
+        (0, mocha_1.it)('should produce serializable unsigned transaction', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '50', memo: '2' })
+                .feeToken(mockFeeToken)
+                .nonce(5)
+                .gas(100000n)
+                .maxFeePerGas(2000000000n)
+                .maxPriorityFeePerGas(1000000000n);
+            const tx = (await builder.build());
+            const unsignedHex = await tx.serialize();
+            assert_1.default.ok(unsignedHex.startsWith(constants_1.AA_TRANSACTION_TYPE));
+            assert_1.default.ok(/^0x[0-9a-f]+$/i.test(unsignedHex));
+        });
+        (0, mocha_1.it)('should support full sign and broadcast flow', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '75', memo: '3' })
+                .feeToken(mockFeeToken)
+                .nonce(123)
+                .gas(120000n)
+                .maxFeePerGas(2500000000n)
+                .maxPriorityFeePerGas(1200000000n);
+            const tx = (await builder.build());
+            const unsignedHex = await tx.serialize();
+            tx.setSignature(tempo_1.SIGNATURE_TEST_DATA.validSignature);
+            const broadcastHex = await tx.toBroadcastFormat();
+            assert_1.default.ok(broadcastHex.startsWith(constants_1.AA_TRANSACTION_TYPE));
+            assert_1.default.ok(broadcastHex.length > unsignedHex.length, 'Signed should be longer');
+        });
+    });
+    (0, mocha_1.describe)('Transaction JSON Representation', () => {
+        (0, mocha_1.it)('should produce consistent JSON from built transaction', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '100', memo: '4' })
+                .feeToken(mockFeeToken)
+                .nonce(50)
+                .gas(200000n)
+                .maxFeePerGas(3000000000n)
+                .maxPriorityFeePerGas(1500000000n);
+            const tx = (await builder.build());
+            const json = tx.toJson();
+            assert_1.default.strictEqual(json.type, constants_1.AA_TRANSACTION_TYPE);
+            assert_1.default.strictEqual(json.nonce, 50);
+            assert_1.default.strictEqual(json.gas, '200000');
+            assert_1.default.strictEqual(json.maxFeePerGas, '3000000000');
+            assert_1.default.strictEqual(json.maxPriorityFeePerGas, '1500000000');
+            assert_1.default.strictEqual(json.callCount, 1);
+            assert_1.default.strictEqual(json.feeToken, mockFeeToken);
+        });
+    });
+    (0, mocha_1.describe)('Transaction id getter', () => {
+        (0, mocha_1.it)('unsigned and signed transactions should have different ids', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '10' })
+                .nonce(1)
+                .gas(100000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            const unsignedId = tx.id;
+            tx.setSignature(tempo_1.SIGNATURE_TEST_DATA.validSignature);
+            const signedId = tx.id;
+            assert_1.default.notStrictEqual(unsignedId, signedId, 'Signed and unsigned tx should have different ids');
+        });
+    });
+    (0, mocha_1.describe)('outputs / inputs population', () => {
+        (0, mocha_1.it)('should expose outputs with base-unit value and token address as coin', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '1.5', memo: '7' })
+                .nonce(0)
+                .gas(100000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            assert_1.default.strictEqual(tx.outputs.length, 1);
+            assert_1.default.strictEqual(tx.outputs[0].address, mockRecipient);
+            // 1.5 tokens * 10^6 = 1_500_000 base units
+            assert_1.default.strictEqual(tx.outputs[0].value, '1500000');
+            // coin is the token contract address, not the chain name
+            assert_1.default.strictEqual(tx.outputs[0].coin?.toLowerCase(), mockToken.toLowerCase());
+        });
+        (0, mocha_1.it)('should expose a single input with the total in base units', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '1.5' })
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '3.5' })
+                .nonce(0)
+                .gas(100000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            assert_1.default.strictEqual(tx.inputs.length, 1);
+            assert_1.default.strictEqual(tx.inputs[0].address, '');
+            // (1.5 + 3.5) tokens * 10^6 = 5_000_000 base units
+            assert_1.default.strictEqual(tx.inputs[0].value, '5000000');
+        });
+    });
+    (0, mocha_1.describe)('Round-Trip: Build -> Serialize -> From (deserialization)', () => {
+        (0, mocha_1.it)('should round-trip a single-operation transaction without a signature', async () => {
+            const operation = { token: mockToken, to: mockRecipient, amount: '25.5', memo: '12345' };
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation(operation)
+                .feeToken(mockFeeToken)
+                .nonce(7)
+                .gas(150000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const originalTx = (await builder.build());
+            const serialized = await originalTx.serialize();
+            // Deserialize via from()
+            const builder2 = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder2.from(serialized);
+            const restoredTx = (await builder2.build());
+            const ops = restoredTx.getOperations();
+            assert_1.default.strictEqual(ops.length, 1);
+            assert_1.default.strictEqual(ops[0].token.toLowerCase(), operation.token.toLowerCase());
+            assert_1.default.strictEqual(ops[0].to.toLowerCase(), operation.to.toLowerCase());
+            assert_1.default.strictEqual(ops[0].amount, operation.amount);
+            assert_1.default.strictEqual(ops[0].memo, operation.memo);
+            assert_1.default.strictEqual(restoredTx.getFeeToken()?.toLowerCase(), mockFeeToken.toLowerCase());
+        });
+        (0, mocha_1.it)('should round-trip a batch transaction', async () => {
+            // Use amounts that match tip20UnitsToAmount output: ethers formatUnits always includes decimal
+            const operations = [
+                { token: tempo_1.TESTNET_TOKENS.alphaUSD.address, to: mockRecipient, amount: '10.0', memo: '1' },
+                { token: tempo_1.TESTNET_TOKENS.betaUSD.address, to: mockRecipient, amount: '20.0', memo: '2' },
+            ];
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation(operations[0])
+                .addOperation(operations[1])
+                .nonce(42)
+                .gas(250000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const originalTx = (await builder.build());
+            const serialized = await originalTx.serialize();
+            const builder2 = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder2.from(serialized);
+            const restoredTx = (await builder2.build());
+            assert_1.default.strictEqual(restoredTx.getOperationCount(), 2);
+            assert_1.default.ok(restoredTx.isBatch());
+            const json = restoredTx.toJson();
+            assert_1.default.strictEqual(json.nonce, 42);
+            assert_1.default.strictEqual(json.gas, '250000');
+            assert_1.default.strictEqual(json.maxFeePerGas, tempo_1.TX_PARAMS.defaultMaxFeePerGas.toString());
+            assert_1.default.strictEqual(json.maxPriorityFeePerGas, tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas.toString());
+            const ops = restoredTx.getOperations();
+            for (let i = 0; i < operations.length; i++) {
+                assert_1.default.strictEqual(ops[i].token.toLowerCase(), operations[i].token.toLowerCase());
+                assert_1.default.strictEqual(ops[i].to.toLowerCase(), mockRecipient.toLowerCase());
+                assert_1.default.strictEqual(ops[i].amount, operations[i].amount);
+                assert_1.default.strictEqual(ops[i].memo, operations[i].memo);
+            }
+        });
+        (0, mocha_1.it)('should round-trip a signed transaction and preserve the signature', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '5' })
+                .nonce(99)
+                .gas(100000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            tx.setSignature(tempo_1.SIGNATURE_TEST_DATA.validSignature);
+            const signedHex = await tx.toBroadcastFormat();
+            // Deserialize the signed transaction
+            const builder2 = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder2.from(signedHex);
+            const restoredTx = (await builder2.build());
+            const sig = restoredTx.getSignature();
+            assert_1.default.ok(sig !== undefined, 'Signature should be preserved');
+            assert_1.default.strictEqual(sig.yParity, tempo_1.SIGNATURE_TEST_DATA.validSignature.yParity);
+        });
+        (0, mocha_1.it)('should produce the same tx id after a serialization round-trip', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '100.0', memo: '99' })
+                .nonce(3)
+                .gas(100000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const originalTx = (await builder.build());
+            const serialized = await originalTx.serialize();
+            const originalId = originalTx.id;
+            const builder2 = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder2.from(serialized);
+            const restoredTx = (await builder2.build());
+            assert_1.default.strictEqual(restoredTx.id, originalId);
+            const originalJson = originalTx.toJson();
+            const restoredJson = restoredTx.toJson();
+            assert_1.default.strictEqual(restoredJson.nonce, originalJson.nonce);
+            assert_1.default.strictEqual(restoredJson.gas, originalJson.gas);
+            assert_1.default.strictEqual(restoredJson.maxFeePerGas, originalJson.maxFeePerGas);
+            assert_1.default.strictEqual(restoredJson.maxPriorityFeePerGas, originalJson.maxPriorityFeePerGas);
+            assert_1.default.strictEqual(restoredJson.feeToken, originalJson.feeToken);
+            assert_1.default.strictEqual(restoredJson.callCount, originalJson.callCount);
+            const originalOps = originalTx.getOperations();
+            const restoredOps = restoredTx.getOperations();
+            assert_1.default.strictEqual(restoredOps.length, originalOps.length);
+            assert_1.default.strictEqual(restoredOps[0].token.toLowerCase(), originalOps[0].token.toLowerCase());
+            assert_1.default.strictEqual(restoredOps[0].to.toLowerCase(), originalOps[0].to.toLowerCase());
+            assert_1.default.strictEqual(restoredOps[0].amount, originalOps[0].amount);
+            assert_1.default.strictEqual(restoredOps[0].memo, originalOps[0].memo);
+            const restoredSerialized = await restoredTx.serialize();
+            assert_1.default.strictEqual(restoredSerialized, serialized);
+        });
+    });
+});
+(0, mocha_1.describe)('Tempo coin - parseTransaction / verifyTransaction', () => {
+    let bitgo;
+    let coin;
+    const mockToken = ethers_1.ethers.utils.getAddress(tempo_1.TESTNET_TOKENS.alphaUSD.address);
+    const mockRecipient = ethers_1.ethers.utils.getAddress(tempo_1.TEST_RECIPIENT_ADDRESS);
+    (0, mocha_1.before)(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.safeRegister('ttempo', (bg) => {
+            const mockStaticsCoin = {
+                name: 'ttempo',
+                fullName: 'Testnet Tempo',
+                network: { type: 'testnet' },
+                features: [],
+            };
+            return ttempo_1.Ttempo.createInstance(bg, mockStaticsCoin);
+        });
+        bitgo.initializeTestVars();
+        coin = bitgo.coin('ttempo');
+    });
+    async function buildSerializedTx(operations, nonce = 0) {
+        const builder = new transactionBuilder_1.Tip20TransactionBuilder(statics_1.coins.get('ttempo'));
+        for (const op of operations) {
+            builder.addOperation(op);
+        }
+        builder
+            .nonce(nonce)
+            .gas(100000n)
+            .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+            .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+        const tx = (await builder.build());
+        return tx.serialize();
+    }
+    (0, mocha_1.describe)('parseTransaction', () => {
+        (0, mocha_1.it)('should parse a single-operation transaction into outputs', async () => {
+            const txHex = await buildSerializedTx([{ token: mockToken, to: mockRecipient, amount: '50', memo: '1' }]);
+            const parsed = await coin.parseTransaction({ txHex });
+            assert_1.default.ok(Array.isArray(parsed.outputs), 'outputs should be an array');
+            assert_1.default.strictEqual(parsed.outputs.length, 1);
+            assert_1.default.strictEqual(parsed.outputs[0].address.toLowerCase(), mockRecipient.toLowerCase());
+            // 50 tokens * 10^6 = 50_000_000 base units
+            assert_1.default.strictEqual(parsed.outputs[0].amount, '50000000');
+        });
+        (0, mocha_1.it)('should return empty object when no txHex is provided', async () => {
+            const parsed = await coin.parseTransaction({});
+            assert_1.default.deepStrictEqual(parsed, {});
+        });
+    });
+    (0, mocha_1.describe)('verifyTransaction', () => {
+        (0, mocha_1.it)('should return true when no recipients are specified', async () => {
+            const txHex = await buildSerializedTx([{ token: mockToken, to: mockRecipient, amount: '10' }]);
+            const result = await coin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {},
+            });
+            assert_1.default.strictEqual(result, true);
+        });
+        (0, mocha_1.it)('should return true when recipients match operations', async () => {
+            const txHex = await buildSerializedTx([{ token: mockToken, to: mockRecipient, amount: '100' }]);
+            const result = await coin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    recipients: [{ address: mockRecipient, amount: '100000000' }], // 100 * 10^6 base units
+                },
+            });
+            assert_1.default.strictEqual(result, true);
+        });
+        (0, mocha_1.it)('should throw when recipient address does not match', async () => {
+            const txHex = await buildSerializedTx([{ token: mockToken, to: mockRecipient, amount: '100' }]);
+            const wrongAddress = ethers_1.ethers.utils.getAddress('0x1111111111111111111111111111111111111111');
+            await assert_1.default.rejects(() => coin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: { recipients: [{ address: wrongAddress, amount: '100000000' }] },
+            }), /recipient mismatch/);
+        });
+        (0, mocha_1.it)('should throw when recipient amount does not match', async () => {
+            const txHex = await buildSerializedTx([{ token: mockToken, to: mockRecipient, amount: '100' }]);
+            await assert_1.default.rejects(() => coin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: { recipients: [{ address: mockRecipient, amount: '999' }] },
+            }), /amount mismatch/);
+        });
+        (0, mocha_1.it)('should throw when operation count differs from recipient count', async () => {
+            const txHex = await buildSerializedTx([{ token: mockToken, to: mockRecipient, amount: '10' }]);
+            await assert_1.default.rejects(() => coin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    recipients: [
+                        { address: mockRecipient, amount: '10000000' },
+                        { address: mockRecipient, amount: '10000000' },
+                    ],
+                },
+            }), /operation\(s\)/);
+        });
+        (0, mocha_1.it)('should return true when no txHex is provided', async () => {
+            const result = await coin.verifyTransaction({ txPrebuild: {}, txParams: {} });
+            assert_1.default.strictEqual(result, true);
+        });
+    });
+    (0, mocha_1.describe)('verifyTransaction with feeToken', () => {
+        (0, mocha_1.it)('should verify transaction with matching fee token', async () => {
+            const feeToken = ethers_1.ethers.utils.getAddress(tempo_1.TESTNET_TOKENS.betaUSD.address);
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(statics_1.coins.get('ttempo'));
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })
+                .feeToken(feeToken)
+                .nonce(0)
+                .gas(100000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            const txHex = await tx.serialize();
+            const result = await coin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: { feeToken: feeToken },
+            });
+            assert_1.default.strictEqual(result, true);
+        });
+        (0, mocha_1.it)('should throw when fee token does not match', async () => {
+            const feeToken = ethers_1.ethers.utils.getAddress(tempo_1.TESTNET_TOKENS.betaUSD.address);
+            const wrongFeeToken = ethers_1.ethers.utils.getAddress(tempo_1.TESTNET_TOKENS.alphaUSD.address);
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(statics_1.coins.get('ttempo'));
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })
+                .feeToken(feeToken)
+                .nonce(0)
+                .gas(100000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            const txHex = await tx.serialize();
+            await assert_1.default.rejects(() => coin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: { feeToken: wrongFeeToken },
+            }), /Fee token mismatch/);
+        });
+        (0, mocha_1.it)('should throw when fee token is expected but transaction has none', async () => {
+            const expectedFeeToken = ethers_1.ethers.utils.getAddress(tempo_1.TESTNET_TOKENS.betaUSD.address);
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(statics_1.coins.get('ttempo'));
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })
+                .nonce(0)
+                .gas(100000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            const txHex = await tx.serialize();
+            await assert_1.default.rejects(() => coin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: { feeToken: expectedFeeToken },
+            }), /Fee token mismatch/);
+        });
+        (0, mocha_1.it)('should pass verification when no fee token is specified in params', async () => {
+            const feeToken = ethers_1.ethers.utils.getAddress(tempo_1.TESTNET_TOKENS.betaUSD.address);
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(statics_1.coins.get('ttempo'));
+            builder
+                .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })
+                .feeToken(feeToken)
+                .nonce(0)
+                .gas(100000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            const txHex = await tx.serialize();
+            // No feeToken in txParams - should not verify, just pass
+            const result = await coin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {},
+            });
+            assert_1.default.strictEqual(result, true);
+        });
+    });
+});
+(0, mocha_1.describe)('Raw Contract Call Builder', () => {
+    const mockContract = ethers_1.ethers.utils.getAddress('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef');
+    const mockCalldata = '0xa9059cbb000000000000000000000000742d35cc6634c0532925a3b844bc454e4438f44e0000000000000000000000000000000000000000000000000000000000989680';
+    (0, mocha_1.describe)('addRawCall', () => {
+        (0, mocha_1.it)('should add a raw call and return it via getRawCalls()', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder.addRawCall({ to: mockContract, data: mockCalldata });
+            const rawCalls = builder.getRawCalls();
+            assert_1.default.strictEqual(rawCalls.length, 1);
+            assert_1.default.strictEqual(rawCalls[0].to, mockContract);
+            assert_1.default.strictEqual(rawCalls[0].data, mockCalldata);
+        });
+        (0, mocha_1.it)('should support chaining addRawCall', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            const result = builder.addRawCall({ to: mockContract, data: mockCalldata });
+            assert_1.default.strictEqual(result, builder);
+        });
+        (0, mocha_1.it)('should throw for invalid contract address', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            assert_1.default.throws(() => builder.addRawCall({ to: '0xinvalid', data: mockCalldata }), /Invalid contract address/);
+        });
+        (0, mocha_1.it)('should throw for empty calldata', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            assert_1.default.throws(() => builder.addRawCall({ to: mockContract, data: '0x' }), /Invalid calldata/);
+        });
+        (0, mocha_1.it)('should throw for non-hex calldata', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            assert_1.default.throws(() => builder.addRawCall({ to: mockContract, data: 'not-hex-data' }), /Invalid calldata/);
+        });
+        (0, mocha_1.it)('should throw for calldata missing 0x prefix', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            assert_1.default.throws(() => builder.addRawCall({ to: mockContract, data: 'a9059cbb' }), /Invalid calldata/);
+        });
+        (0, mocha_1.it)('should throw for odd-length hex calldata', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            assert_1.default.throws(() => builder.addRawCall({ to: mockContract, data: '0xabc' }), /Invalid calldata/);
+        });
+        (0, mocha_1.it)('should throw for invalid value string', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            assert_1.default.throws(() => builder.addRawCall({ to: mockContract, data: mockCalldata, value: '1e18' }), /Invalid value/);
+        });
+        (0, mocha_1.it)('should throw for negative value', () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            assert_1.default.throws(() => builder.addRawCall({ to: mockContract, data: mockCalldata, value: '-1' }), /Invalid value/);
+        });
+        (0, mocha_1.it)('should allow raw-call-only transaction (no operations)', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addRawCall({ to: mockContract, data: mockCalldata })
+                .nonce(0)
+                .gas(100000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            assert_1.default.ok(tx instanceof transaction_1.Tip20Transaction);
+            assert_1.default.strictEqual(tx.getOperations().length, 0);
+            assert_1.default.strictEqual(tx.getRawCalls().length, 1);
+            assert_1.default.strictEqual(tx.getOperationCount(), 1);
+        });
+    });
+    (0, mocha_1.describe)('Round-Trip: Build -> Serialize -> From (raw call deserialization)', () => {
+        (0, mocha_1.it)('should preserve raw call calldata through a round-trip', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addRawCall({ to: mockContract, data: mockCalldata })
+                .nonce(5)
+                .gas(150000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const originalTx = (await builder.build());
+            const serialized = await originalTx.serialize();
+            const builder2 = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder2.from(serialized);
+            const restoredTx = (await builder2.build());
+            assert_1.default.strictEqual(restoredTx.getOperations().length, 0);
+            const rawCalls = restoredTx.getRawCalls();
+            assert_1.default.strictEqual(rawCalls.length, 1);
+            assert_1.default.strictEqual(rawCalls[0].to.toLowerCase(), mockContract.toLowerCase());
+            assert_1.default.strictEqual(rawCalls[0].data.toLowerCase(), mockCalldata.toLowerCase());
+        });
+        (0, mocha_1.it)('should preserve calldata through a signed round-trip', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addRawCall({ to: mockContract, data: mockCalldata })
+                .nonce(7)
+                .gas(120000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            tx.setSignature(tempo_1.SIGNATURE_TEST_DATA.validSignature);
+            const signedHex = await tx.toBroadcastFormat();
+            const builder2 = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder2.from(signedHex);
+            const restoredTx = (await builder2.build());
+            const rawCalls = restoredTx.getRawCalls();
+            assert_1.default.strictEqual(rawCalls.length, 1);
+            assert_1.default.strictEqual(rawCalls[0].data.toLowerCase(), mockCalldata.toLowerCase());
+            const sig = restoredTx.getSignature();
+            assert_1.default.ok(sig !== undefined);
+            assert_1.default.strictEqual(sig.yParity, tempo_1.SIGNATURE_TEST_DATA.validSignature.yParity);
+        });
+        (0, mocha_1.it)('should preserve raw call tx id through a round-trip', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addRawCall({ to: mockContract, data: mockCalldata })
+                .nonce(3)
+                .gas(100000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const originalTx = (await builder.build());
+            const serialized = await originalTx.serialize();
+            const originalId = originalTx.id;
+            const builder2 = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder2.from(serialized);
+            const restoredTx = (await builder2.build());
+            assert_1.default.strictEqual(restoredTx.id, originalId);
+        });
+    });
+    (0, mocha_1.describe)('Raw call toJson and outputs', () => {
+        (0, mocha_1.it)('should expose raw call contract address as output', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addRawCall({ to: mockContract, data: mockCalldata, value: '0' })
+                .nonce(2)
+                .gas(200000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            assert_1.default.strictEqual(tx.outputs.length, 1);
+            assert_1.default.strictEqual(tx.outputs[0].address.toLowerCase(), mockContract.toLowerCase());
+        });
+        (0, mocha_1.it)('should include rawCalls in toJson() output', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addRawCall({ to: mockContract, data: mockCalldata })
+                .nonce(0)
+                .gas(100000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            const json = tx.toJson();
+            assert_1.default.ok(Array.isArray(json.rawCalls));
+            assert_1.default.strictEqual(json.rawCalls.length, 1);
+            assert_1.default.strictEqual(json.rawCalls[0].to, mockContract);
+            assert_1.default.strictEqual(json.rawCalls[0].data, mockCalldata);
+        });
+    });
+});
+(0, mocha_1.describe)('Tempo coin - verifyTransaction with raw calls', () => {
+    let bitgo;
+    let coin;
+    const mockContract = ethers_1.ethers.utils.getAddress('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef');
+    const mockCalldata = '0xa9059cbb000000000000000000000000742d35cc6634c0532925a3b844bc454e4438f44e0000000000000000000000000000000000000000000000000000000000989680';
+    (0, mocha_1.before)(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.safeRegister('ttempo', (bg) => {
+            const mockStaticsCoin = {
+                name: 'ttempo',
+                fullName: 'Testnet Tempo',
+                network: { type: 'testnet' },
+                features: [],
+            };
+            return ttempo_1.Ttempo.createInstance(bg, mockStaticsCoin);
+        });
+        bitgo.initializeTestVars();
+        coin = bitgo.coin('ttempo');
+    });
+    async function buildRawCallTx(contract, calldata, nonce = 0) {
+        const builder = new transactionBuilder_1.Tip20TransactionBuilder(statics_1.coins.get('ttempo'));
+        builder
+            .addRawCall({ to: contract, data: calldata })
+            .nonce(nonce)
+            .gas(150000n)
+            .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+            .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+        const tx = (await builder.build());
+        return tx.serialize();
+    }
+    (0, mocha_1.it)('should verify a raw call transaction when recipient data matches', async () => {
+        const txHex = await buildRawCallTx(mockContract, mockCalldata);
+        const result = await coin.verifyTransaction({
+            txPrebuild: { txHex },
+            txParams: {
+                recipients: [{ address: mockContract, amount: '0', data: mockCalldata }],
+            },
+        });
+        assert_1.default.strictEqual(result, true);
+    });
+    (0, mocha_1.it)('should throw when raw call address does not match recipient', async () => {
+        const txHex = await buildRawCallTx(mockContract, mockCalldata);
+        const wrongAddress = ethers_1.ethers.utils.getAddress('0x1111111111111111111111111111111111111111');
+        await assert_1.default.rejects(() => coin.verifyTransaction({
+            txPrebuild: { txHex },
+            txParams: { recipients: [{ address: wrongAddress, amount: '0', data: mockCalldata }] },
+        }), /address mismatch/);
+    });
+    (0, mocha_1.it)('should throw when raw call calldata does not match', async () => {
+        const txHex = await buildRawCallTx(mockContract, mockCalldata);
+        const wrongCalldata = '0xdeadbeef01020304';
+        await assert_1.default.rejects(() => coin.verifyTransaction({
+            txPrebuild: { txHex },
+            txParams: { recipients: [{ address: mockContract, amount: '0', data: wrongCalldata }] },
+        }), /calldata mismatch/);
+    });
+    (0, mocha_1.it)('should throw when recipient count does not match call count', async () => {
+        const txHex = await buildRawCallTx(mockContract, mockCalldata);
+        await assert_1.default.rejects(() => coin.verifyTransaction({
+            txPrebuild: { txHex },
+            txParams: {
+                recipients: [
+                    { address: mockContract, amount: '0', data: mockCalldata },
+                    { address: mockContract, amount: '0', data: mockCalldata },
+                ],
+            },
+        }), /call\(s\)/);
+    });
+    (0, mocha_1.it)('should parse a raw call transaction and expose the contract as an output', async () => {
+        const txHex = await buildRawCallTx(mockContract, mockCalldata);
+        const parsed = await coin.parseTransaction({ txHex });
+        assert_1.default.ok(Array.isArray(parsed.outputs));
+        assert_1.default.strictEqual(parsed.outputs.length, 1);
+        assert_1.default.strictEqual(parsed.outputs[0].address.toLowerCase(), mockContract.toLowerCase());
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilder.js","sourceRoot":"","sources":["../../../test/unit/transactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport { describe, it, before } from 'mocha';\nimport { ethers } from 'ethers';\nimport { Tip20TransactionBuilder } from '../../src/lib/transactionBuilder';\nimport { Tip20Transaction } from '../../src/lib/transaction';\nimport {\n  amountToTip20Units,\n  tip20UnitsToAmount,\n  stringToBytes32,\n  encodeTip20TransferWithMemo,\n  isValidTip20Amount,\n} from '../../src/lib/utils';\nimport { TIP20_DECIMALS, AA_TRANSACTION_TYPE } from '../../src/lib/constants';\nimport { coins } from '@bitgo-beta/statics';\nimport { Ttempo } from '../../src/ttempo';\nimport { BitGoAPI } from '@bitgo-beta/sdk-api';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { BitGoBase } from '@bitgo-beta/sdk-core';\nimport {\n  TESTNET_TOKENS,\n  TX_PARAMS,\n  ERROR_MESSAGES,\n  SIGNATURE_TEST_DATA,\n  TEST_RECIPIENT_ADDRESS,\n} from '../resources/tempo';\n\nconst mockCoinConfig = coins.get('ttempo');\n\ndescribe('TIP-20 Utilities', () => {\n  describe('amountToTip20Units', () => {\n    it('should convert decimal amount to 6-decimal units', () => {\n      assert.strictEqual(amountToTip20Units('1.5'), 1500000n);\n      assert.strictEqual(amountToTip20Units('100'), 100000000n);\n      assert.strictEqual(amountToTip20Units('0.000001'), 1n);\n    });\n\n    it('should throw error for invalid amount', () => {\n      assert.throws(() => amountToTip20Units('invalid'), /Invalid amount format/);\n    });\n  });\n\n  describe('tip20UnitsToAmount', () => {\n    it('should convert 6-decimal units to human-readable amount', () => {\n      assert.strictEqual(tip20UnitsToAmount(1500000n), '1.5');\n      assert.strictEqual(tip20UnitsToAmount(100000000n), '100.0');\n      assert.strictEqual(tip20UnitsToAmount(1n), '0.000001');\n    });\n  });\n\n  describe('stringToBytes32', () => {\n    it('should convert string to bytes32', () => {\n      const result = stringToBytes32('12345');\n      assert.strictEqual(result.length, 66);\n      assert.ok(result.startsWith('0x'));\n    });\n\n    it('should throw error for string longer than 32 bytes', () => {\n      assert.throws(() => stringToBytes32('a'.repeat(33)), /Memo too long/);\n    });\n  });\n\n  describe('encodeTip20TransferWithMemo', () => {\n    it('should encode transferWithMemo call', () => {\n      const to = ethers.utils.getAddress('0x742d35cc6634c0532925a3b844bc9e7595f0beb1');\n      const encoded = encodeTip20TransferWithMemo(to, 1500000n, '12345');\n      assert.ok(encoded.startsWith('0x'));\n      assert.ok(encoded.length > 10);\n    });\n  });\n\n  describe('isValidTip20Amount', () => {\n    it('should validate amounts correctly', () => {\n      assert.strictEqual(isValidTip20Amount('1.5'), true);\n      assert.strictEqual(isValidTip20Amount('invalid'), false);\n      assert.strictEqual(isValidTip20Amount('-5'), false);\n    });\n  });\n});\n\ndescribe('TIP-20 Transaction Builder', () => {\n  const mockToken = ethers.utils.getAddress('0x1234567890123456789012345678901234567890');\n  const mockRecipient = ethers.utils.getAddress('0x742d35cc6634c0532925a3b844bc9e7595f0beb1');\n  const mockFeeToken = ethers.utils.getAddress('0xabcdefabcdefabcdefabcdefabcdefabcdefabcd');\n\n  describe('addOperation', () => {\n    it('should add operation with and without memo', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder.addOperation({ token: mockToken, to: mockRecipient, amount: '100' });\n      builder.addOperation({ token: mockToken, to: mockRecipient, amount: '50', memo: '1' });\n\n      const operations = builder.getOperations();\n      assert.strictEqual(operations.length, 2);\n      assert.strictEqual(operations[0].memo, undefined);\n      assert.strictEqual(operations[1].memo, '1');\n    });\n\n    it('should throw error for invalid addresses', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      assert.throws(\n        () => builder.addOperation({ token: '0xinvalid' as any, to: mockRecipient, amount: '100' }),\n        /Invalid token address/\n      );\n      assert.throws(\n        () => builder.addOperation({ token: mockToken, to: '0xinvalid' as any, amount: '100' }),\n        /Invalid recipient address/\n      );\n    });\n\n    it('should throw error for invalid amount', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      assert.throws(\n        () => builder.addOperation({ token: mockToken, to: mockRecipient, amount: 'invalid-amount' }),\n        /Invalid amount/\n      );\n    });\n\n    it('should throw error for invalid (non-numeric) memo', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      assert.throws(\n        () => builder.addOperation({ token: mockToken, to: mockRecipient, amount: '100', memo: 'INV-001' }),\n        /Invalid memo/\n      );\n    });\n  });\n\n  describe('feeToken', () => {\n    it('should set and get fee token', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder.feeToken(mockFeeToken);\n      assert.strictEqual(builder.getFeeToken(), mockFeeToken);\n    });\n\n    it('should throw error for invalid fee token address', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      assert.throws(() => builder.feeToken('invalid-address'), /Invalid fee token address/);\n    });\n  });\n\n  describe('Transaction parameters', () => {\n    it('should set nonce, gas, maxFeePerGas, and maxPriorityFeePerGas', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder.nonce(42).gas(500000n).maxFeePerGas(1000000000n).maxPriorityFeePerGas(500000000n);\n\n      assert.strictEqual((builder as any)._nonce, 42);\n      assert.strictEqual((builder as any)._gas, 500000n);\n      assert.strictEqual((builder as any)._maxFeePerGas, 1000000000n);\n      assert.strictEqual((builder as any)._maxPriorityFeePerGas, 500000000n);\n    });\n\n    it('should throw error for invalid nonce and gas', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      assert.throws(() => builder.nonce(-1), /Invalid nonce/);\n      assert.throws(() => builder.gas(0n), /Invalid gas limit/);\n    });\n  });\n\n  describe('Method chaining', () => {\n    it('should support fluent interface', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      const result = builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '100', memo: '5' })\n        .feeToken(mockFeeToken)\n        .nonce(10)\n        .gas(400000n)\n        .maxFeePerGas(2000000000n)\n        .maxPriorityFeePerGas(1000000000n);\n\n      assert.strictEqual(result, builder);\n    });\n  });\n});\n\ndescribe('TIP-20 Constants', () => {\n  it('should have correct decimal places', () => {\n    assert.strictEqual(TIP20_DECIMALS, 6);\n  });\n});\n\ndescribe('TIP-20 Transaction Build', () => {\n  const mockToken = ethers.utils.getAddress(TESTNET_TOKENS.alphaUSD.address);\n  const mockRecipient = ethers.utils.getAddress(TEST_RECIPIENT_ADDRESS);\n  const mockFeeToken = ethers.utils.getAddress(TESTNET_TOKENS.betaUSD.address);\n\n  describe('Build Transaction', () => {\n    it('should build single-operation transaction', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '100', memo: '1' })\n        .feeToken(mockFeeToken)\n        .nonce(0)\n        .gas(100000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n\n      assert.ok(tx instanceof Tip20Transaction);\n      assert.strictEqual(tx.getOperationCount(), 1);\n      assert.strictEqual(tx.getFeeToken(), mockFeeToken);\n    });\n\n    it('should build batch transaction with multiple operations', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: TESTNET_TOKENS.alphaUSD.address, to: mockRecipient, amount: '10', memo: '1' })\n        .addOperation({ token: TESTNET_TOKENS.betaUSD.address, to: mockRecipient, amount: '20', memo: '2' })\n        .addOperation({ token: TESTNET_TOKENS.thetaUSD.address, to: mockRecipient, amount: '30', memo: '3' })\n        .feeToken(mockFeeToken)\n        .nonce(42)\n        .gas(300000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n\n      assert.ok(tx instanceof Tip20Transaction);\n      assert.strictEqual(tx.getOperationCount(), 3);\n      assert.strictEqual(tx.isBatch(), true);\n    });\n\n    it('should build transaction without fee token', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '50' })\n        .nonce(1)\n        .gas(100000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n\n      assert.ok(tx instanceof Tip20Transaction);\n      assert.strictEqual(tx.getFeeToken(), undefined);\n    });\n  });\n\n  describe('Build Validation Errors', () => {\n    it('should throw error when no operations added', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder.nonce(0).gas(100000n).maxFeePerGas(1000000000n).maxPriorityFeePerGas(500000000n);\n      await assert.rejects(async () => await builder.build(), /At least one operation or raw call is required/);\n    });\n\n    it('should throw error when nonce not set', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })\n        .gas(100000n)\n        .maxFeePerGas(1000000000n)\n        .maxPriorityFeePerGas(500000000n);\n      await assert.rejects(async () => await builder.build(), ERROR_MESSAGES.missingNonce);\n    });\n\n    it('should throw error when gas not set', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })\n        .nonce(0)\n        .maxFeePerGas(1000000000n)\n        .maxPriorityFeePerGas(500000000n);\n      await assert.rejects(async () => await builder.build(), ERROR_MESSAGES.missingGas);\n    });\n\n    it('should throw error when maxFeePerGas not set', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })\n        .nonce(0)\n        .gas(100000n)\n        .maxPriorityFeePerGas(500000000n);\n      await assert.rejects(async () => await builder.build(), ERROR_MESSAGES.missingMaxFeePerGas);\n    });\n\n    it('should throw error when maxPriorityFeePerGas not set', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })\n        .nonce(0)\n        .gas(100000n)\n        .maxFeePerGas(1000000000n);\n      await assert.rejects(async () => await builder.build(), ERROR_MESSAGES.missingMaxPriorityFeePerGas);\n    });\n  });\n\n  describe('Round-Trip: Build -> Serialize -> Operations Check', () => {\n    it('should preserve operation data through build', async () => {\n      const operations = [{ token: mockToken, to: mockRecipient, amount: '123', memo: '1' }];\n\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation(operations[0])\n        .feeToken(mockFeeToken)\n        .nonce(10)\n        .gas(150000n)\n        .maxFeePerGas(2000000000n)\n        .maxPriorityFeePerGas(1000000000n);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      const txOps = tx.getOperations();\n\n      assert.strictEqual(txOps.length, 1);\n      assert.strictEqual(txOps[0].token, operations[0].token);\n      assert.strictEqual(txOps[0].to, operations[0].to);\n      assert.strictEqual(txOps[0].amount, operations[0].amount);\n      assert.strictEqual(txOps[0].memo, operations[0].memo);\n    });\n  });\n\n  describe('Build -> Serialize -> Sign Flow', () => {\n    it('should produce serializable unsigned transaction', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '50', memo: '2' })\n        .feeToken(mockFeeToken)\n        .nonce(5)\n        .gas(100000n)\n        .maxFeePerGas(2000000000n)\n        .maxPriorityFeePerGas(1000000000n);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      const unsignedHex = await tx.serialize();\n\n      assert.ok(unsignedHex.startsWith(AA_TRANSACTION_TYPE));\n      assert.ok(/^0x[0-9a-f]+$/i.test(unsignedHex));\n    });\n\n    it('should support full sign and broadcast flow', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '75', memo: '3' })\n        .feeToken(mockFeeToken)\n        .nonce(123)\n        .gas(120000n)\n        .maxFeePerGas(2500000000n)\n        .maxPriorityFeePerGas(1200000000n);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      const unsignedHex = await tx.serialize();\n\n      tx.setSignature(SIGNATURE_TEST_DATA.validSignature);\n\n      const broadcastHex = await tx.toBroadcastFormat();\n      assert.ok(broadcastHex.startsWith(AA_TRANSACTION_TYPE));\n      assert.ok(broadcastHex.length > unsignedHex.length, 'Signed should be longer');\n    });\n  });\n\n  describe('Transaction JSON Representation', () => {\n    it('should produce consistent JSON from built transaction', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '100', memo: '4' })\n        .feeToken(mockFeeToken)\n        .nonce(50)\n        .gas(200000n)\n        .maxFeePerGas(3000000000n)\n        .maxPriorityFeePerGas(1500000000n);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      const json = tx.toJson();\n\n      assert.strictEqual(json.type, AA_TRANSACTION_TYPE);\n      assert.strictEqual(json.nonce, 50);\n      assert.strictEqual(json.gas, '200000');\n      assert.strictEqual(json.maxFeePerGas, '3000000000');\n      assert.strictEqual(json.maxPriorityFeePerGas, '1500000000');\n      assert.strictEqual(json.callCount, 1);\n      assert.strictEqual(json.feeToken, mockFeeToken);\n    });\n  });\n\n  describe('Transaction id getter', () => {\n    it('unsigned and signed transactions should have different ids', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '10' })\n        .nonce(1)\n        .gas(100000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      const unsignedId = tx.id;\n\n      tx.setSignature(SIGNATURE_TEST_DATA.validSignature);\n      const signedId = tx.id;\n\n      assert.notStrictEqual(unsignedId, signedId, 'Signed and unsigned tx should have different ids');\n    });\n  });\n\n  describe('outputs / inputs population', () => {\n    it('should expose outputs with base-unit value and token address as coin', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '1.5', memo: '7' })\n        .nonce(0)\n        .gas(100000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      assert.strictEqual(tx.outputs.length, 1);\n      assert.strictEqual(tx.outputs[0].address, mockRecipient);\n      // 1.5 tokens * 10^6 = 1_500_000 base units\n      assert.strictEqual(tx.outputs[0].value, '1500000');\n      // coin is the token contract address, not the chain name\n      assert.strictEqual(tx.outputs[0].coin?.toLowerCase(), mockToken.toLowerCase());\n    });\n\n    it('should expose a single input with the total in base units', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '1.5' })\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '3.5' })\n        .nonce(0)\n        .gas(100000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      assert.strictEqual(tx.inputs.length, 1);\n      assert.strictEqual(tx.inputs[0].address, '');\n      // (1.5 + 3.5) tokens * 10^6 = 5_000_000 base units\n      assert.strictEqual(tx.inputs[0].value, '5000000');\n    });\n  });\n\n  describe('Round-Trip: Build -> Serialize -> From (deserialization)', () => {\n    it('should round-trip a single-operation transaction without a signature', async () => {\n      const operation = { token: mockToken, to: mockRecipient, amount: '25.5', memo: '12345' };\n\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation(operation)\n        .feeToken(mockFeeToken)\n        .nonce(7)\n        .gas(150000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const originalTx = (await builder.build()) as Tip20Transaction;\n      const serialized = await originalTx.serialize();\n\n      // Deserialize via from()\n      const builder2 = new Tip20TransactionBuilder(mockCoinConfig);\n      builder2.from(serialized);\n      const restoredTx = (await builder2.build()) as Tip20Transaction;\n\n      const ops = restoredTx.getOperations();\n      assert.strictEqual(ops.length, 1);\n      assert.strictEqual(ops[0].token.toLowerCase(), operation.token.toLowerCase());\n      assert.strictEqual(ops[0].to.toLowerCase(), operation.to.toLowerCase());\n      assert.strictEqual(ops[0].amount, operation.amount);\n      assert.strictEqual(ops[0].memo, operation.memo);\n      assert.strictEqual(restoredTx.getFeeToken()?.toLowerCase(), mockFeeToken.toLowerCase());\n    });\n\n    it('should round-trip a batch transaction', async () => {\n      // Use amounts that match tip20UnitsToAmount output: ethers formatUnits always includes decimal\n      const operations = [\n        { token: TESTNET_TOKENS.alphaUSD.address, to: mockRecipient, amount: '10.0', memo: '1' },\n        { token: TESTNET_TOKENS.betaUSD.address, to: mockRecipient, amount: '20.0', memo: '2' },\n      ];\n\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation(operations[0])\n        .addOperation(operations[1])\n        .nonce(42)\n        .gas(250000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const originalTx = (await builder.build()) as Tip20Transaction;\n      const serialized = await originalTx.serialize();\n\n      const builder2 = new Tip20TransactionBuilder(mockCoinConfig);\n      builder2.from(serialized);\n      const restoredTx = (await builder2.build()) as Tip20Transaction;\n\n      assert.strictEqual(restoredTx.getOperationCount(), 2);\n      assert.ok(restoredTx.isBatch());\n\n      const json = restoredTx.toJson();\n      assert.strictEqual(json.nonce, 42);\n      assert.strictEqual(json.gas, '250000');\n      assert.strictEqual(json.maxFeePerGas, TX_PARAMS.defaultMaxFeePerGas.toString());\n      assert.strictEqual(json.maxPriorityFeePerGas, TX_PARAMS.defaultMaxPriorityFeePerGas.toString());\n\n      const ops = restoredTx.getOperations();\n      for (let i = 0; i < operations.length; i++) {\n        assert.strictEqual(ops[i].token.toLowerCase(), operations[i].token.toLowerCase());\n        assert.strictEqual(ops[i].to.toLowerCase(), mockRecipient.toLowerCase());\n        assert.strictEqual(ops[i].amount, operations[i].amount);\n        assert.strictEqual(ops[i].memo, operations[i].memo);\n      }\n    });\n\n    it('should round-trip a signed transaction and preserve the signature', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '5' })\n        .nonce(99)\n        .gas(100000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      tx.setSignature(SIGNATURE_TEST_DATA.validSignature);\n      const signedHex = await tx.toBroadcastFormat();\n\n      // Deserialize the signed transaction\n      const builder2 = new Tip20TransactionBuilder(mockCoinConfig);\n      builder2.from(signedHex);\n      const restoredTx = (await builder2.build()) as Tip20Transaction;\n\n      const sig = restoredTx.getSignature();\n      assert.ok(sig !== undefined, 'Signature should be preserved');\n      assert.strictEqual(sig!.yParity, SIGNATURE_TEST_DATA.validSignature.yParity);\n    });\n\n    it('should produce the same tx id after a serialization round-trip', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '100.0', memo: '99' })\n        .nonce(3)\n        .gas(100000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const originalTx = (await builder.build()) as Tip20Transaction;\n      const serialized = await originalTx.serialize();\n      const originalId = originalTx.id;\n\n      const builder2 = new Tip20TransactionBuilder(mockCoinConfig);\n      builder2.from(serialized);\n      const restoredTx = (await builder2.build()) as Tip20Transaction;\n\n      assert.strictEqual(restoredTx.id, originalId);\n\n      const originalJson = originalTx.toJson();\n      const restoredJson = restoredTx.toJson();\n      assert.strictEqual(restoredJson.nonce, originalJson.nonce);\n      assert.strictEqual(restoredJson.gas, originalJson.gas);\n      assert.strictEqual(restoredJson.maxFeePerGas, originalJson.maxFeePerGas);\n      assert.strictEqual(restoredJson.maxPriorityFeePerGas, originalJson.maxPriorityFeePerGas);\n      assert.strictEqual(restoredJson.feeToken, originalJson.feeToken);\n      assert.strictEqual(restoredJson.callCount, originalJson.callCount);\n\n      const originalOps = originalTx.getOperations();\n      const restoredOps = restoredTx.getOperations();\n      assert.strictEqual(restoredOps.length, originalOps.length);\n      assert.strictEqual(restoredOps[0].token.toLowerCase(), originalOps[0].token.toLowerCase());\n      assert.strictEqual(restoredOps[0].to.toLowerCase(), originalOps[0].to.toLowerCase());\n      assert.strictEqual(restoredOps[0].amount, originalOps[0].amount);\n      assert.strictEqual(restoredOps[0].memo, originalOps[0].memo);\n\n      const restoredSerialized = await restoredTx.serialize();\n      assert.strictEqual(restoredSerialized, serialized);\n    });\n  });\n});\n\ndescribe('Tempo coin - parseTransaction / verifyTransaction', () => {\n  let bitgo: TestBitGoAPI;\n  let coin: any;\n\n  const mockToken = ethers.utils.getAddress(TESTNET_TOKENS.alphaUSD.address);\n  const mockRecipient = ethers.utils.getAddress(TEST_RECIPIENT_ADDRESS);\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.safeRegister('ttempo', (bg: BitGoBase) => {\n      const mockStaticsCoin = {\n        name: 'ttempo',\n        fullName: 'Testnet Tempo',\n        network: { type: 'testnet' },\n        features: [],\n      } as any;\n      return Ttempo.createInstance(bg, mockStaticsCoin);\n    });\n    bitgo.initializeTestVars();\n    coin = bitgo.coin('ttempo');\n  });\n\n  async function buildSerializedTx(\n    operations: { token: string; to: string; amount: string; memo?: string }[],\n    nonce = 0\n  ): Promise<string> {\n    const builder = new Tip20TransactionBuilder(coins.get('ttempo'));\n    for (const op of operations) {\n      builder.addOperation(op);\n    }\n    builder\n      .nonce(nonce)\n      .gas(100000n)\n      .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n      .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n    const tx = (await builder.build()) as Tip20Transaction;\n    return tx.serialize();\n  }\n\n  describe('parseTransaction', () => {\n    it('should parse a single-operation transaction into outputs', async () => {\n      const txHex = await buildSerializedTx([{ token: mockToken, to: mockRecipient, amount: '50', memo: '1' }]);\n      const parsed = await coin.parseTransaction({ txHex });\n      assert.ok(Array.isArray(parsed.outputs), 'outputs should be an array');\n      assert.strictEqual(parsed.outputs.length, 1);\n      assert.strictEqual(parsed.outputs[0].address.toLowerCase(), mockRecipient.toLowerCase());\n      // 50 tokens * 10^6 = 50_000_000 base units\n      assert.strictEqual(parsed.outputs[0].amount, '50000000');\n    });\n\n    it('should return empty object when no txHex is provided', async () => {\n      const parsed = await coin.parseTransaction({});\n      assert.deepStrictEqual(parsed, {});\n    });\n  });\n\n  describe('verifyTransaction', () => {\n    it('should return true when no recipients are specified', async () => {\n      const txHex = await buildSerializedTx([{ token: mockToken, to: mockRecipient, amount: '10' }]);\n      const result = await coin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {},\n      });\n      assert.strictEqual(result, true);\n    });\n\n    it('should return true when recipients match operations', async () => {\n      const txHex = await buildSerializedTx([{ token: mockToken, to: mockRecipient, amount: '100' }]);\n      const result = await coin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {\n          recipients: [{ address: mockRecipient, amount: '100000000' }], // 100 * 10^6 base units\n        },\n      });\n      assert.strictEqual(result, true);\n    });\n\n    it('should throw when recipient address does not match', async () => {\n      const txHex = await buildSerializedTx([{ token: mockToken, to: mockRecipient, amount: '100' }]);\n      const wrongAddress = ethers.utils.getAddress('0x1111111111111111111111111111111111111111');\n      await assert.rejects(\n        () =>\n          coin.verifyTransaction({\n            txPrebuild: { txHex },\n            txParams: { recipients: [{ address: wrongAddress, amount: '100000000' }] },\n          }),\n        /recipient mismatch/\n      );\n    });\n\n    it('should throw when recipient amount does not match', async () => {\n      const txHex = await buildSerializedTx([{ token: mockToken, to: mockRecipient, amount: '100' }]);\n      await assert.rejects(\n        () =>\n          coin.verifyTransaction({\n            txPrebuild: { txHex },\n            txParams: { recipients: [{ address: mockRecipient, amount: '999' }] },\n          }),\n        /amount mismatch/\n      );\n    });\n\n    it('should throw when operation count differs from recipient count', async () => {\n      const txHex = await buildSerializedTx([{ token: mockToken, to: mockRecipient, amount: '10' }]);\n      await assert.rejects(\n        () =>\n          coin.verifyTransaction({\n            txPrebuild: { txHex },\n            txParams: {\n              recipients: [\n                { address: mockRecipient, amount: '10000000' },\n                { address: mockRecipient, amount: '10000000' },\n              ],\n            },\n          }),\n        /operation\\(s\\)/\n      );\n    });\n\n    it('should return true when no txHex is provided', async () => {\n      const result = await coin.verifyTransaction({ txPrebuild: {}, txParams: {} });\n      assert.strictEqual(result, true);\n    });\n  });\n\n  describe('verifyTransaction with feeToken', () => {\n    it('should verify transaction with matching fee token', async () => {\n      const feeToken = ethers.utils.getAddress(TESTNET_TOKENS.betaUSD.address);\n      const builder = new Tip20TransactionBuilder(coins.get('ttempo'));\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })\n        .feeToken(feeToken)\n        .nonce(0)\n        .gas(100000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n      const tx = (await builder.build()) as Tip20Transaction;\n      const txHex = await tx.serialize();\n\n      const result = await coin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: { feeToken: feeToken },\n      });\n      assert.strictEqual(result, true);\n    });\n\n    it('should throw when fee token does not match', async () => {\n      const feeToken = ethers.utils.getAddress(TESTNET_TOKENS.betaUSD.address);\n      const wrongFeeToken = ethers.utils.getAddress(TESTNET_TOKENS.alphaUSD.address);\n      const builder = new Tip20TransactionBuilder(coins.get('ttempo'));\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })\n        .feeToken(feeToken)\n        .nonce(0)\n        .gas(100000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n      const tx = (await builder.build()) as Tip20Transaction;\n      const txHex = await tx.serialize();\n\n      await assert.rejects(\n        () =>\n          coin.verifyTransaction({\n            txPrebuild: { txHex },\n            txParams: { feeToken: wrongFeeToken },\n          }),\n        /Fee token mismatch/\n      );\n    });\n\n    it('should throw when fee token is expected but transaction has none', async () => {\n      const expectedFeeToken = ethers.utils.getAddress(TESTNET_TOKENS.betaUSD.address);\n      const builder = new Tip20TransactionBuilder(coins.get('ttempo'));\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })\n        .nonce(0)\n        .gas(100000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n      const tx = (await builder.build()) as Tip20Transaction;\n      const txHex = await tx.serialize();\n\n      await assert.rejects(\n        () =>\n          coin.verifyTransaction({\n            txPrebuild: { txHex },\n            txParams: { feeToken: expectedFeeToken },\n          }),\n        /Fee token mismatch/\n      );\n    });\n\n    it('should pass verification when no fee token is specified in params', async () => {\n      const feeToken = ethers.utils.getAddress(TESTNET_TOKENS.betaUSD.address);\n      const builder = new Tip20TransactionBuilder(coins.get('ttempo'));\n      builder\n        .addOperation({ token: mockToken, to: mockRecipient, amount: '100' })\n        .feeToken(feeToken)\n        .nonce(0)\n        .gas(100000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n      const tx = (await builder.build()) as Tip20Transaction;\n      const txHex = await tx.serialize();\n\n      // No feeToken in txParams - should not verify, just pass\n      const result = await coin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {},\n      });\n      assert.strictEqual(result, true);\n    });\n  });\n});\n\ndescribe('Raw Contract Call Builder', () => {\n  const mockContract = ethers.utils.getAddress('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef');\n  const mockCalldata =\n    '0xa9059cbb000000000000000000000000742d35cc6634c0532925a3b844bc454e4438f44e0000000000000000000000000000000000000000000000000000000000989680';\n\n  describe('addRawCall', () => {\n    it('should add a raw call and return it via getRawCalls()', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder.addRawCall({ to: mockContract, data: mockCalldata });\n\n      const rawCalls = builder.getRawCalls();\n      assert.strictEqual(rawCalls.length, 1);\n      assert.strictEqual(rawCalls[0].to, mockContract);\n      assert.strictEqual(rawCalls[0].data, mockCalldata);\n    });\n\n    it('should support chaining addRawCall', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      const result = builder.addRawCall({ to: mockContract, data: mockCalldata });\n      assert.strictEqual(result, builder);\n    });\n\n    it('should throw for invalid contract address', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      assert.throws(() => builder.addRawCall({ to: '0xinvalid', data: mockCalldata }), /Invalid contract address/);\n    });\n\n    it('should throw for empty calldata', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      assert.throws(() => builder.addRawCall({ to: mockContract, data: '0x' }), /Invalid calldata/);\n    });\n\n    it('should throw for non-hex calldata', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      assert.throws(() => builder.addRawCall({ to: mockContract, data: 'not-hex-data' }), /Invalid calldata/);\n    });\n\n    it('should throw for calldata missing 0x prefix', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      assert.throws(() => builder.addRawCall({ to: mockContract, data: 'a9059cbb' }), /Invalid calldata/);\n    });\n\n    it('should throw for odd-length hex calldata', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      assert.throws(() => builder.addRawCall({ to: mockContract, data: '0xabc' }), /Invalid calldata/);\n    });\n\n    it('should throw for invalid value string', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      assert.throws(() => builder.addRawCall({ to: mockContract, data: mockCalldata, value: '1e18' }), /Invalid value/);\n    });\n\n    it('should throw for negative value', () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      assert.throws(() => builder.addRawCall({ to: mockContract, data: mockCalldata, value: '-1' }), /Invalid value/);\n    });\n\n    it('should allow raw-call-only transaction (no operations)', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addRawCall({ to: mockContract, data: mockCalldata })\n        .nonce(0)\n        .gas(100000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      assert.ok(tx instanceof Tip20Transaction);\n      assert.strictEqual(tx.getOperations().length, 0);\n      assert.strictEqual(tx.getRawCalls().length, 1);\n      assert.strictEqual(tx.getOperationCount(), 1);\n    });\n  });\n\n  describe('Round-Trip: Build -> Serialize -> From (raw call deserialization)', () => {\n    it('should preserve raw call calldata through a round-trip', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addRawCall({ to: mockContract, data: mockCalldata })\n        .nonce(5)\n        .gas(150000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const originalTx = (await builder.build()) as Tip20Transaction;\n      const serialized = await originalTx.serialize();\n\n      const builder2 = new Tip20TransactionBuilder(mockCoinConfig);\n      builder2.from(serialized);\n      const restoredTx = (await builder2.build()) as Tip20Transaction;\n\n      assert.strictEqual(restoredTx.getOperations().length, 0);\n      const rawCalls = restoredTx.getRawCalls();\n      assert.strictEqual(rawCalls.length, 1);\n      assert.strictEqual(rawCalls[0].to.toLowerCase(), mockContract.toLowerCase());\n      assert.strictEqual(rawCalls[0].data.toLowerCase(), mockCalldata.toLowerCase());\n    });\n\n    it('should preserve calldata through a signed round-trip', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addRawCall({ to: mockContract, data: mockCalldata })\n        .nonce(7)\n        .gas(120000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      tx.setSignature(SIGNATURE_TEST_DATA.validSignature);\n      const signedHex = await tx.toBroadcastFormat();\n\n      const builder2 = new Tip20TransactionBuilder(mockCoinConfig);\n      builder2.from(signedHex);\n      const restoredTx = (await builder2.build()) as Tip20Transaction;\n\n      const rawCalls = restoredTx.getRawCalls();\n      assert.strictEqual(rawCalls.length, 1);\n      assert.strictEqual(rawCalls[0].data.toLowerCase(), mockCalldata.toLowerCase());\n      const sig = restoredTx.getSignature();\n      assert.ok(sig !== undefined);\n      assert.strictEqual(sig!.yParity, SIGNATURE_TEST_DATA.validSignature.yParity);\n    });\n\n    it('should preserve raw call tx id through a round-trip', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addRawCall({ to: mockContract, data: mockCalldata })\n        .nonce(3)\n        .gas(100000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const originalTx = (await builder.build()) as Tip20Transaction;\n      const serialized = await originalTx.serialize();\n      const originalId = originalTx.id;\n\n      const builder2 = new Tip20TransactionBuilder(mockCoinConfig);\n      builder2.from(serialized);\n      const restoredTx = (await builder2.build()) as Tip20Transaction;\n\n      assert.strictEqual(restoredTx.id, originalId);\n    });\n  });\n\n  describe('Raw call toJson and outputs', () => {\n    it('should expose raw call contract address as output', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addRawCall({ to: mockContract, data: mockCalldata, value: '0' })\n        .nonce(2)\n        .gas(200000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      assert.strictEqual(tx.outputs.length, 1);\n      assert.strictEqual(tx.outputs[0].address.toLowerCase(), mockContract.toLowerCase());\n    });\n\n    it('should include rawCalls in toJson() output', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addRawCall({ to: mockContract, data: mockCalldata })\n        .nonce(0)\n        .gas(100000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      const json = tx.toJson();\n\n      assert.ok(Array.isArray(json.rawCalls));\n      assert.strictEqual(json.rawCalls.length, 1);\n      assert.strictEqual(json.rawCalls[0].to, mockContract);\n      assert.strictEqual(json.rawCalls[0].data, mockCalldata);\n    });\n  });\n});\n\ndescribe('Tempo coin - verifyTransaction with raw calls', () => {\n  let bitgo: TestBitGoAPI;\n  let coin: any;\n\n  const mockContract = ethers.utils.getAddress('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef');\n  const mockCalldata =\n    '0xa9059cbb000000000000000000000000742d35cc6634c0532925a3b844bc454e4438f44e0000000000000000000000000000000000000000000000000000000000989680';\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.safeRegister('ttempo', (bg: BitGoBase) => {\n      const mockStaticsCoin = {\n        name: 'ttempo',\n        fullName: 'Testnet Tempo',\n        network: { type: 'testnet' },\n        features: [],\n      } as any;\n      return Ttempo.createInstance(bg, mockStaticsCoin);\n    });\n    bitgo.initializeTestVars();\n    coin = bitgo.coin('ttempo');\n  });\n\n  async function buildRawCallTx(contract: string, calldata: string, nonce = 0): Promise<string> {\n    const builder = new Tip20TransactionBuilder(coins.get('ttempo'));\n    builder\n      .addRawCall({ to: contract, data: calldata })\n      .nonce(nonce)\n      .gas(150000n)\n      .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n      .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n    const tx = (await builder.build()) as Tip20Transaction;\n    return tx.serialize();\n  }\n\n  it('should verify a raw call transaction when recipient data matches', async () => {\n    const txHex = await buildRawCallTx(mockContract, mockCalldata);\n    const result = await coin.verifyTransaction({\n      txPrebuild: { txHex },\n      txParams: {\n        recipients: [{ address: mockContract, amount: '0', data: mockCalldata }],\n      },\n    });\n    assert.strictEqual(result, true);\n  });\n\n  it('should throw when raw call address does not match recipient', async () => {\n    const txHex = await buildRawCallTx(mockContract, mockCalldata);\n    const wrongAddress = ethers.utils.getAddress('0x1111111111111111111111111111111111111111');\n    await assert.rejects(\n      () =>\n        coin.verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: { recipients: [{ address: wrongAddress, amount: '0', data: mockCalldata }] },\n        }),\n      /address mismatch/\n    );\n  });\n\n  it('should throw when raw call calldata does not match', async () => {\n    const txHex = await buildRawCallTx(mockContract, mockCalldata);\n    const wrongCalldata = '0xdeadbeef01020304';\n    await assert.rejects(\n      () =>\n        coin.verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: { recipients: [{ address: mockContract, amount: '0', data: wrongCalldata }] },\n        }),\n      /calldata mismatch/\n    );\n  });\n\n  it('should throw when recipient count does not match call count', async () => {\n    const txHex = await buildRawCallTx(mockContract, mockCalldata);\n    await assert.rejects(\n      () =>\n        coin.verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            recipients: [\n              { address: mockContract, amount: '0', data: mockCalldata },\n              { address: mockContract, amount: '0', data: mockCalldata },\n            ],\n          },\n        }),\n      /call\\(s\\)/\n    );\n  });\n\n  it('should parse a raw call transaction and expose the contract as an output', async () => {\n    const txHex = await buildRawCallTx(mockContract, mockCalldata);\n    const parsed = await coin.parseTransaction({ txHex });\n    assert.ok(Array.isArray(parsed.outputs));\n    assert.strictEqual(parsed.outputs.length, 1);\n    assert.strictEqual(parsed.outputs[0].address.toLowerCase(), mockContract.toLowerCase());\n  });\n});\n"]}