@interchain-kit/react 0.0.1-beta.9 → 0.2.0

package/esm/modal/views/NotExist.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ConnectModalHead, ConnectModalStatus } from "@interchain-ui/react";
+import { useWalletManager } from "../../hooks"; // replace with the actual path
+import { useWalletModal } from "../provider";
+import { useMemo } from "react";
+import { FaAndroid } from "@react-icons/all-files/fa/FaAndroid";
+import { GoDesktopDownload } from "@react-icons/all-files/go/GoDesktopDownload";
+import { GrFirefox } from "@react-icons/all-files/gr/GrFirefox";
+import { RiAppStoreFill } from "@react-icons/all-files/ri/RiAppStoreFill";
+import { RiChromeFill } from "@react-icons/all-files/ri/RiChromeFill";
+export const NotExistHeader = ({ wallet, onBack, }) => {
+    const { close } = useWalletModal();
+    return (_jsx(ConnectModalHead, { title: wallet?.info?.prettyName || "", hasBackButton: true, onClose: close, onBack: onBack, closeButtonProps: { onClick: close } }));
+};
+export const NotExistContent = ({ wallet }) => {
+    const walletManager = useWalletManager();
+    const downloadLink = useMemo(() => {
+        return walletManager.getDownloadLink(wallet.info.name);
+    }, [wallet?.info?.name]);
+    const onInstall = () => {
+        if (downloadLink) {
+            window.open(downloadLink.link, "_blank");
+        }
+    };
+    const IconComp = getIcon(walletManager.getEnv());
+    return (_jsx(ConnectModalStatus, { status: "NotExist", wallet: {
+            name: wallet?.info?.prettyName,
+            logo: typeof wallet?.info?.logo === "string" ? wallet?.info?.logo : "",
+            mobileDisabled: true,
+        }, contentHeader: `${wallet?.info?.prettyName} Not Installed`, contentDesc: true
+            ? `If ${wallet?.info?.prettyName.toLowerCase()} is installed on your device, please refresh this page or follow the browser instruction.`
+            : `Download link not provided. Try searching it or consulting the developer team.`, onInstall: onInstall, installIcon: _jsx(IconComp, {}), disableInstall: downloadLink === null }));
+};
+function getIcon(env) {
+    if (env?.browser === "chrome")
+        return RiChromeFill;
+    if (env?.browser === "firefox")
+        return GrFirefox;
+    if (env?.os === "android")
+        return FaAndroid;
+    if (env?.os === "ios")
+        return RiAppStoreFill;
+    return GoDesktopDownload;
+}

package/esm/modal/views/QRCode.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ConnectModalHead, ConnectModalQRCode } from "@interchain-ui/react";
+import { useWalletManager } from "../../hooks";
+import { useWalletModal } from "../provider";
+export const QRCodeHeader = ({ onBack }) => {
+    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 disconnect(currentWallet?.info?.name || "", currentChainName);
+            onBack();
+        }, closeButtonProps: { onClick: close } }));
+};
+export const QRCodeContent = () => {
+    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: () => connect(currentWallet?.info?.name || "", currentChainName) }));
+};

package/esm/modal/views/Reject.js

@@ -1,16 +1,11 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { ConnectModalHead, ConnectModalStatus } from "@interchain-ui/react";
 import { useWalletModal } from "../provider";
-import { useActiveWallet, useWalletManager } from "../../hooks";
 import { getWalletInfo } from "../../utils";
