@bitgo-beta/sdk-coin-xdc 1.0.1-beta.142 → 1.0.1-beta.1421

package/dist/test/unit/xdcToken.js

@@ -0,0 +1,189 @@
+"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 sdk_core_1 = require("@bitgo-beta/sdk-core");
+const src_1 = require("../../src");
+const getBuilder_1 = require("./getBuilder");
+/** Encode ERC-20 transfer(address,uint256) calldata without ethereumjs-abi. */
+function encodeErc20Transfer(to, amount) {
+    const address = to.toLowerCase().replace(/^0x/, '').padStart(64, '0');
+    const value = BigInt(amount).toString(16).padStart(64, '0');
+    return `0xa9059cbb${address}${value}`;
+}
+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 () {
+        const recipientAddress = '0x174cfd823af8ce27ed0afee3fcf3c3ba259116be';
+        const wrongAddress = '0x7e85bdc27c050e3905ebf4b8e634d9ad6edd0de6';
+        const tokenContractAddress = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48';
+        it('should accept an ERC-20 transfer where calldata matches declared recipient', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            const erc20TransferData = encodeErc20Transfer(recipientAddress, '10000000');
+            const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+            txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+            txBuilder.fee({ fee: '10', gasLimit: '60000' });
+            txBuilder.counter(1);
+            txBuilder.contract(tokenContractAddress);
+            txBuilder.data(erc20TransferData);
+            const tx = await txBuilder.build();
+            const txHex = tx.toBroadcastFormat();
+            const wallet = new sdk_core_1.Wallet(bitgo, token, { coinSpecific: { baseAddress: recipientAddress } });
+            const result = await token.verifyTssTransaction({
+                txParams: {
+                    type: 'transfer',
+                    recipients: [{ address: recipientAddress, amount: '10000000' }],
+                },
+                txPrebuild: { txHex, coin: 'txdc:tmt', walletId: 'fakeWalletId' },
+                wallet,
+            });
+            result.should.equal(true);
+        });
+        it('should reject an ERC-20 transfer when calldata recipient does not match declared recipient', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            const erc20TransferData = encodeErc20Transfer(wrongAddress, '10000000');
+            const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+            txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+            txBuilder.fee({ fee: '10', gasLimit: '60000' });
+            txBuilder.counter(1);
+            txBuilder.contract(tokenContractAddress);
+            txBuilder.data(erc20TransferData);
+            const tx = await txBuilder.build();
+            const txHex = tx.toBroadcastFormat();
+            const wallet = new sdk_core_1.Wallet(bitgo, token, { coinSpecific: { baseAddress: recipientAddress } });
+            await token
+                .verifyTssTransaction({
+                txParams: {
+                    type: 'transfer',
+                    recipients: [{ address: recipientAddress, amount: '10000000' }],
+                },
+                txPrebuild: { txHex, coin: 'txdc:tmt', walletId: 'fakeWalletId' },
+                wallet,
+            })
+                .should.be.rejectedWith('destination address does not match with the recipient address');
+        });
+        it('should throw error when txParams.recipients is missing and no valid type', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            const wallet = new sdk_core_1.Wallet(bitgo, token, { coinSpecific: { baseAddress: recipientAddress } });
+            await token
+                .verifyTssTransaction({
+                txParams: {},
+                txPrebuild: { txHex: '0x00', coin: 'txdc:tmt', walletId: 'fakeWalletId' },
+                wallet,
+            })
+                .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: {
+                    type: 'transfer',
+                    recipients: [{ address: recipientAddress, amount: '10000000' }],
+                },
+                txPrebuild: { txHex: '0x00', coin: 'txdc:tmt', walletId: 'fakeWalletId' },
+                wallet: undefined,
+            })
+                .should.be.rejectedWith('missing params');
+        });
+    });
+});
+//# 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 { TransactionType, Wallet } from '@bitgo-beta/sdk-core';\n\nimport { register, XdcToken } from '../../src';\nimport { TransactionBuilder } from '../../src/lib';\nimport { getBuilder } from './getBuilder';\n\n/** Encode ERC-20 transfer(address,uint256) calldata without ethereumjs-abi. */\nfunction encodeErc20Transfer(to: string, amount: string): string {\n  const address = to.toLowerCase().replace(/^0x/, '').padStart(64, '0');\n  const value = BigInt(amount).toString(16).padStart(64, '0');\n  return `0xa9059cbb${address}${value}`;\n}\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    const recipientAddress = '0x174cfd823af8ce27ed0afee3fcf3c3ba259116be';\n    const wrongAddress = '0x7e85bdc27c050e3905ebf4b8e634d9ad6edd0de6';\n    const tokenContractAddress = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48';\n\n    it('should accept an ERC-20 transfer where calldata matches declared recipient', async function () {\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n\n      const erc20TransferData = encodeErc20Transfer(recipientAddress, '10000000');\n\n      const txBuilder = getBuilder('txdc') as TransactionBuilder;\n      txBuilder.type(TransactionType.ContractCall);\n      txBuilder.fee({ fee: '10', gasLimit: '60000' });\n      txBuilder.counter(1);\n      txBuilder.contract(tokenContractAddress);\n      txBuilder.data(erc20TransferData);\n      const tx = await txBuilder.build();\n      const txHex = tx.toBroadcastFormat();\n\n      const wallet = new Wallet(bitgo, token, { coinSpecific: { baseAddress: recipientAddress } });\n\n      const result = await token.verifyTssTransaction({\n        txParams: {\n          type: 'transfer',\n          recipients: [{ address: recipientAddress, amount: '10000000' }],\n        } as any,\n        txPrebuild: { txHex, coin: 'txdc:tmt', walletId: 'fakeWalletId' } as any,\n        wallet,\n      });\n      result.should.equal(true);\n    });\n\n    it('should reject an ERC-20 transfer when calldata recipient does not match declared recipient', async function () {\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n\n      const erc20TransferData = encodeErc20Transfer(wrongAddress, '10000000');\n\n      const txBuilder = getBuilder('txdc') as TransactionBuilder;\n      txBuilder.type(TransactionType.ContractCall);\n      txBuilder.fee({ fee: '10', gasLimit: '60000' });\n      txBuilder.counter(1);\n      txBuilder.contract(tokenContractAddress);\n      txBuilder.data(erc20TransferData);\n      const tx = await txBuilder.build();\n      const txHex = tx.toBroadcastFormat();\n\n      const wallet = new Wallet(bitgo, token, { coinSpecific: { baseAddress: recipientAddress } });\n\n      await token\n        .verifyTssTransaction({\n          txParams: {\n            type: 'transfer',\n            recipients: [{ address: recipientAddress, amount: '10000000' }],\n          } as any,\n          txPrebuild: { txHex, coin: 'txdc:tmt', walletId: 'fakeWalletId' } as any,\n          wallet,\n        })\n        .should.be.rejectedWith('destination address does not match with the recipient address');\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 wallet = new Wallet(bitgo, token, { coinSpecific: { baseAddress: recipientAddress } });\n\n      await token\n        .verifyTssTransaction({\n          txParams: {},\n          txPrebuild: { txHex: '0x00', coin: 'txdc:tmt', walletId: 'fakeWalletId' } as any,\n          wallet,\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            type: 'transfer',\n            recipients: [{ address: recipientAddress, amount: '10000000' }],\n          } as any,\n          txPrebuild: { txHex: '0x00', coin: 'txdc:tmt', walletId: 'fakeWalletId' } as any,\n          wallet: undefined as unknown as Wallet,\n        })\n        .should.be.rejectedWith('missing params');\n    });\n  });\n});\n"]}