@interchain-kit/store 0.3.47

package/proxied-wallets/multi-chain-wallet.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMultiChainWallet = void 0;
+const core_1 = require("@interchain-kit/core");
+const aop_1 = require("../utils/aop");
+const createMultiChainWallet = (target, store) => {
+    return (0, aop_1.createAOPProxy)({
+        target,
+        advice: {
+            connect: {
+                async around(methodName, target, originalMethod, chainId) {
+                    const chain = target.getChainById(chainId);
+                    store.updateChainWalletState(target.info.name, chain.chainName, { walletState: core_1.WalletState.Connecting });
+                    await originalMethod(chainId);
+                    const account = await target.getAccount(chainId);
+                    store.updateChainWalletState(target.info.name, chain.chainName, {
+                        walletState: core_1.WalletState.Connected,
+                        account
+                    });
+                }
+            },
+            disconnect: {
+                after(methodName, target, result, chainId) {
+                    const chain = target.getChainById(chainId);
+                    store.updateChainWalletState(target.info.name, chain.chainName, { walletState: core_1.WalletState.Disconnected });
+                },
+            },
+        }
+    });
+};
+exports.createMultiChainWallet = createMultiChainWallet;

package/store/index.d.ts

@@ -0,0 +1,21 @@
+import { ChainWalletState, InterchainStoreType } from '../types';
+export declare class InterchainStore {
+    private state;
+    private listeners;
+    private chainWalletIndexMap;
+    constructor();
+    getState(): InterchainStoreType;
+    subscribe(listener: (state: InterchainStoreType) => void): () => void;
+    emit(): void;
+    setState(newState: Partial<InterchainStoreType>): void;
+    updateState(partialState: Partial<InterchainStoreType>): void;
+    setCurrentChainName(chainName: string): void;
+    setCurrentWalletName(walletName: string): void;
+    updateChainWalletState(walletName: string, chainName: string, state: Partial<ChainWalletState>): void;
+    addChainWalletState(walletName: string, chainName: string, state: Partial<ChainWalletState>): void;
+    removeChainWalletState(walletName: string, chainName: string): void;
+    getChainWalletState(walletName: string, chainName: string): ChainWalletState | undefined;
+    buildIndexMap(): void;
+    updateWalletState(walletName: string, state: Partial<ChainWalletState>): void;
+    isChainWalletStateExisted(walletName: string, chainName: string): number;
+}