-export const RejectHeader = ({ onBack }) => {
+export const RejectHeader = ({ wallet, onBack, }) => {
     const { close } = useWalletModal();
-    const activeWallet = useActiveWallet();
-    return (_jsx(ConnectModalHead, { title: activeWallet.option.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 RejectContent = () => {
-    const activeWallet = useActiveWallet();
-    const walletManager = useWalletManager();
-    const { close } = useWalletModal();
-    return (_jsx(ConnectModalStatus, { status: "Rejected", wallet: getWalletInfo(activeWallet), contentHeader: 'Request Rejected', contentDesc: activeWallet.errorMessage || 'Connection permission is denied.', onConnect: () => walletManager.connect(activeWallet.option.name).then(close) }));
+export const RejectContent = ({ wallet, onReconnect, }) => {
+    return (_jsx(ConnectModalStatus, { status: "Rejected", wallet: getWalletInfo(wallet), contentHeader: "Request Rejected", contentDesc: wallet.errorMessage || "Connection permission is denied.", onConnect: onReconnect }));
 };

package/esm/modal/views/WalletList.js

@@ -6,27 +6,35 @@ export const WalletListHeader = () => {
     const { close } = useWalletModal();
     return (_jsx(ConnectModalHead, { title: "Select your wallet", hasBackButton: false, onClose: close, closeButtonProps: { onClick: close } }));
 };
-export const WalletListContent = () => {
+export const WalletListContent = ({ onSelectWallet, }) => {
     const walletManager = useWalletManager();
-    const { close } = useWalletModal();
     const wallets = walletManager.wallets.map((w) => {
-        return ({
-            name: w.option.name,
-            prettyName: w.option.prettyName,
-            logo: w.option.logo,
+        return {
+            name: w.info.name,
+            prettyName: w.info.prettyName,
+            logo: w.info.logo,
             mobileDisabled: true,
-            shape: 'list',
-            originalWallet: w
-        });
+            shape: "list",
+            originalWallet: {
+                ...w,
+                pairing: null,
+            },
+        };
     });
-    const onWalletClick = async (wallet) => {
-        try {
-            await walletManager.connect(wallet.option.name);
-            close();
-        }
-        catch (error) {
-            console.log(error);
-        }
-    };
-    return _jsx(ConnectModalWalletList, { wallets: wallets, onWalletItemClick: onWalletClick });
+    const wcWallet = walletManager.wallets.find((w) => w.info.mode === "wallet-connect");
+    if (wcWallet) {
+        const activePairings = wcWallet.getActivePairing();
+        activePairings.forEach((pairing) => {
+            wallets.push({
+                name: pairing?.peerMetadata?.name,
+                prettyName: pairing?.peerMetadata?.name,
+                logo: pairing?.peerMetadata?.icons?.[0],
+                mobileDisabled: true,
+                shape: "list",
+                originalWallet: { ...wcWallet, pairing },
+                subLogo: wcWallet.info.logo,
+            });
+        });
+    }
+    return (_jsx(ConnectModalWalletList, { wallets: wallets, onWalletItemClick: onSelectWallet }));
 };

package/esm/modal/views/index.js

@@ -2,3 +2,5 @@ export * from './Connecting';
 export * from './WalletList';
 export * from './Connected';
 export * from './Reject';
+export * from './QRCode';
+export * from './NotExist';

package/esm/provider.js

@@ -1,23 +1,23 @@
 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 } from '@interChain-kit/core';
-import { WalletModalProvider } from './modal';
-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({}));
-    }, []);
+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 = new WalletManager(chains, assetLists, wallets, signerOptions, endpointOptions);
+    const store = useRef(createInterchainStore(walletManager));
     useEffect(() => {
         walletManager.init();
     }, []);
-    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);
+export const useInterchainWalletContext = () => {
+    const context = useContext(InterchainWalletContext);
     if (!context) {
-        throw new Error('useInterChainWalletContext must be used within a InterChainProvider');
+        throw new Error("useInterChainWalletContext must be used within a InterChainProvider");
     }
     return context;
 };

package/esm/store/chain-wallet.js

@@ -0,0 +1,59 @@
+import { BaseWallet } from "@interchain-kit/core";
+export class ChainWallet extends BaseWallet {
+    originalWallet;
+    connectWithState;
+    disconnectWithState;
+    getAccountWithState;
+    constructor(originalWallet, connectWithState, disconnectWithState, getAccountWithState) {
+        super(originalWallet?.info);
+        this.originalWallet = originalWallet;
+        this.connectWithState = connectWithState;
+        this.disconnectWithState = disconnectWithState;
+        this.getAccountWithState = getAccountWithState;
+    }
+    async init(meta) {
+        return this.originalWallet.init(meta);
+    }
+    async connect(chainId) {
+        return this.connectWithState(chainId);
+    }
+    async disconnect(chainId) {
+        return this.disconnectWithState(chainId);
+    }
+    async getAccount(chainId) {
+        return this.getAccountWithState(chainId);
+    }
+    async getAccounts(chainIds) {
+        return this.originalWallet.getAccounts(chainIds);
+    }
+    async getSimpleAccount(chainId) {
+        return this.originalWallet.getSimpleAccount(chainId);
+    }
+    getOfflineSigner(chainId) {
+        return this.originalWallet.getOfflineSigner(chainId);
+    }
+    getOfflineSignerAmino(chainId) {
+        return this.originalWallet.getOfflineSignerAmino(chainId);
+    }
+    getOfflineSignerDirect(chainId) {
+        return this.originalWallet.getOfflineSignerDirect(chainId);
+    }
+    async signAmino(chainId, signer, signDoc, signOptions) {
+        return this.originalWallet.signAmino(chainId, signer, signDoc, signOptions);
+    }
+    async signArbitrary(chainId, signer, data) {
+        return this.originalWallet.signArbitrary(chainId, signer, data);
+    }
+    async verifyArbitrary(chainId, signer, data) {
+        return this.originalWallet.verifyArbitrary(chainId, signer, data);
+    }
+    async signDirect(chainId, signer, signDoc, signOptions) {
+        return this.originalWallet.signDirect(chainId, signer, signDoc, signOptions);
+    }
+    async sendTx(chainId, tx, mode) {
+        return this.originalWallet.sendTx(chainId, tx, mode);
+    }
+    async addSuggestChain(chain, assetLists) {
+        return this.originalWallet.addSuggestChain(chain, assetLists);
+    }
+}

package/esm/store/index.js

@@ -0,0 +1,191 @@
+import { WalletState } from "@interchain-kit/core";
+import { createStore } from "zustand";
+import { immer } from "zustand/middleware/immer";
+import { persist, createJSONStorage } from 'zustand/middleware';
+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: WalletState.Disconnected,
+                rpcEndpoint: "",
+                errorMessage: "",
+                signerOption: undefined,
+                account: undefined
+            });
+        });
+    });
+    return createStore(persist(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: signerOptions?.signing?.(newChain.chainName),
+                                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) {
+                if (error.message === 'Request rejected') {
+                    get().updateChainWalletState(walletName, chainName, { walletState: WalletState.Rejected, errorMessage: error.message });
+                    return;
+                }
+                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 exist = get().getChainWalletState(walletName, chainName).rpcEndpoint;
+            if (exist)
+                return exist;
+            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();
+        },
+    })), {
+        name: 'interchain-kit-store',
+        storage: createJSONStorage(() => localStorage),
+        partialize: state => ({
+            chainWalletState: state.chainWalletState,
+            currentWalletName: state.currentWalletName,
+            currentChainName: state.currentChainName
+        }),
+        onRehydrateStorage: (state) => {
+            console.log('interchain-kit store hydration starts');
+            // optional
+            return (state, error) => {
+                if (error) {
+                    console.log('an error happened during hydration', error);
+                }
+                else {
+                    console.log('interchain-kit store hydration finished');
+                }
+            };
+        },
+    }));
+};

