@interchain-kit/store 0.3.47

package/wallet-manager/wallet-manager-store.d.ts

@@ -0,0 +1,58 @@
+import { AssetList, Chain } from '@chain-registry/types';
+import { BaseWallet, ChainName, CosmosSigningOptions, DeviceType, DownloadInfo, EndpointOptions, Endpoints, OS, SignerOptions, SignType, WalletAccount, WalletManager } from '@interchain-kit/core';
+import { ISigningClient } from '@interchainjs/cosmos';
+import { HttpEndpoint } from '@interchainjs/types';
+import { InterchainStore } from '../store';
+import { ChainWalletState, InterchainStoreType } from '../types';
+import { LocalStorage } from '../utils/local-storage';
+import { WalletStore } from './wallet-store';
+export declare class WalletManagerStore implements WalletManager {
+    wallets: WalletStore[];
+    store: InterchainStore;
+    walletManager: WalletManager;
+    chains: Chain[];
+    assetLists: AssetList[];
+    localStorage: LocalStorage;
+    constructor(chains: Chain[], assetLists: AssetList[], wallets: BaseWallet[], signerOptions?: SignerOptions, endpointOptions?: EndpointOptions);
+    init(): Promise<void>;
+    restore(): void;
+    subscribe(callback: (state: InterchainStoreType) => void): () => void;
+    getState(): InterchainStoreType;
+    get walletConnectQRCodeUri(): string;
+    get isReady(): boolean;
+    get currentWalletName(): string;
+    get currentChainName(): string;
+    setCurrentWalletName(walletName: string): void;
+    setCurrentChainName(chainName: string): void;
+    getChainById(chainId: string): Chain | undefined;
+    getChainWalletState(walletName: string, chainName: string): ChainWalletState | undefined;
+    updateChainWalletState(walletName: string, chainName: string, data: Partial<ChainWalletState>): void;
+    getChainWalletByName(walletName: string, chainName: Chain['chainName']): import("./chain-wallet-store").ChainWalletStore;
+    get modalIsOpen(): boolean;
+    openModal(): void;
+    closeModal(): void;
+    get signerOptions(): SignerOptions;
+    get endpointOptions(): EndpointOptions;
+    get preferredSignTypeMap(): Record<string, SignType>;
+    get signerOptionMap(): Record<string, CosmosSigningOptions>;
+    get endpointOptionsMap(): Record<string, Endpoints>;
+    addChains(newChains: Chain[], newAssetLists: AssetList[], signerOptions?: SignerOptions, newEndpointOptions?: EndpointOptions): Promise<void>;
+    getChainLogoUrl(chainName: ChainName): string;
+    getWalletByName(walletName: string): WalletStore | undefined;
+    getChainByName(chainName: string): Chain | undefined;
+    getAssetListByName(chainName: string): AssetList;
+    connect(walletName: string, chainName: string): Promise<void>;
+    disconnect(walletName: string, chainName: string): Promise<void>;
+    getAccount(walletName: string, chainName: string): Promise<WalletAccount>;
+    getRpcEndpoint(walletName: string, chainName: string): Promise<string | HttpEndpoint>;
+    getPreferSignType(chainName: string): SignType;
+    getSignerOptions(chainName: string): CosmosSigningOptions;
+    getOfflineSigner(walletName: string, chainName: string): Promise<any>;
+    getSigningClient(walletName: string, chainName: ChainName): Promise<ISigningClient>;
+    getEnv(): {
+        browser: string;
+        device: DeviceType;
+        os: OS;
+    };
+    getDownloadLink(walletName: string): DownloadInfo;
+}

