@interchain-kit/react 0.0.1-beta.8 → 0.1.0

package/provider.js

@@ -1,28 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useInterChainWalletContext = exports.ChainProvider = void 0;
+exports.useInterchainWalletContext = exports.ChainProvider = void 0;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
 const react_2 = require("react");
-const core_1 = require("@interChain-kit/core");
+const core_1 = require("@interchain-kit/core");
 const modal_1 = require("./modal");
-const InterChainWalletContext = (0, react_2.createContext)(null);
-const ChainProvider = ({ chains, assetLists, wallets, signerOptions, endpointOptions, children }) => {
-    const [_, forceRender] = (0, react_1.useState)({});
-    const walletManager = (0, react_1.useMemo)(() => {
-        return new core_1.WalletManager(chains, assetLists, wallets, signerOptions, endpointOptions, () => forceRender({}));
-    }, []);
+const store_1 = require("./store");
+const InterchainWalletContext = (0, react_2.createContext)(null);
+const ChainProvider = ({ chains, assetLists, wallets, signerOptions, endpointOptions, children, }) => {
+    // const [_, forceRender] = useState({});
+    const walletManager = new core_1.WalletManager(chains, assetLists, wallets, signerOptions, endpointOptions);
+    const store = (0, react_1.useRef)((0, store_1.createInterchainStore)(walletManager));
     (0, react_1.useEffect)(() => {
         walletManager.init();
     }, []);
-    return ((0, jsx_runtime_1.jsx)(InterChainWalletContext.Provider, { value: { walletManager }, children: (0, jsx_runtime_1.jsx)(modal_1.WalletModalProvider, { children: children }) }));
+    return ((0, jsx_runtime_1.jsx)(InterchainWalletContext.Provider, { value: store.current, children: (0, jsx_runtime_1.jsx)(modal_1.WalletModalProvider, { children: children }) }));
 };
 exports.ChainProvider = ChainProvider;
-const useInterChainWalletContext = () => {
-    const context = (0, react_2.useContext)(InterChainWalletContext);
+const useInterchainWalletContext = () => {
+    const context = (0, react_2.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;
 };
-exports.useInterChainWalletContext = useInterChainWalletContext;
+exports.useInterchainWalletContext = useInterchainWalletContext;

package/store/chain-wallet.d.ts

@@ -0,0 +1,26 @@
+import { Chain, AssetList } from "@chain-registry/v2-types";
+import { BaseWallet, BroadcastMode, DirectSignDoc, SignOptions, SimpleAccount, WalletAccount } from "@interchain-kit/core";
+import { OfflineSigner, OfflineAminoSigner, OfflineDirectSigner, AminoSignResponse, StdSignature, DirectSignResponse } from "@interchainjs/cosmos/types/wallet";
+import { StdSignDoc } from "@interchainjs/types";
+export declare class ChainWallet<TWallet extends BaseWallet> extends BaseWallet {
+    originalWallet: TWallet;
+    connectWithState: TWallet['connect'];
+    disconnectWithState: TWallet['disconnect'];
+    getAccountWithState: TWallet['getAccount'];
+    constructor(originalWallet: TWallet, connectWithState: TWallet['connect'], disconnectWithState: TWallet['disconnect'], getAccountWithState: TWallet['getAccount']);
+    init(meta?: unknown): Promise<void>;
+    connect(chainId: string | string[]): Promise<void>;
+    disconnect(chainId: string | string[]): Promise<void>;
+    getAccount(chainId: string): Promise<WalletAccount>;
+    getAccounts(chainIds: string[]): Promise<WalletAccount[]>;
+    getSimpleAccount(chainId: string): Promise<SimpleAccount>;
+    getOfflineSigner(chainId: string): OfflineSigner;
+    getOfflineSignerAmino(chainId: string): OfflineAminoSigner;
+    getOfflineSignerDirect(chainId: string): OfflineDirectSigner;
+    signAmino(chainId: string, signer: string, signDoc: StdSignDoc, signOptions?: SignOptions): Promise<AminoSignResponse>;
+    signArbitrary(chainId: string, signer: string, data: string | Uint8Array): Promise<StdSignature>;
+    verifyArbitrary(chainId: string, signer: string, data: string | Uint8Array): Promise<boolean>;
+    signDirect(chainId: string, signer: string, signDoc: DirectSignDoc, signOptions?: SignOptions): Promise<DirectSignResponse>;
+    sendTx(chainId: string, tx: Uint8Array, mode: BroadcastMode): Promise<Uint8Array>;
+    addSuggestChain(chain: Chain, assetLists: AssetList[]): Promise<void>;
+}

package/store/chain-wallet.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainWallet = void 0;
+const core_1 = require("@interchain-kit/core");
+class ChainWallet extends core_1.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);
+    }
+}
+exports.ChainWallet = ChainWallet;

