@bitgo-beta/sdk-coin-xdc 1.0.1-beta.89 → 1.0.1-beta.890

package/dist/test/unit/utils.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const should_1 = __importDefault(require("should"));
+const statics_1 = require("@bitgo-beta/statics");
+const utils_1 = require("../../src/lib/utils");
+describe('Network Common Configuration', () => {
+    it('getCommon for mainnet', () => {
+        const common = (0, utils_1.getCommon)(statics_1.NetworkType.MAINNET);
+        should_1.default.equal(common.chainName(), 'xdc mainnet');
+        should_1.default.equal(common.chainIdBN().toString(), '50');
+        should_1.default.equal(common.networkIdBN().toString(), '50');
+    });
+    it('getCommon for testnet', () => {
+        const common = (0, utils_1.getCommon)(statics_1.NetworkType.TESTNET);
+        should_1.default.equal(common.chainName(), 'xdc testnet');
+        should_1.default.equal(common.chainIdBN().toString(), '51');
+        should_1.default.equal(common.networkIdBN().toString(), '51');
+    });
+    it('getCommon for invalid network', () => {
+        assert_1.default.throws(() => (0, utils_1.getCommon)('invalidNetwork'), (e) => e.message === 'Missing network common configuration');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

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

package/dist/test/unit/xdc.js

@@ -0,0 +1,172 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const should = __importStar(require("should"));
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const index_1 = require("../../src/index");
+const resources_1 = require("../resources");
+const nock_1 = __importDefault(require("nock"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const tx_1 = require("@ethereumjs/tx");
+const util_1 = require("@ethereumjs/util");
+const bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+describe('xdc', function () {
+    before(function () {
+        bitgo.safeRegister('xdc', index_1.Xdc.createInstance);
+        bitgo.safeRegister('txdc', index_1.Txdc.createInstance);
+        bitgo.initializeTestVars();
+    });
+    describe('Basic Coin Info', function () {
+        it('should return the right info for xdc', function () {
+            const xdc = bitgo.coin('xdc');
+            xdc.should.be.an.instanceof(index_1.Xdc);
+            xdc.getChain().should.equal('xdc');
+            xdc.getFamily().should.equal('xdc');
+            xdc.getFullName().should.equal('XDC');
+            xdc.getBaseFactor().should.equal(1e18);
+            xdc.supportsTss().should.equal(true);
+            xdc.allowsAccountConsolidations().should.equal(false);
+        });
+        it('should return the right info for txdc', function () {
+            const txdc = bitgo.coin('txdc');
+            txdc.should.be.an.instanceof(index_1.Txdc);
+            txdc.getChain().should.equal('txdc');
+            txdc.getFamily().should.equal('xdc');
+            txdc.getFullName().should.equal('Testnet XDC');
+            txdc.getBaseFactor().should.equal(1e18);
+            txdc.supportsTss().should.equal(true);
+            txdc.allowsAccountConsolidations().should.equal(false);
+        });
+    });
+});
+describe('Build Unsigned Sweep for Self-Custody Cold Wallets - (MPCv2)', function () {
+    const bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+    bitgo.register('txdc', index_1.Txdc.createInstance);
+    const explorerUrl = sdk_core_1.common.Environments[bitgo.getEnv()].xdcExplorerBaseUrl;
+    const gasPrice = 20000000000;
+    const gasLimitValue = 500000;
+    const chain_id = 51;
+    it('should generate an unsigned sweep without derivation path', async () => {
+        (0, nock_1.default)(explorerUrl)
+            .get('/api')
+            .twice()
+            .query(resources_1.mockDataUnsignedSweep.getTxListRequest)
+            .reply(200, resources_1.mockDataUnsignedSweep.getTxListResponse);
+        (0, nock_1.default)(explorerUrl)
+            .get('/api')
+            .query(resources_1.mockDataUnsignedSweep.getBalanceRequest)
+            .reply(200, resources_1.mockDataUnsignedSweep.getBalanceResponse);
+        const baseCoin = bitgo.coin('txdc');
+        const transaction = (await baseCoin.recover({
+            userKey: resources_1.mockDataUnsignedSweep.userKey,
+            backupKey: resources_1.mockDataUnsignedSweep.backupKey,
+            walletContractAddress: resources_1.mockDataUnsignedSweep.walletBaseAddress,
+            recoveryDestination: resources_1.mockDataUnsignedSweep.recoveryDestination,
+            isTss: true,
+            gasPrice: gasPrice,
+            gasLimit: gasLimitValue,
+            replayProtectionOptions: {
+                chain: chain_id,
+                hardfork: 'petersburg',
+            },
+        }));
+        should.exist(transaction);
+        transaction.should.have.property('txRequests');
+        transaction.txRequests.length.should.equal(1);
+        const txRequest = transaction.txRequests[0];
+        txRequest.should.have.property('walletCoin');
+        txRequest.walletCoin.should.equal('txdc');
+        txRequest.should.have.property('transactions');
+        txRequest.transactions.length.should.equal(1);
+        const tx = txRequest.transactions[0];
+        tx.should.have.property('nonce');
+        tx.should.have.property('unsignedTx');
+        tx.unsignedTx.should.have.property('serializedTxHex');
+        tx.unsignedTx.should.have.property('signableHex');
+        tx.unsignedTx.should.have.property('derivationPath');
+        tx.unsignedTx.should.have.property('feeInfo');
+        tx.unsignedTx.feeInfo?.should.have.property('fee');
+        tx.unsignedTx.feeInfo?.should.have.property('feeString');
+        tx.unsignedTx.should.have.property('parsedTx');
+        tx.unsignedTx.parsedTx?.should.have.property('spendAmount');
+        tx.unsignedTx.parsedTx?.should.have.property('outputs');
+    });
+});
+describe('Non Bitgo Recovery for Hot Wallets', function () {
+    const bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+    bitgo.register('txdc', index_1.Txdc.createInstance);
+    const explorerUrl = sdk_core_1.common.Environments[bitgo.getEnv()].xdcExplorerBaseUrl;
+    const gasPrice = 20000000000;
+    const chain_id = 51;
+    const gasLimitvalue = 500000;
+    it('should generate a signed non-bitgo recovery tx', async () => {
+        (0, nock_1.default)(explorerUrl)
+            .get('/api')
+            .twice()
+            .query(resources_1.mockDataNonBitGoRecovery.getTxListRequest)
+            .reply(200, resources_1.mockDataNonBitGoRecovery.getTxListResponse);
+        (0, nock_1.default)(explorerUrl)
+            .get('/api')
+            .query(resources_1.mockDataNonBitGoRecovery.getBalanceRequest)
+            .reply(200, resources_1.mockDataNonBitGoRecovery.getBalanceResponse);
+        const baseCoin = bitgo.coin('txdc');
+        const transaction = await baseCoin.recover({
+            userKey: resources_1.mockDataNonBitGoRecovery.userKeyData,
+            backupKey: resources_1.mockDataNonBitGoRecovery.backupKeyData,
+            walletContractAddress: resources_1.mockDataNonBitGoRecovery.walletRootAddress,
+            walletPassphrase: resources_1.mockDataNonBitGoRecovery.walletPassphrase,
+            recoveryDestination: resources_1.mockDataNonBitGoRecovery.recoveryDestination,
+            isTss: true,
+            gasPrice: gasPrice,
+            gasLimit: gasLimitvalue,
+            replayProtectionOptions: {
+                chain: chain_id,
+                hardfork: 'petersburg',
+            },
+        });
+        should.exist(transaction);
+        transaction.should.have.property('id');
+        transaction.should.have.property('tx');
+        const tx = tx_1.Transaction.fromSerializedTx(Buffer.from((0, util_1.stripHexPrefix)(transaction.tx), 'hex'));
+        tx.getSenderAddress().toString().should.equal(resources_1.mockDataNonBitGoRecovery.walletRootAddress);
+        const jsonTx = tx.toJSON();
+        jsonTx.to?.should.equal(resources_1.mockDataNonBitGoRecovery.recoveryDestination);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xdc.js","sourceRoot":"","sources":["../../../test/unit/xdc.ts"],"names":[],"mappings":"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","sourcesContent":["import * as should from 'should';\n\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { BitGoAPI } from '@bitgo-beta/sdk-api';\n\nimport { Xdc, Txdc } from '../../src/index';\nimport { UnsignedSweepTxMPCv2 } from '@bitgo-beta/abstract-eth';\nimport { mockDataUnsignedSweep, mockDataNonBitGoRecovery } from '../resources';\nimport nock from 'nock';\nimport { common } from '@bitgo-beta/sdk-core';\nimport { Transaction } from '@ethereumjs/tx';\nimport { stripHexPrefix } from '@ethereumjs/util';\n\nconst bitgo: TestBitGoAPI = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n\ndescribe('xdc', function () {\n  before(function () {\n    bitgo.safeRegister('xdc', Xdc.createInstance);\n    bitgo.safeRegister('txdc', Txdc.createInstance);\n    bitgo.initializeTestVars();\n  });\n\n  describe('Basic Coin Info', function () {\n    it('should return the right info for xdc', function () {\n      const xdc = bitgo.coin('xdc');\n\n      xdc.should.be.an.instanceof(Xdc);\n      xdc.getChain().should.equal('xdc');\n      xdc.getFamily().should.equal('xdc');\n      xdc.getFullName().should.equal('XDC');\n      xdc.getBaseFactor().should.equal(1e18);\n      xdc.supportsTss().should.equal(true);\n      xdc.allowsAccountConsolidations().should.equal(false);\n    });\n\n    it('should return the right info for txdc', function () {\n      const txdc = bitgo.coin('txdc');\n\n      txdc.should.be.an.instanceof(Txdc);\n      txdc.getChain().should.equal('txdc');\n      txdc.getFamily().should.equal('xdc');\n      txdc.getFullName().should.equal('Testnet XDC');\n      txdc.getBaseFactor().should.equal(1e18);\n      txdc.supportsTss().should.equal(true);\n      txdc.allowsAccountConsolidations().should.equal(false);\n    });\n  });\n});\n\ndescribe('Build Unsigned Sweep for Self-Custody Cold Wallets - (MPCv2)', function () {\n  const bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n  bitgo.register('txdc', Txdc.createInstance);\n  const explorerUrl = common.Environments[bitgo.getEnv()].xdcExplorerBaseUrl as string;\n  const gasPrice = 20000000000;\n  const gasLimitValue = 500000;\n  const chain_id = 51;\n\n  it('should generate an unsigned sweep without derivation path', async () => {\n    nock(explorerUrl)\n      .get('/api')\n      .twice()\n      .query(mockDataUnsignedSweep.getTxListRequest)\n      .reply(200, mockDataUnsignedSweep.getTxListResponse);\n    nock(explorerUrl)\n      .get('/api')\n      .query(mockDataUnsignedSweep.getBalanceRequest)\n      .reply(200, mockDataUnsignedSweep.getBalanceResponse);\n\n    const baseCoin: any = bitgo.coin('txdc');\n    const transaction = (await baseCoin.recover({\n      userKey: mockDataUnsignedSweep.userKey,\n      backupKey: mockDataUnsignedSweep.backupKey,\n      walletContractAddress: mockDataUnsignedSweep.walletBaseAddress,\n      recoveryDestination: mockDataUnsignedSweep.recoveryDestination,\n      isTss: true,\n      gasPrice: gasPrice,\n      gasLimit: gasLimitValue,\n      replayProtectionOptions: {\n        chain: chain_id,\n        hardfork: 'petersburg',\n      },\n    })) as UnsignedSweepTxMPCv2;\n    should.exist(transaction);\n    transaction.should.have.property('txRequests');\n    transaction.txRequests.length.should.equal(1);\n    const txRequest = transaction.txRequests[0];\n    txRequest.should.have.property('walletCoin');\n    txRequest.walletCoin.should.equal('txdc');\n    txRequest.should.have.property('transactions');\n    txRequest.transactions.length.should.equal(1);\n    const tx = txRequest.transactions[0];\n    tx.should.have.property('nonce');\n    tx.should.have.property('unsignedTx');\n    tx.unsignedTx.should.have.property('serializedTxHex');\n    tx.unsignedTx.should.have.property('signableHex');\n    tx.unsignedTx.should.have.property('derivationPath');\n    tx.unsignedTx.should.have.property('feeInfo');\n    tx.unsignedTx.feeInfo?.should.have.property('fee');\n    tx.unsignedTx.feeInfo?.should.have.property('feeString');\n    tx.unsignedTx.should.have.property('parsedTx');\n    tx.unsignedTx.parsedTx?.should.have.property('spendAmount');\n    tx.unsignedTx.parsedTx?.should.have.property('outputs');\n  });\n});\n\ndescribe('Non Bitgo Recovery for Hot Wallets', function () {\n  const bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n  bitgo.register('txdc', Txdc.createInstance);\n  const explorerUrl = common.Environments[bitgo.getEnv()].xdcExplorerBaseUrl as string;\n  const gasPrice = 20000000000;\n  const chain_id = 51;\n  const gasLimitvalue = 500000;\n\n  it('should generate a signed non-bitgo recovery tx', async () => {\n    nock(explorerUrl)\n      .get('/api')\n      .twice()\n      .query(mockDataNonBitGoRecovery.getTxListRequest)\n      .reply(200, mockDataNonBitGoRecovery.getTxListResponse);\n    nock(explorerUrl)\n      .get('/api')\n      .query(mockDataNonBitGoRecovery.getBalanceRequest)\n      .reply(200, mockDataNonBitGoRecovery.getBalanceResponse);\n\n    const baseCoin: any = bitgo.coin('txdc');\n    const transaction = await baseCoin.recover({\n      userKey: mockDataNonBitGoRecovery.userKeyData,\n      backupKey: mockDataNonBitGoRecovery.backupKeyData,\n      walletContractAddress: mockDataNonBitGoRecovery.walletRootAddress,\n      walletPassphrase: mockDataNonBitGoRecovery.walletPassphrase,\n      recoveryDestination: mockDataNonBitGoRecovery.recoveryDestination,\n      isTss: true,\n      gasPrice: gasPrice,\n      gasLimit: gasLimitvalue,\n      replayProtectionOptions: {\n        chain: chain_id,\n        hardfork: 'petersburg',\n      },\n    });\n    should.exist(transaction);\n    transaction.should.have.property('id');\n    transaction.should.have.property('tx');\n    const tx = Transaction.fromSerializedTx(Buffer.from(stripHexPrefix(transaction.tx), 'hex'));\n    tx.getSenderAddress().toString().should.equal(mockDataNonBitGoRecovery.walletRootAddress);\n    const jsonTx = tx.toJSON();\n    jsonTx.to?.should.equal(mockDataNonBitGoRecovery.recoveryDestination);\n  });\n});\n"]}

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

@@ -0,0 +1,2 @@
+import 'should';
+//# sourceMappingURL=xdcToken.d.ts.map

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

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

package/dist/test/unit/xdcToken.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("should");
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const src_1 = require("../../src");
+const resources_1 = require("../resources");
+describe('XDC Token:', function () {
+    let bitgo;
+    let xdcTokenCoin;
+    const tokenName = 'xdc:usdc';
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'prod' });
+        (0, src_1.register)(bitgo);
+        bitgo.initializeTestVars();
+        xdcTokenCoin = bitgo.coin(tokenName);
+    });
+    it('should return constants', function () {
+        xdcTokenCoin.getChain().should.equal('xdc:usdc');
+        xdcTokenCoin.getBaseChain().should.equal('xdc');
+        xdcTokenCoin.getFullName().should.equal('XDC Token');
+        xdcTokenCoin.getBaseFactor().should.equal(1e6);
+        xdcTokenCoin.type.should.equal(tokenName);
+        xdcTokenCoin.name.should.equal('USD Coin');
+        xdcTokenCoin.coin.should.equal('xdc');
+        xdcTokenCoin.network.should.equal('Mainnet');
+        xdcTokenCoin.decimalPlaces.should.equal(6);
+    });
+    describe('Token Registration and TransactionBuilder', function () {
+        const mainnetTokens = ['xdc:usdc', 'xdc:lbt', 'xdc:gama', 'xdc:srx', 'xdc:weth'];
+        const testnetTokens = ['txdc:tmt'];
+        describe('Mainnet tokens', function () {
+            mainnetTokens.forEach((tokenName) => {
+                it(`${tokenName} should be registered as XdcToken`, function () {
+                    const token = bitgo.coin(tokenName);
+                    token.should.be.instanceOf(src_1.XdcToken);
+                });
+                it(`${tokenName} should create TransactionBuilder without error`, function () {
+                    const token = bitgo.coin(tokenName);
+                    // @ts-expect-error - accessing protected method for testing
+                    (() => token.getTransactionBuilder()).should.not.throw();
+                });
+                it(`${tokenName} should use XDC-specific TransactionBuilder`, function () {
+                    const token = bitgo.coin(tokenName);
+                    // @ts-expect-error - accessing protected method for testing
+                    const builder = token.getTransactionBuilder();
+                    builder.should.have.property('_common');
+                    // Verify it's using XDC's getCommon, not EVM's
+                    // XDC's TransactionBuilder should create successfully without SHARED_EVM_SDK feature
+                    builder.constructor.name.should.equal('TransactionBuilder');
+                });
+            });
+        });
+        describe('Testnet tokens', function () {
+            testnetTokens.forEach((tokenName) => {
+                it(`${tokenName} should be registered as XdcToken`, function () {
+                    const token = bitgo.coin(tokenName);
+                    token.should.be.instanceOf(src_1.XdcToken);
+                });
+                it(`${tokenName} should create TransactionBuilder without error`, function () {
+                    const token = bitgo.coin(tokenName);
+                    // @ts-expect-error - accessing protected method for testing
+                    (() => token.getTransactionBuilder()).should.not.throw();
+                });
+                it(`${tokenName} should use XDC-specific TransactionBuilder`, function () {
+                    const token = bitgo.coin(tokenName);
+                    // @ts-expect-error - accessing protected method for testing
+                    const builder = token.getTransactionBuilder();
+                    builder.should.have.property('_common');
+                    builder.constructor.name.should.equal('TransactionBuilder');
+                });
+                it(`${tokenName} should have correct base chain`, function () {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const token = bitgo.coin(tokenName);
+                    token.getBaseChain().should.equal('txdc');
+                });
+                it(`${tokenName} should not throw "Cannot use common sdk module" error`, function () {
+                    const token = bitgo.coin(tokenName);
+                    let errorThrown = false;
+                    let errorMessage = '';
+                    try {
+                        // @ts-expect-error - accessing protected method for testing
+                        const builder = token.getTransactionBuilder();
+                        // Try to use the builder to ensure it's fully functional
+                        // @ts-expect-error - type expects TransactionType enum
+                        builder.type('Send');
+                    }
+                    catch (e) {
+                        errorThrown = true;
+                        errorMessage = e.message;
+                    }
+                    errorThrown.should.equal(false);
+                    errorMessage.should.not.match(/Cannot use common sdk module/);
+                });
+            });
+        });
+        it('should verify all XDC tokens use XdcToken class, not EthLikeErc20Token', function () {
+            const allTokens = [...mainnetTokens, ...testnetTokens];
+            allTokens.forEach((tokenName) => {
+                const token = bitgo.coin(tokenName);
+                token.should.be.instanceOf(src_1.XdcToken);
+                token.constructor.name.should.equal('XdcToken');
+                token.constructor.name.should.not.equal('EthLikeErc20Token');
+            });
+        });
+    });
+    describe('verifyTssTransaction', function () {
+        it('should return true for valid token transfer params', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            const mockWallet = {};
+            const result = await token.verifyTssTransaction({
+                txParams: {
+                    recipients: [
+                        {
+                            address: resources_1.mockTokenTransferData.recipientAddress,
+                            amount: resources_1.mockTokenTransferData.tokenAmount,
+                        },
+                    ],
+                },
+                txPrebuild: resources_1.mockTokenTransferData.txPrebuild,
+                wallet: mockWallet,
+            });
+            result.should.equal(true);
+        });
+        it('should return true for transferToken type without recipients', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            const mockWallet = {};
+            const result = await token.verifyTssTransaction({
+                txParams: {
+                    type: 'transferToken',
+                },
+                txPrebuild: resources_1.mockTokenTransferData.txPrebuild,
+                wallet: mockWallet,
+            });
+            result.should.equal(true);
+        });
+        it('should throw error when txParams.recipients is missing and no valid type', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            const mockWallet = {};
+            await token
+                .verifyTssTransaction({
+                txParams: {},
+                txPrebuild: resources_1.mockTokenTransferData.txPrebuild,
+                wallet: mockWallet,
+            })
+                .should.be.rejectedWith('missing txParams');
+        });
+        it('should throw error when wallet is missing', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            await token
+                .verifyTssTransaction({
+                txParams: {
+                    recipients: [
+                        {
+                            address: resources_1.mockTokenTransferData.recipientAddress,
+                            amount: resources_1.mockTokenTransferData.tokenAmount,
+                        },
+                    ],
+                },
+                txPrebuild: resources_1.mockTokenTransferData.txPrebuild,
+                wallet: undefined,
+            })
+                .should.be.rejectedWith('missing params');
+        });
+        it('should throw error when txPrebuild is missing', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            const mockWallet = {};
+            await token
+                .verifyTssTransaction({
+                txParams: {
+                    recipients: [
+                        {
+                            address: resources_1.mockTokenTransferData.recipientAddress,
+                            amount: resources_1.mockTokenTransferData.tokenAmount,
+                        },
+                    ],
+                },
+                txPrebuild: undefined,
+                wallet: mockWallet,
+            })
+                .should.be.rejectedWith('missing params');
+        });
+        it('should throw error for batch + hop transaction', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            const mockWallet = {};
+            await token
+                .verifyTssTransaction({
+                txParams: {
+                    hop: true,
+                    recipients: [
+                        { address: '0x1111111111111111111111111111111111111111', amount: '1000' },
+                        { address: '0x2222222222222222222222222222222222222222', amount: '2000' },
+                    ],
+                },
+                txPrebuild: resources_1.mockTokenTransferData.txPrebuild,
+                wallet: mockWallet,
+            })
+                .should.be.rejectedWith('tx cannot be both a batch and hop transaction');
+        });
+        it('should not throw EIP155 error when verifying token transaction', async function () {
+            // This test ensures that verifyTssTransaction does NOT parse the txHex
+            // which would fail with "Incompatible EIP155-based V" error
+            const token = bitgo.coin('txdc:tmt');
+            const mockWallet = {};
+            // Use the signableHex (with v=51) which would fail if parsed
+            const txPrebuildWithSignableHex = {
+                ...resources_1.mockTokenTransferData.txPrebuild,
+                txHex: resources_1.mockTokenTransferData.signableHex,
+            };
+            // This should NOT throw EIP155 error because verifyTssTransaction
+            // does not parse the transaction
+            const result = await token.verifyTssTransaction({
+                txParams: {
+                    recipients: [
+                        {
+                            address: resources_1.mockTokenTransferData.recipientAddress,
+                            amount: resources_1.mockTokenTransferData.tokenAmount,
+                        },
+                    ],
+                },
+                txPrebuild: txPrebuildWithSignableHex,
+                wallet: mockWallet,
+            });
+            result.should.equal(true);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xdcToken.js","sourceRoot":"","sources":["../../../test/unit/xdcToken.ts"],"names":[],"mappings":"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","sourcesContent":["import 'should';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { BitGoAPI } from '@bitgo-beta/sdk-api';\nimport { IWallet } from '@bitgo-beta/sdk-core';\n\nimport { register, XdcToken } from '../../src';\nimport { mockTokenTransferData } from '../resources';\n\ndescribe('XDC Token:', function () {\n  let bitgo: TestBitGoAPI;\n  let xdcTokenCoin;\n  const tokenName = 'xdc:usdc';\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'prod' });\n    register(bitgo);\n    bitgo.initializeTestVars();\n    xdcTokenCoin = bitgo.coin(tokenName);\n  });\n\n  it('should return constants', function () {\n    xdcTokenCoin.getChain().should.equal('xdc:usdc');\n    xdcTokenCoin.getBaseChain().should.equal('xdc');\n    xdcTokenCoin.getFullName().should.equal('XDC Token');\n    xdcTokenCoin.getBaseFactor().should.equal(1e6);\n    xdcTokenCoin.type.should.equal(tokenName);\n    xdcTokenCoin.name.should.equal('USD Coin');\n    xdcTokenCoin.coin.should.equal('xdc');\n    xdcTokenCoin.network.should.equal('Mainnet');\n    xdcTokenCoin.decimalPlaces.should.equal(6);\n  });\n\n  describe('Token Registration and TransactionBuilder', function () {\n    const mainnetTokens = ['xdc:usdc', 'xdc:lbt', 'xdc:gama', 'xdc:srx', 'xdc:weth'];\n    const testnetTokens = ['txdc:tmt'];\n\n    describe('Mainnet tokens', function () {\n      mainnetTokens.forEach((tokenName) => {\n        it(`${tokenName} should be registered as XdcToken`, function () {\n          const token = bitgo.coin(tokenName);\n          token.should.be.instanceOf(XdcToken);\n        });\n\n        it(`${tokenName} should create TransactionBuilder without error`, function () {\n          const token = bitgo.coin(tokenName) as XdcToken;\n          // @ts-expect-error - accessing protected method for testing\n          (() => token.getTransactionBuilder()).should.not.throw();\n        });\n\n        it(`${tokenName} should use XDC-specific TransactionBuilder`, function () {\n          const token = bitgo.coin(tokenName) as XdcToken;\n          // @ts-expect-error - accessing protected method for testing\n          const builder = token.getTransactionBuilder();\n          builder.should.have.property('_common');\n          // Verify it's using XDC's getCommon, not EVM's\n          // XDC's TransactionBuilder should create successfully without SHARED_EVM_SDK feature\n          builder.constructor.name.should.equal('TransactionBuilder');\n        });\n      });\n    });\n\n    describe('Testnet tokens', function () {\n      testnetTokens.forEach((tokenName) => {\n        it(`${tokenName} should be registered as XdcToken`, function () {\n          const token = bitgo.coin(tokenName);\n          token.should.be.instanceOf(XdcToken);\n        });\n\n        it(`${tokenName} should create TransactionBuilder without error`, function () {\n          const token = bitgo.coin(tokenName) as XdcToken;\n          // @ts-expect-error - accessing protected method for testing\n          (() => token.getTransactionBuilder()).should.not.throw();\n        });\n\n        it(`${tokenName} should use XDC-specific TransactionBuilder`, function () {\n          const token = bitgo.coin(tokenName) as XdcToken;\n          // @ts-expect-error - accessing protected method for testing\n          const builder = token.getTransactionBuilder();\n          builder.should.have.property('_common');\n          builder.constructor.name.should.equal('TransactionBuilder');\n        });\n\n        it(`${tokenName} should have correct base chain`, function () {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          const token: any = bitgo.coin(tokenName);\n          token.getBaseChain().should.equal('txdc');\n        });\n\n        it(`${tokenName} should not throw \"Cannot use common sdk module\" error`, function () {\n          const token = bitgo.coin(tokenName) as XdcToken;\n          let errorThrown = false;\n          let errorMessage = '';\n\n          try {\n            // @ts-expect-error - accessing protected method for testing\n            const builder = token.getTransactionBuilder();\n            // Try to use the builder to ensure it's fully functional\n            // @ts-expect-error - type expects TransactionType enum\n            builder.type('Send');\n          } catch (e) {\n            errorThrown = true;\n            errorMessage = (e as Error).message;\n          }\n\n          errorThrown.should.equal(false);\n          errorMessage.should.not.match(/Cannot use common sdk module/);\n        });\n      });\n    });\n\n    it('should verify all XDC tokens use XdcToken class, not EthLikeErc20Token', function () {\n      const allTokens = [...mainnetTokens, ...testnetTokens];\n\n      allTokens.forEach((tokenName) => {\n        const token = bitgo.coin(tokenName);\n        token.should.be.instanceOf(XdcToken);\n        token.constructor.name.should.equal('XdcToken');\n        token.constructor.name.should.not.equal('EthLikeErc20Token');\n      });\n    });\n  });\n\n  describe('verifyTssTransaction', function () {\n    it('should return true for valid token transfer params', async function () {\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n      const mockWallet = {} as unknown as IWallet;\n\n      const result = await token.verifyTssTransaction({\n        txParams: {\n          recipients: [\n            {\n              address: mockTokenTransferData.recipientAddress,\n              amount: mockTokenTransferData.tokenAmount,\n            },\n          ],\n        },\n        txPrebuild: mockTokenTransferData.txPrebuild as unknown as Parameters<\n          typeof token.verifyTssTransaction\n        >[0]['txPrebuild'],\n        wallet: mockWallet,\n      });\n\n      result.should.equal(true);\n    });\n\n    it('should return true for transferToken type without recipients', async function () {\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n      const mockWallet = {} as unknown as IWallet;\n\n      const result = await token.verifyTssTransaction({\n        txParams: {\n          type: 'transferToken',\n        },\n        txPrebuild: mockTokenTransferData.txPrebuild as unknown as Parameters<\n          typeof token.verifyTssTransaction\n        >[0]['txPrebuild'],\n        wallet: mockWallet,\n      });\n\n      result.should.equal(true);\n    });\n\n    it('should throw error when txParams.recipients is missing and no valid type', async function () {\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n      const mockWallet = {} as unknown as IWallet;\n\n      await token\n        .verifyTssTransaction({\n          txParams: {},\n          txPrebuild: mockTokenTransferData.txPrebuild as unknown as Parameters<\n            typeof token.verifyTssTransaction\n          >[0]['txPrebuild'],\n          wallet: mockWallet,\n        })\n        .should.be.rejectedWith('missing txParams');\n    });\n\n    it('should throw error when wallet is missing', async function () {\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n\n      await token\n        .verifyTssTransaction({\n          txParams: {\n            recipients: [\n              {\n                address: mockTokenTransferData.recipientAddress,\n                amount: mockTokenTransferData.tokenAmount,\n              },\n            ],\n          },\n          txPrebuild: mockTokenTransferData.txPrebuild as unknown as Parameters<\n            typeof token.verifyTssTransaction\n          >[0]['txPrebuild'],\n          wallet: undefined as unknown as IWallet,\n        })\n        .should.be.rejectedWith('missing params');\n    });\n\n    it('should throw error when txPrebuild is missing', async function () {\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n      const mockWallet = {} as unknown as IWallet;\n\n      await token\n        .verifyTssTransaction({\n          txParams: {\n            recipients: [\n              {\n                address: mockTokenTransferData.recipientAddress,\n                amount: mockTokenTransferData.tokenAmount,\n              },\n            ],\n          },\n          txPrebuild: undefined as unknown as Parameters<typeof token.verifyTssTransaction>[0]['txPrebuild'],\n          wallet: mockWallet,\n        })\n        .should.be.rejectedWith('missing params');\n    });\n\n    it('should throw error for batch + hop transaction', async function () {\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n      const mockWallet = {} as unknown as IWallet;\n\n      await token\n        .verifyTssTransaction({\n          txParams: {\n            hop: true,\n            recipients: [\n              { address: '0x1111111111111111111111111111111111111111', amount: '1000' },\n              { address: '0x2222222222222222222222222222222222222222', amount: '2000' },\n            ],\n          },\n          txPrebuild: mockTokenTransferData.txPrebuild as unknown as Parameters<\n            typeof token.verifyTssTransaction\n          >[0]['txPrebuild'],\n          wallet: mockWallet,\n        })\n        .should.be.rejectedWith('tx cannot be both a batch and hop transaction');\n    });\n\n    it('should not throw EIP155 error when verifying token transaction', async function () {\n      // This test ensures that verifyTssTransaction does NOT parse the txHex\n      // which would fail with \"Incompatible EIP155-based V\" error\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n      const mockWallet = {} as unknown as IWallet;\n\n      // Use the signableHex (with v=51) which would fail if parsed\n      const txPrebuildWithSignableHex = {\n        ...mockTokenTransferData.txPrebuild,\n        txHex: mockTokenTransferData.signableHex,\n      };\n\n      // This should NOT throw EIP155 error because verifyTssTransaction\n      // does not parse the transaction\n      const result = await token.verifyTssTransaction({\n        txParams: {\n          recipients: [\n            {\n              address: mockTokenTransferData.recipientAddress,\n              amount: mockTokenTransferData.tokenAmount,\n            },\n          ],\n        },\n        txPrebuild: txPrebuildWithSignableHex as unknown as Parameters<\n          typeof token.verifyTssTransaction\n        >[0]['txPrebuild'],\n        wallet: mockWallet,\n      });\n\n      result.should.equal(true);\n    });\n  });\n});\n"]}