@bitgo/sdk-coin-xdc 1.6.0 → 1.7.0

package/dist/test/unit/transactionBuilder/uploadKyc.js

@@ -0,0 +1,215 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getBuilder_1 = require("../getBuilder");
+const should_1 = __importDefault(require("should"));
+const sdk_core_1 = require("@bitgo/sdk-core");
+const statics_1 = require("@bitgo/statics");
+const lib_1 = require("../../../src/lib");
+describe('XDC Upload KYC Builder', () => {
+    const coinConfig = statics_1.coins.get('txdc');
+    describe('UploadKycBuilder', () => {
+        it('should build uploadKYC call with valid IPFS hash', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            const ipfsHash = 'QmRealIPFSHashExample123456789012345678901234';
+            const call = builder.ipfsHash(ipfsHash).build();
+            should_1.default.exist(call);
+            call.should.be.instanceOf(lib_1.UploadKycCall);
+            call.ipfsHash.should.equal(ipfsHash);
+            call.contractAddress.should.equal(lib_1.XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);
+        });
+        it('should build uploadKYC call with custom contract address', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            const ipfsHash = 'QmCustomIPFSHash123456789012345678901234567';
+            const customAddress = '0x1234567890123456789012345678901234567890';
+            const call = builder.ipfsHash(ipfsHash).contractAddress(customAddress).build();
+            should_1.default.exist(call);
+            call.contractAddress.should.equal(customAddress);
+        });
+        it('should accept IPFS v1 hash format (starting with "b")', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            const ipfsHash = 'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi';
+            const call = builder.ipfsHash(ipfsHash).build();
+            should_1.default.exist(call);
+            call.ipfsHash.should.equal(ipfsHash);
+        });
+        it('should throw error when IPFS hash is empty', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            (() => builder.ipfsHash('')).should.throw('IPFS hash cannot be empty');
+        });
+        it('should throw error when IPFS hash format is invalid', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            (() => builder.ipfsHash('InvalidHash123')).should.throw('Invalid IPFS hash format. Expected hash starting with "Qm" (v0) or "b" (v1)');
+        });
+        it('should throw error when contract address is empty', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            (() => builder.contractAddress('')).should.throw('Contract address cannot be empty');
+        });
+        it('should throw error when contract address format is invalid', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            (() => builder.contractAddress('InvalidAddress')).should.throw('Invalid contract address format');
+        });
+        it('should throw error when building without IPFS hash', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            (() => builder.build()).should.throw('Missing IPFS hash for uploadKYC transaction');
+        });
+        it('should normalize contract address with 0x prefix', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            const ipfsHash = 'QmTestHash123456789012345678901234567890123';
+            const addressWithoutPrefix = '1234567890123456789012345678901234567890';
+            const call = builder.ipfsHash(ipfsHash).contractAddress(addressWithoutPrefix).build();
+            call.contractAddress.should.equal('0x' + addressWithoutPrefix);
+        });
+    });
+    describe('UploadKycCall', () => {
+        it('should serialize uploadKYC call correctly', () => {
+            const ipfsHash = 'QmTestIPFSHash1234567890123456789012345678';
+            const contractAddress = lib_1.XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET;
+            const call = new lib_1.UploadKycCall(contractAddress, ipfsHash);
+            const serialized = call.serialize();
+            should_1.default.exist(serialized);
+            serialized.should.be.type('string');
+            // Should start with the method ID
+            serialized.should.startWith(lib_1.UPLOAD_KYC_METHOD_ID);
+        });
+        it('should have correct properties', () => {
+            const ipfsHash = 'QmTestIPFSHash1234567890123456789012345678';
+            const contractAddress = '0x0000000000000000000000000000000000000088';
+            const call = new lib_1.UploadKycCall(contractAddress, ipfsHash);
+            call.contractAddress.should.equal(contractAddress);
+            call.ipfsHash.should.equal(ipfsHash);
+        });
+    });
+    describe('TransactionBuilder integration', () => {
+        it('should build uploadKYC transaction with TransactionBuilder', async () => {
+            const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+            const ipfsHash = 'QmTestIPFSHash1234567890123456789012345678';
+            txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+            txBuilder.fee({
+                fee: '10000000000',
+                gasLimit: '100000',
+            });
+            txBuilder.counter(1);
+            txBuilder.uploadKyc().ipfsHash(ipfsHash);
+            const tx = await txBuilder.build();
+            should_1.default.exist(tx);
+            const txJson = tx.toJson();
+            should_1.default.exist(txJson.to);
+            txJson.to.should.equal(lib_1.XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);
+            txJson.value.should.equal('0');
+            should_1.default.exist(txJson.data);
+            // Data should start with uploadKYC method ID
+            txJson.data.should.startWith(lib_1.UPLOAD_KYC_METHOD_ID);
+        });
+        it('should throw error when uploadKyc() is called on non-ContractCall transaction', () => {
+            const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+            txBuilder.type(sdk_core_1.TransactionType.Send);
+            (() => txBuilder.uploadKyc()).should.throw('uploadKYC can only be set for contract call transactions');
+        });
+        it('should build transaction with custom validator contract address', async () => {
+            const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+            const ipfsHash = 'QmCustomIPFSHash123456789012345678901234567';
+            const customAddress = '0x1234567890123456789012345678901234567890';
+            txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+            txBuilder.fee({
+                fee: '10000000000',
+                gasLimit: '100000',
+            });
+            txBuilder.counter(1);
+            txBuilder.uploadKyc().ipfsHash(ipfsHash).contractAddress(customAddress);
+            const tx = await txBuilder.build();
+            should_1.default.exist(tx);
+            const txJson = tx.toJson();
+            should_1.default.exist(txJson.to);
+            txJson.to.should.equal(customAddress);
+        });
+        it('should build and serialize uploadKYC transaction', async () => {
+            const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+            const ipfsHash = 'QmRealIPFSHashForSerialization1234567890123';
+            txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+            txBuilder.fee({
+                fee: '10000000000',
+                gasLimit: '100000',
+            });
+            txBuilder.counter(5);
+            txBuilder.uploadKyc().ipfsHash(ipfsHash);
+            const tx = await txBuilder.build();
+            const serialized = tx.toBroadcastFormat();
+            should_1.default.exist(serialized);
+            serialized.should.be.type('string');
+            // Should be a valid hex string
+            serialized.should.match(/^(0x)?[0-9a-f]+$/i);
+        });
+        it('should parse uploadKYC transaction from hex', async () => {
+            const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+            const ipfsHash = 'QmParseTestHash12345678901234567890123456';
+            // First build a transaction
+            txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+            txBuilder.fee({
+                fee: '10000000000',
+                gasLimit: '100000',
+            });
+            txBuilder.counter(10);
+            txBuilder.uploadKyc().ipfsHash(ipfsHash);
+            const tx = await txBuilder.build();
+            const serialized = tx.toBroadcastFormat();
+            // Now parse it back
+            const txBuilder2 = (0, getBuilder_1.getBuilder)('txdc');
+            txBuilder2.from(serialized);
+            const parsedTx = await txBuilder2.build();
+            should_1.default.exist(parsedTx);
+            const parsedJson = parsedTx.toJson();
+            should_1.default.exist(parsedJson.to);
+            parsedJson.to.should.equal(lib_1.XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);
+            parsedJson.nonce.should.equal(10);
+        });
+    });
+    describe('Real-world scenarios', () => {
+        it('should create transaction matching sandbox code pattern', async () => {
+            const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+            // Mock IPFS hash similar to what would be generated
+            const mockIPFSHash = 'Qm' + 'a'.repeat(44);
+            txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+            txBuilder.fee({
+                fee: '20000000000',
+                gasLimit: '200000',
+            });
+            txBuilder.counter(0);
+            txBuilder.uploadKyc().ipfsHash(mockIPFSHash);
+            const tx = await txBuilder.build();
+            const txJson = tx.toJson();
+            // Verify transaction structure matches expected format
+            should_1.default.exist(txJson.to);
+            txJson.to.should.equal(lib_1.XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);
+            txJson.value.should.equal('0');
+            should_1.default.exist(txJson.data);
+            txJson.data.should.startWith(lib_1.UPLOAD_KYC_METHOD_ID);
+            should_1.default.exist(txJson.gasLimit);
+            should_1.default.exist(txJson.nonce);
+        });
+        it('should handle multiple IPFS hash formats', async () => {
+            const testHashes = [
+                'QmRealIPFSHashExample123456789012345678901234', // v0
+                'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi', // v1
+                'QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG', // real example
+            ];
+            for (const hash of testHashes) {
+                const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+                txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+                txBuilder.fee({
+                    fee: '10000000000',
+                    gasLimit: '100000',
+                });
+                txBuilder.counter(1);
+                txBuilder.uploadKyc().ipfsHash(hash);
+                const tx = await txBuilder.build();
+                should_1.default.exist(tx);
+                const txJson = tx.toJson();
+                txJson.data.should.startWith(lib_1.UPLOAD_KYC_METHOD_ID);
+            }
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"uploadKyc.js","sourceRoot":"","sources":["../../../../test/unit/transactionBuilder/uploadKyc.ts"],"names":[],"mappings":"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","sourcesContent":["import { getBuilder } from '../getBuilder';\nimport should from 'should';\nimport { TransactionType } from '@bitgo/sdk-core';\nimport { coins } from '@bitgo/statics';\nimport {\n  UploadKycBuilder,\n  UploadKycCall,\n  XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET,\n  UPLOAD_KYC_METHOD_ID,\n} from '../../../src/lib';\n\ndescribe('XDC Upload KYC Builder', () => {\n  const coinConfig = coins.get('txdc');\n\n  describe('UploadKycBuilder', () => {\n    it('should build uploadKYC call with valid IPFS hash', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n      const ipfsHash = 'QmRealIPFSHashExample123456789012345678901234';\n\n      const call = builder.ipfsHash(ipfsHash).build();\n\n      should.exist(call);\n      call.should.be.instanceOf(UploadKycCall);\n      call.ipfsHash.should.equal(ipfsHash);\n      call.contractAddress.should.equal(XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);\n    });\n\n    it('should build uploadKYC call with custom contract address', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n      const ipfsHash = 'QmCustomIPFSHash123456789012345678901234567';\n      const customAddress = '0x1234567890123456789012345678901234567890';\n\n      const call = builder.ipfsHash(ipfsHash).contractAddress(customAddress).build();\n\n      should.exist(call);\n      call.contractAddress.should.equal(customAddress);\n    });\n\n    it('should accept IPFS v1 hash format (starting with \"b\")', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n      const ipfsHash = 'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi';\n\n      const call = builder.ipfsHash(ipfsHash).build();\n\n      should.exist(call);\n      call.ipfsHash.should.equal(ipfsHash);\n    });\n\n    it('should throw error when IPFS hash is empty', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n\n      (() => builder.ipfsHash('')).should.throw('IPFS hash cannot be empty');\n    });\n\n    it('should throw error when IPFS hash format is invalid', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n\n      (() => builder.ipfsHash('InvalidHash123')).should.throw(\n        'Invalid IPFS hash format. Expected hash starting with \"Qm\" (v0) or \"b\" (v1)'\n      );\n    });\n\n    it('should throw error when contract address is empty', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n\n      (() => builder.contractAddress('')).should.throw('Contract address cannot be empty');\n    });\n\n    it('should throw error when contract address format is invalid', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n\n      (() => builder.contractAddress('InvalidAddress')).should.throw('Invalid contract address format');\n    });\n\n    it('should throw error when building without IPFS hash', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n\n      (() => builder.build()).should.throw('Missing IPFS hash for uploadKYC transaction');\n    });\n\n    it('should normalize contract address with 0x prefix', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n      const ipfsHash = 'QmTestHash123456789012345678901234567890123';\n      const addressWithoutPrefix = '1234567890123456789012345678901234567890';\n\n      const call = builder.ipfsHash(ipfsHash).contractAddress(addressWithoutPrefix).build();\n\n      call.contractAddress.should.equal('0x' + addressWithoutPrefix);\n    });\n  });\n\n  describe('UploadKycCall', () => {\n    it('should serialize uploadKYC call correctly', () => {\n      const ipfsHash = 'QmTestIPFSHash1234567890123456789012345678';\n      const contractAddress = XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET;\n\n      const call = new UploadKycCall(contractAddress, ipfsHash);\n      const serialized = call.serialize();\n\n      should.exist(serialized);\n      serialized.should.be.type('string');\n      // Should start with the method ID\n      serialized.should.startWith(UPLOAD_KYC_METHOD_ID);\n    });\n\n    it('should have correct properties', () => {\n      const ipfsHash = 'QmTestIPFSHash1234567890123456789012345678';\n      const contractAddress = '0x0000000000000000000000000000000000000088';\n\n      const call = new UploadKycCall(contractAddress, ipfsHash);\n\n      call.contractAddress.should.equal(contractAddress);\n      call.ipfsHash.should.equal(ipfsHash);\n    });\n  });\n\n  describe('TransactionBuilder integration', () => {\n    it('should build uploadKYC transaction with TransactionBuilder', async () => {\n      const txBuilder = getBuilder('txdc');\n      const ipfsHash = 'QmTestIPFSHash1234567890123456789012345678';\n\n      txBuilder.type(TransactionType.ContractCall);\n      txBuilder.fee({\n        fee: '10000000000',\n        gasLimit: '100000',\n      });\n      txBuilder.counter(1);\n      txBuilder.uploadKyc().ipfsHash(ipfsHash);\n\n      const tx = await txBuilder.build();\n\n      should.exist(tx);\n      const txJson = tx.toJson();\n      should.exist(txJson.to);\n      txJson.to!.should.equal(XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);\n      txJson.value.should.equal('0');\n      should.exist(txJson.data);\n      // Data should start with uploadKYC method ID\n      txJson.data.should.startWith(UPLOAD_KYC_METHOD_ID);\n    });\n\n    it('should throw error when uploadKyc() is called on non-ContractCall transaction', () => {\n      const txBuilder = getBuilder('txdc');\n\n      txBuilder.type(TransactionType.Send);\n\n      (() => txBuilder.uploadKyc()).should.throw('uploadKYC can only be set for contract call transactions');\n    });\n\n    it('should build transaction with custom validator contract address', async () => {\n      const txBuilder = getBuilder('txdc');\n      const ipfsHash = 'QmCustomIPFSHash123456789012345678901234567';\n      const customAddress = '0x1234567890123456789012345678901234567890';\n\n      txBuilder.type(TransactionType.ContractCall);\n      txBuilder.fee({\n        fee: '10000000000',\n        gasLimit: '100000',\n      });\n      txBuilder.counter(1);\n      txBuilder.uploadKyc().ipfsHash(ipfsHash).contractAddress(customAddress);\n\n      const tx = await txBuilder.build();\n\n      should.exist(tx);\n      const txJson = tx.toJson();\n      should.exist(txJson.to);\n      txJson.to!.should.equal(customAddress);\n    });\n\n    it('should build and serialize uploadKYC transaction', async () => {\n      const txBuilder = getBuilder('txdc');\n      const ipfsHash = 'QmRealIPFSHashForSerialization1234567890123';\n\n      txBuilder.type(TransactionType.ContractCall);\n      txBuilder.fee({\n        fee: '10000000000',\n        gasLimit: '100000',\n      });\n      txBuilder.counter(5);\n      txBuilder.uploadKyc().ipfsHash(ipfsHash);\n\n      const tx = await txBuilder.build();\n      const serialized = tx.toBroadcastFormat();\n\n      should.exist(serialized);\n      serialized.should.be.type('string');\n      // Should be a valid hex string\n      serialized.should.match(/^(0x)?[0-9a-f]+$/i);\n    });\n\n    it('should parse uploadKYC transaction from hex', async () => {\n      const txBuilder = getBuilder('txdc');\n      const ipfsHash = 'QmParseTestHash12345678901234567890123456';\n\n      // First build a transaction\n      txBuilder.type(TransactionType.ContractCall);\n      txBuilder.fee({\n        fee: '10000000000',\n        gasLimit: '100000',\n      });\n      txBuilder.counter(10);\n      txBuilder.uploadKyc().ipfsHash(ipfsHash);\n\n      const tx = await txBuilder.build();\n      const serialized = tx.toBroadcastFormat();\n\n      // Now parse it back\n      const txBuilder2 = getBuilder('txdc');\n      txBuilder2.from(serialized);\n      const parsedTx = await txBuilder2.build();\n\n      should.exist(parsedTx);\n      const parsedJson = parsedTx.toJson();\n      should.exist(parsedJson.to);\n      parsedJson.to!.should.equal(XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);\n      parsedJson.nonce.should.equal(10);\n    });\n  });\n\n  describe('Real-world scenarios', () => {\n    it('should create transaction matching sandbox code pattern', async () => {\n      const txBuilder = getBuilder('txdc');\n      // Mock IPFS hash similar to what would be generated\n      const mockIPFSHash = 'Qm' + 'a'.repeat(44);\n\n      txBuilder.type(TransactionType.ContractCall);\n      txBuilder.fee({\n        fee: '20000000000',\n        gasLimit: '200000',\n      });\n      txBuilder.counter(0);\n      txBuilder.uploadKyc().ipfsHash(mockIPFSHash);\n\n      const tx = await txBuilder.build();\n      const txJson = tx.toJson();\n\n      // Verify transaction structure matches expected format\n      should.exist(txJson.to);\n      txJson.to!.should.equal(XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);\n      txJson.value.should.equal('0');\n      should.exist(txJson.data);\n      txJson.data.should.startWith(UPLOAD_KYC_METHOD_ID);\n      should.exist(txJson.gasLimit);\n      should.exist(txJson.nonce);\n    });\n\n    it('should handle multiple IPFS hash formats', async () => {\n      const testHashes = [\n        'QmRealIPFSHashExample123456789012345678901234', // v0\n        'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi', // v1\n        'QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG', // real example\n      ];\n\n      for (const hash of testHashes) {\n        const txBuilder = getBuilder('txdc');\n\n        txBuilder.type(TransactionType.ContractCall);\n        txBuilder.fee({\n          fee: '10000000000',\n          gasLimit: '100000',\n        });\n        txBuilder.counter(1);\n        txBuilder.uploadKyc().ipfsHash(hash);\n\n        const tx = await txBuilder.build();\n        should.exist(tx);\n\n        const txJson = tx.toJson();\n        txJson.data.should.startWith(UPLOAD_KYC_METHOD_ID);\n      }\n    });\n  });\n});\n"]}

package/dist/test/unit/xdcToken.js

@@ -4,6 +4,7 @@ require("should");
 const sdk_test_1 = require("@bitgo/sdk-test");
 const sdk_api_1 = require("@bitgo/sdk-api");
 const src_1 = require("../../src");
+const resources_1 = require("../resources");
 describe('XDC Token:', function () {
     let bitgo;
     let xdcTokenCoin;
@@ -25,5 +26,203 @@ describe('XDC Token:', function () {
         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,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
+//# 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/sdk-test';\nimport { BitGoAPI } from '@bitgo/sdk-api';\nimport { IWallet } from '@bitgo/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"]}