package/store/index.d.ts

@@ -0,0 +1,45 @@
+import { AssetList, Chain } from "@chain-registry/v2-types";
+import { BaseWallet, EndpointOptions, SignerOptions, WalletAccount, WalletManager, WalletState } from "@interchain-kit/core";
+import { SignerOptions as InterchainSignerOptions } from '@interchainjs/cosmos/types/signing-client';
+import { HttpEndpoint } from '@interchainjs/types';
+type ChainWalletState = {
+    chainName: string;
+    walletName: string;
+    walletState: WalletState;
+    rpcEndpoint: string | HttpEndpoint;
+    errorMessage: string;
+    signerOption: InterchainSignerOptions;
+    account: WalletAccount;
+};
+export interface InterchainStore extends WalletManager {
+    chainWalletState: ChainWalletState[];
+    currentWalletName: string;
+    currentChainName: string;
+    setCurrentChainName: (chainName: string) => void;
+    setCurrentWalletName: (walletName: string) => void;
+    getDraftChainWalletState: (state: InterchainStore, walletName: string, chainName: string) => ChainWalletState;
+    getChainWalletState: (walletName: string, chainName: string) => ChainWalletState | undefined;
+    updateChainWalletState: (walletName: string, chainName: string, data: Partial<ChainWalletState>) => void;
+}
+export type InterchainStoreData = {
+    chains: Chain[];
+    assetLists: AssetList[];
+    wallets: BaseWallet[];
+    signerOptions: SignerOptions;
+    endpointOptions: EndpointOptions;
+};
+export declare const createInterchainStore: (walletManager: WalletManager) => Omit<Omit<import("zustand").StoreApi<InterchainStore>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<InterchainStore, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: InterchainStore) => void) => () => void;
+        onFinishHydration: (fn: (state: InterchainStore) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<InterchainStore, unknown>>;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: InterchainStore | Partial<InterchainStore> | ((state: import("immer").WritableDraft<InterchainStore>) => void), shouldReplace?: false): void;
+    setState(nextStateOrUpdater: InterchainStore | ((state: import("immer").WritableDraft<InterchainStore>) => void), shouldReplace: true): void;
+};
+export {};

package/store/index.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInterchainStore = void 0;
+const core_1 = require("@interchain-kit/core");
+const zustand_1 = require("zustand");
+const immer_1 = require("zustand/middleware/immer");
+const middleware_1 = require("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;
+    };
+};
+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: core_1.WalletState.Disconnected,
+                rpcEndpoint: "",
+                errorMessage: "",
+                signerOption: undefined,
+                account: undefined
+            });
+        });
+    });
+    return (0, zustand_1.createStore)((0, middleware_1.persist)((0, immer_1.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: core_1.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: core_1.WalletState.Connecting });
+            try {
+                await walletManager.connect(walletName, chainName);
+                set(draft => {
+                    draft.currentChainName = chainName;
+                    draft.currentWalletName = walletName;
+                });
+                get().updateChainWalletState(walletName, chainName, { walletState: core_1.WalletState.Connected });
+            }
+            catch (error) {
+                if (error.message === 'Request rejected') {
+                    get().updateChainWalletState(walletName, chainName, { walletState: core_1.WalletState.Rejected, errorMessage: error.message });
+                    return;
+                }
+                get().updateChainWalletState(walletName, chainName, { walletState: core_1.WalletState.Disconnected, errorMessage: error.message });
+            }
+        },
+        disconnect: async (walletName, chainName) => {
+            try {
+                await walletManager.disconnect(walletName, chainName);
+                get().updateChainWalletState(walletName, chainName, { walletState: core_1.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: (0, middleware_1.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');
+                }
+            };
+        },
+    }));
+};
+exports.createInterchainStore = createInterchainStore;

package/types/chain.d.ts

@@ -1,31 +1,30 @@
 import { HttpEndpoint } from '@interchainjs/types';
-import { CosmWasmSigningClient } from 'interchainjs/cosmwasm-stargate';
-import { SigningClient } from 'interchainjs/signing-client';
-import { RpcQuery } from 'interchainjs/query/rpc';
-import { StargateSigningClient } from 'interchainjs/stargate';
 import { Chain, AssetList } from '@chain-registry/v2-types';
