@interchain-kit/react 0.2.207 → 0.2.211

package/store/index.d.ts

@@ -1,43 +1,2 @@
-import { AssetList, Chain } from "@chain-registry/v2-types";
-import { BaseWallet, EndpointOptions, SignerOptions, WalletAccount, WalletManager, WalletState } from "@interchain-kit/core";
-import { HttpEndpoint } from '@interchainjs/types';
-type ChainWalletState = {
-    chainName: string;
-    walletName: string;
-    walletState: WalletState;
-    rpcEndpoint: string | HttpEndpoint;
-    errorMessage: string;
-    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 {};
+export * from './chain-wallet';
+export * from './store';

package/store/index.js

@@ -1,218 +1,18 @@
 "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)
-    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: async () => {
-            const existedChainWalletStatesMap = new Map(get().chainWalletState.map(cws => [cws.walletName + cws.chainName, cws]));
-            wallets.forEach(wallet => {
-                chains.forEach(chain => {
-                    if (!existedChainWalletStatesMap.has(wallet.info.name + chain.chainName)) {
-                        set(draft => {
-                            draft.chainWalletState.push({
-                                chainName: chain.chainName,
-                                walletName: wallet.info.name,
-                                walletState: core_1.WalletState.Disconnected,
-                                rpcEndpoint: "",
-                                errorMessage: "",
-                                account: undefined
-                            });
-                        });
-                    }
-                });
-            });
-            const NotExistWallets = [];
-            await Promise.all(get().wallets.map(async (wallet) => {
-                try {
-                    await wallet.init();
-                }
-                catch (error) {
-                    if (error === core_1.clientNotExistError.message) {
-                        NotExistWallets.push(wallet.info.name);
-                    }
-                }
-            }));
-            set(draft => {
-                draft.chainWalletState = draft.chainWalletState.map(cws => {
-                    if (NotExistWallets.includes(cws.walletName)) {
-                        return { ...cws, walletState: core_1.WalletState.NotExist };
-                    }
-                    return cws;
-                });
-            });
-            // return 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: "",
-                                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');
-                }
-            };
-        },
-    }));
+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.createInterchainStore = createInterchainStore;
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./chain-wallet"), exports);
+__exportStar(require("./store"), exports);

package/store/store.d.ts

@@ -0,0 +1,43 @@
+import { AssetList, Chain } from "@chain-registry/v2-types";
+import { BaseWallet, EndpointOptions, SignerOptions, WalletAccount, WalletManager, WalletState } from "@interchain-kit/core";
+import { HttpEndpoint } from '@interchainjs/types';
+export type ChainWalletState = {
+    chainName: string;
+    walletName: string;
+    walletState: WalletState;
+    rpcEndpoint: string | HttpEndpoint;
+    errorMessage: string;
+    account: WalletAccount;
+};
+export interface InterchainStore extends WalletManager {
+    chainWalletState: ChainWalletState[];
+    currentWalletName: string;
+    currentChainName: string;
+    walletConnectQRCodeUri: 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;
+};

package/store/store.js