package/store/index.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterchainStore = void 0;
+const core_1 = require("@interchain-kit/core");
+class InterchainStore {
+    state;
+    listeners = new Set();
+    // 快速查找索引的 Map: walletName-chainName -> index
+    chainWalletIndexMap = new Map();
+    constructor() {
+        this.state = {
+            currentWalletName: '',
+            currentChainName: '',
+            chainWalletStates: [],
+            isReady: false,
+            modalIsOpen: false,
+            walletConnectQRCodeUri: '',
+        };
+    }
+    // Get current state
+    getState() {
+        return this.state;
+    }
+    // Subscribe to state changes
+    subscribe(listener) {
+        this.listeners.add(listener);
+        // Return unsubscribe function
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    // Emit state changes to all listeners
+    emit() {
+        this.listeners.forEach(listener => {
+            try {
+                listener(this.state);
+            }
+            catch (error) {
+                console.error('Error in store listener:', error);
+            }
+        });
+    }
+    // Update state and emit changes
+    setState(newState) {
+        this.state = { ...this.state, ...newState };
+        this.emit();
+    }
+    // Update partial state and emit changes
+    updateState(partialState) {
+        this.state = { ...this.state, ...partialState };
+        this.emit();
+    }
+    setCurrentChainName(chainName) {
+        this.setState({ ...this.state, currentChainName: chainName });
+    }
+    setCurrentWalletName(walletName) {
+        this.setState({ ...this.state, currentWalletName: walletName });
+    }
+    updateChainWalletState(walletName, chainName, state) {
+        const key = `${walletName}-${chainName}`;
+        const index = this.chainWalletIndexMap.get(key);
+        if (index !== undefined) {
+            // 直接通过索引更新，避免遍历
+            const newChainWalletStates = [...this.state.chainWalletStates];
+            newChainWalletStates[index] = { ...newChainWalletStates[index], ...state };
+            this.setState({ ...this.state, chainWalletStates: newChainWalletStates });
+        }
+        else {
+            this.addChainWalletState(walletName, chainName, state);
+        }
+    }
+    // 添加新的 chain wallet state
+    addChainWalletState(walletName, chainName, state) {
+        const newChainWalletState = [...this.state.chainWalletStates];
+        const newIndex = newChainWalletState.length;
+        newChainWalletState.push({
+            chainName,
+            walletName,
+            walletState: core_1.WalletState.Disconnected,
+            rpcEndpoint: '', errorMessage: '', account: undefined, ...state
+        });
+        // 更新索引映射
+        const key = `${walletName}-${chainName}`;
+        this.chainWalletIndexMap.set(key, newIndex);
+        this.setState({ ...this.state, chainWalletStates: newChainWalletState });
+    }
+    // 移除 chain wallet state
+    removeChainWalletState(walletName, chainName) {
+        const key = `${walletName}-${chainName}`;
+        const index = this.chainWalletIndexMap.get(key);
+        if (index !== undefined) {
+            const newChainWalletState = this.state.chainWalletStates.filter((_, i) => i !== index);
+            // 重新构建索引映射
+            this.chainWalletIndexMap.clear();
+            newChainWalletState.forEach((item, i) => {
+                const itemKey = `${item.walletName}-${item.chainName}`;
+                this.chainWalletIndexMap.set(itemKey, i);
+            });
+            this.setState({ ...this.state, chainWalletStates: newChainWalletState });
+        }
+    }
+    // 获取指定 chain 的 wallet state
+    getChainWalletState(walletName, chainName) {
+        const key = `${walletName}-${chainName}`;
+        const index = this.chainWalletIndexMap.get(key);
+        return index !== undefined ? this.state.chainWalletStates[index] : undefined;
+    }
+    // 恢复索引映射（用于从localStorage恢复数据后重建索引）
+    buildIndexMap() {
+        this.chainWalletIndexMap.clear();
+        this.state.chainWalletStates.forEach((item, index) => {
+            const key = `${item.walletName}-${item.chainName}`;
+            this.chainWalletIndexMap.set(key, index);
+        });
+    }
+    updateWalletState(walletName, state) {
+        const newChainWalletStates = this.state.chainWalletStates.map(cws => {
+            if (cws.walletName === walletName) {
+                return { ...cws, ...state };
+            }
+            return cws;
+        });
+        this.setState({ chainWalletStates: newChainWalletStates });
+    }
+    isChainWalletStateExisted(walletName, chainName) {
+        return this.chainWalletIndexMap.get(`${walletName}-${chainName}`);
+    }
+}
+exports.InterchainStore = InterchainStore;

package/types/index.d.ts

@@ -0,0 +1 @@
+export * from './store';

package/types/index.js

@@ -0,0 +1,17 @@
+"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("./store"), exports);

package/types/store.d.ts

@@ -0,0 +1,17 @@
+import { WalletAccount, WalletState } from '@interchain-kit/core';
+export type ChainWalletState = {
+    chainName: string;
+    walletName: string;
+    walletState: WalletState;
+    rpcEndpoint: string;
+    errorMessage: string;
+    account: WalletAccount | undefined;
+};
+export type InterchainStoreType = {
+    currentWalletName: string;
+    currentChainName: string;
+    chainWalletStates: ChainWalletState[];
+    isReady: boolean;
+    modalIsOpen: boolean;
+    walletConnectQRCodeUri: string;
+};

package/types/store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/utils/aop.d.ts

@@ -0,0 +1,58 @@
+/**
+ * AOP (Aspect-Oriented Programming) implementation similar to Java AOP
+ * Using Object.create, Object.getOwnPropertyNames, and Object.getPrototypeOf
+ */
+export type MethodName<T> = keyof T & string;
+export type MethodArgs<T, K extends MethodName<T>> = T[K] extends (...args: infer A) => any ? A : never;
+export type MethodReturn<T, K extends MethodName<T>> = T[K] extends (...args: any[]) => infer R ? R : never;
+export interface MethodAdvice<T, K extends MethodName<T>> {
+    before?: (methodName: K, target: T, ...args: MethodArgs<T, K>) => void;
+    after?: (methodName: K, target: T, result: MethodReturn<T, K>, ...args: MethodArgs<T, K>) => void;
+    afterReturn?: (methodName: K, target: T, result: MethodReturn<T, K>, ...args: MethodArgs<T, K>) => void;
+    around?: (methodName: K, target: T, originalMethod: T[K], ...args: MethodArgs<T, K>) => MethodReturn<T, K>;
+    onError?: (methodName: K, target: T, error: Error, ...args: MethodArgs<T, K>) => void;
+}
+export interface AOPConfig<T = any> {
+    target: T;
+    advice: {
+        [K in MethodName<T>]?: MethodAdvice<T, K>;
+    };
+    defaultAdvice?: MethodAdvice<T, MethodName<T>>;
+}
+export type AOPProxyType<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? T[K] : T[K];
+};
+export declare class AOPProxy<T = any> {
+    private target;
+    private advice;
+    private defaultAdvice?;
+    constructor(config: AOPConfig<T>);
+    /**
+     * Get advice for a specific method
+     */
+    private getMethodAdvice;
+    /**
+     * Collect all property names from the instance and its prototype chain
+     * (excluding Object.prototype). This allows intercepting prototype methods
+     * in addition to own instance methods.
+     */
+    private getAllMemberNames;
+    /**
+     * Create a proxy object with AOP capabilities
+     */
+    createProxy(): AOPProxyType<T>;
+    /**
+     * Intercept a specific method with AOP advice
+     */
+    private interceptMethod;
+}
+/**
+ * Utility function to create AOP proxy with type safety
+ */
+export declare function createAOPProxy<T>(config: AOPConfig<T>): AOPProxyType<T>;
+/**
+ * Utility function to apply advice to an existing object
+ */
+export declare function applyAdvice<T>(target: T, advice: {
+    [K in MethodName<T>]?: MethodAdvice<T, K>;
+}, defaultAdvice?: MethodAdvice<T, MethodName<T>>): AOPProxyType<T>;

