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

package/store/index.js

@@ -0,0 +1,167 @@
+"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 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: null,
+                rpcEndpoint: "",
+                errorMessage: "",
+                signerOption: undefined,
+                account: undefined
+            });
+        });
+    });
+    return (0, zustand_1.createStore)((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: 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: 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) {
+                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 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();
+        },
+    })));
+};
+exports.createInterchainStore = createInterchainStore;

package/types/chain.d.ts

@@ -19,15 +19,7 @@ export type UseChainReturnType = {
     address: string;
     wallet: BaseWallet;
     rpcEndpoint: string | HttpEndpoint;
-    signingClient: SigningClient;
     getSigningClient: () => Promise<SigningClient>;
-    isRpcEndpointLoading: boolean;
-    isAccountLoading: boolean;
-    isSigningClientLoading: boolean;
-    isLoading: boolean;
-    getRpcEndpointError: Error | null;
-    getSigningClientError: Error | null;
-    getAccountError: Error | null;
 } & CosmosKitUseChainReturnType;
 export type UseChainWalletReturnType = Omit<UseChainReturnType, 'openView' | 'closeView'>;
 export type UseInterchainClientReturnType = {

package/utils/wallet.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWalletInfo = void 0;
 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/esm/hooks/useAccount.js

@@ -1,26 +0,0 @@
-import { WalletState } from "@interchain-kit/core";
-import { useWalletManager } from './useWalletManager';
-import { useEffect } from "react";
-export const useAccount = (chainName, walletName) => {
-    const walletManager = useWalletManager();
-    const chainAccount = walletManager.getWalletRepositoryByName(walletName)?.getChainAccountByName(chainName);
-    useEffect(() => {
-        if (chainAccount?.walletState === WalletState.Connected && chainName && walletName) {
-            chainAccount.getAccount();
-        }
-    }, [chainName, walletName, chainAccount?.walletState]);
-    if (chainAccount?.walletState === WalletState.Connected && chainName && walletName) {
-        return {
-            account: chainAccount?.account,
-            isLoading: chainAccount.getAccountState().loading,
-            error: chainAccount.getAccountState().error,
-            getAccount: () => chainAccount?.getAccount()
-        };
-    }
-    return {
-        account: undefined,
-        isLoading: false,
-        error: null,
-        getAccount: () => chainAccount?.getAccount()
-    };
-};

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/useCurrentChainWallet.js

@@ -1,12 +0,0 @@
-import { bindAllMethodsToContext } from "../utils/helpers";
-import { useWalletManager } from "./useWalletManager";
-export const useCurrentChainWallet = () => {
-    const walletManager = useWalletManager();
-    const { currentChainName, currentWalletName } = walletManager;
-    const chainWallet = walletManager.getWalletRepositoryByName(currentWalletName)?.getChainAccountByName(currentChainName);
-    console.log('chainWallet', currentChainName, currentWalletName, chainWallet);
-    if (chainWallet) {
-        return bindAllMethodsToContext(chainWallet);
-    }
-    return {};
-};

package/esm/hooks/useCurrentWallet.js

@@ -1,18 +0,0 @@
-import { useWalletManager } from "./useWalletManager";
-import { useWalletModal } from "../modal";
-import { bindAllMethodsToContext } from "../utils/helpers";
-export const useCurrentWallet = () => {
-    const walletManager = useWalletManager();
-    const { open } = useWalletModal();
-    // useEffect(() => {
-    //   if (!walletManager.currentWalletName && walletManager.state === WalletManagerState.Initialized) {
-    //     open()
-    //   }
-    // }, [walletManager.currentWalletName, walletManager.state])
-    const { currentWalletName, currentChainName, getWalletRepositoryByName } = walletManager;
-    const wallet = getWalletRepositoryByName(currentWalletName);
-    if (wallet) {
-        return bindAllMethodsToContext(wallet);
-    }
-    return {};
-};

package/esm/hooks/useInterchainClient.js

@@ -1,20 +0,0 @@
-import { useWalletManager } from './useWalletManager';
-import { WalletState } from '@interchain-kit/core';
-export const useInterchainClient = (chainName, walletName) => {
-    const walletManager = useWalletManager();
-    const chainAccount = walletManager.getWalletRepositoryByName(walletName)?.getChainAccountByName(chainName);
-    if (chainAccount && chainAccount.walletState === WalletState.Connected) {
-        return {
-            signingClient: chainAccount?.signingClient,
-            isLoading: chainAccount?.getSigningClientState().loading,
-            error: chainAccount?.getSigningClientState().error,
-            getSigningClient: () => chainAccount?.getSigningClient()
-        };
-    }
-    return {
-        signingClient: undefined,
-        isLoading: false,
-        error: undefined,
-        getSigningClient: () => chainAccount?.getSigningClient()
-    };
-};

package/esm/hooks/useOfflineSigner.js

@@ -1,20 +0,0 @@
-import { useWalletManager } from "./useWalletManager";
-import { WalletState } from "@interchain-kit/core";
-export const useOfflineSigner = (chainName, walletName) => {
-    const walletManager = useWalletManager();
-    const chainAccount = walletManager.getWalletRepositoryByName(walletName)?.getChainAccountByName(chainName);
-    if (chainAccount && chainAccount.walletState === WalletState.Connected) {
-        return {
-            offlineSigner: chainAccount?.offlineSigner,
-            isLoading: chainAccount?.getOfflineSignerState().loading,
-            error: chainAccount?.getOfflineSignerState().error,
-            getOfflineSigner: () => chainAccount?.getOfflineSigner()
-        };
-    }
-    return {
-        offlineSigner: undefined,
-        isLoading: false,
-        error: undefined,
-        getOfflineSigner: () => chainAccount?.getOfflineSigner()
-    };
-};

package/esm/hooks/useRpcEndpoint.js

@@ -1,26 +0,0 @@
-import { useEffect } from "react";
-import { useWalletManager } from "./useWalletManager";
-import { WalletState } from "@interchain-kit/core";
-export const useRpcEndpoint = (chainName, walletName) => {
-    const walletManager = useWalletManager();
-    const chainAccount = walletManager.getWalletRepositoryByName(walletName)?.getChainAccountByName(chainName);
-    useEffect(() => {
-        if (chainAccount?.walletState === WalletState.Connected) {
-            chainAccount.getRpcEndpoint();
-        }
-    }, [chainName, walletName, chainAccount?.walletState]);
-    if (chainAccount && chainAccount.walletState === WalletState.Connected) {
-        return {
-            rpcEndpoint: chainAccount?.rpcEndpoint,
-            isLoading: chainAccount?.getRpcEndpointState().loading,
-            error: chainAccount?.getRpcEndpointState().error,
-            getRpcEndpoint: () => chainAccount?.getRpcEndpoint()
-        };
-    }
-    return {
-        rpcEndpoint: undefined,
-        isLoading: false,
-        error: undefined,
-        getRpcEndpoint: () => chainAccount?.getRpcEndpoint()
-    };
-};

package/hooks/useAccount.d.ts

@@ -1,6 +0,0 @@
-export declare const useAccount: (chainName: string, walletName: string) => {
-    account: import("@interchain-kit/core").WalletAccount;
-    isLoading: boolean;
-    error: Error;
-    getAccount: () => Promise<import("@interchain-kit/core").WalletAccount>;
-};

package/hooks/useAccount.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useAccount = void 0;
-const core_1 = require("@interchain-kit/core");
-const useWalletManager_1 = require("./useWalletManager");
-const react_1 = require("react");
-const useAccount = (chainName, walletName) => {
-    const walletManager = (0, useWalletManager_1.useWalletManager)();
-    const chainAccount = walletManager.getWalletRepositoryByName(walletName)?.getChainAccountByName(chainName);
-    (0, react_1.useEffect)(() => {
-        if (chainAccount?.walletState === core_1.WalletState.Connected && chainName && walletName) {
-            chainAccount.getAccount();
-        }
-    }, [chainName, walletName, chainAccount?.walletState]);
-    if (chainAccount?.walletState === core_1.WalletState.Connected && chainName && walletName) {
-        return {
-            account: chainAccount?.account,
-            isLoading: chainAccount.getAccountState().loading,
-            error: chainAccount.getAccountState().error,
-            getAccount: () => chainAccount?.getAccount()
-        };
-    }
-    return {
-        account: undefined,
-        isLoading: false,
-        error: null,
-        getAccount: () => chainAccount?.getAccount()
-    };
-};
-exports.useAccount = useAccount;

package/hooks/useConfig.d.ts

@@ -1,8 +0,0 @@
-import { AssetList, Chain } from "@chain-registry/v2-types";
-import { EndpointOptions, SignerOptions } from "@interchain-kit/core";
-export declare const useConfig: () => {
-    updateChains: (chains: Chain[]) => Chain[];
-    updateAssetLists: (assetLists: AssetList[]) => AssetList[];
-    updateSignerOptions: (signerOptions: SignerOptions) => SignerOptions;
-    updateEndpoints: (endpointOptions: EndpointOptions) => EndpointOptions;
-};

package/hooks/useConfig.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useConfig = void 0;
-const useWalletManager_1 = require("./useWalletManager");
-const useConfig = () => {
-    const walletManager = (0, useWalletManager_1.useWalletManager)();
-    return {
-        updateChains: (chains) => walletManager.chains = chains,
-        updateAssetLists: (assetLists) => walletManager.assetLists = assetLists,
-        updateSignerOptions: (signerOptions) => walletManager.signerOptions = signerOptions,
-        updateEndpoints: (endpointOptions) => walletManager.endpointOptions = endpointOptions,
-    };
-};
-exports.useConfig = useConfig;

package/hooks/useConnect.d.ts

@@ -1 +0,0 @@
-export declare const useConnect: () => {};

package/hooks/useConnect.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useConnect = void 0;
-const useConnect = () => {
-    // const { walletManager } = useInterChainWalletContext()
-    // const activeWallet = useCurrentWallet()
-    // const account = useAccount()
-    // return {
-    //     connect: walletManager.connect,
-    //     isConnected: activeWallet.walletState === WalletState.Connected,
-    //     account
-    // }
-    return {};
-};
-exports.useConnect = useConnect;

package/hooks/useCurrentChainWallet.d.ts

@@ -1,2 +0,0 @@
-import { ChainAccount } from "@interchain-kit/core/chain-account";
-export declare const useCurrentChainWallet: () => ChainAccount;

package/hooks/useCurrentChainWallet.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useCurrentChainWallet = void 0;
-const helpers_1 = require("../utils/helpers");
-const useWalletManager_1 = require("./useWalletManager");
-const useCurrentChainWallet = () => {
-    const walletManager = (0, useWalletManager_1.useWalletManager)();
-    const { currentChainName, currentWalletName } = walletManager;
-    const chainWallet = walletManager.getWalletRepositoryByName(currentWalletName)?.getChainAccountByName(currentChainName);
-    console.log('chainWallet', currentChainName, currentWalletName, chainWallet);
-    if (chainWallet) {
-        return (0, helpers_1.bindAllMethodsToContext)(chainWallet);
-    }
-    return {};
-};
-exports.useCurrentChainWallet = useCurrentChainWallet;

package/hooks/useCurrentWallet.d.ts

@@ -1,2 +0,0 @@
-import { WalletRepository } from "@interchain-kit/core/wallet-repository";
-export declare const useCurrentWallet: () => WalletRepository;

package/hooks/useCurrentWallet.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useCurrentWallet = void 0;
-const useWalletManager_1 = require("./useWalletManager");
-const modal_1 = require("../modal");
-const helpers_1 = require("../utils/helpers");
-const useCurrentWallet = () => {
-    const walletManager = (0, useWalletManager_1.useWalletManager)();
-    const { open } = (0, modal_1.useWalletModal)();
-    // useEffect(() => {
-    //   if (!walletManager.currentWalletName && walletManager.state === WalletManagerState.Initialized) {
-    //     open()
-    //   }
-    // }, [walletManager.currentWalletName, walletManager.state])
-    const { currentWalletName, currentChainName, getWalletRepositoryByName } = walletManager;
-    const wallet = getWalletRepositoryByName(currentWalletName);
-    if (wallet) {
-        return (0, helpers_1.bindAllMethodsToContext)(wallet);
-    }
-    return {};
-};
-exports.useCurrentWallet = useCurrentWallet;

package/hooks/useInterchainClient.d.ts

@@ -1,6 +0,0 @@
-export declare const useInterchainClient: (chainName: string, walletName: string) => {
-    signingClient: import("@interchainjs/cosmos/signing-client").SigningClient;
-    isLoading: boolean;
-    error: Error;
-    getSigningClient: () => Promise<import("@interchainjs/cosmos/signing-client").SigningClient>;
-};

package/hooks/useInterchainClient.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useInterchainClient = void 0;
-const useWalletManager_1 = require("./useWalletManager");
-const core_1 = require("@interchain-kit/core");
-const useInterchainClient = (chainName, walletName) => {
-    const walletManager = (0, useWalletManager_1.useWalletManager)();
-    const chainAccount = walletManager.getWalletRepositoryByName(walletName)?.getChainAccountByName(chainName);
-    if (chainAccount && chainAccount.walletState === core_1.WalletState.Connected) {
-        return {
-            signingClient: chainAccount?.signingClient,
-            isLoading: chainAccount?.getSigningClientState().loading,
-            error: chainAccount?.getSigningClientState().error,
-            getSigningClient: () => chainAccount?.getSigningClient()
-        };
-    }
-    return {
-        signingClient: undefined,
-        isLoading: false,
-        error: undefined,
-        getSigningClient: () => chainAccount?.getSigningClient()
-    };
-};
-exports.useInterchainClient = useInterchainClient;

package/hooks/useOfflineSigner.d.ts

@@ -1,6 +0,0 @@
-export declare const useOfflineSigner: (chainName: string, walletName: string) => {
-    offlineSigner: import("@interchainjs/cosmos/types/wallet").OfflineSigner;
-    isLoading: boolean;
-    error: Error;
-    getOfflineSigner: () => import("@interchainjs/cosmos/types/wallet").ICosmosGenericOfflineSigner;
-};

package/hooks/useOfflineSigner.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useOfflineSigner = void 0;
-const useWalletManager_1 = require("./useWalletManager");
-const core_1 = require("@interchain-kit/core");
-const useOfflineSigner = (chainName, walletName) => {
-    const walletManager = (0, useWalletManager_1.useWalletManager)();
-    const chainAccount = walletManager.getWalletRepositoryByName(walletName)?.getChainAccountByName(chainName);
-    if (chainAccount && chainAccount.walletState === core_1.WalletState.Connected) {
-        return {
-            offlineSigner: chainAccount?.offlineSigner,
-            isLoading: chainAccount?.getOfflineSignerState().loading,
-            error: chainAccount?.getOfflineSignerState().error,
-            getOfflineSigner: () => chainAccount?.getOfflineSigner()
-        };
-    }
-    return {
-        offlineSigner: undefined,
-        isLoading: false,
-        error: undefined,
-        getOfflineSigner: () => chainAccount?.getOfflineSigner()
-    };
-};
-exports.useOfflineSigner = useOfflineSigner;

package/hooks/useRpcEndpoint.d.ts

@@ -1,6 +0,0 @@
-export declare const useRpcEndpoint: (chainName: string, walletName: string) => {
-    rpcEndpoint: string | import("@interchainjs/types").HttpEndpoint;
-    isLoading: boolean;
-    error: Error;
-    getRpcEndpoint: () => Promise<string | import("@interchainjs/types").HttpEndpoint>;
-};

package/hooks/useRpcEndpoint.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useRpcEndpoint = void 0;
-const react_1 = require("react");
-const useWalletManager_1 = require("./useWalletManager");
-const core_1 = require("@interchain-kit/core");
-const useRpcEndpoint = (chainName, walletName) => {
-    const walletManager = (0, useWalletManager_1.useWalletManager)();
-    const chainAccount = walletManager.getWalletRepositoryByName(walletName)?.getChainAccountByName(chainName);
-    (0, react_1.useEffect)(() => {
-        if (chainAccount?.walletState === core_1.WalletState.Connected) {
-            chainAccount.getRpcEndpoint();
-        }
-    }, [chainName, walletName, chainAccount?.walletState]);
-    if (chainAccount && chainAccount.walletState === core_1.WalletState.Connected) {
-        return {
-            rpcEndpoint: chainAccount?.rpcEndpoint,
-            isLoading: chainAccount?.getRpcEndpointState().loading,
-            error: chainAccount?.getRpcEndpointState().error,
-            getRpcEndpoint: () => chainAccount?.getRpcEndpoint()
-        };
-    }
-    return {
-        rpcEndpoint: undefined,
-        isLoading: false,
-        error: undefined,
-        getRpcEndpoint: () => chainAccount?.getRpcEndpoint()
-    };
-};
-exports.useRpcEndpoint = useRpcEndpoint;