@@ -0,0 +1,238 @@
+"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)
+    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 },
+        walletConnectQRCodeUri: '',
+        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: async () => {
+            const existedChainWalletStatesMap = new Map(get().chainWalletState.map(cws => [cws.walletName + cws.chainName, cws]));
+            wallets.forEach(wallet => {
+                chains.forEach(chain => {
+                    if (!existedChainWalletStatesMap.has(wallet.info.name + chain.chainName)) {
+                        set(draft => {
+                            draft.chainWalletState.push({
+                                chainName: chain.chainName,
+                                walletName: wallet.info.name,
+                                walletState: core_1.WalletState.Disconnected,
+                                rpcEndpoint: "",
+                                errorMessage: "",
+                                account: undefined
+                            });
+                        });
+                    }
+                });
+            });
+            const NotExistWallets = [];
+            const ExistWallets = [];
+            await Promise.all(get().wallets.map(async (wallet) => {
+                try {
+                    await wallet.init();
+                    ExistWallets.push(wallet.info.name);
+                }
+                catch (error) {
+                    if (error === core_1.clientNotExistError) {
+                        NotExistWallets.push(wallet.info.name);
+                    }
+                }
+            }));
+            set(draft => {
+                draft.chainWalletState = draft.chainWalletState.map(cws => {
+                    if (NotExistWallets.includes(cws.walletName)) {
+                        return { ...cws, walletState: core_1.WalletState.NotExist };
+                    }
+                    return cws;
+                });
+                draft.chainWalletState = draft.chainWalletState.map(cws => {
+                    if (ExistWallets.includes(cws.walletName)) {
+                        return { ...cws, walletState: cws.walletState === core_1.WalletState.NotExist ? core_1.WalletState.Disconnected : cws.walletState };
+                    }
+                    return cws;
+                });
+            });
+        },
+        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: endpointOptions.endpoints[newChain.chainName]?.rpc?.[0] || '',
+                                errorMessage: "",
+                                account: undefined
+                            });
+                        });
+                    }
+                    draft.signerOptionMap[newChain.chainName] = signerOptions?.signing?.(newChain.chainName);
+                    draft.endpointOptionsMap[newChain.chainName] = endpointOptions?.endpoints?.[newChain.chainName];
+                });
+            });
+        },
+        connect: async (walletName, chainName) => {
+            const state = get().getChainWalletState(walletName, chainName)?.walletState;
+            if (state === core_1.WalletState.NotExist) {
+                return;
+            }
+            if (walletName === 'WalletConnect' && state === core_1.WalletState.Connected) {
+                return;
+            }
+            set(draft => {
+                draft.currentChainName = chainName;
+                draft.currentWalletName = walletName;
+                draft.walletConnectQRCodeUri = '';
+            });
+            get().updateChainWalletState(walletName, chainName, { walletState: core_1.WalletState.Connecting, errorMessage: '' });
+            try {
+                await walletManager.connect(walletName, chainName, (uri) => {
+                    set(draft => {
+                        draft.walletConnectQRCodeUri = uri;
+                    });
+                });
+                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/utils/wallet.d.ts

@@ -5,3 +5,29 @@ export declare const getWalletInfo: (wallet: BaseWallet) => {
     logo: string;
     mobileDisabled: boolean;
 };
+export declare const transferToWalletUISchema: (w: BaseWallet) => {
+    name: string;
+    prettyName: string;
+    logo: string;
+    mobileDisabled: boolean;
+    shape: "list";
+    originalWallet: {
+        session: import("@walletconnect/types").SessionTypes.Struct;
+        info: import("@interchain-kit/core").Wallet;
+        errorMessage: string;
+        walletState: import("@interchain-kit/core").WalletState;
+        events: import("events")<import("@interchain-kit/core").WalletEvents>;
+        chainMap: Map<import("@chain-registry/v2-types").Chain["chainId"], import("@chain-registry/v2-types").Chain>;
+        assetLists: import("@chain-registry/v2-types").AssetList[];
+        client: any;
+    };
+    subLogo: string;
+} | {
+    name: string;
+    prettyName: string;
+    logo: string;
+    mobileDisabled: boolean;
+    shape: "list";
+    originalWallet: BaseWallet;
+    subLogo?: undefined;
+};

package/utils/wallet.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWalletInfo = void 0;
+exports.transferToWalletUISchema = exports.getWalletInfo = void 0;
 const getWalletInfo = (wallet) => {
     return {
         name: wallet?.info?.name,
@@ -10,3 +10,28 @@ const getWalletInfo = (wallet) => {
     };
 };
 exports.getWalletInfo = getWalletInfo;
+const transferToWalletUISchema = (w) => {
+    if (w.info.mode === "wallet-connect") {
+        const wc = w;
+        if (wc.session) {
+            return {
+                name: wc.session?.peer.metadata?.name,
+                prettyName: `${wc.session?.peer.metadata?.name} - Mobile`,
+                logo: wc.session?.peer.metadata?.icons?.[0],
+                mobileDisabled: true,
+                shape: "list",
+                originalWallet: { ...w, session: wc.session },
+                subLogo: w.info.logo,
+            };
+        }
+    }
+    return {
+        name: w.info.name,
+        prettyName: w.info.prettyName,
+        logo: w.info.logo,
+        mobileDisabled: true,
+        shape: "list",
+        originalWallet: w,
+    };
+};
+exports.transferToWalletUISchema = transferToWalletUISchema;