package/utils/aop.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * AOP (Aspect-Oriented Programming) implementation similar to Java AOP
+ * Using Object.create, Object.getOwnPropertyNames, and Object.getPrototypeOf
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AOPProxy = void 0;
+exports.createAOPProxy = createAOPProxy;
+exports.applyAdvice = applyAdvice;
+class AOPProxy {
+    target;
+    advice;
+    defaultAdvice;
+    constructor(config) {
+        this.target = config.target;
+        this.advice = config.advice;
+        this.defaultAdvice = config.defaultAdvice;
+    }
+    /**
+     * Get advice for a specific method
+     */
+    getMethodAdvice(methodName) {
+        return this.advice[methodName] || this.defaultAdvice;
+    }
+    /**
+     * Collect all property names from the instance and its prototype chain
+     * (excluding Object.prototype). This allows intercepting prototype methods
+     * in addition to own instance methods.
+     */
+    getAllMemberNames() {
+        const names = new Set();
+        // Own properties (instance fields and own methods)
+        Object.getOwnPropertyNames(this.target).forEach((name) => {
+            names.add(name);
+        });
+        // Prototype chain methods
+        let proto = Object.getPrototypeOf(this.target);
+        while (proto && proto !== Object.prototype) {
+            Object.getOwnPropertyNames(proto).forEach((name) => {
+                if (name !== 'constructor') {
+                    names.add(name);
+                }
+            });
+            proto = Object.getPrototypeOf(proto);
+        }
+        return Array.from(names);
+    }
+    /**
+     * Create a proxy object with AOP capabilities
+     */
+    createProxy() {
+        const proxy = Object.create(Object.getPrototypeOf(this.target));
+        // Gather members from the instance and its prototype chain
+        const memberNames = this.getAllMemberNames();
+        memberNames.forEach((name) => {
+            const value = this.target[name];
+            const isFunction = typeof value === 'function';
+            if (isFunction) {
+                const methodAdvice = this.getMethodAdvice(name);
+                if (methodAdvice) {
+                    // 只拦截有 advice 的方法，其他方法保持原型链结构
+                    this.interceptMethod(proxy, name, methodAdvice);
+                }
+                else {
+                    // 对于没有 advice 的方法，创建一个委托到原始实例的包装器
+                    Object.defineProperty(proxy, name, {
+                        value: (...args) => {
+                            return value.apply(this.target, args);
+                        },
+                        writable: true,
+                        enumerable: true,
+                        configurable: true
+                    });
+                }
+            }
+            else {
+                // 对于非函数属性，创建 getter/setter 来委托到原始实例
+                Object.defineProperty(proxy, name, {
+                    get: () => this.target[name],
+                    set: (newValue) => {
+                        this.target[name] = newValue;
+                    },
+                    enumerable: true,
+                    configurable: true
+                });
+            }
+        });
+        return proxy;
+    }
+    /**
+     * Intercept a specific method with AOP advice
+     */
+    interceptMethod(proxy, methodName, methodAdvice) {
+        const originalMethod = this.target[methodName];
+        Object.defineProperty(proxy, methodName, {
+            value: (...args) => {
+                try {
+                    // Before advice - 传递 proxy 作为 target 参数
+                    if (methodAdvice.before) {
+                        methodAdvice.before(methodName, proxy, ...args);
+                    }
+                    let result;
+                    // Around advice - 传递绑定了原始目标上下文的原始方法
+                    if (methodAdvice.around) {
+                        // 创建一个包装函数，确保 originalMethod 使用 target 作为 this 上下文
+                        // 使用 bind 来确保 this 上下文正确绑定
+                        const wrappedOriginalMethod = originalMethod.bind(this.target);
+                        result = methodAdvice.around(methodName, proxy, wrappedOriginalMethod, ...args);
+                        return result;
+                    }
+                    else {
+                        // Execute original method with target as this context to ensure state consistency
+                        result = originalMethod.apply(this.target, args);
+                    }
+                    // 检查结果是否是 Promise
+                    if (result && typeof result.then === 'function') {
+                        // 异步方法 - 使用 Promise 链处理
+                        return result
+                            .then((resolvedResult) => {
+                            // After advice - 传递 proxy 作为 target 参数
+                            if (methodAdvice.after) {
+                                methodAdvice.after(methodName, proxy, resolvedResult, ...args);
+                            }
+                            // AfterReturn advice - 在方法返回之前执行
+                            if (methodAdvice.afterReturn) {
+                                methodAdvice.afterReturn(methodName, proxy, resolvedResult, ...args);
+                            }
+                            return resolvedResult;
+                        })
+                            .catch((error) => {
+                            // Error advice - 传递 proxy 作为 target 参数
+                            if (methodAdvice.onError) {
+                                methodAdvice.onError(methodName, proxy, error, ...args);
+                            }
+                            throw error;
+                        });
+                    }
+                    else {
+                        // 同步方法
+                        // After advice - 传递 proxy 作为 target 参数
+                        if (methodAdvice.after) {
+                            methodAdvice.after(methodName, proxy, result, ...args);
+                        }
+                        // AfterReturn advice - 在方法返回之前执行
+                        if (methodAdvice.afterReturn) {
+                            methodAdvice.afterReturn(methodName, proxy, result, ...args);
+                        }
+                        return result;
+                    }
+                }
+                catch (error) {
+                    // Error advice - 传递 proxy 作为 target 参数
+                    if (methodAdvice.onError) {
+                        methodAdvice.onError(methodName, proxy, error, ...args);
+                    }
+                    throw error;
+                }
+            },
+            writable: true,
+            enumerable: true,
+            configurable: true
+        });
+    }
+}
+exports.AOPProxy = AOPProxy;
+/**
+ * Utility function to create AOP proxy with type safety
+ */
+function createAOPProxy(config) {
+    const aopProxy = new AOPProxy(config);
+    return aopProxy.createProxy();
+}
+/**
+ * Utility function to apply advice to an existing object
+ */
+function applyAdvice(target, advice, defaultAdvice) {
+    return createAOPProxy({ target, advice, defaultAdvice });
+}