package/esm/types/index.js

@@ -1 +1 @@
-export * from './wallet';
+export * from './sign-client';

package/esm/utils/index.js

@@ -1,8 +1 @@
-export const getWalletInfo = (wallet) => {
-    return {
-        name: wallet.option.name,
-        prettyName: wallet.option.prettyName,
-        logo: wallet.option.logo,
-        mobileDisabled: true,
-    };
-};
+export * from './wallet';

package/esm/utils/wallet.js

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

package/hooks/index.d.ts

@@ -1,7 +1,3 @@
 export * from './useWalletManager';
-export * from './useActiveWallet';
-export * from './useAccount';
 export * from './useChain';
-export * from './useConnect';
 export * from './useChainWallet';
-export * from './useConfig';

package/hooks/index.js

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

package/hooks/useChain.d.ts

@@ -1,2 +1,2 @@
-import { CosmosKitUseChainReturnType, UseChainReturnType } from '../types/chain';
-export declare const useChain: (chainName: string) => UseChainReturnType & CosmosKitUseChainReturnType;
+import { UseChainReturnType } from '../types/chain';
+export declare const useChain: (chainName: string) => UseChainReturnType;

package/hooks/useChain.js

@@ -1,46 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useChain = void 0;
-const useWalletManager_1 = require("./useWalletManager");
-const useAccount_1 = require("./useAccount");
-const useActiveWallet_1 = require("./useActiveWallet");
-const useInterchainClient_1 = require("./useInterchainClient");
 const modal_1 = require("../modal");