package/wallet-manager/wallet-manager-store.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletManagerStore = void 0;
+const core_1 = require("@interchain-kit/core");
+const cosmos_1 = require("@interchainjs/cosmos");
+const interchainjs_1 = require("interchainjs");
+const proxied_wallets_1 = require("../proxied-wallets");
+const store_1 = require("../store");
+const local_storage_1 = require("../utils/local-storage");
+const wallet_store_1 = require("./wallet-store");
+class WalletManagerStore {
+    wallets;
+    store;
+    walletManager;
+    chains;
+    assetLists;
+    localStorage;
+    constructor(chains, assetLists, wallets, signerOptions, endpointOptions) {
+        this.localStorage = new local_storage_1.LocalStorage();
+        this.store = new store_1.InterchainStore();
+        const proxiedWallets = wallets.map(wallet => {
+            wallet.setChainMap(chains);
+            wallet.setAssetLists(assetLists);
+            return (0, proxied_wallets_1.createProxiedWallet)(wallet, this.store);
+        });
+        this.walletManager = new core_1.WalletManager(chains, assetLists, proxiedWallets, signerOptions, endpointOptions);
+        this.chains = chains;
+        this.assetLists = assetLists;
+        this.wallets = proxiedWallets.map(proxiedWallet => new wallet_store_1.WalletStore(proxiedWallet, chains, this.store, this.walletManager));
+    }
+    async init() {
+        try {
+            // 先恢复数据，再设置订阅
+            this.restore();
+            this.store.subscribe((state) => {
+                this.localStorage.save({
+                    chainWalletStates: state.chainWalletStates,
+                    currentWalletName: state.currentWalletName,
+                    currentChainName: state.currentChainName,
+                });
+            });
+            await Promise.all(this.wallets.map(wallet => {
+                return wallet.init();
+            }));
+            this.store.setState({ isReady: true });
+        }
+        catch (error) {
+            console.log(error);
+            throw error;
+        }
+    }
+    restore() {
+        const oldState = this.localStorage.load();
+        // 直接设置state，避免触发emit
+        this.store.setState({
+            chainWalletStates: oldState.chainWalletStates || [],
+            currentWalletName: oldState.currentWalletName || '',
+            currentChainName: oldState.currentChainName || '',
+        });
+        // 重建索引映射
+        this.store.buildIndexMap();
+        // 获取当前有效的 wallet 和 chain 名称集合
+        const validWalletNames = new Set(this.wallets.map(wallet => wallet.info.name));
+        const validChainNames = new Set(this.chains.map(chain => chain.chainName));
+        // 1. 移除不需要的 chain wallet state（wallet 或 chain 不再存在）
+        const filteredChainWalletStates = this.store.getState().chainWalletStates.filter(state => {
+            return validWalletNames.has(state.walletName) && validChainNames.has(state.chainName);
+        });
+        // 2. 新增原本没有的 chain wallet state
+        const newChainWalletStates = [];
+        this.wallets.forEach(wallet => {
+            this.chains.forEach(chain => {
+                if (!this.store.isChainWalletStateExisted(wallet.info.name, chain.chainName)) {
+                    newChainWalletStates.push({
+                        walletName: wallet.info.name,
+                        chainName: chain.chainName,
+                        rpcEndpoint: '',
+                        walletState: core_1.WalletState.Disconnected,
+                        account: undefined,
+                        errorMessage: ''
+                    });
+                }
+            });
+        });
+        // 合并过滤后的状态和新增的状态
+        const finalChainWalletStates = [...filteredChainWalletStates, ...newChainWalletStates];
+        this.store.setState({ chainWalletStates: finalChainWalletStates });
+        this.store.buildIndexMap();
+    }
+    subscribe(callback) {
+        return this.store.subscribe(callback);
+    }
+    getState() {
+        return this.store.getState();
+    }
+    get walletConnectQRCodeUri() {
+        return this.store.getState().walletConnectQRCodeUri;
+    }
+    get isReady() {
+        return this.store.getState().isReady;
+    }
+    get currentWalletName() {
+        return this.store.getState().currentWalletName;
+    }
+    get currentChainName() {
+        return this.store.getState().currentChainName;
+    }
+    setCurrentWalletName(walletName) {
+        this.store.setCurrentWalletName(walletName);
+    }
+    setCurrentChainName(chainName) {
+        this.store.setCurrentChainName(chainName);
+    }
+    getChainById(chainId) {
+        return this.walletManager.getChainById(chainId);
+    }
+    getChainWalletState(walletName, chainName) {
+        return this.store.getChainWalletState(walletName, chainName);
+    }
+    updateChainWalletState(walletName, chainName, data) {
+        this.store.updateChainWalletState(walletName, chainName, data);
+    }
+    getChainWalletByName(walletName, chainName) {
+        const walletStore = this.wallets.find(w => w.info.name === walletName);
+        return walletStore?.getChainWalletStore(chainName);
+    }
+    get modalIsOpen() {
+        return this.store.getState().modalIsOpen;
+    }
+    openModal() {
+        this.store.setState({ modalIsOpen: true });
+    }
+    closeModal() {
+        this.store.setState({ modalIsOpen: false });
+    }
+    get signerOptions() {
+        return this.walletManager.signerOptions;
+    }
+    get endpointOptions() {
+        return this.walletManager.endpointOptions;
+    }
+    get preferredSignTypeMap() {
+        return this.walletManager.preferredSignTypeMap;
+    }
+    get signerOptionMap() {
+        return this.walletManager.signerOptionMap;
+    }
+    get endpointOptionsMap() {
+        return this.walletManager.endpointOptionsMap;
+    }
+    addChains(newChains, newAssetLists, signerOptions, newEndpointOptions) {
+        return this.walletManager.addChains(newChains, newAssetLists, signerOptions, newEndpointOptions);
+    }
+    getChainLogoUrl(chainName) {
+        return this.walletManager.getChainLogoUrl(chainName);
+    }
+    getWalletByName(walletName) {
+        return this.wallets.find(w => w.info.name === walletName);
+    }
+    getChainByName(chainName) {
+        return this.walletManager.getChainByName(chainName);
+    }
+    getAssetListByName(chainName) {
+        return this.walletManager.getAssetListByName(chainName);
+    }
+    connect(walletName, chainName) {
+        const chainWallet = this.getWalletByName(walletName).getChainWalletStore(chainName);
+        return chainWallet.connect();
+    }
+    disconnect(walletName, chainName) {
+        const chainWallet = this.getWalletByName(walletName).getChainWalletStore(chainName);
+        return chainWallet.disconnect();
+    }
+    getAccount(walletName, chainName) {
+        const chainWallet = this.getWalletByName(walletName).getChainWalletStore(chainName);
+        return chainWallet.getAccount();
+    }
+    async getRpcEndpoint(walletName, chainName) {
+        const existed = this.getChainWalletState(walletName, chainName)?.rpcEndpoint;
+        if (existed) {
+            return existed;
+        }
+        const rpcEndpoint = await this.walletManager.getRpcEndpoint(walletName, chainName);
+        this.updateChainWalletState(walletName, chainName, { rpcEndpoint });
+        return rpcEndpoint;
+    }
+    getPreferSignType(chainName) {
+        return this.walletManager.getPreferSignType(chainName);
+    }
+    getSignerOptions(chainName) {
+        return this.walletManager.getSignerOptions(chainName);
+    }
+    getOfflineSigner(walletName, chainName) {
+        return this.getWalletByName(walletName).getChainWalletStore(chainName).getOfflineSigner();
+    }
+    async getSigningClient(walletName, chainName) {
+        try {
+            const chain = this.getChainByName(chainName);
+            const rpcEndpoint = await this.getRpcEndpoint(walletName, chainName);
+            const preferredSignType = this.getPreferSignType(chainName);
+            const offlineSigner = (await this.getOfflineSigner(walletName, chainName));
+            const defaultSignerOptions = await this.getSignerOptions(chainName);
+            const signerOptions = {
+                queryClient: await (0, cosmos_1.createCosmosQueryClient)(rpcEndpoint),
+                addressPrefix: chain.bech32Prefix,
+                chainId: chain.chainId,
+                ...defaultSignerOptions,
+            };
+            if (preferredSignType === 'direct') {
+                return (0, interchainjs_1.getSigner)(offlineSigner, {
+                    preferredSignType: 'direct',
+                    signerOptions,
+                });
+            }
+            else {
+                return (0, interchainjs_1.getSigner)(offlineSigner, {
+                    preferredSignType: 'amino',
+                    signerOptions,
+                });
+            }
+        }
+        catch (error) {
+            console.log(error);
+            throw error;
+        }
+    }
+    getEnv() {
+        return this.walletManager.getEnv();
+    }
+    getDownloadLink(walletName) {
+        return this.walletManager.getDownloadLink(walletName);
+    }
+}
+exports.WalletManagerStore = WalletManagerStore;