package/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './aop';

package/utils/index.js

@@ -0,0 +1,17 @@
+"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("./aop"), exports);

package/utils/local-storage.d.ts

@@ -0,0 +1,5 @@
+import { InterchainStoreType } from "../types";
+export declare class LocalStorage {
+    save(value: Partial<InterchainStoreType>): void;
+    load(): Partial<InterchainStoreType>;
+}

package/utils/local-storage.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStorage = void 0;
+const INTERCHAIN_KIT_STORAGE_KEY = 'interchain-kit-store';
+class LocalStorage {
+    save(value) {
+        localStorage.setItem(INTERCHAIN_KIT_STORAGE_KEY, JSON.stringify(value));
+    }
+    load() {
+        return JSON.parse(localStorage.getItem(INTERCHAIN_KIT_STORAGE_KEY) || '{}');
+    }
+}
+exports.LocalStorage = LocalStorage;

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

@@ -0,0 +1,22 @@
+import { Chain } from '@chain-registry/types';
+import { BaseWallet, OfflineAminoSigner, OfflineDirectSigner, SignType, WalletAccount, WalletManager, WalletState } from '@interchain-kit/core';
+import { InterchainStore } from '../store';
+export declare class ChainWalletStore extends BaseWallet {
+    networkWalletMap: Map<Chain['chainType'], BaseWallet>;
+    wallet: BaseWallet;
+    chain: Chain;
+    store: InterchainStore;
+    walletManager: WalletManager;
+    constructor(wallet: BaseWallet, chain: Chain, store: InterchainStore, walletManager: WalletManager);
+    get walletState(): WalletState;
+    get errorMessage(): string;
+    init(): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    refreshAccount(): Promise<void>;
+    getAccount(): Promise<WalletAccount>;
+    addSuggestChain(): Promise<void>;
+    getProvider(): Promise<any>;
+    getOfflineSigner(preferSignType?: SignType): Promise<OfflineAminoSigner | OfflineDirectSigner>;
+    getWalletOfType<T>(WalletClass: new (...args: any[]) => T): T;
+}

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

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainWalletStore = void 0;
+const core_1 = require("@interchain-kit/core");
+class ChainWalletStore extends core_1.BaseWallet {
+    networkWalletMap;
+    wallet;
+    chain;
+    store;
+    walletManager;
+    constructor(wallet, chain, store, walletManager) {
+        super(wallet.info);
+        this.wallet = wallet;
+        this.chain = chain;
+        this.store = store;
+        this.walletManager = walletManager;
+    }
+    get walletState() {
+        return this.store.getChainWalletState(this.chain.chainName, this.wallet.info.name)?.walletState || core_1.WalletState.NotExist;
+    }
+    get errorMessage() {
+        return this.store.getChainWalletState(this.chain.chainName, this.wallet.info.name)?.errorMessage || '';
+    }
+    async init() {
+        this.wallet.events.on('accountChanged', () => {
+            this.refreshAccount();
+        });
+    }
+    async connect() {
+        const chainWalletState = this.store.getChainWalletState(this.wallet.info.name, this.chain.chainName);
+        if (chainWalletState && chainWalletState.walletState === core_1.WalletState.NotExist) {
+            return Promise.resolve();
+        }
+        if ((0, core_1.isInstanceOf)(this.wallet, core_1.WCWallet)) {
+            this.wallet.setOnPairingUriCreatedCallback((uri) => {
+                console.log('Callback called with uri:', uri);
+                this.store.setState({ walletConnectQRCodeUri: uri });
+            });
+        }
+        try {
+            this.store.updateChainWalletState(this.wallet.info.name, this.chain.chainName, { walletState: core_1.WalletState.Connecting });
+            await this.wallet.connect(this.chain.chainId);
+            const account = await this.getAccount();
+            this.store.updateChainWalletState(this.wallet.info.name, this.chain.chainName, { walletState: core_1.WalletState.Connected, account });
+        }
+        catch (error) {
+            this.store.updateChainWalletState(this.wallet.info.name, this.chain.chainName, { walletState: core_1.WalletState.Disconnected, errorMessage: error.message });
+        }
+    }
+    async disconnect() {
+        if ((0, core_1.isInstanceOf)(this.wallet, core_1.WCWallet)) {
+            this.wallet.events.on('disconnect', () => {
+                this.store.updateChainWalletState(this.wallet.info.name, this.chain.chainName, { walletState: core_1.WalletState.Disconnected, account: undefined });
+            });
+        }
+        try {
+            await this.wallet.disconnect(this.chain.chainId);
+            this.store.updateChainWalletState(this.wallet.info.name, this.chain.chainName, { walletState: core_1.WalletState.Disconnected, account: undefined, errorMessage: '' });
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    async refreshAccount() {
+        try {
+            const account = await this.wallet.getAccount(this.chain.chainId);
+            console.log(this.wallet);
+            this.store.updateChainWalletState(this.wallet.info.name, this.chain.chainName, { account });
+        }
+        catch (error) {
+            this.store.updateChainWalletState(this.wallet.info.name, this.chain.chainName, { walletState: core_1.WalletState.Disconnected, account: undefined, errorMessage: error.message });
+        }
+    }
+    async getAccount() {
+        const existed = this.store.getChainWalletState(this.wallet.info.name, this.chain.chainName)?.account;
+        if (existed) {
+            return existed;
+        }
+        const account = await this.wallet.getAccount(this.chain.chainId);
+        this.store.updateChainWalletState(this.wallet.info.name, this.chain.chainName, { account });
+        return account;
+    }
+    addSuggestChain() {
+        return this.wallet.addSuggestChain(this.chain.chainId);
+    }
+    getProvider() {
+        return this.wallet.getProvider(this.chain.chainId);
+    }
+    async getOfflineSigner(preferSignType) {
+        const cosmosWallet = (0, core_1.getWalletByType)(this.wallet, core_1.CosmosWallet);
+        const preferredSignTypeFromSettings = this.walletManager.getPreferSignType(this.chain.chainName);
+        const account = await this.getAccount();
+        const aminoOfflineSigner = {
+            getAccounts: async () => [account],
+            signAmino: async (signer, signDoc) => {
+                return cosmosWallet.signAmino(this.chain.chainId, signer, signDoc, {});
+            }
+        };
+        const directOfflineSigner = {
+            getAccounts: async () => [account],
+            signDirect: async (signer, signDoc) => {
+                return cosmosWallet.signDirect(this.chain.chainId, signer, signDoc, {});
+            }
+        };
+        const signType = preferSignType || preferredSignTypeFromSettings;
+        if (account.isNanoLedger || signType === 'amino') {
+            return aminoOfflineSigner;
+        }
+        return directOfflineSigner;
+    }
+    getWalletOfType(WalletClass) {
+        return (0, core_1.getWalletByType)(this.wallet, WalletClass);
+    }
+}
+exports.ChainWalletStore = ChainWalletStore;

package/wallet-manager/index.d.ts

@@ -0,0 +1,3 @@
+export * from './wallet-manager-store';
+export * from './wallet-store';
+export * from './chain-wallet-store';

package/wallet-manager/index.js

@@ -0,0 +1,19 @@
+"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-manager-store"), exports);
+__exportStar(require("./wallet-store"), exports);
+__exportStar(require("./chain-wallet-store"), exports);