complete add chains function

Author: theothersideofgods

examples/react/src/main.tsx

@@ -132,14 +132,14 @@ const _wallets: BaseWallet[] = [
   // mock1Wallet,
   // mock2Wallet,
   keplrWallet,
-  leapWallet,
+  // leapWallet,
   // cosmostationWallet,
   // stationWallet,
   // galaxyStationWallet,
   // walletConnect,
   // ledgerWallet,
   // cosmosExtensionMetaMask,
-  walletConnect,
+  // walletConnect,
   // ledgerWallet,
   // leapCosmosExtensionMetaMask,
   // compassWallet,

packages/core/__tests__/wallet-manager.test.ts

@@ -2,7 +2,7 @@ import { WalletManager } from '../src/wallet-manager';
 import { Chain, AssetList } from '@chain-registry/v2-types';
 import { BaseWallet } from '../src/wallets/base-wallet';
 import { SignerOptions, EndpointOptions, SignType } from '../src/types';
-import { WalletNotExist, ChainNameNotExist, NoValidRpcEndpointFound } from '../src/utils';
+import { WalletNotExist, ChainNameNotExist, NoValidRpcEndpointFound, getValidRpcEndpoint } from '../src/utils';
 
 import { createMockAssetList } from './helpers/mock-asset-list-factory';
 import { createMockChain } from './helpers/mock-chain-factory';
@@ -11,6 +11,13 @@ import { AminoGenericOfflineSigner } from '@interchainjs/cosmos/types/wallet';
 import { SigningClient } from '@interchainjs/cosmos/signing-client';
 import { createSignerOption } from './helpers/mock-setting-factory';
 
+jest.mock('../src/utils/endpoint.ts', () => {
+  return {
+    ...jest.requireActual('../src/utils/endpoint.ts'),
+    getValidRpcEndpoint: jest.fn()
+  };
+});
+
 describe('WalletManager', () => {
   (global as any).window = {
 
@@ -22,6 +29,7 @@ describe('WalletManager', () => {
   };
 
 
+
   let chains: Chain[];
   let assetLists: AssetList[];
   let wallets: BaseWallet[];
@@ -36,7 +44,11 @@ describe('WalletManager', () => {
   let assetList1: AssetList
   let assetList2: AssetList
 
+
+
   beforeEach(() => {
+
+
     chain1 = createMockChain({ chainName: 'chain-1', chainId: '1', rpcEndpoint: [{ address: 'http://localhost:26657' }], chainType: 'cosmos' });
     chain2 = createMockChain({ chainName: 'chain-2', chainId: '2', rpcEndpoint: [{ address: 'http://localhost:26658' }], chainType: 'cosmos' });
     assetList1 = createMockAssetList({
@@ -91,6 +103,8 @@ describe('WalletManager', () => {
 
     walletManager = new WalletManager(chains, assetLists, wallets, signerOptions, endpointOptions);
 
+
+    (getValidRpcEndpoint as jest.Mock).mockClear()
   });
 
   it('should set assetLists for wallets, after walletManager constructor', () => {
@@ -103,6 +117,15 @@ describe('WalletManager', () => {
     expect(wallet2.chainMap.get(chain1.chainId)).toEqual(chain1);
   });
 
+  it('should have right signerOptions and endpointOptions for each chain', () => {
+    expect(walletManager.signerOptionMap[chain1.chainName]).toEqual(signerOptions.signing?.(chain1.chainName));
+    expect(walletManager.signerOptionMap[chain2.chainName]).toEqual(signerOptions.signing?.(chain2.chainName));
+    expect(walletManager.endpointOptionsMap[chain1.chainName]).toEqual(endpointOptions.endpoints?.[chain1.chainName]);
+    expect(walletManager.endpointOptionsMap[chain2.chainName]).toEqual(undefined);
+    expect(walletManager.preferredSignTypeMap[chain1.chainName]).toEqual('amino');
+    expect(walletManager.preferredSignTypeMap[chain2.chainName]).toEqual('direct');
+  });
+
   it('should initialize wallets', async () => {
     wallet1.init = jest.fn();
     wallet2.init = jest.fn();
@@ -116,10 +139,10 @@ describe('WalletManager', () => {
     expect(wm).toBeInstanceOf(WalletManager);
   });
 
-  it('should add new chains', () => {
+  it('should add new chains', async () => {
     const newChain = createMockChain({ chainName: 'chainToAdd', chainId: '3', rpcEndpoint: [{ address: 'http://localhost:26659' }], chainType: 'cosmos' });
     const newAssetList = createMockAssetList({ chainName: 'chainToAdd', assets: [] });
-    walletManager.addChains([newChain], [newAssetList], signerOptions, endpointOptions);
+    await walletManager.addChains([newChain], [newAssetList], signerOptions, endpointOptions);
     expect(walletManager.chains).toContain(newChain);
     expect(walletManager.assetLists).toContain(newAssetList);
     expect(walletManager.signerOptionMap[newChain.chainName]).toEqual(signerOptions.signing?.(newChain.chainName));
@@ -185,6 +208,7 @@ describe('WalletManager', () => {
   });
 
   it('should throw error if no valid RPC endpoint found', async () => {
+    (getValidRpcEndpoint as jest.Mock).mockReturnValue(Promise.resolve(''));
     if (walletManager.endpointOptions?.endpoints?.['chain-1']) {
       walletManager.endpointOptions.endpoints['chain-1'].rpc = [];
     }
@@ -253,14 +277,80 @@ describe('WalletManager', () => {
     expect(chain).toBeUndefined();
   });
 
-  it('new chains should be added into chainMaps of wallet, after addChains', () => {
+  it('new chains should be added into chainMaps of wallet, after addChains', async () => {
     const newChain = createMockChain({ chainName: 'chainToAdd', chainId: '3', rpcEndpoint: [{ address: 'http://localhost:26659' }], chainType: 'cosmos' });
     const newAssetList = createMockAssetList({ chainName: 'chainToAdd', assets: [] });
-    walletManager.addChains([newChain], [newAssetList], signerOptions, endpointOptions);
+    await walletManager.addChains([newChain], [newAssetList], signerOptions, endpointOptions);
     expect(wallet1.chainMap.get(newChain.chainId)).toEqual(newChain);
     expect(wallet2.chainMap.get(newChain.chainId)).toEqual(newChain);
   })
 
+  it('addChains should update right signerOptions for new chains', async () => {
+    const newChain = createMockChain({ chainName: 'chainToAdd', chainId: '3', rpcEndpoint: [{ address: 'http://localhost:26659' }], chainType: 'cosmos' });
+    const newAssetList = createMockAssetList({ chainName: 'chainToAdd', assets: [] });
+
+    const endpointOptions1 = {
+      endpoints: {
+        'chainToAdd': {
+          rpc: ['http://localhost:26679']
+        }
+      }
+    } as EndpointOptions
+
+    const signerOptions1 = {
+      signing: jest.fn().mockImplementation((chainName: string) => {
+        return {
+          'chainToAdd': {
+            gasPrice: '1000uatom',
+          }
+        }[chainName]
+      })
+    } as SignerOptions
+
+
+    await walletManager.addChains([newChain], [newAssetList], signerOptions1, endpointOptions1);
+    expect(walletManager.chains).toContain(newChain);
+    expect(walletManager.assetLists).toContain(newAssetList);
+    expect(walletManager.signerOptionMap[newChain.chainName]).toEqual({ gasPrice: '1000uatom' });
+    expect(walletManager.endpointOptionsMap[newChain.chainName]).toEqual({ rpc: ['http://localhost:26679'] });
+
+    const endpointOptions2 = {
+      endpoints: {
+        'chainToAdd': {
+          rpc: ['http://localhost:26659']
+        }
+      }
+    } as EndpointOptions
+
+    const signerOptions2 = {
+      signing: jest.fn().mockImplementation((chainName: string) => {
+        return {
+          'chainToAdd': {
+            gasPrice: '2000uatom',
+          }
+        }[chainName]
+      })
+    } as SignerOptions
+
+
+    await walletManager.addChains([newChain], [newAssetList], signerOptions2, endpointOptions2);
+    expect(walletManager.signerOptionMap[newChain.chainName]).toEqual({ gasPrice: '2000uatom' });
+    expect(walletManager.endpointOptionsMap[newChain.chainName]).toEqual({ rpc: ['http://localhost:26659'] });
+  })
+
+  it('addChains should update endpoint from chain rpc list', async () => {
+    (getValidRpcEndpoint as jest.Mock).mockReturnValue('https://rpc.example.com');
+
+    const newChain = createMockChain({ chainName: 'chainToAdd', chainId: '3', rpcEndpoint: [{ address: 'https://rpc.example.com' }], chainType: 'cosmos' });
+    const newAssetList = createMockAssetList({ chainName: 'chainToAdd', assets: [] });
+
+    await walletManager.addChains([newChain], [newAssetList]);
+    expect(walletManager.chains).toContain(newChain);
+    expect(walletManager.assetLists).toContain(newAssetList);
+    expect(walletManager.endpointOptionsMap[newChain.chainName]).toEqual({ rpc: ['https://rpc.example.com'] });
+
+  })
+
 });
 
 

packages/core/src/wallet-manager.ts

@@ -63,22 +63,46 @@ export class WalletManager {
     return wm
   }
 
-  addChains(chains: Chain[], assetLists: AssetList[], signerOptions?: SignerOptions, endpointOptions?: EndpointOptions) {
+  async addChains(newChains: Chain[], newAssetLists: AssetList[], signerOptions?: SignerOptions, newEndpointOptions?: EndpointOptions) {
     const existChains = this.chains
-    chains.forEach(newChain => {
-      const existChain = existChains.find(c => c.chainId === newChain.chainId)
-      if (!existChain) {
+
+    const rpcEndpointTable = new Map<Chain['chainId'], string | HttpEndpoint>()
+
+
+    await Promise.all(newChains.map(async (newChain) => {
+
+
+      const rpcEndpoint = await getValidRpcEndpoint(newChain.apis.rpc.map(url => ({ chainType: newChain.chainType, endpoint: url.address })))
+
+      if (rpcEndpoint) {
+        rpcEndpointTable.set(newChain.chainId, rpcEndpoint)
+      }
+    }))
+
+    const existChainsTable = new Map(existChains.map(chain => [chain.chainId, chain]))
+    const newAssetListsTable = new Map(newAssetLists.map(assetList => [assetList.chainName, assetList]))
+
+    newChains.forEach(newChain => {
+
+      if (!existChainsTable.has(newChain.chainId)) {
+        const assetList = newAssetListsTable.get(newChain.chainName)
+
         this.chains.push(newChain)
-        const assetList = assetLists.find(a => a.chainName === newChain.chainName)
         this.assetLists.push(assetList)
+
         this.wallets.forEach(wallet => {
           wallet.addChain(newChain)
+          wallet.addAssetList(assetList)
         })
       }
 
       this.signerOptionMap[newChain.chainName] = signerOptions?.signing?.(newChain.chainName)
-      this.endpointOptionsMap[newChain.chainName] = endpointOptions?.endpoints?.[newChain.chainName]
+
+      this.endpointOptionsMap[newChain.chainName] = {
+        rpc: [newEndpointOptions?.endpoints?.[newChain.chainName]?.rpc?.[0] || rpcEndpointTable.get(newChain.chainId)],
+      }
     })
+
   }
 
   getChainLogoUrl(chainName: ChainName) {

packages/core/src/wallets/base-wallet.ts

@@ -24,6 +24,9 @@ export abstract class BaseWallet {
   setAssetLists(assetLists: AssetList[]) {
     this.assetLists = assetLists
   }
+  addAssetList(assetList: AssetList) {
+    this.assetLists.push(assetList)
+  }
   getChainById(chainId: Chain['chainId']): Chain {
     const chain = this.chainMap.get(chainId);
     if (!chain) {

packages/react/__tests__/store/store.test.ts

@@ -189,27 +189,6 @@ describe('InterchainStore', () => {
     (walletManager.getRpcEndpoint as jest.Mock).mockResolvedValueOnce(rpcEndpoint);
     const result = await useStore.getState().getRpcEndpoint('wallet1', 'chain1');
     expect(result).toBe(rpcEndpoint);
-    const state = useStore.getState().getChainWalletState('wallet1', 'chain1');
-    expect(state?.rpcEndpoint).toBe(rpcEndpoint);
-  });
-
-  it('should add chains', () => {
-    const newChains = [{ chainName: 'chain2', chainId: '2' }] as Chain[];
-    const newAssetLists = [{ chainName: 'chain2', assets: [] }] as AssetList[];
-    const signingMock = jest.fn().mockReturnValue('prefix');
-    const newSignerOptions = {
-      signing: signingMock,
-    } as SignerOptions;
-    const newEndpointOptions = {
-      endpoints: { chain2: { rpc: ['http://localhost:26657'] } },
-    } as EndpointOptions;
-    useStore.getState().addChains(newChains, newAssetLists, newSignerOptions, newEndpointOptions);
-    expect(walletManager.addChains).toHaveBeenCalledWith(newChains, newAssetLists, newSignerOptions, newEndpointOptions);
-    expect(useStore.getState().chains).toContainEqual(newChains[0]);
-    expect(useStore.getState().assetLists).toContainEqual(newAssetLists[0]);
-    expect(useStore.getState().signerOptionMap).toEqual({ chain2: 'prefix' });
-    expect(useStore.getState().endpointOptionsMap).toEqual({ chain2: newEndpointOptions.endpoints?.chain2 ?? {} });
-    expect(useStore.getState().getChainWalletState('wallet1', 'chain2')?.rpcEndpoint).toBe('http://localhost:26657');
   });
 
   it('should not reconnect WalletConnect if already connected', async () => {
@@ -312,23 +291,39 @@ describe('InterchainStore', () => {
     expect(walletManager.addChains).toHaveBeenCalledWith(newChains, newAssetLists, undefined, undefined);
   });
 
-  it('should update endpoints if use addChains to add newChain', () => {
+  it('should update endpoints if use addChains to add newChain', async () => {
     const newChains = [{ chainName: 'chain2', chainId: '2' }] as Chain[];
     const newAssetLists = [{ chainName: 'chain2', assets: [] }] as AssetList[];
     const newSignerOptions = {
-      signing: jest.fn().mockReturnValue('prefix'),
+      signing: jest.fn().mockReturnValue({ gasPrice: '1000' }),
     } as SignerOptions;
     const newEndpointOptions = {
       endpoints: { chain2: { rpc: ['http://localhost:26657'] } },
     } as EndpointOptions;
-    useStore.getState().addChains(newChains, newAssetLists, newSignerOptions, newEndpointOptions);
-    expect(useStore.getState().endpointOptionsMap).toEqual({ chain2: newEndpointOptions.endpoints?.chain2 ?? {} });
-
+    await useStore.getState().addChains(newChains, newAssetLists, newSignerOptions, newEndpointOptions);
+    expect(useStore.getState().chains).toContainEqual(newChains[0]);
+    expect(useStore.getState().assetLists).toContainEqual(newAssetLists[0]);
+    expect(useStore.getState().signerOptionMap).toEqual(expect.objectContaining({ chain2: { gasPrice: '1000' } }));
+    expect(useStore.getState().endpointOptionsMap).toEqual(expect.objectContaining({ chain2: newEndpointOptions.endpoints?.chain2 }));
+
+    const newSignerOptionss = {
+      signing: jest.fn().mockImplementation((chainName: string) => {
+        return {
+          'chain1': { gasPrice: '3000' },
+          'chain2': { gasPrice: '4000' },
+        }[chainName]
+      }),
+    } as SignerOptions;
     const newEndpointOptionss = {
-      endpoints: { chain2: { rpc: ['http://localhost:26668'] } },
+      endpoints: {
+        chain2: { rpc: ['http://localhost:26668'] },
+        chain1: { rpc: ['http://localhost:27774'] }
+      },
     } as EndpointOptions;
-    useStore.getState().addChains(newChains, newAssetLists, newSignerOptions, newEndpointOptionss);
-    expect(useStore.getState().endpointOptionsMap).toEqual({ chain2: newEndpointOptionss.endpoints?.chain2 ?? {} });
+
+    await useStore.getState().addChains(newChains, newAssetLists, newSignerOptionss, newEndpointOptionss);
+    expect(useStore.getState().signerOptionMap).toEqual(expect.objectContaining({ chain1: { gasPrice: '3000' }, chain2: { gasPrice: '4000' } }));
+    expect(useStore.getState().endpointOptionsMap).toEqual(expect.objectContaining({ chain2: newEndpointOptionss.endpoints?.chain2, chain1: newEndpointOptionss.endpoints?.chain1 }));
   })
 
   it('should update wallet state to Connected and fetch account after connection', async () => {
@@ -342,4 +337,61 @@ describe('InterchainStore', () => {
     expect(walletManager.getAccount).toHaveBeenCalledWith('wallet1', 'chain1');
     expect(state?.account).toBe(account);
   });
+
+  it('should add new chain wallet states for new chains and wallets', async () => {
+    const newChains = [{ chainName: 'chain2', chainId: '2' }] as Chain[];
+    const newAssetLists = [{ chainName: 'chain2', assets: [] }] as AssetList[];
+
+    await useStore.getState().addChains(newChains, newAssetLists);
+
+    const chainWalletState = useStore.getState().chainWalletState;
+
+    expect(chainWalletState).toEqual([
+      {
+        "chainName": "chain1",
+        "errorMessage": "",
+        "rpcEndpoint": "",
+        "walletName": "wallet1",
+        "walletState": "Disconnected",
+      },
+      {
+        "chainName": "chain1",
+        "errorMessage": "",
+        "rpcEndpoint": "",
+        "walletName": "WalletConnect",
+        "walletState": "Disconnected",
+      },
+      {
+        "account": undefined,
+        "chainName": "chain2",
+        "errorMessage": "",
+        "rpcEndpoint": "",
+        "walletName": "wallet1",
+        "walletState": "Disconnected",
+      },
+      {
+        "account": undefined,
+        "chainName": "chain2",
+        "errorMessage": "",
+        "rpcEndpoint": "",
+        "walletName": "WalletConnect",
+        "walletState": "Disconnected",
+      },
+    ]);
+  });
+
+  it('should not duplicate chain wallet states for existing chains and wallets', async () => {
+    const newChains = [{ chainName: 'chain1', chainId: '1' }] as Chain[];
+    const newAssetLists = [{ chainName: 'chain1', assets: [] }] as AssetList[];
+
+    await useStore.getState().addChains(newChains, newAssetLists);
+
+    const chainWalletState = useStore.getState().chainWalletState;
+
+    // Ensure no duplicate entries for chain1 and wallet1
+    const filteredStates = chainWalletState.filter(
+      (cws) => cws.chainName === 'chain1' && cws.walletName === 'wallet1'
+    );
+    expect(filteredStates.length).toBe(1);
+  });
 });