-import { BaseWallet, WalletState } from '@interchain-kit/core';
+import { WalletState } from '@interchain-kit/core';
+import { SigningClient } from './sign-client';
+import { ChainWallet } from '../store/chain-wallet';
 export type CosmosKitUseChainReturnType = {
     connect: () => void;
+    disconnect: () => void;
     openView: () => void;
     closeView: () => void;
     getRpcEndpoint: () => Promise<string | HttpEndpoint>;
     status: WalletState;
     username: string;
     message: string;
-    getSigningCosmWasmClient: () => Promise<CosmWasmSigningClient>;
-    getSigningStargateClient: () => Promise<StargateSigningClient>;
 };
 export type UseChainReturnType = {
+    logoUrl: string | undefined;
     chain: Chain;
     assetList: AssetList;
     address: string;
-    wallet: BaseWallet;
+    wallet: ChainWallet;
     rpcEndpoint: string | HttpEndpoint;
-    queryClient: RpcQuery;
-    signingClient: SigningClient;
-    signingStargateClient: StargateSigningClient;
-    signingCosmWasmClient: CosmWasmSigningClient;
+    getSigningClient: () => Promise<SigningClient>;
+} & CosmosKitUseChainReturnType;
+export type UseChainWalletReturnType = Omit<UseChainReturnType, 'openView' | 'closeView'>;
+export type UseInterchainClientReturnType = {
+    signingClient: SigningClient | null;
+    error: string | unknown | null;
     isLoading: boolean;
-    error: unknown;
 };

package/types/index.d.ts

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

package/types/index.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./wallet"), exports);
+__exportStar(require("./sign-client"), exports);

package/types/sign-client.d.ts

@@ -0,0 +1,2 @@
+import { WalletManager } from "@interchain-kit/core";
+export type SigningClient = Awaited<ReturnType<WalletManager['getSigningClient']>>;

package/utils/index.d.ts

@@ -1,7 +1 @@
-import { BaseWallet } from "@interChain-kit/core";
-export declare const getWalletInfo: (wallet: BaseWallet) => {
-    name: string;
-    prettyName: string;
-    logo: string;
-    mobileDisabled: boolean;
-};
+export * from './wallet';

package/utils/index.js