-const core_1 = require("@interChain-kit/core");
+const useWalletManager_1 = require("./useWalletManager");
+const core_1 = require("@interchain-kit/core");
+const chain_wallet_1 = require("../store/chain-wallet");
 const useChain = (chainName) => {
-    const walletManager = (0, useWalletManager_1.useWalletManager)();
-    const chainToShow = walletManager.chains.find((c) => c.chainName === chainName);
-    const assetList = walletManager.assetLists.find((a) => a.chainName === chainName);
-    const activeWallet = (0, useActiveWallet_1.useActiveWallet)();
-    const account = (0, useAccount_1.useAccount)(chainName, activeWallet?.option?.name);
-    const interchainClient = (0, useInterchainClient_1.useInterchainClient)(chainName, activeWallet?.option?.name);
-    if (!chainToShow) {
+    const { assetLists, currentWalletName, disconnect, setCurrentChainName, getChainByName, getWalletByName, getChainWalletState, getChainLogoUrl, connect, getSigningClient, getRpcEndpoint, getAccount } = (0, useWalletManager_1.useWalletManager)();
+    const chain = getChainByName(chainName);
+    if (!chain) {
         throw new core_1.ChainNameNotExist(chainName);
     }
+    const assetList = assetLists.find(a => a.chainName === chainName);
+    const wallet = getWalletByName(currentWalletName);
+    const chainWalletStateToShow = getChainWalletState(currentWalletName, chainName);
     const { open, close } = (0, modal_1.useWalletModal)();
-    const cosmosKitUserChainReturnType = {
+    return {
+        //for migration cosmos kit
         connect: () => {
-            if (activeWallet) {
-                return;
-            }
+            setCurrentChainName(chainName);
+            open();
+        },
+        disconnect: async () => disconnect(currentWalletName, chainName),
+        openView: () => {
+            setCurrentChainName(chainName);
             open();
         },
-        openView: open,
         closeView: close,
-        getRpcEndpoint: () => walletManager.getRpcEndpoint(activeWallet, chainName),
-        status: activeWallet?.walletState,
-        username: account?.username,
-        message: activeWallet?.errorMessage,
-        getSigningCosmWasmClient: () => walletManager.createClientFactory(activeWallet, chainName).then((c) => c.getSigningCosmwasmClient()),
-        getSigningStargateClient: () => walletManager.createClientFactory(activeWallet, chainName).then((c) => c.getSigningStargateClient())
-    };
-    return {
-        chain: chainToShow,
+        getRpcEndpoint: () => getRpcEndpoint(currentWalletName, chainName),
+        status: chainWalletStateToShow?.walletState,
+        username: chainWalletStateToShow?.account?.username,
+        message: chainWalletStateToShow?.errorMessage,
+        // new api
+        logoUrl: getChainLogoUrl(chainName),
+        chain,
         assetList,
-        address: account?.address,
-        wallet: activeWallet,
-        ...cosmosKitUserChainReturnType, //for migration cosmos kit
-        ...interchainClient
+        address: chainWalletStateToShow?.account?.address,
+        wallet: new chain_wallet_1.ChainWallet(wallet, () => connect(currentWalletName, chainName), () => disconnect(currentWalletName, chainName), () => getAccount(currentWalletName, chainName)),
+        rpcEndpoint: chainWalletStateToShow?.rpcEndpoint,
+        getSigningClient: () => getSigningClient(currentWalletName, chainName),
     };
 };
 exports.useChain = useChain;

package/hooks/useChainWallet.d.ts

@@ -1,2 +1,2 @@
-import { UseChainReturnType } from "../types/chain";
-export declare const useChainWallet: (chainName: string, walletName: string) => UseChainReturnType;
+import { UseChainWalletReturnType } from "../types/chain";
+export declare const useChainWallet: (chainName: string, walletName: string) => UseChainWalletReturnType;

package/hooks/useChainWallet.js

@@ -2,21 +2,34 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useChainWallet = void 0;
 const useWalletManager_1 = require("./useWalletManager");
-const useAccount_1 = require("./useAccount");
-const useInterchainClient_1 = require("./useInterchainClient");
+const chain_wallet_1 = require("../store/chain-wallet");
 const useChainWallet = (chainName, walletName) => {
-    const walletManager = (0, useWalletManager_1.useWalletManager)();
-    const chainToShow = walletManager.chains.find((c) => c.chainName === chainName);
-    const assetList = walletManager.assetLists.find((a) => a.chainName === chainName);
-    const wallet = walletManager.wallets.find((w) => w.option.name === walletName);
-    const account = (0, useAccount_1.useAccount)(chainName, walletName);
-    const interchainClient = (0, useInterchainClient_1.useInterchainClient)(chainName, walletName);
+    const { assetLists, disconnect, setCurrentChainName, setCurrentWalletName, getChainByName, getWalletByName, getChainWalletState, getChainLogoUrl, connect, getSigningClient, getRpcEndpoint, getAccount } = (0, useWalletManager_1.useWalletManager)();
+    const chain = getChainByName(chainName);
+    const wallet = getWalletByName(walletName);
+    const assetList = assetLists.find(a => a.chainName === chainName);
+    const chainWalletStateToShow = getChainWalletState(walletName, chainName);
     return {
-        chain: chainToShow,
+        //for migration cosmos kit
+        connect: async () => {
+            await connect(walletName, chainName);
+            setCurrentWalletName(walletName);
+            setCurrentChainName(chainName);
+            await getAccount(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: account?.address,
-        wallet,
-        ...interchainClient
+        address: chainWalletStateToShow?.account?.address,
+        wallet: new chain_wallet_1.ChainWallet(wallet, () => connect(walletName, chainName), () => disconnect(walletName, chainName), () => getAccount(walletName, chainName)),
+        rpcEndpoint: chainWalletStateToShow?.rpcEndpoint,
+        getSigningClient: () => getSigningClient(walletName, chainName),
     };
 };
 exports.useChainWallet = useChainWallet;

package/hooks/useWalletManager.d.ts

@@ -1,2 +1 @@
-import { WalletManager } from '@interchain-kit/core';
-export declare const useWalletManager: () => WalletManager;
+export declare const useWalletManager: () => import("..").InterchainStore;

package/hooks/useWalletManager.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useWalletManager = void 0;
 const provider_1 = require("../provider");
+const zustand_1 = require("zustand");
 const useWalletManager = () => {
-    const { walletManager } = (0, provider_1.useInterChainWalletContext)();
-    return walletManager;
+    const store = (0, provider_1.useInterchainWalletContext)();
+    return (0, zustand_1.useStore)(store);
 };
 exports.useWalletManager = useWalletManager;

package/index.d.ts

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