@bitgo-beta/sdk-coin-trx 1.0.2-beta.232 → 1.0.2-beta.2321

package/dist/test/unit/verifyTransaction.js

@@ -0,0 +1,695 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const crypto_1 = require("crypto");
+const node_test_1 = require("node:test");
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const src_1 = require("../../src");
+const lib_1 = require("../../src/lib");
+const resources_1 = require("../resources");
+(0, node_test_1.describe)('TRON Verify Transaction:', function () {
+    const bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+    bitgo.initializeTestVars();
+    bitgo.safeRegister('trx', src_1.Trx.createInstance);
+    bitgo.safeRegister('ttrx', src_1.Ttrx.createInstance);
+    let basecoin;
+    (0, node_test_1.before)(function () {
+        basecoin = bitgo.coin('ttrx');
+    });
+    (0, node_test_1.describe)('Parameter Validation', () => {
+        (0, node_test_1.it)('should throw error when txParams is missing', async function () {
+            const params = {
+                txPrebuild: {
+                    txHex: JSON.stringify({
+                        ...resources_1.UnsignedBuildTransaction,
+                        raw_data: {
+                            ...resources_1.UnsignedBuildTransaction.raw_data,
+                            expiration: Date.now() + 3600000,
+                            timestamp: Date.now(),
+                        },
+                    }),
+                },
+                wallet: {},
+            };
+            await node_assert_1.default.rejects(basecoin.verifyTransaction(params), {
+                message: 'missing txParams',
+            });
+        });
+        (0, node_test_1.it)('should throw error when wallet or txPrebuild is missing', async function () {
+            const params = {
+                txParams: {
+                    recipients: [{ address: 'TQFxDSoXy2yXRE5HtKwAwrNRXGxYxkeSGk', amount: '1000000' }],
+                },
+            };
+            await node_assert_1.default.rejects(basecoin.verifyTransaction(params), {
+                message: 'missing txPrebuild',
+            });
+        });
+        (0, node_test_1.it)('should throw error when txPrebuild.txHex is missing', async function () {
+            const params = {
+                txParams: {
+                    recipients: [{ address: 'TQFxDSoXy2yXRE5HtKwAwrNRXGxYxkeSGk', amount: '1000000' }],
+                },
+                txPrebuild: {},
+                wallet: {},
+            };
+            await node_assert_1.default.rejects(basecoin.verifyTransaction(params), {
+                message: 'missing txHex in txPrebuild',
+            });
+        });
+    });
+    (0, node_test_1.describe)('Contract Type Validation', () => {
+        (0, node_test_1.describe)('TransferContract', () => {
+            (0, node_test_1.it)('should validate valid TransferContract', async function () {
+                const timestamp = Date.now();
+                const transferContract = {
+                    parameter: {
+                        value: {
+                            amount: 1000000,
+                            owner_address: '4173a5993cd182ae152adad8203163f780c65a8aa5',
+                            to_address: '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882',
+                        },
+                        type_url: 'type.googleapis.com/protocol.TransferContract',
+                    },
+                    type: 'TransferContract',
+                };
+                const rawData = {
+                    contract: [transferContract],
+                    ref_block_bytes: 'c8cf',
+                    ref_block_hash: '89177fd84c5d9196',
+                    expiration: timestamp + 3600000,
+                    timestamp: timestamp,
+                    fee_limit: 150000000,
+                };
+                // Transform rawData to match the expected parameter structure
+                const transformedRawData = {
+                    contract: rawData.contract,
+                    refBlockBytes: rawData.ref_block_bytes,
+                    refBlockHash: rawData.ref_block_hash,
+                    expiration: rawData.expiration,
+                    timestamp: rawData.timestamp,
+                    feeLimit: rawData.fee_limit,
+                };
+                // Generate raw_data_hex using the utility function
+                const rawDataHex = lib_1.Utils.generateRawDataHex(transformedRawData);
+                // Calculate txID as SHA256 hash of raw_data_hex
+                const txID = (0, crypto_1.createHash)('sha256').update(Buffer.from(rawDataHex, 'hex')).digest('hex');
+                const params = {
+                    txParams: {
+                        recipients: [
+                            {
+                                address: lib_1.Utils.getBase58AddressFromHex('41d6cd6a2c0ff35a319e6abb5b9503ba0278679882'),
+                                amount: '1000000',
+                            },
+                        ],
+                    },
+                    txPrebuild: {
+                        txHex: JSON.stringify({
+                            txID,
+                            raw_data: rawData,
+                            raw_data_hex: rawDataHex,
+                        }),
+                    },
+                    wallet: {},
+                };
+                const result = await basecoin.verifyTransaction(params);
+                node_assert_1.default.strictEqual(result, true);
+            });
+            (0, node_test_1.it)('should validate TransferContract when recipient is 0x-prefixed hex (COINS-1575)', async function () {
+                const timestamp = Date.now();
+                const toAddressHex = '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882';
+                const transferContract = {
+                    parameter: {
+                        value: {
+                            amount: 1000000,
+                            owner_address: '4173a5993cd182ae152adad8203163f780c65a8aa5',
+                            to_address: toAddressHex,
+                        },
+                        type_url: 'type.googleapis.com/protocol.TransferContract',
+                    },
+                    type: 'TransferContract',
+                };
+                const rawData = {
+                    contract: [transferContract],
+                    ref_block_bytes: 'c8cf',
+                    ref_block_hash: '89177fd84c5d9196',
+                    expiration: timestamp + 3600000,
+                    timestamp: timestamp,
+                    fee_limit: 150000000,
+                };
+                const transformedRawData = {
+                    contract: rawData.contract,
+                    refBlockBytes: rawData.ref_block_bytes,
+                    refBlockHash: rawData.ref_block_hash,
+                    expiration: rawData.expiration,
+                    timestamp: rawData.timestamp,
+                    feeLimit: rawData.fee_limit,
+                };
+                const rawDataHex = lib_1.Utils.generateRawDataHex(transformedRawData);
+                const txID = (0, crypto_1.createHash)('sha256').update(Buffer.from(rawDataHex, 'hex')).digest('hex');
+                const params = {
+                    txParams: {
+                        recipients: [
+                            {
+                                address: '0x' + toAddressHex.slice(2),
+                                amount: '1000000',
+                            },
+                        ],
+                    },
+                    txPrebuild: {
+                        txHex: JSON.stringify({
+                            txID,
+                            raw_data: rawData,
+                            raw_data_hex: rawDataHex,
+                        }),
+                    },
+                    wallet: {},
+                };
+                const result = await basecoin.verifyTransaction(params);
+                node_assert_1.default.strictEqual(result, true);
+            });
+            (0, node_test_1.it)('should fail with missing owner address', async function () {
+                const timestamp = Date.now();
+                const txID = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
+                const transferContract = {
+                    parameter: {
+                        value: {
+                            amount: 1000000,
+                            to_address: '41c25420255c2c5a2dd54ef69f92ef261e6bd4216a',
+                        },
+                        type_url: 'type.googleapis.com/protocol.TransferContract',
+                    },
+                    type: 'TransferContract',
+                };
+                const rawData = {
+                    txID,
+                    contract: [transferContract],
+                    ref_block_bytes: 'c8cf',
+                    ref_block_hash: '89177fd84c5d9196',
+                    expiration: timestamp + 3600000,
+                    timestamp: timestamp,
+                    fee_limit: 150000000,
+                };
+                const transformedRawData = {
+                    contract: rawData.contract,
+                    refBlockBytes: rawData.ref_block_bytes,
+                    refBlockHash: rawData.ref_block_hash,
+                    expiration: rawData.expiration,
+                    timestamp: rawData.timestamp,
+                    feeLimit: rawData.fee_limit,
+                };
+                const expectedRawDataHex = lib_1.Utils.generateRawDataHex(transformedRawData);
+                const params = {
+                    txParams: {
+                        recipients: [{ address: 'TLWh67P93KgtnZNCtGnEHM1H33Nhq2uvvN', amount: '1000000' }],
+                    },
+                    txPrebuild: {
+                        txHex: JSON.stringify({
+                            txID,
+                            raw_data: rawData,
+                            raw_data_hex: expectedRawDataHex,
+                        }),
+                    },
+                    wallet: {},
+                };
+                await node_assert_1.default.rejects(basecoin.verifyTransaction(params), {
+                    message: 'Transaction has not have a valid id',
+                });
+            });
+            (0, node_test_1.it)('should fail with missing destination address', async function () {
+                const timestamp = Date.now();
+                const txID = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
+                const transferContract = {
+                    parameter: {
+                        value: {
+                            amount: 1000000,
+                            owner_address: '4173a5993cd182ae152adad8203163f780c65a8aa5',
+                        },
+                        type_url: 'type.googleapis.com/protocol.TransferContract',
+                    },
+                    type: 'TransferContract',
+                };
+                const rawData = {
+                    txID,
+                    contract: [transferContract],
+                    ref_block_bytes: 'c8cf',
+                    ref_block_hash: '89177fd84c5d9196',
+                    expiration: timestamp + 3600000,
+                    timestamp: timestamp,
+                    fee_limit: 150000000,
+                };
+                const transformedRawData = {
+                    contract: rawData.contract,
+                    refBlockBytes: rawData.ref_block_bytes,
+                    refBlockHash: rawData.ref_block_hash,
+                    expiration: rawData.expiration,
+                    timestamp: rawData.timestamp,
+                    feeLimit: rawData.fee_limit,
+                };
+                const expectedRawDataHex = lib_1.Utils.generateRawDataHex(transformedRawData);
+                const params = {
+                    txParams: {
+                        recipients: [{ address: 'TLWh67P93KgtnZNCtGnEHM1H33Nhq2uvvN', amount: '1000000' }],
+                    },
+                    txPrebuild: {
+                        txHex: JSON.stringify({
+                            txID,
+                            raw_data: rawData,
+                            raw_data_hex: expectedRawDataHex,
+                        }),
+                    },
+                    wallet: {},
+                };
+                await node_assert_1.default.rejects(basecoin.verifyTransaction(params), {
+                    message: 'Transaction has not have a valid id',
+                });
+            });
+            (0, node_test_1.it)('should fail with missing amount', async function () {
+                const timestamp = Date.now();
+                const transferContract = {
+                    parameter: {
+                        value: {
+                            owner_address: '4173a5993cd182ae152adad8203163f780c65a8aa5',
+                            to_address: '41c25420255c2c5a2dd54ef69f92ef261e6bd4216a',
+                        },
+                        type_url: 'type.googleapis.com/protocol.TransferContract',
+                    },
+                    type: 'TransferContract',
+                };
+                const rawData = {
+                    contract: [transferContract],
+                    ref_block_bytes: 'c8cf',
+                    ref_block_hash: '89177fd84c5d9196',
+                    expiration: timestamp + 3600000,
+                    timestamp: timestamp,
+                    fee_limit: 150000000,
+                };
+                const transformedRawData = {
+                    contract: rawData.contract,
+                    refBlockBytes: rawData.ref_block_bytes,
+                    refBlockHash: rawData.ref_block_hash,
+                    expiration: rawData.expiration,
+                    timestamp: rawData.timestamp,
+                    feeLimit: rawData.fee_limit,
+                };
+                const expectedRawDataHex = lib_1.Utils.generateRawDataHex(transformedRawData);
+                const params = {
+                    txParams: {
+                        recipients: [{ address: 'TLWh67P93KgtnZNCtGnEHM1H33Nhq2uvvN', amount: '1000000' }],
+                    },
+                    txPrebuild: {
+                        txHex: JSON.stringify({
+                            raw_data: rawData,
+                            raw_data_hex: expectedRawDataHex,
+                        }),
+                    },
+                    wallet: {},
+                };
+                await node_assert_1.default.rejects(basecoin.verifyTransaction(params), {
+                    message: 'Amount does not exist in this transfer contract.',
+                });
+            });
+            (0, node_test_1.it)('should fail due to amount missmatch', async function () {
+                const timestamp = Date.now();
+                const transferContract = {
+                    parameter: {
+                        value: {
+                            amount: 2000000,
+                            owner_address: '4173a5993cd182ae152adad8203163f780c65a8aa5',
+                            to_address: '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882',
+                        },
+                        type_url: 'type.googleapis.com/protocol.TransferContract',
+                    },
+                    type: 'TransferContract',
+                };
+                const rawData = {
+                    contract: [transferContract],
+                    ref_block_bytes: 'c8cf',
+                    ref_block_hash: '89177fd84c5d9196',
+                    expiration: timestamp + 3600000,
+                    timestamp: timestamp,
+                    fee_limit: 150000000,
+                };
+                // Transform rawData to match the expected parameter structure
+                const transformedRawData = {
+                    contract: rawData.contract,
+                    refBlockBytes: rawData.ref_block_bytes,
+                    refBlockHash: rawData.ref_block_hash,
+                    expiration: rawData.expiration,
+                    timestamp: rawData.timestamp,
+                    feeLimit: rawData.fee_limit,
+                };
+                // Generate raw_data_hex using the utility function
+                const rawDataHex = lib_1.Utils.generateRawDataHex(transformedRawData);
+                // Calculate txID as SHA256 hash of raw_data_hex
+                const txID = (0, crypto_1.createHash)('sha256').update(Buffer.from(rawDataHex, 'hex')).digest('hex');
+                const params = {
+                    txParams: {
+                        recipients: [
+                            {
+                                address: '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882',
+                                amount: '1000000',
+                            },
+                        ],
+                    },
+                    txPrebuild: {
+                        txHex: JSON.stringify({
+                            txID,
+                            raw_data: rawData,
+                            raw_data_hex: rawDataHex,
+                        }),
+                    },
+                    wallet: {},
+                };
+                await node_assert_1.default.rejects(basecoin.verifyTransaction(params), {
+                    message: 'transaction amount in txPrebuild does not match the value given by client',
+                });
+            });
+            (0, node_test_1.it)('should fail due to destination address missmatch', async function () {
+                const timestamp = Date.now();
+                const transferContract = {
+                    parameter: {
+                        value: {
+                            amount: 1000000,
+                            owner_address: '4173a5993cd182ae152adad8203163f780c65a8aa5',
+                            to_address: '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882',
+                        },
+                        type_url: 'type.googleapis.com/protocol.TransferContract',
+                    },
+                    type: 'TransferContract',
+                };
+                const rawData = {
+                    contract: [transferContract],
+                    ref_block_bytes: 'c8cf',
+                    ref_block_hash: '89177fd84c5d9196',
+                    expiration: timestamp + 3600000,
+                    timestamp: timestamp,
+                    fee_limit: 150000000,
+                };
+                // Transform rawData to match the expected parameter structure
+                const transformedRawData = {
+                    contract: rawData.contract,
+                    refBlockBytes: rawData.ref_block_bytes,
+                    refBlockHash: rawData.ref_block_hash,
+                    expiration: rawData.expiration,
+                    timestamp: rawData.timestamp,
+                    feeLimit: rawData.fee_limit,
+                };
+                // Generate raw_data_hex using the utility function
+                const rawDataHex = lib_1.Utils.generateRawDataHex(transformedRawData);
+                // Calculate txID as SHA256 hash of raw_data_hex
+                const txID = (0, crypto_1.createHash)('sha256').update(Buffer.from(rawDataHex, 'hex')).digest('hex');
+                const params = {
+                    txParams: {
+                        recipients: [
+                            {
+                                address: '41d6cd6a2c0ff35a319e6abb5b9503ba0278679883',
+                                amount: '1000000',
+                            },
+                        ],
+                    },
+                    txPrebuild: {
+                        txHex: JSON.stringify({
+                            txID,
+                            raw_data: rawData,
+                            raw_data_hex: rawDataHex,
+                        }),
+                    },
+                    wallet: {},
+                };
+                await node_assert_1.default.rejects(basecoin.verifyTransaction(params), {
+                    message: 'destination address does not match with the recipient address',
+                });
+            });
+        });
+    });
+    (0, node_test_1.describe)('TSS Wallet Verification', () => {
+        /**
+         * Helper to build a raw_data_hex (protobuf) for a TransferContract.
+         * For TSS, txPrebuild.txHex is the raw_data_hex directly (not a JSON string).
+         */
+        function buildTssTransferTxHex(params) {
+            const timestamp = params.timestamp || Date.now();
+            const transferContract = {
+                parameter: {
+                    value: {
+                        amount: params.amount,
+                        owner_address: params.ownerAddress,
+                        to_address: params.toAddress,
+                    },
+                    type_url: 'type.googleapis.com/protocol.TransferContract',
+                },
+                type: 'TransferContract',
+            };
+            const transformedRawData = {
+                contract: [transferContract],
+                refBlockBytes: 'c8cf',
+                refBlockHash: '89177fd84c5d9196',
+                expiration: params.expiration || timestamp + 3600000,
+                timestamp: timestamp,
+            };
+            return lib_1.Utils.generateRawDataHex(transformedRawData);
+        }
+        (0, node_test_1.describe)('TransferContract', () => {
+            (0, node_test_1.it)('should validate a valid TSS TransferContract', async function () {
+                const ownerHex = '4173a5993cd182ae152adad8203163f780c65a8aa5';
+                const toHex = '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882';
+                const amount = 1000000;
+                const rawDataHex = buildTssTransferTxHex({ ownerAddress: ownerHex, toAddress: toHex, amount });
+                const params = {
+                    txParams: {
+                        recipients: [
+                            {
+                                // TSS path: recipients use base58 addresses
+                                address: lib_1.Utils.getBase58AddressFromHex(toHex),
+                                amount: amount.toString(),
+                            },
+                        ],
+                    },
+                    txPrebuild: {
+                        // TSS path: txHex is the raw protobuf hex, not a JSON string
+                        txHex: rawDataHex,
+                    },
+                    wallet: {},
+                    walletType: 'tss',
+                };
+                const result = await basecoin.verifyTransaction(params);
+                node_assert_1.default.strictEqual(result, true);
+            });
+            (0, node_test_1.it)('should fail TSS verification when amount does not match', async function () {
+                const ownerHex = '4173a5993cd182ae152adad8203163f780c65a8aa5';
+                const toHex = '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882';
+                const rawDataHex = buildTssTransferTxHex({ ownerAddress: ownerHex, toAddress: toHex, amount: 2000000 });
+                const params = {
+                    txParams: {
+                        recipients: [
+                            {
+                                address: lib_1.Utils.getBase58AddressFromHex(toHex),
+                                amount: '1000000', // mismatch: txHex has 2000000
+                            },
+                        ],
+                    },
+                    txPrebuild: {
+                        txHex: rawDataHex,
+                    },
+                    wallet: {},
+                    walletType: 'tss',
+                };
+                await node_assert_1.default.rejects(basecoin.verifyTransaction(params), {
+                    message: 'transaction amount in txPrebuild does not match the value given by client',
+                });
+            });
+            (0, node_test_1.it)('should fail TSS verification when destination address does not match', async function () {
+                const ownerHex = '4173a5993cd182ae152adad8203163f780c65a8aa5';
+                const toHex = '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882';
+                const rawDataHex = buildTssTransferTxHex({ ownerAddress: ownerHex, toAddress: toHex, amount: 1000000 });
+                const params = {
+                    txParams: {
+                        recipients: [
+                            {
+                                // Different address than what's in the transaction
+                                address: 'TTsGwnTLQ4eryFJpDvJSfuGQxPXRCjXvZz',
+                                amount: '1000000',
+                            },
+                        ],
+                    },
+                    txPrebuild: {
+                        txHex: rawDataHex,
+                    },
+                    wallet: {},
+                    walletType: 'tss',
+                };
+                await node_assert_1.default.rejects(basecoin.verifyTransaction(params), {
+                    message: 'destination address does not match with the recipient address',
+                });
+            });
+        });
+        (0, node_test_1.it)('should return true for non-Transfer, non-TriggerSmartContract types in TSS', async function () {
+            // AccountPermissionUpdate and other native TRX contracts (freeze, vote, etc.) pass through
+            // without recipient validation in the TSS path.
+            const rawDataHex = resources_1.UnsignedAccountPermissionUpdateContractTx.raw_data_hex;
+            const params = {
+                txParams: {
+                    recipients: [],
+                },
+                txPrebuild: {
+                    txHex: rawDataHex,
+                },
+                wallet: {},
+                walletType: 'tss',
+            };
+            const result = await basecoin.verifyTransaction(params);
+            node_assert_1.default.strictEqual(result, true);
+        });
+        (0, node_test_1.describe)('TriggerSmartContract (TRC20) routed through native Trx', () => {
+            // CECHO-2248: token wallets are sometimes constructed with the native coin instance
+            // (e.g. bitgo.coin('trx').wallets().get() on a trx:<token> wallet), so a TRC20
+            // TriggerSmartContract prebuild can reach the native Trx verifier. It must validate
+            // recipient and amount (same as TrxToken.verifyTransaction) instead of throwing.
+            const trc20RawDataHex = '0a02578b22086113bb9ac351432b4088eae7a6de305aae01081f12a9010a31747970652e676f6f676c65617069732e636f6d2f70726f746f636f6c2e54726967676572536d617274436f6e747261637412740a1541c51fbeea78910b15b1d3e8a9b62914ca94d1a4ac12154142a1e39aefa49290f2b3f9ed688d7cecf86cd6e02244a9059cbb0000000000000000000000008483618ca85c35a9b923d98bebca718f5a1db2790000000000000000000000000000000000000000000000000000000005f5e10070888d8ca5de309001c0c39307';
+            // Recipient address decoded from the ABI data in the protobuf above (41 prefix → base58)
+            const trc20RecipientHex = '418483618ca85c35a9b923d98bebca718f5a1db279';
+            const trc20RecipientBase58 = lib_1.Utils.getBase58AddressFromHex(trc20RecipientHex);
+            const trc20Amount = '100000000';
+            (0, node_test_1.it)('should validate a matching TRC20 transfer instead of throwing', async function () {
+                const params = {
+                    txParams: {
+                        recipients: [{ address: trc20RecipientBase58, amount: trc20Amount }],
+                    },
+                    txPrebuild: {
+                        txHex: trc20RawDataHex,
+                    },
+                    wallet: {},
+                    walletType: 'tss',
+                };
+                const result = await basecoin.verifyTransaction(params);
+                node_assert_1.default.strictEqual(result, true);
+            });
+            (0, node_test_1.it)('should fail when TRC20 amount does not match', async function () {
+                const params = {
+                    txParams: {
+                        recipients: [{ address: trc20RecipientBase58, amount: '999' }],
+                    },
+                    txPrebuild: {
+                        txHex: trc20RawDataHex,
+                    },
+                    wallet: {},
+                    walletType: 'tss',
+                };
+                await node_assert_1.default.rejects(basecoin.verifyTransaction(params), {
+                    message: 'transaction amount in txPrebuild does not match the value given by client',
+                });
+            });
+            (0, node_test_1.it)('should fail when TRC20 destination does not match', async function () {
+                const params = {
+                    txParams: {
+                        recipients: [{ address: 'TLWh67P93KgtnZNCtGnEHM1H33Nhq2uvvN', amount: trc20Amount }],
+                    },
+                    txPrebuild: {
+                        txHex: trc20RawDataHex,
+                    },
+                    wallet: {},
+                    walletType: 'tss',
+                };
+                await node_assert_1.default.rejects(basecoin.verifyTransaction(params), {
+                    message: 'destination address does not match with the recipient address',
+                });
+            });
+            (0, node_test_1.it)('should return true when no recipients are provided (consolidation path)', async function () {
+                const params = {
+                    txParams: {
+                        recipients: [],
+                    },
+                    txPrebuild: {
+                        txHex: trc20RawDataHex,
+                    },
+                    wallet: {},
+                    walletType: 'tss',
+                };
+                const result = await basecoin.verifyTransaction(params);
+                node_assert_1.default.strictEqual(result, true);
+            });
+        });
+        (0, node_test_1.it)('should throw error when txHex is missing for TSS wallet', async function () {
+            const params = {
+                txParams: {
+                    recipients: [{ address: 'TQFxDSoXy2yXRE5HtKwAwrNRXGxYxkeSGk', amount: '1000000' }],
+                },
+                txPrebuild: {},
+                wallet: {},
+                walletType: 'tss',
+            };
+            await node_assert_1.default.rejects(basecoin.verifyTransaction(params), {
+                message: 'missing txHex in txPrebuild',
+            });
+        });
+        (0, node_test_1.describe)('serializedTxHex (JSON string) path', () => {
+            // prebuildAndSignTransaction passes txHex as serializedTxHex — a full JSON string
+            // containing { txID, raw_data, raw_data_hex }. The TSS branch must handle this format
+            // by extracting raw_data_hex before protobuf decoding.
+            (0, node_test_1.it)('should validate TSS TransferContract when txHex is a JSON string (serializedTxHex)', async function () {
+                const ownerHex = '4173a5993cd182ae152adad8203163f780c65a8aa5';
+                const toHex = '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882';
+                const amount = 1000000;
+                const rawDataHex = buildTssTransferTxHex({ ownerAddress: ownerHex, toAddress: toHex, amount });
+                const txID = (0, crypto_1.createHash)('sha256').update(Buffer.from(rawDataHex, 'hex')).digest('hex');
+                // Simulate the serializedTxHex format from BitGo API (JSON string with txID + raw_data_hex)
+                const serializedTxHex = JSON.stringify({
+                    txID,
+                    raw_data_hex: rawDataHex,
+                    raw_data: {},
+                });
+                const params = {
+                    txParams: {
+                        recipients: [
+                            {
+                                address: lib_1.Utils.getBase58AddressFromHex(toHex),
+                                amount: amount.toString(),
+                            },
+                        ],
+                    },
+                    txPrebuild: {
+                        txHex: serializedTxHex,
+                    },
+                    wallet: {},
+                    walletType: 'tss',
+                };
+                const result = await basecoin.verifyTransaction(params);
+                node_assert_1.default.strictEqual(result, true);
+            });
+            (0, node_test_1.it)('should fail when amount mismatches with JSON txHex', async function () {
+                const ownerHex = '4173a5993cd182ae152adad8203163f780c65a8aa5';
+                const toHex = '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882';
+                const rawDataHex = buildTssTransferTxHex({ ownerAddress: ownerHex, toAddress: toHex, amount: 2000000 });
+                const serializedTxHex = JSON.stringify({
+                    txID: (0, crypto_1.createHash)('sha256').update(Buffer.from(rawDataHex, 'hex')).digest('hex'),
+                    raw_data_hex: rawDataHex,
+                    raw_data: {},
+                });
+                const params = {
+                    txParams: {
+                        recipients: [
+                            {
+                                address: lib_1.Utils.getBase58AddressFromHex(toHex),
+                                amount: '1000000', // mismatch
+                            },
+                        ],
+                    },
+                    txPrebuild: {
+                        txHex: serializedTxHex,
+                    },
+                    wallet: {},
+                    walletType: 'tss',
+                };
+                await node_assert_1.default.rejects(basecoin.verifyTransaction(params), {
+                    message: 'transaction amount in txPrebuild does not match the value given by client',
+                });
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"verifyTransaction.js","sourceRoot":"","sources":["../../../test/unit/verifyTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'node:assert';\nimport { createHash } from 'crypto';\nimport { describe, it, before } from 'node:test';\nimport { BitGoAPI } from '@bitgo-beta/sdk-api';\nimport { TestBitGoAPI, TestBitGo } from '@bitgo-beta/sdk-test';\nimport { Trx, Ttrx } from '../../src';\nimport { Utils } from '../../src/lib';\nimport { UnsignedBuildTransaction, UnsignedAccountPermissionUpdateContractTx } from '../resources';\n\ndescribe('TRON Verify Transaction:', function () {\n  const bitgo: TestBitGoAPI = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n  bitgo.initializeTestVars();\n  bitgo.safeRegister('trx', Trx.createInstance);\n  bitgo.safeRegister('ttrx', Ttrx.createInstance);\n\n  let basecoin;\n\n  before(function () {\n    basecoin = bitgo.coin('ttrx');\n  });\n\n  describe('Parameter Validation', () => {\n    it('should throw error when txParams is missing', async function () {\n      const params = {\n        txPrebuild: {\n          txHex: JSON.stringify({\n            ...UnsignedBuildTransaction,\n            raw_data: {\n              ...UnsignedBuildTransaction.raw_data,\n              expiration: Date.now() + 3600000,\n              timestamp: Date.now(),\n            },\n          }),\n        },\n        wallet: {},\n      };\n\n      await assert.rejects(basecoin.verifyTransaction(params), {\n        message: 'missing txParams',\n      });\n    });\n\n    it('should throw error when wallet or txPrebuild is missing', async function () {\n      const params = {\n        txParams: {\n          recipients: [{ address: 'TQFxDSoXy2yXRE5HtKwAwrNRXGxYxkeSGk', amount: '1000000' }],\n        },\n      };\n\n      await assert.rejects(basecoin.verifyTransaction(params), {\n        message: 'missing txPrebuild',\n      });\n    });\n\n    it('should throw error when txPrebuild.txHex is missing', async function () {\n      const params = {\n        txParams: {\n          recipients: [{ address: 'TQFxDSoXy2yXRE5HtKwAwrNRXGxYxkeSGk', amount: '1000000' }],\n        },\n        txPrebuild: {},\n        wallet: {},\n      };\n\n      await assert.rejects(basecoin.verifyTransaction(params), {\n        message: 'missing txHex in txPrebuild',\n      });\n    });\n  });\n\n  describe('Contract Type Validation', () => {\n    describe('TransferContract', () => {\n      it('should validate valid TransferContract', async function () {\n        const timestamp = Date.now();\n        const transferContract = {\n          parameter: {\n            value: {\n              amount: 1000000,\n              owner_address: '4173a5993cd182ae152adad8203163f780c65a8aa5',\n              to_address: '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882',\n            },\n            type_url: 'type.googleapis.com/protocol.TransferContract',\n          },\n          type: 'TransferContract',\n        };\n\n        const rawData = {\n          contract: [transferContract],\n          ref_block_bytes: 'c8cf',\n          ref_block_hash: '89177fd84c5d9196',\n          expiration: timestamp + 3600000,\n          timestamp: timestamp,\n          fee_limit: 150000000,\n        };\n\n        // Transform rawData to match the expected parameter structure\n        const transformedRawData = {\n          contract: rawData.contract as any,\n          refBlockBytes: rawData.ref_block_bytes,\n          refBlockHash: rawData.ref_block_hash,\n          expiration: rawData.expiration,\n          timestamp: rawData.timestamp,\n          feeLimit: rawData.fee_limit,\n        };\n\n        // Generate raw_data_hex using the utility function\n        const rawDataHex = Utils.generateRawDataHex(transformedRawData);\n\n        // Calculate txID as SHA256 hash of raw_data_hex\n        const txID = createHash('sha256').update(Buffer.from(rawDataHex, 'hex')).digest('hex');\n\n        const params = {\n          txParams: {\n            recipients: [\n              {\n                address: Utils.getBase58AddressFromHex('41d6cd6a2c0ff35a319e6abb5b9503ba0278679882'),\n                amount: '1000000',\n              },\n            ],\n          },\n          txPrebuild: {\n            txHex: JSON.stringify({\n              txID,\n              raw_data: rawData,\n              raw_data_hex: rawDataHex,\n            }),\n          },\n          wallet: {},\n        };\n\n        const result = await basecoin.verifyTransaction(params);\n        assert.strictEqual(result, true);\n      });\n\n      it('should validate TransferContract when recipient is 0x-prefixed hex (COINS-1575)', async function () {\n        const timestamp = Date.now();\n        const toAddressHex = '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882';\n        const transferContract = {\n          parameter: {\n            value: {\n              amount: 1000000,\n              owner_address: '4173a5993cd182ae152adad8203163f780c65a8aa5',\n              to_address: toAddressHex,\n            },\n            type_url: 'type.googleapis.com/protocol.TransferContract',\n          },\n          type: 'TransferContract',\n        };\n\n        const rawData = {\n          contract: [transferContract],\n          ref_block_bytes: 'c8cf',\n          ref_block_hash: '89177fd84c5d9196',\n          expiration: timestamp + 3600000,\n          timestamp: timestamp,\n          fee_limit: 150000000,\n        };\n\n        const transformedRawData = {\n          contract: rawData.contract as any,\n          refBlockBytes: rawData.ref_block_bytes,\n          refBlockHash: rawData.ref_block_hash,\n          expiration: rawData.expiration,\n          timestamp: rawData.timestamp,\n          feeLimit: rawData.fee_limit,\n        };\n\n        const rawDataHex = Utils.generateRawDataHex(transformedRawData);\n        const txID = createHash('sha256').update(Buffer.from(rawDataHex, 'hex')).digest('hex');\n\n        const params = {\n          txParams: {\n            recipients: [\n              {\n                address: '0x' + toAddressHex.slice(2),\n                amount: '1000000',\n              },\n            ],\n          },\n          txPrebuild: {\n            txHex: JSON.stringify({\n              txID,\n              raw_data: rawData,\n              raw_data_hex: rawDataHex,\n            }),\n          },\n          wallet: {},\n        };\n\n        const result = await basecoin.verifyTransaction(params);\n        assert.strictEqual(result, true);\n      });\n\n      it('should fail with missing owner address', async function () {\n        const timestamp = Date.now();\n        const txID = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';\n        const transferContract = {\n          parameter: {\n            value: {\n              amount: 1000000,\n              to_address: '41c25420255c2c5a2dd54ef69f92ef261e6bd4216a',\n            },\n            type_url: 'type.googleapis.com/protocol.TransferContract',\n          },\n          type: 'TransferContract',\n        };\n\n        const rawData = {\n          txID,\n          contract: [transferContract],\n          ref_block_bytes: 'c8cf',\n          ref_block_hash: '89177fd84c5d9196',\n          expiration: timestamp + 3600000,\n          timestamp: timestamp,\n          fee_limit: 150000000,\n        };\n\n        const transformedRawData = {\n          contract: rawData.contract as any,\n          refBlockBytes: rawData.ref_block_bytes,\n          refBlockHash: rawData.ref_block_hash,\n          expiration: rawData.expiration,\n          timestamp: rawData.timestamp,\n          feeLimit: rawData.fee_limit,\n        };\n\n        const expectedRawDataHex = Utils.generateRawDataHex(transformedRawData);\n\n        const params = {\n          txParams: {\n            recipients: [{ address: 'TLWh67P93KgtnZNCtGnEHM1H33Nhq2uvvN', amount: '1000000' }],\n          },\n          txPrebuild: {\n            txHex: JSON.stringify({\n              txID,\n              raw_data: rawData,\n              raw_data_hex: expectedRawDataHex,\n            }),\n          },\n          wallet: {},\n        };\n\n        await assert.rejects(basecoin.verifyTransaction(params), {\n          message: 'Transaction has not have a valid id',\n        });\n      });\n\n      it('should fail with missing destination address', async function () {\n        const timestamp = Date.now();\n        const txID = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';\n        const transferContract = {\n          parameter: {\n            value: {\n              amount: 1000000,\n              owner_address: '4173a5993cd182ae152adad8203163f780c65a8aa5',\n            },\n            type_url: 'type.googleapis.com/protocol.TransferContract',\n          },\n          type: 'TransferContract',\n        };\n\n        const rawData = {\n          txID,\n          contract: [transferContract],\n          ref_block_bytes: 'c8cf',\n          ref_block_hash: '89177fd84c5d9196',\n          expiration: timestamp + 3600000,\n          timestamp: timestamp,\n          fee_limit: 150000000,\n        };\n\n        const transformedRawData = {\n          contract: rawData.contract as any,\n          refBlockBytes: rawData.ref_block_bytes,\n          refBlockHash: rawData.ref_block_hash,\n          expiration: rawData.expiration,\n          timestamp: rawData.timestamp,\n          feeLimit: rawData.fee_limit,\n        };\n\n        const expectedRawDataHex = Utils.generateRawDataHex(transformedRawData);\n\n        const params = {\n          txParams: {\n            recipients: [{ address: 'TLWh67P93KgtnZNCtGnEHM1H33Nhq2uvvN', amount: '1000000' }],\n          },\n          txPrebuild: {\n            txHex: JSON.stringify({\n              txID,\n              raw_data: rawData,\n              raw_data_hex: expectedRawDataHex,\n            }),\n          },\n          wallet: {},\n        };\n\n        await assert.rejects(basecoin.verifyTransaction(params), {\n          message: 'Transaction has not have a valid id',\n        });\n      });\n\n      it('should fail with missing amount', async function () {\n        const timestamp = Date.now();\n        const transferContract = {\n          parameter: {\n            value: {\n              owner_address: '4173a5993cd182ae152adad8203163f780c65a8aa5',\n              to_address: '41c25420255c2c5a2dd54ef69f92ef261e6bd4216a',\n            },\n            type_url: 'type.googleapis.com/protocol.TransferContract',\n          },\n          type: 'TransferContract',\n        };\n\n        const rawData = {\n          contract: [transferContract],\n          ref_block_bytes: 'c8cf',\n          ref_block_hash: '89177fd84c5d9196',\n          expiration: timestamp + 3600000,\n          timestamp: timestamp,\n          fee_limit: 150000000,\n        };\n\n        const transformedRawData = {\n          contract: rawData.contract as any,\n          refBlockBytes: rawData.ref_block_bytes,\n          refBlockHash: rawData.ref_block_hash,\n          expiration: rawData.expiration,\n          timestamp: rawData.timestamp,\n          feeLimit: rawData.fee_limit,\n        };\n\n        const expectedRawDataHex = Utils.generateRawDataHex(transformedRawData);\n\n        const params = {\n          txParams: {\n            recipients: [{ address: 'TLWh67P93KgtnZNCtGnEHM1H33Nhq2uvvN', amount: '1000000' }],\n          },\n          txPrebuild: {\n            txHex: JSON.stringify({\n              raw_data: rawData,\n              raw_data_hex: expectedRawDataHex,\n            }),\n          },\n          wallet: {},\n        };\n\n        await assert.rejects(basecoin.verifyTransaction(params), {\n          message: 'Amount does not exist in this transfer contract.',\n        });\n      });\n\n      it('should fail due to amount missmatch', async function () {\n        const timestamp = Date.now();\n        const transferContract = {\n          parameter: {\n            value: {\n              amount: 2000000,\n              owner_address: '4173a5993cd182ae152adad8203163f780c65a8aa5',\n              to_address: '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882',\n            },\n            type_url: 'type.googleapis.com/protocol.TransferContract',\n          },\n          type: 'TransferContract',\n        };\n\n        const rawData = {\n          contract: [transferContract],\n          ref_block_bytes: 'c8cf',\n          ref_block_hash: '89177fd84c5d9196',\n          expiration: timestamp + 3600000,\n          timestamp: timestamp,\n          fee_limit: 150000000,\n        };\n\n        // Transform rawData to match the expected parameter structure\n        const transformedRawData = {\n          contract: rawData.contract as any,\n          refBlockBytes: rawData.ref_block_bytes,\n          refBlockHash: rawData.ref_block_hash,\n          expiration: rawData.expiration,\n          timestamp: rawData.timestamp,\n          feeLimit: rawData.fee_limit,\n        };\n\n        // Generate raw_data_hex using the utility function\n        const rawDataHex = Utils.generateRawDataHex(transformedRawData);\n\n        // Calculate txID as SHA256 hash of raw_data_hex\n        const txID = createHash('sha256').update(Buffer.from(rawDataHex, 'hex')).digest('hex');\n\n        const params = {\n          txParams: {\n            recipients: [\n              {\n                address: '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882',\n                amount: '1000000',\n              },\n            ],\n          },\n          txPrebuild: {\n            txHex: JSON.stringify({\n              txID,\n              raw_data: rawData,\n              raw_data_hex: rawDataHex,\n            }),\n          },\n          wallet: {},\n        };\n\n        await assert.rejects(basecoin.verifyTransaction(params), {\n          message: 'transaction amount in txPrebuild does not match the value given by client',\n        });\n      });\n\n      it('should fail due to destination address missmatch', async function () {\n        const timestamp = Date.now();\n        const transferContract = {\n          parameter: {\n            value: {\n              amount: 1000000,\n              owner_address: '4173a5993cd182ae152adad8203163f780c65a8aa5',\n              to_address: '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882',\n            },\n            type_url: 'type.googleapis.com/protocol.TransferContract',\n          },\n          type: 'TransferContract',\n        };\n\n        const rawData = {\n          contract: [transferContract],\n          ref_block_bytes: 'c8cf',\n          ref_block_hash: '89177fd84c5d9196',\n          expiration: timestamp + 3600000,\n          timestamp: timestamp,\n          fee_limit: 150000000,\n        };\n\n        // Transform rawData to match the expected parameter structure\n        const transformedRawData = {\n          contract: rawData.contract as any,\n          refBlockBytes: rawData.ref_block_bytes,\n          refBlockHash: rawData.ref_block_hash,\n          expiration: rawData.expiration,\n          timestamp: rawData.timestamp,\n          feeLimit: rawData.fee_limit,\n        };\n\n        // Generate raw_data_hex using the utility function\n        const rawDataHex = Utils.generateRawDataHex(transformedRawData);\n\n        // Calculate txID as SHA256 hash of raw_data_hex\n        const txID = createHash('sha256').update(Buffer.from(rawDataHex, 'hex')).digest('hex');\n\n        const params = {\n          txParams: {\n            recipients: [\n              {\n                address: '41d6cd6a2c0ff35a319e6abb5b9503ba0278679883',\n                amount: '1000000',\n              },\n            ],\n          },\n          txPrebuild: {\n            txHex: JSON.stringify({\n              txID,\n              raw_data: rawData,\n              raw_data_hex: rawDataHex,\n            }),\n          },\n          wallet: {},\n        };\n\n        await assert.rejects(basecoin.verifyTransaction(params), {\n          message: 'destination address does not match with the recipient address',\n        });\n      });\n    });\n  });\n\n  describe('TSS Wallet Verification', () => {\n    /**\n     * Helper to build a raw_data_hex (protobuf) for a TransferContract.\n     * For TSS, txPrebuild.txHex is the raw_data_hex directly (not a JSON string).\n     */\n    function buildTssTransferTxHex(params: {\n      ownerAddress: string;\n      toAddress: string;\n      amount: number;\n      timestamp?: number;\n      expiration?: number;\n    }): string {\n      const timestamp = params.timestamp || Date.now();\n      const transferContract = {\n        parameter: {\n          value: {\n            amount: params.amount,\n            owner_address: params.ownerAddress,\n            to_address: params.toAddress,\n          },\n          type_url: 'type.googleapis.com/protocol.TransferContract',\n        },\n        type: 'TransferContract',\n      };\n\n      const transformedRawData = {\n        contract: [transferContract] as any,\n        refBlockBytes: 'c8cf',\n        refBlockHash: '89177fd84c5d9196',\n        expiration: params.expiration || timestamp + 3600000,\n        timestamp: timestamp,\n      };\n\n      return Utils.generateRawDataHex(transformedRawData);\n    }\n\n    describe('TransferContract', () => {\n      it('should validate a valid TSS TransferContract', async function () {\n        const ownerHex = '4173a5993cd182ae152adad8203163f780c65a8aa5';\n        const toHex = '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882';\n        const amount = 1000000;\n\n        const rawDataHex = buildTssTransferTxHex({ ownerAddress: ownerHex, toAddress: toHex, amount });\n\n        const params = {\n          txParams: {\n            recipients: [\n              {\n                // TSS path: recipients use base58 addresses\n                address: Utils.getBase58AddressFromHex(toHex),\n                amount: amount.toString(),\n              },\n            ],\n          },\n          txPrebuild: {\n            // TSS path: txHex is the raw protobuf hex, not a JSON string\n            txHex: rawDataHex,\n          },\n          wallet: {},\n          walletType: 'tss',\n        };\n\n        const result = await basecoin.verifyTransaction(params);\n        assert.strictEqual(result, true);\n      });\n\n      it('should fail TSS verification when amount does not match', async function () {\n        const ownerHex = '4173a5993cd182ae152adad8203163f780c65a8aa5';\n        const toHex = '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882';\n\n        const rawDataHex = buildTssTransferTxHex({ ownerAddress: ownerHex, toAddress: toHex, amount: 2000000 });\n\n        const params = {\n          txParams: {\n            recipients: [\n              {\n                address: Utils.getBase58AddressFromHex(toHex),\n                amount: '1000000', // mismatch: txHex has 2000000\n              },\n            ],\n          },\n          txPrebuild: {\n            txHex: rawDataHex,\n          },\n          wallet: {},\n          walletType: 'tss',\n        };\n\n        await assert.rejects(basecoin.verifyTransaction(params), {\n          message: 'transaction amount in txPrebuild does not match the value given by client',\n        });\n      });\n\n      it('should fail TSS verification when destination address does not match', async function () {\n        const ownerHex = '4173a5993cd182ae152adad8203163f780c65a8aa5';\n        const toHex = '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882';\n\n        const rawDataHex = buildTssTransferTxHex({ ownerAddress: ownerHex, toAddress: toHex, amount: 1000000 });\n\n        const params = {\n          txParams: {\n            recipients: [\n              {\n                // Different address than what's in the transaction\n                address: 'TTsGwnTLQ4eryFJpDvJSfuGQxPXRCjXvZz',\n                amount: '1000000',\n              },\n            ],\n          },\n          txPrebuild: {\n            txHex: rawDataHex,\n          },\n          wallet: {},\n          walletType: 'tss',\n        };\n\n        await assert.rejects(basecoin.verifyTransaction(params), {\n          message: 'destination address does not match with the recipient address',\n        });\n      });\n    });\n\n    it('should return true for non-Transfer, non-TriggerSmartContract types in TSS', async function () {\n      // AccountPermissionUpdate and other native TRX contracts (freeze, vote, etc.) pass through\n      // without recipient validation in the TSS path.\n      const rawDataHex = UnsignedAccountPermissionUpdateContractTx.raw_data_hex;\n\n      const params = {\n        txParams: {\n          recipients: [],\n        },\n        txPrebuild: {\n          txHex: rawDataHex,\n        },\n        wallet: {},\n        walletType: 'tss',\n      };\n\n      const result = await basecoin.verifyTransaction(params);\n      assert.strictEqual(result, true);\n    });\n\n    describe('TriggerSmartContract (TRC20) routed through native Trx', () => {\n      // CECHO-2248: token wallets are sometimes constructed with the native coin instance\n      // (e.g. bitgo.coin('trx').wallets().get() on a trx:<token> wallet), so a TRC20\n      // TriggerSmartContract prebuild can reach the native Trx verifier. It must validate\n      // recipient and amount (same as TrxToken.verifyTransaction) instead of throwing.\n      const trc20RawDataHex =\n        '0a02578b22086113bb9ac351432b4088eae7a6de305aae01081f12a9010a31747970652e676f6f676c65617069732e636f6d2f70726f746f636f6c2e54726967676572536d617274436f6e747261637412740a1541c51fbeea78910b15b1d3e8a9b62914ca94d1a4ac12154142a1e39aefa49290f2b3f9ed688d7cecf86cd6e02244a9059cbb0000000000000000000000008483618ca85c35a9b923d98bebca718f5a1db2790000000000000000000000000000000000000000000000000000000005f5e10070888d8ca5de309001c0c39307';\n\n      // Recipient address decoded from the ABI data in the protobuf above (41 prefix → base58)\n      const trc20RecipientHex = '418483618ca85c35a9b923d98bebca718f5a1db279';\n      const trc20RecipientBase58 = Utils.getBase58AddressFromHex(trc20RecipientHex);\n      const trc20Amount = '100000000';\n\n      it('should validate a matching TRC20 transfer instead of throwing', async function () {\n        const params = {\n          txParams: {\n            recipients: [{ address: trc20RecipientBase58, amount: trc20Amount }],\n          },\n          txPrebuild: {\n            txHex: trc20RawDataHex,\n          },\n          wallet: {},\n          walletType: 'tss',\n        };\n\n        const result = await basecoin.verifyTransaction(params);\n        assert.strictEqual(result, true);\n      });\n\n      it('should fail when TRC20 amount does not match', async function () {\n        const params = {\n          txParams: {\n            recipients: [{ address: trc20RecipientBase58, amount: '999' }],\n          },\n          txPrebuild: {\n            txHex: trc20RawDataHex,\n          },\n          wallet: {},\n          walletType: 'tss',\n        };\n\n        await assert.rejects(basecoin.verifyTransaction(params), {\n          message: 'transaction amount in txPrebuild does not match the value given by client',\n        });\n      });\n\n      it('should fail when TRC20 destination does not match', async function () {\n        const params = {\n          txParams: {\n            recipients: [{ address: 'TLWh67P93KgtnZNCtGnEHM1H33Nhq2uvvN', amount: trc20Amount }],\n          },\n          txPrebuild: {\n            txHex: trc20RawDataHex,\n          },\n          wallet: {},\n          walletType: 'tss',\n        };\n\n        await assert.rejects(basecoin.verifyTransaction(params), {\n          message: 'destination address does not match with the recipient address',\n        });\n      });\n\n      it('should return true when no recipients are provided (consolidation path)', async function () {\n        const params = {\n          txParams: {\n            recipients: [],\n          },\n          txPrebuild: {\n            txHex: trc20RawDataHex,\n          },\n          wallet: {},\n          walletType: 'tss',\n        };\n\n        const result = await basecoin.verifyTransaction(params);\n        assert.strictEqual(result, true);\n      });\n    });\n\n    it('should throw error when txHex is missing for TSS wallet', async function () {\n      const params = {\n        txParams: {\n          recipients: [{ address: 'TQFxDSoXy2yXRE5HtKwAwrNRXGxYxkeSGk', amount: '1000000' }],\n        },\n        txPrebuild: {},\n        wallet: {},\n        walletType: 'tss',\n      };\n\n      await assert.rejects(basecoin.verifyTransaction(params), {\n        message: 'missing txHex in txPrebuild',\n      });\n    });\n\n    describe('serializedTxHex (JSON string) path', () => {\n      // prebuildAndSignTransaction passes txHex as serializedTxHex — a full JSON string\n      // containing { txID, raw_data, raw_data_hex }. The TSS branch must handle this format\n      // by extracting raw_data_hex before protobuf decoding.\n\n      it('should validate TSS TransferContract when txHex is a JSON string (serializedTxHex)', async function () {\n        const ownerHex = '4173a5993cd182ae152adad8203163f780c65a8aa5';\n        const toHex = '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882';\n        const amount = 1000000;\n\n        const rawDataHex = buildTssTransferTxHex({ ownerAddress: ownerHex, toAddress: toHex, amount });\n        const txID = createHash('sha256').update(Buffer.from(rawDataHex, 'hex')).digest('hex');\n\n        // Simulate the serializedTxHex format from BitGo API (JSON string with txID + raw_data_hex)\n        const serializedTxHex = JSON.stringify({\n          txID,\n          raw_data_hex: rawDataHex,\n          raw_data: {},\n        });\n\n        const params = {\n          txParams: {\n            recipients: [\n              {\n                address: Utils.getBase58AddressFromHex(toHex),\n                amount: amount.toString(),\n              },\n            ],\n          },\n          txPrebuild: {\n            txHex: serializedTxHex,\n          },\n          wallet: {},\n          walletType: 'tss',\n        };\n\n        const result = await basecoin.verifyTransaction(params);\n        assert.strictEqual(result, true);\n      });\n\n      it('should fail when amount mismatches with JSON txHex', async function () {\n        const ownerHex = '4173a5993cd182ae152adad8203163f780c65a8aa5';\n        const toHex = '41d6cd6a2c0ff35a319e6abb5b9503ba0278679882';\n\n        const rawDataHex = buildTssTransferTxHex({ ownerAddress: ownerHex, toAddress: toHex, amount: 2000000 });\n        const serializedTxHex = JSON.stringify({\n          txID: createHash('sha256').update(Buffer.from(rawDataHex, 'hex')).digest('hex'),\n          raw_data_hex: rawDataHex,\n          raw_data: {},\n        });\n\n        const params = {\n          txParams: {\n            recipients: [\n              {\n                address: Utils.getBase58AddressFromHex(toHex),\n                amount: '1000000', // mismatch\n              },\n            ],\n          },\n          txPrebuild: {\n            txHex: serializedTxHex,\n          },\n          wallet: {},\n          walletType: 'tss',\n        };\n\n        await assert.rejects(basecoin.verifyTransaction(params), {\n          message: 'transaction amount in txPrebuild does not match the value given by client',\n        });\n      });\n    });\n  });\n});\n"]}