@interchain-kit/react 0.0.1-beta.52 → 0.0.1-beta.54

package/esm/hooks/index.js

@@ -1,9 +1,3 @@
 export * from './useWalletManager';
-export * from './useCurrentWallet';
-export * from './useAccount';
 export * from './useChain';
-export * from './useConnect';
 export * from './useChainWallet';
-export * from './useConfig';
-export * from './useOfflineSigner';
-export * from './useRpcEndpoint';

package/esm/hooks/useChain.js

@@ -1,78 +1,44 @@
-import { useWalletManager } from "./useWalletManager";
-import { useAccount } from "./useAccount";
-import { useInterchainClient } from './useInterchainClient';
 import { useWalletModal } from "../modal";
-import { useRpcEndpoint } from "./useRpcEndpoint";
-import { WalletState } from "@interchain-kit/core";
-import { useCurrentChainWallet } from "./useCurrentChainWallet";
+import { useWalletManager } from './useWalletManager';
+import { ChainNameNotExist } from '@interchain-kit/core';
 export const useChain = (chainName) => {
-    const walletManager = useWalletManager();
-    const chainAccount = useCurrentChainWallet();
-    const chain = walletManager.getChainByName(chainName);
-    walletManager.currentChainName = chainName;
-    const walletName = chainAccount?.info?.name;
-    const rpcEndpointHook = useRpcEndpoint(chainName, walletName);
-    const accountHook = useAccount(chainName, walletName);
-    const signingClientHook = useInterchainClient(chainName, walletName);
+    const { assetLists, currentWalletName, disconnect, setCurrentChainName, getChainByName, getWalletByName, getChainWalletState, getChainLogoUrl, connect, getSigningClient, getRpcEndpoint, getAccount } = useWalletManager();
+    const chain = getChainByName(chainName);
+    if (!chain) {
+        throw new ChainNameNotExist(chainName);
+    }
+    const assetList = assetLists.find(a => a.chainName === chainName);
+    const wallet = getWalletByName(currentWalletName);
+    const chainWalletStateToShow = getChainWalletState(currentWalletName, chainName);
     const { open, close } = useWalletModal();
-    const cosmosKitUserChainReturnType = {
+    console.log({ chainName, chain });
+    return {
+        //for migration cosmos kit
         connect: () => {
-            if (chainAccount?.walletState === WalletState.Connected) {
-                return;
-            }
-            walletManager.currentChainName = chainName;
+            setCurrentChainName(chainName);
             open();
         },
-        disconnect: async () => {
-            walletManager.currentChainName = chainName;
-            await chainAccount?.disconnect();
-        },
+        disconnect: async () => disconnect(currentWalletName, chainName),
         openView: () => {
-            walletManager.currentChainName = chainName;
+            setCurrentChainName(chainName);
             open();
         },
         closeView: close,
-        getRpcEndpoint: () => chainAccount.getRpcEndpoint(),
-        status: chainAccount?.walletState,
-        username: accountHook.account?.username,
-        message: chainAccount?.errorMessage
-    };
-    if (chainAccount && chainAccount?.walletState === WalletState.Connected) {
-        return {
-            logoUrl: walletManager.getChainLogoUrl(chainName),
-            chain,
-            assetList: chainAccount?.assetList,
-            address: accountHook.account?.address,
-            wallet: chainAccount,
-            rpcEndpoint: rpcEndpointHook.rpcEndpoint,
-            ...cosmosKitUserChainReturnType, //for migration cosmos kit
-            signingClient: signingClientHook.signingClient,
-            getSigningClient: () => signingClientHook.getSigningClient(),
-            isRpcEndpointLoading: rpcEndpointHook.isLoading,
-            isAccountLoading: accountHook.isLoading,
-            isSigningClientLoading: signingClientHook.isLoading,
-            isLoading: rpcEndpointHook.isLoading || accountHook.isLoading || signingClientHook.isLoading,
-            getRpcEndpointError: rpcEndpointHook.error,
-            getSigningClientError: signingClientHook.error,
-            getAccountError: accountHook.error
-        };
-    }
-    return {
-        logoUrl: walletManager.getChainLogoUrl(chainName),
+        getRpcEndpoint: () => getRpcEndpoint(currentWalletName, chainName),
+        status: chainWalletStateToShow?.walletState,
+        username: chainWalletStateToShow?.account?.username,
+        message: chainWalletStateToShow?.errorMessage,
+        // new api
+        logoUrl: getChainLogoUrl(chainName),
         chain,
-        assetList: chainAccount?.assetList,
-        address: accountHook.account?.address,
-        wallet: chainAccount,
-        rpcEndpoint: rpcEndpointHook.rpcEndpoint,
-        ...cosmosKitUserChainReturnType, //for migration cosmos kit
-        signingClient: signingClientHook.signingClient,
-        getSigningClient: () => signingClientHook.getSigningClient(),
-        isRpcEndpointLoading: rpcEndpointHook.isLoading,
-        isAccountLoading: accountHook.isLoading,
-        isSigningClientLoading: signingClientHook.isLoading,
-        isLoading: rpcEndpointHook.isLoading || accountHook.isLoading || signingClientHook.isLoading,
-        getRpcEndpointError: rpcEndpointHook.error,
-        getSigningClientError: signingClientHook.error,
-        getAccountError: accountHook.error
+        assetList,
+        address: chainWalletStateToShow?.account?.address,
+        wallet: wallet ? Object.assign({}, wallet, {
+            walletState: chainWalletStateToShow?.walletState,
+            connect: () => connect(currentWalletName, chainName),
+            getAccount: () => getAccount(currentWalletName, chainName)
+        }) : undefined,
+        rpcEndpoint: chainWalletStateToShow?.rpcEndpoint,
+        getSigningClient: () => getSigningClient(currentWalletName, chainName),
     };
 };

package/esm/hooks/useChainWallet.js

@@ -1,41 +1,30 @@
 import { useWalletManager } from "./useWalletManager";
-import { useAccount } from "./useAccount";
-import { useInterchainClient } from "./useInterchainClient";
-import { useRpcEndpoint } from "./useRpcEndpoint";
-import { WalletState } from "@interchain-kit/core";
 export const useChainWallet = (chainName, walletName) => {
-    const walletManager = useWalletManager();
-    const walletRepository = walletManager.getWalletRepositoryByName(walletName);
-    const chainAccount = walletRepository.getChainAccountByName(chainName);
-    const rpcEndpointHook = useRpcEndpoint(chainName, walletName);
-    const accountHook = useAccount(chainName, walletName);
-    const signingClientHook = useInterchainClient(chainName, walletName);
+    const { assetLists, disconnect, getChainByName, getWalletByName, getChainWalletState, getChainLogoUrl, connect, getSigningClient, getRpcEndpoint, getAccount } = useWalletManager();
+    const chain = getChainByName(chainName);
+    const wallet = getWalletByName(walletName);
+    const assetList = assetLists.find(a => a.chainName === chainName);
+    const chainWalletStateToShow = getChainWalletState(walletName, chainName);
     return {
-        connect: () => {
-            if (!chainAccount && chainAccount.walletState === WalletState.Connected) {
-                return;
-            }
-            chainAccount.connect();
-        },
-        disconnect: () => chainAccount.disconnect(),
-        getRpcEndpoint: () => chainAccount.getRpcEndpoint(),
-        status: chainAccount.walletState,
-        username: accountHook.account?.username,
-        message: chainAccount.errorMessage,
-        logoUrl: walletManager.getChainLogoUrl(chainName),
-        rpcEndpoint: rpcEndpointHook.rpcEndpoint,
-        chain: chainAccount.chain,
-        assetList: chainAccount.assetList,
-        address: accountHook.account?.address,
-        wallet: walletRepository,
-        signingClient: signingClientHook.signingClient,
-        getSigningClient: () => signingClientHook.getSigningClient(),
-        isRpcEndpointLoading: rpcEndpointHook.isLoading,
-        isAccountLoading: accountHook.isLoading,
-        isSigningClientLoading: signingClientHook.isLoading,
-        isLoading: rpcEndpointHook.isLoading || accountHook.isLoading || signingClientHook.isLoading,
-        getRpcEndpointError: rpcEndpointHook.error,
-        getSigningClientError: signingClientHook.error,
-        getAccountError: accountHook.error
+        //for migration cosmos kit
+        connect: () => connect(walletName, chainName),
+        disconnect: () => disconnect(walletName, chainName),
+        getRpcEndpoint: () => getRpcEndpoint(walletName, chainName),
+        status: chainWalletStateToShow?.walletState,
+        username: chainWalletStateToShow?.account?.username,
+        message: chainWalletStateToShow?.errorMessage,
+        // new api
+        logoUrl: getChainLogoUrl(chainName),
+        chain,
+        assetList,
+        address: chainWalletStateToShow?.account?.address,
+        wallet: wallet ? Object.assign({}, wallet, {
+            walletState: chainWalletStateToShow?.walletState,
+            connect: () => connect(walletName, chainName),
+            disconnect: () => disconnect(walletName, chainName),
+            getAccount: () => getAccount(walletName, chainName)
+        }) : undefined,
+        rpcEndpoint: chainWalletStateToShow?.rpcEndpoint,
+        getSigningClient: () => getSigningClient(walletName, chainName),
     };
 };

package/esm/hooks/useWalletManager.js

@@ -1,6 +1,6 @@
 import { useInterchainWalletContext } from "../provider";
-import { bindAllMethodsToContext } from '../utils/helpers';
+import { useStore } from 'zustand';
 export const useWalletManager = () => {
-    const { walletManager } = useInterchainWalletContext();
-    return bindAllMethodsToContext(walletManager);
+    const store = useInterchainWalletContext();
+    return useStore(store);
 };

package/esm/index.js

@@ -3,3 +3,4 @@ export * from './hooks';
 export * from './types';
 export * from './enum';
 export * from './modal';
+export * from './store';

package/esm/modal/modal.js

@@ -1,76 +1,72 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { ConnectedContent, ConnectedHeader, ConnectingContent, ConnectingHeader, NotExistContent, NotExistHeader, QRCodeContent, QRCodeHeader, RejectContent, RejectHeader, WalletListContent, WalletListHeader, } from "./views";
 import { useWalletModal } from "./provider";
-import { useWalletManager } from "../hooks";
-import { useEffect, useMemo, useState } from "react";
-import { WalletState, } from "@interchain-kit/core";
+import { useChainWallet, useWalletManager } from "../hooks";
+import { useEffect, useState } from "react";
+import { WalletState } from "@interchain-kit/core";
 import { ConnectModal } from "@interchain-ui/react";
-import { useCurrentChainWallet } from "../hooks/useCurrentChainWallet";
 export const WalletModal = () => {
     const { modalIsOpen, open, close } = useWalletModal();
-    const walletManager = useWalletManager();
-    const handleSelectWallet = async (wallet) => {
-        walletManager.currentWalletName = wallet.info.name;
-        const currentWallet = walletManager
-            .getWalletRepositoryByName(wallet.info.name)
-            .getChainAccountByName(walletManager.currentChainName);
-        console.log(wallet.info.name, walletManager.currentChainName, Boolean(currentWallet));
+    const { currentWalletName, currentChainName, wallets, setCurrentWalletName, connect, getAccount, getWalletByName, } = useWalletManager();
+    const handleSelectWallet = async (selectedWallet) => {
+        const walletToView = wallets.find((w) => w.info.name === selectedWallet.info.name);
+        setCurrentWalletName(selectedWallet.info.name);
         setModalView({
-            header: _jsx(ConnectingHeader, { wallet: wallet, onBack: gotoWalletList }),
-            content: _jsx(ConnectingContent, { wallet: wallet }),
+            header: (_jsx(ConnectingHeader, { wallet: walletToView, onBack: gotoWalletList })),
+            content: _jsx(ConnectingContent, { wallet: walletToView }),
         });
-        if (currentWallet?.wallet?.info.mode === "extension" &&
-            !(currentWallet?.wallet).isExtensionInstalled) {
+        if (walletToView?.info.mode === "extension" &&
+            !walletToView.isExtensionInstalled) {
             setModalView({
-                header: (_jsx(NotExistHeader, { wallet: currentWallet, onBack: gotoWalletList })),
-                content: _jsx(NotExistContent, { wallet: currentWallet }),
+                header: (_jsx(NotExistHeader, { wallet: walletToView, onBack: gotoWalletList })),
+                content: _jsx(NotExistContent, { wallet: walletToView }),
             });
             return;
         }
         try {
-            if (currentWallet?.wallet?.info.mode === "wallet-connect") {
-                (currentWallet?.wallet).setOnPairingUriCreatedCallback(() => {
+            if (walletToView?.info.mode === "wallet-connect") {
+                walletToView.setOnPairingUriCreatedCallback(() => {
                     setModalView({
                         header: _jsx(QRCodeHeader, { onBack: gotoWalletList }),
                         content: _jsx(QRCodeContent, {}),
                     });
                 });
-                (currentWallet?.wallet).setPairingToConnect(wallet.pairing);
+                walletToView.setPairingToConnect(wallet.pairing);
             }
-            await currentWallet?.connect();
-            await currentWallet?.getAccount();
+            console.log({ currentChainName });
+            await connect(selectedWallet.info.name, currentChainName);
+            await getAccount(selectedWallet.info.name, currentChainName);
             setModalView({
-                header: _jsx(ConnectedHeader, { onBack: gotoWalletList }),
+                header: (_jsx(ConnectedHeader, { wallet: walletToView, onBack: gotoWalletList })),
                 content: _jsx(ConnectedContent, {}),
             });
         }
         catch (error) {
             console.log(error);
             setModalView({
-                header: _jsx(RejectHeader, { wallet: wallet, onBack: gotoWalletList }),
-                content: _jsx(RejectContent, { wallet: wallet }),
+                header: _jsx(RejectHeader, { wallet: walletToView, onBack: gotoWalletList }),
+                content: _jsx(RejectContent, { wallet: walletToView }),
             });
         }
     };
-    const defaultModalView = useMemo(() => {
-        return {
-            header: _jsx(WalletListHeader, {}),
-            content: _jsx(WalletListContent, { onSelectWallet: handleSelectWallet }),
-        };
-    }, []);
+    const defaultModalView = {
+        header: _jsx(WalletListHeader, {}),
+        content: _jsx(WalletListContent, { onSelectWallet: handleSelectWallet }),
+    };
     const [modalView, setModalView] = useState(defaultModalView);
     const gotoWalletList = () => setModalView(defaultModalView);
-    const currentWallet = useCurrentChainWallet();
+    const { status } = useChainWallet(currentChainName, currentWalletName);
     useEffect(() => {
-        if (modalIsOpen && currentWallet?.walletState === WalletState.Connected) {
+        const currentWallet = getWalletByName(currentWalletName);
+        if (modalIsOpen && status === WalletState.Connected) {
             setModalView({
-                header: _jsx(ConnectedHeader, { onBack: gotoWalletList }),
+                header: (_jsx(ConnectedHeader, { wallet: currentWallet, onBack: gotoWalletList })),
                 content: _jsx(ConnectedContent, {}),
             });
         }
         else {
             setModalView(defaultModalView);
         }
-    }, [modalIsOpen]);
+    }, [modalIsOpen, status]);
     return (_jsx(ConnectModal, { isOpen: modalIsOpen, header: modalView.header, onOpen: open, onClose: close, children: modalView.content }));
 };

package/esm/modal/views/Connected.js

@@ -1,33 +1,31 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { ConnectModalHead, ConnectModalStatus } from "@interchain-ui/react";
-import { useAccount, useWalletManager } from "../../hooks";
+import { useChainWallet, useWalletManager } from "../../hooks";
 import { useWalletModal } from "../provider";
 import { getWalletInfo } from "../../utils";
 import { AstronautSvg } from "./Astronaut";
-import { useCurrentChainWallet } from "../../hooks/useCurrentChainWallet";
-export const ConnectedHeader = ({ onBack }) => {
-    const currentWallet = useCurrentChainWallet();
+export const ConnectedHeader = ({ wallet, onBack, }) => {
     const { close } = useWalletModal();
-    return (_jsx(ConnectModalHead, { title: currentWallet?.info?.prettyName || "", hasBackButton: true, onClose: close, onBack: onBack, closeButtonProps: { onClick: close } }));
+    return (_jsx(ConnectModalHead, { title: wallet?.info?.prettyName || "", hasBackButton: true, onClose: close, onBack: onBack, closeButtonProps: { onClick: close } }));
 };
 export const ConnectedContent = () => {
-    const currentWallet = useCurrentChainWallet();
-    const walletManager = useWalletManager();
-    const { account } = useAccount(walletManager.currentChainName, currentWallet?.info?.name);
+    const { currentChainName, currentWalletName } = useWalletManager();
+    console.log({ currentChainName, currentWalletName });
+    const { address, username, wallet } = useChainWallet(currentChainName, currentWalletName);
     const { close } = useWalletModal();
-    if (!currentWallet) {
+    if (!wallet) {
         return null;
     }
-    return (_jsx(ConnectModalStatus, { wallet: getWalletInfo(currentWallet), status: "Connected", connectedInfo: {
-            name: account?.username || "Wallet",
+    return (_jsx(ConnectModalStatus, { wallet: getWalletInfo(wallet), status: "Connected", connectedInfo: {
+            name: username || "Wallet",
             avatar: (_jsx(AstronautSvg, { style: {
                     fontSize: "inherit",
                     width: "100%",
                     height: "100%",
                 } })),
-            address: account?.address,
+            address: address,
         }, onDisconnect: async () => {
-            await currentWallet.disconnect();
+            await wallet.disconnect(currentChainName);
             close();
         } }));
 };

package/esm/modal/views/QRCode.js

@@ -1,20 +1,19 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { ConnectModalHead, ConnectModalQRCode } from "@interchain-ui/react";
-import { useCurrentWallet, useWalletManager } from "../../hooks";
+import { useWalletManager } from "../../hooks";
 import { useWalletModal } from "../provider";
 export const QRCodeHeader = ({ onBack }) => {
-    const currentWallet = useCurrentWallet();
-    const walletManager = useWalletManager();
+    const { currentChainName, currentWalletName, getWalletByName, disconnect } = useWalletManager();
     const { close } = useWalletModal();
+    const currentWallet = getWalletByName(currentWalletName);
     return (_jsx(ConnectModalHead, { title: currentWallet?.info?.prettyName || "", hasBackButton: true, onClose: () => void 0, onBack: async () => {
-            await walletManager.disconnect(currentWallet?.info?.name || "");
+            await disconnect(currentWallet?.info?.name || "", currentChainName);
             onBack();
         }, closeButtonProps: { onClick: close } }));
 };
 export const QRCodeContent = () => {
-    const currentWalletRepository = useCurrentWallet();
-    const currentWallet = currentWalletRepository.wallet;
-    const walletManager = useWalletManager();
+    const { currentChainName, currentWalletName, getWalletByName, connect } = useWalletManager();
+    const currentWallet = getWalletByName(currentWalletName);
     const data = currentWallet.pairingUri;
-    return (_jsx(ConnectModalQRCode, { status: data ? "Done" : "Pending", link: data, description: "Open App to connect", errorTitle: "errorTitle", errorDesc: currentWallet.errorMessage || "", onRefresh: () => walletManager.connect(currentWallet?.info?.name || "") }));
+    return (_jsx(ConnectModalQRCode, { status: data ? "Done" : "Pending", link: data, description: "Open App to connect", errorTitle: "errorTitle", errorDesc: currentWallet.errorMessage || "", onRefresh: () => connect(currentWallet?.info?.name || "", currentChainName) }));
 };

package/esm/modal/views/Reject.js

@@ -10,5 +10,5 @@ export const RejectHeader = ({ wallet, onBack, }) => {
 export const RejectContent = ({ wallet }) => {
     const walletManager = useWalletManager();
     const { close } = useWalletModal();
-    return (_jsx(ConnectModalStatus, { status: "Rejected", wallet: getWalletInfo(wallet), contentHeader: "Request Rejected", contentDesc: wallet.errorMessage || "Connection permission is denied.", onConnect: () => walletManager.connect(wallet.info.name).then(close) }));
+    return (_jsx(ConnectModalStatus, { status: "Rejected", wallet: getWalletInfo(wallet), contentHeader: "Request Rejected", contentDesc: wallet.errorMessage || "Connection permission is denied.", onConnect: () => walletManager.connect(wallet.info.name, walletManager.currentChainName) }));
 };

package/esm/provider.js

@@ -1,21 +1,18 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useRef } from "react";
 import { createContext, useContext } from "react";
-import { WalletManager, WalletManagerState, } from "@interchain-kit/core";
+import { WalletManager, } from "@interchain-kit/core";
 import { WalletModalProvider } from "./modal";
+import { createInterchainStore } from "./store";
 const InterchainWalletContext = createContext(null);
 export const ChainProvider = ({ chains, assetLists, wallets, signerOptions, endpointOptions, children, }) => {
-    const [_, forceRender] = useState({});
-    const walletManager = useMemo(() => {
-        return new WalletManager(chains, assetLists, wallets, signerOptions, endpointOptions, () => forceRender({}));
-    }, []);
+    // const [_, forceRender] = useState({});
+    const walletManager = new WalletManager(chains, assetLists, wallets, signerOptions, endpointOptions);
+    const store = useRef(createInterchainStore(walletManager));
     useEffect(() => {
         walletManager.init();
     }, []);
-    if (walletManager.state === WalletManagerState.Initializing) {
-        return _jsx("div", { children: "Interchain Kit Initializing..." });
-    }
-    return (_jsx(InterchainWalletContext.Provider, { value: { walletManager }, children: _jsx(WalletModalProvider, { children: children }) }));
+    return (_jsx(InterchainWalletContext.Provider, { value: store.current, children: _jsx(WalletModalProvider, { children: children }) }));
 };
 export const useInterchainWalletContext = () => {
     const context = useContext(InterchainWalletContext);

package/esm/store/index.js

@@ -0,0 +1,163 @@
+import { WalletState } from "@interchain-kit/core";
+import { createStore } from "zustand";
+import { immer } from "zustand/middleware/immer";
+const immerSyncUp = (newWalletManager) => {
+    return (draft) => {
+        draft.chains = newWalletManager.chains;
+        draft.assetLists = newWalletManager.assetLists;
+        draft.wallets = newWalletManager.wallets;
+        draft.signerOptions = newWalletManager.signerOptions;
+        draft.endpointOptions = newWalletManager.endpointOptions;
+        draft.signerOptionMap = newWalletManager.signerOptionMap;
+        draft.endpointOptionsMap = newWalletManager.endpointOptionsMap;
+        draft.preferredSignTypeMap = newWalletManager.preferredSignTypeMap;
+    };
+};
+export const createInterchainStore = (walletManager) => {
+    const { chains, assetLists, wallets, signerOptions, endpointOptions } = walletManager;
+    // const walletManager = new WalletManager(chains, assetLists, wallets, signerOptions, endpointOptions)
+    const chainWalletState = [];
+    wallets.forEach(wallet => {
+        chains.forEach(chain => {
+            chainWalletState.push({
+                chainName: chain.chainName,
+                walletName: wallet.info.name,
+                walletState: null,
+                rpcEndpoint: "",
+                errorMessage: "",
+                signerOption: undefined,
+                account: undefined
+            });
+        });
+    });
+    return createStore(immer((set, get) => ({
+        chainWalletState,
+        currentWalletName: '',
+        currentChainName: '',
+        chains: [...walletManager.chains],
+        assetLists: [...walletManager.assetLists],
+        wallets: walletManager.wallets,
+        signerOptions: walletManager.signerOptions,
+        endpointOptions: walletManager.endpointOptions,
+        preferredSignTypeMap: { ...walletManager.preferredSignTypeMap },
+        signerOptionMap: { ...walletManager.signerOptionMap },
+        endpointOptionsMap: { ...walletManager.endpointOptionsMap },
+        updateChainWalletState: (walletName, chainName, data) => {
+            set(draft => {
+                let targetIndex = draft.chainWalletState.findIndex(cws => cws.walletName === walletName && cws.chainName === chainName);
+                draft.chainWalletState[targetIndex] = { ...draft.chainWalletState[targetIndex], ...data };
+            });
+        },
+        init: () => walletManager.init(),
+        setCurrentChainName: (chainName) => {
+            set(draft => { draft.currentChainName = chainName; });
+        },
+        setCurrentWalletName: (walletName) => {
+            set(draft => { draft.currentWalletName = walletName; });
+        },
+        getDraftChainWalletState: (state, walletName, chainName) => {
+            const targetIndex = state.chainWalletState.findIndex(cws => cws.walletName === walletName && cws.chainName === chainName);
+            return state.chainWalletState[targetIndex];
+        },
+        getChainWalletState: (walletName, chainName) => {
+            return get().chainWalletState.find(cws => cws.walletName === walletName && cws.chainName === chainName);
+        },
+        addChains: (chains, assetLists, signerOptions, endpointOptions) => {
+            walletManager.addChains(chains, assetLists, signerOptions, endpointOptions);
+            // console.log(walletManager.chains, walletManager.assetLists)
+            // set(immerSyncUp(walletManager))
+            // set(draft => {
+            //   draft.chains = walletManager.chains
+            // })
+            set(draft => {
+                chains.forEach(newChain => {
+                    const existChain = draft.chains.find(c => c.chainId === newChain.chainId);
+                    if (!existChain) {
+                        draft.chains.push(newChain);
+                        const assetList = assetLists.find(a => a.chainName === newChain.chainName);
+                        draft.assetLists.push(assetList);
+                    }
+                    draft.wallets.forEach(w => {
+                        draft.chainWalletState.push({
+                            chainName: newChain.chainName,
+                            walletName: w.info.name,
+                            walletState: WalletState.Disconnected,
+                            rpcEndpoint: "",
+                            errorMessage: "",
+                            signerOption: undefined,
+                            account: undefined
+                        });
+                    });
+                    draft.signerOptionMap[newChain.chainName] = signerOptions?.signing?.(newChain.chainName);
+                    draft.endpointOptionsMap[newChain.chainName] = endpointOptions?.endpoints?.[newChain.chainName];
+                });
+            });
+        },
+        connect: async (walletName, chainName) => {
+            get().updateChainWalletState(walletName, chainName, { walletState: WalletState.Connecting });
+            try {
+                await walletManager.connect(walletName, chainName);
+                set(draft => {
+                    draft.currentChainName = chainName;
+                    draft.currentWalletName = walletName;
+                });
+                get().updateChainWalletState(walletName, chainName, { walletState: WalletState.Connected });
+            }
+            catch (error) {
+                get().updateChainWalletState(walletName, chainName, { walletState: WalletState.Disconnected, errorMessage: error.message });
+            }
+        },
+        disconnect: async (walletName, chainName) => {
+            try {
+                await walletManager.disconnect(walletName, chainName);
+                get().updateChainWalletState(walletName, chainName, { walletState: WalletState.Disconnected, account: null });
+            }
+            catch (error) {
+            }
+        },
+        getAccount: async (walletName, chainName) => {
+            const account = await walletManager.getAccount(walletName, chainName);
+            get().updateChainWalletState(walletName, chainName, { account });
+            return account;
+        },
+        getRpcEndpoint: async (walletName, chainName) => {
+            const rpcEndpoint = await walletManager.getRpcEndpoint(walletName, chainName);
+            get().updateChainWalletState(walletName, chainName, { rpcEndpoint });
+            return rpcEndpoint;
+        },
+        getChainLogoUrl(chainName) {
+            return walletManager.getChainLogoUrl(chainName);
+        },
+        getChainByName(chainName) {
+            return walletManager.getChainByName(chainName);
+        },
+        getAssetListByName(chainName) {
+            return walletManager.getAssetListByName(chainName);
+        },
+        getDownloadLink(walletName) {
+            return walletManager.getDownloadLink(walletName);
+        },
+        getOfflineSigner(walletName, chainName) {
+            return walletManager.getOfflineSigner(walletName, chainName);
+        },
+        getPreferSignType(chainName) {
+            const result = walletManager.getPreferSignType(chainName);
+            set(immerSyncUp(walletManager));
+            return result;
+        },
+        getSignerOptions(chainName) {
+            const result = walletManager.getSignerOptions(chainName);
+            set(immerSyncUp(walletManager));
+            return result;
+        },
+        getWalletByName(walletName) {
+            return walletManager.getWalletByName(walletName);
+        },
+        getSigningClient(walletName, chainName) {
+            return walletManager.getSigningClient(walletName, chainName);
+        },
+        getEnv() {
+            return walletManager.getEnv();
+        },
+    })));
+};

package/esm/utils/wallet.js

@@ -1,8 +1,8 @@
 export const getWalletInfo = (wallet) => {
     return {
-        name: wallet.info?.name,
-        prettyName: wallet.info?.prettyName,
-        logo: wallet.info?.logo,
+        name: wallet.info.name,
+        prettyName: wallet.info.prettyName,
+        logo: wallet.info.logo,
         mobileDisabled: true,
     };
 };

package/hooks/index.d.ts

@@ -1,9 +1,3 @@
 export * from './useWalletManager';
-export * from './useCurrentWallet';
-export * from './useAccount';
 export * from './useChain';
-export * from './useConnect';
 export * from './useChainWallet';
-export * from './useConfig';
-export * from './useOfflineSigner';
-export * from './useRpcEndpoint';

package/hooks/index.js

@@ -15,11 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./useWalletManager"), exports);
-__exportStar(require("./useCurrentWallet"), exports);
-__exportStar(require("./useAccount"), exports);
 __exportStar(require("./useChain"), exports);
-__exportStar(require("./useConnect"), exports);
 __exportStar(require("./useChainWallet"), exports);
-__exportStar(require("./useConfig"), exports);
-__exportStar(require("./useOfflineSigner"), exports);
-__exportStar(require("./useRpcEndpoint"), exports);