feat: add XDC_FEATURES to xdc tokens

Ticket: COIN-7060

Author: ArunBala-Bitgo

modules/sdk-coin-xdc/test/unit/xdcToken.ts

@@ -2,7 +2,7 @@ import 'should';
 import { TestBitGo, TestBitGoAPI } from '@bitgo/sdk-test';
 import { BitGoAPI } from '@bitgo/sdk-api';
 
-import { register } from '../../src';
+import { register, XdcToken } from '../../src';
 
 describe('XDC Token:', function () {
   let bitgo: TestBitGoAPI;
@@ -27,4 +27,94 @@ 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(XdcToken);
+        });
+
+        it(`${tokenName} should create TransactionBuilder without error`, function () {
+          const token = bitgo.coin(tokenName) as XdcToken;
+          // @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) as XdcToken;
+          // @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(XdcToken);
+        });
+
+        it(`${tokenName} should create TransactionBuilder without error`, function () {
+          const token = bitgo.coin(tokenName) as XdcToken;
+          // @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) as XdcToken;
+          // @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: any = 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) as XdcToken;
+          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 as Error).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(XdcToken);
+        token.constructor.name.should.equal('XdcToken');
+        token.constructor.name.should.not.equal('EthLikeErc20Token');
+      });
+    });
+  });
 });

modules/statics/src/allCoinsAndTokens.ts

@@ -2996,31 +2996,35 @@ export const allCoinsAndTokens = [
     'Law Block Token',
     18,
     '0x05940b2df33d6371201e7ae099ced4c363855dfe',
-    UnderlyingAsset['xdc:lbt']
+    UnderlyingAsset['xdc:lbt'],
+    XDC_FEATURES
   ),
   xdcErc20(
     'f03302de-b06b-4ddc-94a2-ad7e89896725',
     'xdc:gama',
     'Gama Token',
     18,
     '0x3a170c7c987f55c84f28733bfa27962d8cdd5d3b',
-    UnderlyingAsset['xdc:gama']
+    UnderlyingAsset['xdc:gama'],
+    XDC_FEATURES
   ),
   xdcErc20(
     'bdf602ea-3a6c-407a-8afd-33d6c04a8bc3',
     'xdc:srx',
     'STORX',
     18,
     '0x5d5f074837f5d4618b3916ba74de1bf9662a3fed',
-    UnderlyingAsset['xdc:srx']
+    UnderlyingAsset['xdc:srx'],
+    XDC_FEATURES
   ),
   xdcErc20(
     'd42c9497-0987-497d-97f2-8b19c539e350',
     'xdc:weth',
     'Wrapped Ether',
     18,
     '0xa7348290de5cf01772479c48d50dec791c3fc212',
-    UnderlyingAsset['xdc:weth']
+    UnderlyingAsset['xdc:weth'],
+    XDC_FEATURES
   ),
 
   // XDC testnet tokens
@@ -3030,7 +3034,8 @@ export const allCoinsAndTokens = [
     'XDC Network TMT',
     6,
     '0xb283ec8dad644effc5c4c50bb7bb21442ac3c2db',
-    UnderlyingAsset['txdc:tmt']
+    UnderlyingAsset['txdc:tmt'],
+    XDC_FEATURES
   ),
 
   // MON mainnet tokens