@@ -1,12 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWalletInfo = void 0;
-const getWalletInfo = (wallet) => {
-    return {
-        name: wallet.option.name,
-        prettyName: wallet.option.prettyName,
-        logo: wallet.option.logo,
-        mobileDisabled: true,
-    };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-exports.getWalletInfo = getWalletInfo;
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./wallet"), exports);

package/utils/wallet.d.ts

@@ -1 +1,7 @@
-export * from './wallet';
+import { BaseWallet } from "@interchain-kit/core";
+export declare const getWalletInfo: (wallet: BaseWallet) => {
+    name: string;
+    prettyName: string;
+    logo: string;
+    mobileDisabled: boolean;
+};

package/utils/wallet.js

@@ -1,17 +1,12 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./wallet"), exports);
+exports.getWalletInfo = void 0;
+const getWalletInfo = (wallet) => {
+    return {
+        name: wallet?.info?.name,
+        prettyName: wallet?.info?.prettyName,
+        logo: wallet?.info?.logo,
+        mobileDisabled: true,
+    };
+};
+exports.getWalletInfo = getWalletInfo;

package/esm/hooks/useAccount.js

@@ -1,28 +0,0 @@
-import { useEffect, useState } from "react";
-import { useWalletManager } from './useWalletManager';
-export const useAccount = (chainName, walletName) => {
-    const walletManager = useWalletManager();
-    const wallet = walletManager.wallets.find(w => w.option.name === walletName);
-    const [account, setAccount] = useState(null);
-    const chain = walletManager.chains.find(c => c.chainName === chainName);
-    const getAccount = async () => {
-        if (wallet && chain) {
-            if (wallet.walletState === "Connected" /* WalletState.Connected */) {
-                const account = await wallet.getAccount(chain.chainId);
-                setAccount(account);
-            }
-            if (wallet.walletState === "Disconnected" /* WalletState.Disconnected */) {
-                setAccount(null);
-            }
-        }
-    };
-    useEffect(() => {
-        if (wallet) {
-            wallet.events.on('keystoreChange', getAccount);
-        }
-    }, [wallet]);
-    useEffect(() => {
-        getAccount();
-    }, [wallet, chainName, wallet?.walletState]);
-    return account;
-};

package/esm/hooks/useActiveWallet.js

@@ -1,13 +0,0 @@
-import { useEffect } from "react";
-import { useWalletManager } from "./useWalletManager";
-import { useWalletModal } from "../modal";
-export const useActiveWallet = () => {
-    const walletManager = useWalletManager();
-    const { open } = useWalletModal();
-    useEffect(() => {
-        if (!walletManager.activeWalletName) {
-            open();
-        }
-    }, [walletManager.activeWalletName]);
-    return walletManager.getActiveWallet();
-};

package/esm/hooks/useConfig.js

@@ -1,10 +0,0 @@
-import { useWalletManager } from "./useWalletManager";
-export const useConfig = () => {
-    const walletManager = useWalletManager();
-    return {
-        updateChains: (chains) => walletManager.chains = chains,
-        updateAssetLists: (assetLists) => walletManager.assetLists = assetLists,
-        updateSignerOptions: (signerOptions) => walletManager.signerOptions = signerOptions,
-        updateEndpoints: (endpointOptions) => walletManager.endpointOptions = endpointOptions,
-    };
-};

package/esm/hooks/useConnect.js

@@ -1,11 +0,0 @@
-export const useConnect = () => {
-    // const { walletManager } = useInterChainWalletContext()
-    // const activeWallet = useCurrentWallet()
-    // const account = useAccount()
-    // return {
-    //     connect: walletManager.connect,
-    //     isConnected: activeWallet.walletState === WalletState.Connected,
-    //     account
-    // }
-    return {};
-};

package/esm/hooks/useInterchainClient.js

@@ -1,52 +0,0 @@
-import { useEffect, useState } from "react";
-import { useWalletManager } from './useWalletManager';
-import { useAccount } from './useAccount';
-export const useInterchainClient = (chainName, walletName) => {
-    const [rpcEndpoint, setRpcEndpoint] = useState();
-    const [signingClient, setSigningClient] = useState(null);
-    const [queryClient, setQueryClient] = useState(null);
-    const [signingStargateClient, setSigningStargateClient] = useState(null);
-    const [signingCosmWasmClient, setSigningCosmWasmClient] = useState(null);
-    const [error, setError] = useState(null);
-    const [isLoading, setIsLoading] = useState(false);
-    const walletManager = useWalletManager();
-    const account = useAccount(chainName, walletName);
-    const wallet = walletManager.wallets.find((w) => w.option.name === walletName);
-    const chainToShow = walletManager.chains.find((c) => c.chainName === chainName);
-    const initialize = async () => {
-        if (wallet && chainToShow && wallet?.walletState === "Connected" /* WalletState.Connected */) {
-            try {
-                setIsLoading(true);
-                const rpcEndpoint = await walletManager.getRpcEndpoint(wallet, chainName);
-                setRpcEndpoint(rpcEndpoint);
-                const clientFactory = await walletManager.createClientFactory(wallet, chainName);
-                const queryClient = await clientFactory.getClient();
-                setQueryClient(queryClient);
-                const signingClient = await clientFactory.getSigningClient();
-                setSigningClient(signingClient);
-                const signingStargateClient = await clientFactory.getSigningStargateClient(chainToShow.bech32Prefix);
-                setSigningStargateClient(signingStargateClient);
-                const signingCosmwasmClient = await clientFactory.getSigningCosmwasmClient();
-                setSigningCosmWasmClient(signingCosmwasmClient);
-            }
-            catch (error) {
-                setError(error);
-            }
-            finally {
-                setIsLoading(false);
-            }
-        }
-    };
-    useEffect(() => {
-        initialize();
-    }, [chainName, walletName, account, wallet?.walletState]);
-    return {
-        rpcEndpoint,
-        signingClient,
-        queryClient,
-        signingStargateClient,
-        signingCosmWasmClient,
-        error,
-        isLoading
-    };
-};

package/esm/hooks/useOfflineSigner.js

@@ -1,15 +0,0 @@
-import { useEffect, useState } from "react";
-import { useWalletManager } from "./useWalletManager";
-export const useOfflineSigner = (chainName, walletName) => {
-    const walletManager = useWalletManager();
-    const wallet = walletManager.wallets.find((w) => w.option.name === walletName);
-    const [offlineSigner, setOfflineSigner] = useState(null);
-    useEffect(() => {
-        if (wallet && chainName) {
-            setOfflineSigner(walletManager.getOfflineSigner(wallet, chainName));
-        }
-    }, [wallet, chainName]);
-    return {
-        offlineSigner
-    };
-};

package/hooks/useAccount.d.ts

@@ -1,2 +0,0 @@
-import { WalletAccount } from "@interChain-kit/core";
-export declare const useAccount: (chainName: string, walletName: string) => WalletAccount | null;