package/wallet-manager/wallet-store.d.ts

@@ -0,0 +1,21 @@
+import { Chain } from '@chain-registry/types';
+import { BaseWallet, WalletAccount, WalletManager, WalletState } from '@interchain-kit/core';
+import { InterchainStore } from '../store';
+import { ChainWalletStore } from './chain-wallet-store';
+export declare class WalletStore extends BaseWallet {
+    wallet: BaseWallet;
+    chains: Chain[];
+    chainWalletStoreMap: Map<Chain['chainName'], ChainWalletStore>;
+    store: InterchainStore;
+    walletManager: WalletManager;
+    constructor(wallet: BaseWallet, chains: Chain[], store: InterchainStore, walletManager: WalletManager);
+    get walletState(): WalletState;
+    get errorMessage(): string;
+    init(): Promise<void>;
+    getChainWalletStore(chainName: Chain['chainName']): ChainWalletStore;
+    connect(chainId: Chain['chainId']): Promise<void>;
+    disconnect(chainId: Chain['chainId']): Promise<void>;
+    getAccount(chainId: Chain['chainId']): Promise<WalletAccount>;
+    addSuggestChain(chainId: Chain['chainId']): Promise<void>;
+    getProvider(chainId: Chain['chainId']): Promise<any>;
+}

