@bitgo-beta/sdk-coin-trx 1.2.3-alpha.43 → 1.2.3-alpha.431

package/dist/test/unit/util.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=util.d.ts.map

package/dist/test/unit/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../test/unit/util.ts"],"names":[],"mappings":""}

package/dist/test/unit/util.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const assert_1 = __importDefault(require("assert"));
+const src_1 = require("../../src");
+const resources_1 = require("../resources");
+const utils_1 = require("../../src/lib/utils");
+(0, node_test_1.describe)('Util library should', function () {
+    // arbitrary text
+    const arr = [127, 255, 31, 192, 3, 126, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    const hex = '7FFF1FC0037E0000000000000000000000000000000000000000000000000000';
+    const txt = 'arbitrary string to sign';
+    const signedString = '0x9424113f32c17b6ffbeee024e1a54b6991d756e82f66cca16a41231fdfa270d03b08e833f5dbbd5cc86896c2e5ea6c74d2e292cda21f717164f994fcdf28486d1b';
+    // prv-pub-address hex
+    const prv = 'FB3AA887E0BE3FAC9D75E661DAFF4A7FE0E91AAB13DA9775CD8586D7CB9B7640';
+    const pub = '046EBFB90C396B4A3B992B727CB4714A32E2A6DE43FDB3EC266286AC2246D8FD1E23E12C0DEB752C631A9011BBF8B56E2FBAA20E99D3952F0A558D11F96E7C1C5D';
+    const addressHex = '412C2BA4A9FF6C53207DC5B686BFECF75EA7B80577';
+    const base58 = 'TDzm1tCXM2YS1PDa3GoXSvxdy4AgwVbBPE';
+    const addrBytes = [65, 44, 43, 164, 169, 255, 108, 83, 32, 125, 197, 182, 134, 191, 236, 247, 94, 167, 184, 5, 119];
+    // tx information
+    (0, node_test_1.it)('be able to convert hex to bytes', () => {
+        const ba = src_1.Utils.getByteArrayFromHexAddress(hex);
+        assert_1.default.deepStrictEqual(ba, arr);
+    });
+    (0, node_test_1.it)('be able to convert hex with 0x to bytes ', () => {
+        const ba = src_1.Utils.getByteArrayFromHexAddress('0x' + hex);
+        assert_1.default.deepStrictEqual(ba, arr);
+    });
+    (0, node_test_1.it)('be able to convert hex to bytes', () => {
+        const hs = src_1.Utils.getHexAddressFromByteArray(arr);
+        assert_1.default.equal(hs, hex);
+    });
+    (0, node_test_1.it)('get a pub from a prv', () => {
+        const derivedPub = src_1.Utils.getPubKeyFromPriKey(Buffer.from(prv, 'hex'));
+        const derivedPubHex = src_1.Utils.getHexAddressFromByteArray(derivedPub);
+        assert_1.default.equal(derivedPubHex, pub);
+    });
+    (0, node_test_1.it)('get an hex address from a prv', () => {
+        const addr = src_1.Utils.getAddressFromPriKey(Buffer.from(prv, 'hex'));
+        const hexAddr = src_1.Utils.getHexAddressFromByteArray(addr);
+        assert_1.default.equal(hexAddr, addressHex);
+    });
+    (0, node_test_1.it)('get an base58 address', () => {
+        const addr = src_1.Utils.getAddressFromPriKey(Buffer.from(prv, 'hex'));
+        const addr58 = src_1.Utils.getBase58AddressFromByteArray(addr);
+        assert_1.default.equal(addr58, base58);
+    });
+    (0, node_test_1.it)('get an base58 address from hex', () => {
+        const addr58 = src_1.Utils.getBase58AddressFromHex(addressHex);
+        assert_1.default.equal(addr58, base58);
+    });
+    (0, node_test_1.it)('get hex from base58 address', () => {
+        const hexAddr = src_1.Utils.getHexAddressFromBase58Address(base58);
+        assert_1.default.equal(hexAddr, addressHex);
+    });
+    (0, node_test_1.it)('validate a hex string', () => {
+        const hex = ['0xaffd', '0x11'];
+        hex.map((hex) => {
+            assert_1.default.ok(src_1.Utils.isValidHex(hex));
+        });
+        const invalidHex = ['0xa11', '0xFFdYYY', '0x', ''];
+        invalidHex.map((hex) => {
+            assert_1.default.strictEqual(src_1.Utils.isValidHex(hex), false);
+        });
+    });
+    (0, node_test_1.it)('sign a string', () => {
+        const hexText = Buffer.from(txt).toString('hex');
+        const signed = src_1.Utils.signString(hexText, prv);
+        assert_1.default.equal(signedString, signed);
+    });
+    (0, node_test_1.it)('should calculate an address from a pub', () => {
+        const pubBytes = src_1.Utils.getByteArrayFromHexAddress(pub);
+        const bytes = src_1.Utils.getRawAddressFromPubKey(pubBytes);
+        assert_1.default.deepStrictEqual(bytes, addrBytes);
+    });
+    (0, node_test_1.it)('should verify a signed message', () => {
+        const hexEncodedMessage = Buffer.from(txt).toString('hex');
+        assert_1.default.strictEqual(src_1.Utils.verifySignature(hexEncodedMessage, base58, signedString, true), true);
+    });
+    (0, node_test_1.it)('should fail to verify a signed message if the message is not in hex', () => {
+        assert_1.default.throws(() => src_1.Utils.verifySignature(txt, base58, signedString, true));
+    });
+    (0, node_test_1.it)('should fail to verify a signed message if the address is not in base58', () => {
+        const hexEncodedString = Buffer.from(txt).toString('hex');
+        assert_1.default.throws(() => src_1.Utils.verifySignature(hexEncodedString, addressHex, signedString, true));
+    });
+    (0, node_test_1.it)('should fail to verify a signed message if the signature is not in hex', () => {
+        const hexEncodedString = Buffer.from(txt).toString('hex');
+        assert_1.default.throws(() => src_1.Utils.verifySignature(hexEncodedString, base58, 'abc', true));
+    });
+    (0, node_test_1.it)('should return transaction data', () => {
+        const data = src_1.Utils.decodeRawTransaction(resources_1.UnsignedTransferContractTx.tx.raw_data_hex);
+        assert_1.default.equal(data.timestamp, resources_1.UnsignedTransferContractTx.tx.raw_data.timestamp);
+        assert_1.default.equal(data.expiration, resources_1.UnsignedTransferContractTx.tx.raw_data.expiration);
+        assert_1.default.ok(data.contracts);
+    });
+    (0, node_test_1.it)('should decode a transfer contract', () => {
+        const tx = resources_1.UnsignedTransferContractTx.tx;
+        const rawTx = src_1.Utils.decodeRawTransaction(tx.raw_data_hex);
+        const value = resources_1.UnsignedTransferContractTx.tx.raw_data.contract[0].parameter.value;
+        const parsedContract = src_1.Utils.decodeTransferContract(rawTx.contracts[0].parameter.value);
+        const toAddress = src_1.Utils.getBase58AddressFromHex(value.to_address);
+        const ownerAddress = src_1.Utils.getBase58AddressFromHex(value.owner_address);
+        const amount = value.amount;
+        assert_1.default.equal(parsedContract[0].parameter.value.to_address, toAddress);
+        assert_1.default.equal(parsedContract[0].parameter.value.owner_address, ownerAddress);
+        assert_1.default.equal(parsedContract[0].parameter.value.amount, amount);
+    });
+    (0, node_test_1.it)('should decode an AccountPermissionUpdate Contract', () => {
+        const tx = resources_1.SignedAccountPermissionUpdateContractTx;
+        const value = tx.raw_data.contract[0].parameter.value;
+        const rawTx = src_1.Utils.decodeRawTransaction(tx.raw_data_hex);
+        const parsedTx = src_1.Utils.decodeAccountPermissionUpdateContract(rawTx.contracts[0].parameter.value);
+        const ownerAddress = src_1.Utils.getBase58AddressFromHex(value.owner_address);
+        assert_1.default.equal(parsedTx.ownerAddress, ownerAddress);
+        assert_1.default.equal(parsedTx.owner.type, 0);
+        assert_1.default.equal(parsedTx.owner.threshold, 2);
+        assert_1.default.equal(parsedTx.actives.length, 1);
+        assert_1.default.equal(parsedTx.actives[0].type, 2);
+        assert_1.default.equal(parsedTx.actives[0].threshold, 2);
+    });
+    (0, node_test_1.it)('should encode and decode data parameters for transfer', () => {
+        const types = ['address', 'uint256'];
+        const amount = '2000000000000000000000';
+        const values = [addressHex, amount];
+        const methodId = '0xa9059cbb';
+        const data = src_1.Utils.encodeDataParams(types, values, methodId);
+        assert_1.default.equal(data, 'a9059cbb0000000000000000000000002c2ba4a9ff6c53207dc5b686bfecf75ea7b8057700000000000000000000000000000000000000000000006c6b935b8bbd400000');
+        const decodedData = src_1.Utils.decodeDataParams(types, 'a9059cbb0000000000000000000000002c2ba4a9ff6c53207dc5b686bfecf75ea7b8057700000000000000000000000000000000000000000000006c6b935b8bbd400000');
+        assert_1.default.equal(decodedData[0], addressHex.toLocaleLowerCase());
+        assert_1.default.equal(decodedData[1].toString(), amount);
+    });
+    (0, node_test_1.it)('should correctly map testnet and mainnet tokens', () => {
+        assert_1.default.strictEqual(utils_1.tokenMainnetContractAddresses.includes('TSSMHYeV2uE9qYH95DqyoCuNCzEL1NvU3S'), true);
+        assert_1.default.strictEqual(utils_1.tokenTestnetContractAddresses.includes('TGkfUshdbAiNj5G1mynp2meq2BfF6XSGPf'), true);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../test/unit/util.ts"],"names":[],"mappings":"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","sourcesContent":["import { describe, it } from 'node:test';\nimport assert from 'assert';\nimport { Interface, Utils } from '../../src';\n\nimport { UnsignedTransferContractTx, SignedAccountPermissionUpdateContractTx } from '../resources';\nimport { tokenMainnetContractAddresses, tokenTestnetContractAddresses } from '../../src/lib/utils';\n\ndescribe('Util library should', function () {\n  // arbitrary text\n  const arr = [127, 255, 31, 192, 3, 126, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n  const hex = '7FFF1FC0037E0000000000000000000000000000000000000000000000000000';\n  const txt = 'arbitrary string to sign';\n  const signedString =\n    '0x9424113f32c17b6ffbeee024e1a54b6991d756e82f66cca16a41231fdfa270d03b08e833f5dbbd5cc86896c2e5ea6c74d2e292cda21f717164f994fcdf28486d1b';\n\n  // prv-pub-address hex\n  const prv = 'FB3AA887E0BE3FAC9D75E661DAFF4A7FE0E91AAB13DA9775CD8586D7CB9B7640';\n  const pub =\n    '046EBFB90C396B4A3B992B727CB4714A32E2A6DE43FDB3EC266286AC2246D8FD1E23E12C0DEB752C631A9011BBF8B56E2FBAA20E99D3952F0A558D11F96E7C1C5D';\n  const addressHex = '412C2BA4A9FF6C53207DC5B686BFECF75EA7B80577';\n  const base58 = 'TDzm1tCXM2YS1PDa3GoXSvxdy4AgwVbBPE';\n  const addrBytes = [65, 44, 43, 164, 169, 255, 108, 83, 32, 125, 197, 182, 134, 191, 236, 247, 94, 167, 184, 5, 119];\n\n  // tx information\n  it('be able to convert hex to bytes', () => {\n    const ba = Utils.getByteArrayFromHexAddress(hex);\n    assert.deepStrictEqual(ba, arr);\n  });\n\n  it('be able to convert hex with 0x to bytes ', () => {\n    const ba = Utils.getByteArrayFromHexAddress('0x' + hex);\n    assert.deepStrictEqual(ba, arr);\n  });\n\n  it('be able to convert hex to bytes', () => {\n    const hs = Utils.getHexAddressFromByteArray(arr);\n    assert.equal(hs, hex);\n  });\n\n  it('get a pub from a prv', () => {\n    const derivedPub = Utils.getPubKeyFromPriKey(Buffer.from(prv, 'hex'));\n    const derivedPubHex = Utils.getHexAddressFromByteArray(derivedPub);\n    assert.equal(derivedPubHex, pub);\n  });\n\n  it('get an hex address from a prv', () => {\n    const addr = Utils.getAddressFromPriKey(Buffer.from(prv, 'hex'));\n    const hexAddr = Utils.getHexAddressFromByteArray(addr);\n    assert.equal(hexAddr, addressHex);\n  });\n\n  it('get an base58 address', () => {\n    const addr = Utils.getAddressFromPriKey(Buffer.from(prv, 'hex'));\n    const addr58 = Utils.getBase58AddressFromByteArray(addr);\n    assert.equal(addr58, base58);\n  });\n\n  it('get an base58 address from hex', () => {\n    const addr58 = Utils.getBase58AddressFromHex(addressHex);\n    assert.equal(addr58, base58);\n  });\n\n  it('get hex from base58 address', () => {\n    const hexAddr = Utils.getHexAddressFromBase58Address(base58);\n    assert.equal(hexAddr, addressHex);\n  });\n\n  it('validate a hex string', () => {\n    const hex = ['0xaffd', '0x11'];\n    hex.map((hex) => {\n      assert.ok(Utils.isValidHex(hex));\n    });\n\n    const invalidHex = ['0xa11', '0xFFdYYY', '0x', ''];\n    invalidHex.map((hex) => {\n      assert.strictEqual(Utils.isValidHex(hex), false);\n    });\n  });\n\n  it('sign a string', () => {\n    const hexText = Buffer.from(txt).toString('hex');\n    const signed = Utils.signString(hexText, prv);\n\n    assert.equal(signedString, signed);\n  });\n\n  it('should calculate an address from a pub', () => {\n    const pubBytes = Utils.getByteArrayFromHexAddress(pub);\n    const bytes = Utils.getRawAddressFromPubKey(pubBytes);\n    assert.deepStrictEqual(bytes, addrBytes);\n  });\n\n  it('should verify a signed message', () => {\n    const hexEncodedMessage = Buffer.from(txt).toString('hex');\n    assert.strictEqual(Utils.verifySignature(hexEncodedMessage, base58, signedString, true), true);\n  });\n\n  it('should fail to verify a signed message if the message is not in hex', () => {\n    assert.throws(() => Utils.verifySignature(txt, base58, signedString, true));\n  });\n\n  it('should fail to verify a signed message if the address is not in base58', () => {\n    const hexEncodedString = Buffer.from(txt).toString('hex');\n    assert.throws(() => Utils.verifySignature(hexEncodedString, addressHex, signedString, true));\n  });\n\n  it('should fail to verify a signed message if the signature is not in hex', () => {\n    const hexEncodedString = Buffer.from(txt).toString('hex');\n    assert.throws(() => Utils.verifySignature(hexEncodedString, base58, 'abc', true));\n  });\n\n  it('should return transaction data', () => {\n    const data = Utils.decodeRawTransaction(UnsignedTransferContractTx.tx.raw_data_hex);\n    assert.equal(data.timestamp, UnsignedTransferContractTx.tx.raw_data.timestamp);\n    assert.equal(data.expiration, UnsignedTransferContractTx.tx.raw_data.expiration);\n    assert.ok(data.contracts);\n  });\n\n  it('should decode a transfer contract', () => {\n    const tx = UnsignedTransferContractTx.tx;\n    const rawTx = Utils.decodeRawTransaction(tx.raw_data_hex);\n    const value = UnsignedTransferContractTx.tx.raw_data.contract[0].parameter.value;\n    const parsedContract = Utils.decodeTransferContract(\n      rawTx.contracts[0].parameter.value\n    ) as Interface.TransferContract[];\n\n    const toAddress = Utils.getBase58AddressFromHex(value.to_address);\n    const ownerAddress = Utils.getBase58AddressFromHex(value.owner_address);\n    const amount = value.amount;\n\n    assert.equal(parsedContract[0].parameter.value.to_address, toAddress);\n    assert.equal(parsedContract[0].parameter.value.owner_address, ownerAddress);\n    assert.equal(parsedContract[0].parameter.value.amount, amount);\n  });\n\n  it('should decode an AccountPermissionUpdate Contract', () => {\n    const tx = SignedAccountPermissionUpdateContractTx;\n    const value = tx.raw_data.contract[0].parameter.value;\n    const rawTx = Utils.decodeRawTransaction(tx.raw_data_hex);\n    const parsedTx = Utils.decodeAccountPermissionUpdateContract(\n      rawTx.contracts[0].parameter.value\n    ) as Interface.AccountPermissionUpdateContract;\n    const ownerAddress = Utils.getBase58AddressFromHex(value.owner_address);\n    assert.equal(parsedTx.ownerAddress, ownerAddress);\n    assert.equal(parsedTx.owner.type, 0);\n    assert.equal(parsedTx.owner.threshold, 2);\n    assert.equal(parsedTx.actives.length, 1);\n    assert.equal(parsedTx.actives[0].type, 2);\n    assert.equal(parsedTx.actives[0].threshold, 2);\n  });\n\n  it('should encode and decode data parameters for transfer', () => {\n    const types = ['address', 'uint256'];\n    const amount = '2000000000000000000000';\n    const values = [addressHex, amount];\n    const methodId = '0xa9059cbb';\n    const data = Utils.encodeDataParams(types, values, methodId);\n    assert.equal(\n      data,\n      'a9059cbb0000000000000000000000002c2ba4a9ff6c53207dc5b686bfecf75ea7b8057700000000000000000000000000000000000000000000006c6b935b8bbd400000'\n    );\n\n    const decodedData = Utils.decodeDataParams(\n      types,\n      'a9059cbb0000000000000000000000002c2ba4a9ff6c53207dc5b686bfecf75ea7b8057700000000000000000000000000000000000000000000006c6b935b8bbd400000'\n    );\n    assert.equal(decodedData[0], addressHex.toLocaleLowerCase());\n    assert.equal(decodedData[1].toString(), amount);\n  });\n\n  it('should correctly map testnet and mainnet tokens', () => {\n    assert.strictEqual(tokenMainnetContractAddresses.includes('TSSMHYeV2uE9qYH95DqyoCuNCzEL1NvU3S'), true);\n    assert.strictEqual(tokenTestnetContractAddresses.includes('TGkfUshdbAiNj5G1mynp2meq2BfF6XSGPf'), true);\n  });\n});\n"]}

package/dist/test/unit/verifyTransaction.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=verifyTransaction.d.ts.map

package/dist/test/unit/verifyTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyTransaction.d.ts","sourceRoot":"","sources":["../../../test/unit/verifyTransaction.ts"],"names":[],"mappings":""}

package/dist/test/unit/verifyTransaction.js

@@ -0,0 +1,378 @@
+"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 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',
+                });
+            });
+        });
+    });
+});
+//# 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 } 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 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"]}