add unit test

packages/bridge-ui-v2/src/components/Bridge/Actions.svelte

@@ -3,10 +3,10 @@
 
   import { Button } from '$components/Button';
   import { Icon } from '$components/Icon';
-  import { bridges, ContractType,type RequireApprovalArgs } from '$libs/bridge';
+  import { bridges, ContractType, type RequireApprovalArgs } from '$libs/bridge';
   import type { ERC721Bridge } from '$libs/bridge/ERC721Bridge';
   import type { ERC1155Bridge } from '$libs/bridge/ERC1155Bridge';
-  import { getContractAddressBasedOnType } from '$libs/bridge/getContractAddressBasedOnType';
+  import { getContractAddressByType } from '$libs/bridge/getContractAddressByType';
   import { type NFT, TokenType } from '$libs/token';
   import { checkOwnershipOfNFT } from '$libs/token/checkOwnership';
   import { getConnectedWallet } from '$libs/util/getConnectedWallet';
@@ -63,7 +63,7 @@
 
         const wallet = await getConnectedWallet();
 
-        const spenderAddress = getContractAddressBasedOnType({
+        const spenderAddress = getContractAddressByType({
           srcChainId: currentChainId,
           destChainId: destinationChainId,
           tokenType: token.type,

packages/bridge-ui-v2/src/libs/bridge/getContractAddressByType.test.ts

@@ -0,0 +1,166 @@
+import { routingContractsMap } from '$bridgeConfig';
+import { ContractType, type GetContractAddressType } from '$libs/bridge';
+import { TokenType } from '$libs/token';
+
+import { getContractAddressByType } from './getContractAddressByType';
+
+const SRC_CHAIN_ID = 1;
+const DEST_CHAIN_ID = 2;
+
+vi.mock('$customToken', () => ({ customToken: [] }));
+
+vi.mock('$bridgeConfig', () => ({
+  routingContractsMap: {
+    1: {
+      2: {
+        erc20VaultAddress: '0x00001',
+        bridgeAddress: '0x00002',
+        erc721VaultAddress: '0x00003',
+        erc1155VaultAddress: '0x00004',
+        crossChainSyncAddress: '0x00005',
+        signalServiceAddress: '0x00006',
+      },
+    },
+    2: {
+      1: {
+        erc20VaultAddress: '0x00007',
+        bridgeAddress: '0x00008',
+        erc721VaultAddress: '0x00009',
+        erc1155VaultAddress: '0x00010',
+        crossChainSyncAddress: '0x00011',
+        signalServiceAddress: '0x00012',
+      },
+    },
+  },
+}));
+
+describe('getContractAddressBasedOnType', () => {
+  it('should return the correct vault contract address based on contract type (ERC20)', () => {
+    // Given
+    const args: GetContractAddressType = {
+      srcChainId: SRC_CHAIN_ID,
+      destChainId: DEST_CHAIN_ID,
+      tokenType: TokenType.ERC20,
+      contractType: ContractType.VAULT,
+    };
+
+    const expectedAddress = routingContractsMap[SRC_CHAIN_ID][DEST_CHAIN_ID].erc20VaultAddress;
+
+    // When
+    const address = getContractAddressByType(args);
+
+    // Then
+    expect(address).to.equal(expectedAddress);
+    expect(address).not.toBeUndefined();
+  });
+
+  it('should return the correct vault contract address based on token type (ERC721)', () => {
+    // Given
+    const args: GetContractAddressType = {
+      srcChainId: SRC_CHAIN_ID,
+      destChainId: DEST_CHAIN_ID,
+      tokenType: TokenType.ERC721,
+      contractType: ContractType.VAULT,
+    };
+
+    const expectedAddress = routingContractsMap[SRC_CHAIN_ID][DEST_CHAIN_ID].erc721VaultAddress;
+
+    // When
+    const address = getContractAddressByType(args);
+
+    // Then
+    expect(address).to.equal(expectedAddress);
+    expect(address).not.toBeUndefined();
+  });
+
+  it('should return the correct vault contract address based on token type (ERC1155)', () => {
+    // Given
+    const args: GetContractAddressType = {
+      srcChainId: SRC_CHAIN_ID,
+      destChainId: DEST_CHAIN_ID,
+      tokenType: TokenType.ERC1155,
+      contractType: ContractType.VAULT,
+    };
+
+    const expectedAddress = routingContractsMap[SRC_CHAIN_ID][DEST_CHAIN_ID].erc1155VaultAddress;
+
+    // When
+    const address = getContractAddressByType(args);
+
+    // Then
+    expect(address).to.equal(expectedAddress);
+    expect(address).not.toBeUndefined();
+  });
+
+  it('should return the correct bridge contract address', () => {
+    // Given
+    const args: GetContractAddressType = {
+      srcChainId: SRC_CHAIN_ID,
+      destChainId: DEST_CHAIN_ID,
+      contractType: ContractType.BRIDGE,
+    };
+
+    const expectedAddress = routingContractsMap[SRC_CHAIN_ID][DEST_CHAIN_ID].bridgeAddress;
+
+    // When
+    const address = getContractAddressByType(args);
+
+    // Then
+    expect(address).to.equal(expectedAddress);
+    expect(address).not.toBeUndefined();
+  });
+
+  it('should return the correct crosschain sync contract address', () => {
+    // Given
+    const args: GetContractAddressType = {
+      srcChainId: SRC_CHAIN_ID,
+      destChainId: DEST_CHAIN_ID,
+      contractType: ContractType.CROSSCHAINSYNC,
+    };
+
+    const expectedAddress = routingContractsMap[SRC_CHAIN_ID][DEST_CHAIN_ID].crossChainSyncAddress;
+
+    // When
+    const address = getContractAddressByType(args);
+
+    // Then
+    expect(address).to.equal(expectedAddress);
+    expect(address).not.toBeUndefined();
+  });
+
+  it('should return the correct signalservice contract address', () => {
+    // Given
+    const args: GetContractAddressType = {
+      srcChainId: SRC_CHAIN_ID,
+      destChainId: DEST_CHAIN_ID,
+      contractType: ContractType.SIGNALSERVICE,
+    };
+
+    const expectedAddress = routingContractsMap[SRC_CHAIN_ID][DEST_CHAIN_ID].signalServiceAddress;
+
+    // When
+    const address = getContractAddressByType(args);
+
+    // Then
+    expect(address).to.equal(expectedAddress);
+    expect(address).not.toBeUndefined();
+  });
+
+  it('should return the correct contract address for different configs', () => {
+    // Given
+    const args: GetContractAddressType = {
+      srcChainId: DEST_CHAIN_ID,
+      destChainId: SRC_CHAIN_ID,
+      contractType: ContractType.SIGNALSERVICE,
+    };
+
+    const expectedAddress = routingContractsMap[DEST_CHAIN_ID][SRC_CHAIN_ID].signalServiceAddress;
+
+    // When
+    const address = getContractAddressByType(args);
+
+    // Then
+    expect(address).to.equal(expectedAddress);
+    expect(address).not.toBeUndefined();
+  });
+});

packages/bridge-ui-v2/src/libs/bridge/getContractAddressBasedOnType.ts → packages/bridge-ui-v2/src/libs/bridge/getContractAddressByType.ts

@@ -14,6 +14,7 @@ const getVaultAddress = (args: GetContractAddressType): Address => {
     [TokenType.ETH]: (config) => config.etherVaultAddress || zeroAddress,
   };
 
+  if (!args.tokenType) throw new Error('Token type is required');
   const getAddress = addressGetters[args.tokenType];
 
   if (!getAddress) {
@@ -23,7 +24,7 @@ const getVaultAddress = (args: GetContractAddressType): Address => {
   return getAddress(addressConfig);
 };
 
-export const getContractAddressBasedOnType = (args: GetContractAddressType): Address => {
+export const getContractAddressByType = (args: GetContractAddressType): Address => {
   const addressConfig = routingContractsMap[args.srcChainId][args.destChainId];
 
   switch (args.contractType) {

packages/bridge-ui-v2/src/libs/bridge/types.ts

@@ -212,6 +212,6 @@ export enum ContractType {
 export type GetContractAddressType = {
   srcChainId: number;
   destChainId: number;
-  tokenType: TokenType;
+  tokenType?: TokenType;
   contractType: ContractType;
 };