package/wallet-manager/wallet-store.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletStore = void 0;
+const core_1 = require("@interchain-kit/core");
+const chain_wallet_store_1 = require("./chain-wallet-store");
+class WalletStore extends core_1.BaseWallet {
+    wallet;
+    chains;
+    chainWalletStoreMap = new Map();
+    store;
+    walletManager;
+    constructor(wallet, chains, store, walletManager) {
+        super(wallet.info);
+        this.wallet = wallet;
+        this.chains = chains;
+        chains.forEach(chain => {
+            this.chainWalletStoreMap.set(chain.chainName, new chain_wallet_store_1.ChainWalletStore(this.wallet, chain, store, walletManager));
+        });
+        this.store = store;
+        this.walletManager = walletManager;
+    }
+    get walletState() {
+        const chainWalletStates = [];
+        this.store.getState().chainWalletStates.forEach(cws => {
+            if (cws.walletName === this.info.name) {
+                chainWalletStates.push(cws.walletState);
+            }
+        });
+        if (chainWalletStates.some(ws => ws === core_1.WalletState.NotExist)) {
+            return core_1.WalletState.NotExist;
+        }
+        if (chainWalletStates.some(ws => ws === core_1.WalletState.Connected)) {
+            return core_1.WalletState.Connected;
+        }
+        if (chainWalletStates.some(ws => ws === core_1.WalletState.Connecting)) {
+            return core_1.WalletState.Connecting;
+        }
+        return core_1.WalletState.Disconnected;
+    }
+    get errorMessage() {
+        let errorMessage = '';
+        for (const cws of this.store.getState().chainWalletStates) {
+            if (cws.walletName === this.info.name) {
+                errorMessage = cws.errorMessage;
+                break;
+            }
+        }
+        return errorMessage;
+    }
+    async init() {
+        try {
+            const chainWalletStores = Array.from(this.chainWalletStoreMap.values());
+            await Promise.all(chainWalletStores.map(chainWalletStore => chainWalletStore.init()));
+            await this.wallet.init();
+        }
+        catch (error) {
+            this.store.updateWalletState(this.wallet.info.name, { walletState: core_1.WalletState.NotExist, errorMessage: '' });
+        }
+    }
+    getChainWalletStore(chainName) {
+        const chainWalletStore = this.chainWalletStoreMap.get(chainName);
+        if (!chainWalletStore) {
+            throw new Error(`Chain wallet store with chain name ${chainName} not found`);
+        }
+        return chainWalletStore;
+    }
+    async connect(chainId) {
+        const chain = this.walletManager.getChainById(chainId);
+        if (!chain) {
+            throw new Error(`Chain with ID ${chainId} not found`);
+        }
+        return this.getChainWalletStore(chain.chainName).connect();
+    }
+    async disconnect(chainId) {
+        const chain = this.walletManager.getChainById(chainId);
+        if (!chain) {
+            throw new Error(`Chain with ID ${chainId} not found`);
+        }
+        return this.getChainWalletStore(chain.chainName).disconnect();
+    }
+    async getAccount(chainId) {
+        const chain = this.walletManager.getChainById(chainId);
+        if (!chain) {
+            throw new Error(`Chain with ID ${chainId} not found`);
+        }
+        return this.getChainWalletStore(chain.chainName).getAccount();
+    }
+    async addSuggestChain(chainId) {
+        const chain = this.walletManager.getChainById(chainId);
+        if (!chain) {
+            throw new Error(`Chain with ID ${chainId} not found`);
+        }
+        return this.getChainWalletStore(chain.chainName).addSuggestChain();
+    }
+    async getProvider(chainId) {
+        const chain = this.walletManager.getChainById(chainId);
+        if (!chain) {
+            throw new Error(`Chain with ID ${chainId} not found`);
+        }
+        return this.getChainWalletStore(chain.chainName).getProvider();
+    }
+}
+exports.WalletStore = WalletStore;