@interchain-kit/store 0.3.47

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Cosmology Developers <developers@hyperweb.io>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+> **⚠️ UPGRADE TO 2.0**
+>
+> **Create Cosmos App 2.0 is here!** This package has been superseded by the new version.
+>
+> Please upgrade to [**Create Interchain App**](https://github.com/hyperweb-io/create-interchain-app) (Create Cosmos App 2.0), featuring enhanced capabilities and expanded Interchain ecosystem support.
+
+# **MODULENAME**
+
+<p align="center">
+  <img src="https://user-images.githubusercontent.com/545047/188804067-28e67e5e-0214-4449-ab04-2e0c564a6885.svg" width="80"><br />
+    interchain-kit wallet connector store package
+</p>
+
+## install
+
+```sh
+npm install store
+```
+
+## Table of contents
+
+- [**MODULENAME**](#store)
+  - [Install](#install)
+  - [Table of contents](#table-of-contents)
+- [Developing](#developing)
+- [Credits](#credits)
+
+## Developing
+
+When first cloning the repo:
+
+```sh
+yarn
+# build the prod packages. When devs would like to navigate to the source code, this will only navigate from references to their definitions (.d.ts files) between packages.
+yarn build
+```
+
+Or if you want to make your dev process smoother, you can run:
+
+```sh
+yarn
+# build the dev packages with .map files, this enables navigation from references to their source code between packages.
+yarn build:dev
+```
+
+## Interchain JavaScript Stack
+
+A unified toolkit for building applications and smart contracts in the Interchain ecosystem ⚛️
+
+| Category                       | Tools                                                                                                                                                                                                     | Description                                                                                                         |
+| ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
+| **Chain Information**          | [**Chain Registry**](https://github.com/hyperweb-io/chain-registry), [**Utils**](https://www.npmjs.com/package/@chain-registry/utils), [**Client**](https://www.npmjs.com/package/@chain-registry/client) | Everything from token symbols, logos, and IBC denominations for all assets you want to support in your application. |
+| **Wallet Connectors**          | [**Interchain Kit**](https://github.com/hyperweb-io/interchain-kit)<sup>beta</sup>, [**Cosmos Kit**](https://github.com/hyperweb-io/cosmos-kit)                                                           | Experience the convenience of connecting with a variety of web3 wallets through a single, streamlined interface.    |
+| **Signing Clients**            | [**InterchainJS**](https://github.com/hyperweb-io/interchainjs)<sup>beta</sup>, [**CosmJS**](https://github.com/cosmos/cosmjs)                                                                            | A single, universal signing interface for any network                                                               |
+| **SDK Clients**                | [**Telescope**](https://github.com/hyperweb-io/telescope)                                                                                                                                                 | Your Frontend Companion for Building with TypeScript with Cosmos SDK Modules.                                       |
+| **Starter Kits**               | [**Create Interchain App**](https://github.com/hyperweb-io/create-interchain-app)<sup>beta</sup>, [**Create Cosmos App**](https://github.com/hyperweb-io/create-cosmos-app)                               | Set up a modern Interchain app by running one command.                                                              |
+| **UI Kits**                    | [**Interchain UI**](https://github.com/hyperweb-io/interchain-ui)                                                                                                                                         | The Interchain Design System, empowering developers with a flexible, easy-to-use UI kit.                            |
+| **Testing Frameworks**         | [**Starship**](https://github.com/hyperweb-io/starship)                                                                                                                                                   | Unified Testing and Development for the Interchain.                                                                 |
+| **TypeScript Smart Contracts** | [**Create Hyperweb App**](https://github.com/hyperweb-io/create-hyperweb-app)                                                                                                                             | Build and deploy full-stack blockchain applications with TypeScript                                                 |
+| **CosmWasm Contracts**         | [**CosmWasm TS Codegen**](https://github.com/CosmWasm/ts-codegen)                                                                                                                                         | Convert your CosmWasm smart contracts into dev-friendly TypeScript classes.                                         |
+
+## Credits
+
+🛠 Built by Hyperweb (formerly Cosmology) — if you like our tools, please checkout and contribute to [our github ⚛️](https://github.com/hyperweb-io)
+
+## Disclaimer
+
+AS DESCRIBED IN THE LICENSES, THE SOFTWARE IS PROVIDED “AS IS”, AT YOUR OWN RISK, AND WITHOUT WARRANTIES OF ANY KIND.
+
+No developer or entity involved in creating this software will be liable for any claims or damages whatsoever associated with your use, inability to use, or your interaction with other users of the code, including any direct, indirect, incidental, special, exemplary, punitive or consequential damages, or loss of profits, cryptocurrencies, tokens, or anything else of value.

package/esm/index.js

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

package/esm/proxied-wallets/cosmos-wallet.js

@@ -0,0 +1,51 @@
+import { createAOPProxy } from '../utils';
+export const createCosmosWallet = (target, store) => {
+    return createAOPProxy({
+        target,
+        advice: {
+            signAmino: {
+                before(methodName, target, chainId, signer, signDoc, signOptions) {
+                    console.log('signAmino before - AOP proxy is working!', methodName, chainId);
+                },
+                onError(methodName, target, error, chainId, signer, signDoc, signOptions) {
+                    console.log('signAmino onError - AOP caught error!', error, chainId);
+                    const chain = target.getChainById(chainId);
+                    store.updateChainWalletState(target.info.name, chain.chainName, { errorMessage: error.message });
+                    throw error; // 重新抛出错误
+                },
+            },
+            signDirect: {
+                async around(methodName, target, originalMethod, chainId, signer, signDoc, signOptions) {
+                    console.log('signDirect around - AOP is working!', methodName, chainId);
+                    try {
+                        const result = await originalMethod(chainId, signer, signDoc, signOptions);
+                        console.log('signDirect success - AOP is working!', methodName, chainId);
+                        return result;
+                    }
+                    catch (error) {
+                        console.log('signDirect error - AOP caught the error!', error, chainId);
+                        const chain = target.getChainById(chainId);
+                        store.updateChainWalletState(target.info.name, chain.chainName, { errorMessage: error.message });
+                        throw error; // 重新抛出错误
+                    }
+                }
+            },
+            signArbitrary: {
+                async around(methodName, target, originalMethod, chainId, signer, data) {
+                    console.log('signArbitrary around - AOP is working!', methodName, chainId);
+                    try {
+                        const result = await originalMethod(chainId, signer, data);
+                        console.log('signArbitrary success - AOP is working!', methodName, chainId);
+                        return result;
+                    }
+                    catch (error) {
+                        console.log('signArbitrary error - AOP caught the error!', error, chainId);
+                        const chain = target.getChainById(chainId);
+                        store.updateChainWalletState(target.info.name, chain.chainName, { errorMessage: error.message });
+                        throw error; // 重新抛出错误
+                    }
+                },
+            }
+        },
+    });
+};

package/esm/proxied-wallets/create-proxied-wallet.js

@@ -0,0 +1,30 @@
+import { isInstanceOf } from '@interchain-kit/core';
+import { CosmosWallet, EthereumWallet, MultiChainWallet } from '@interchain-kit/core';
+import { createCosmosWallet } from './cosmos-wallet';
+import { createEthereumWallet } from './ethereum-wallet';
+import { createMultiChainWallet } from './multi-chain-wallet';
+// import { createWCWallet } from './wc-wallet';
+export const createProxiedWallet = (wallet, store) => {
+    // WalletConnect wallets are now handled by the generic AOP system
+    // No need for special handling
+    if (isInstanceOf(wallet, CosmosWallet)) {
+        return createCosmosWallet(wallet, store);
+    }
+    if (isInstanceOf(wallet, EthereumWallet)) {
+        return createEthereumWallet(wallet, store);
+    }
+    if (isInstanceOf(wallet, MultiChainWallet)) {
+        Array.from(wallet.networkWalletMap.keys()).forEach(chainType => {
+            const chainWallet = wallet.networkWalletMap.get(chainType);
+            if (isInstanceOf(chainWallet, CosmosWallet)) {
+                wallet.setNetworkWallet(chainType, createCosmosWallet(chainWallet, store));
+            }
+            if (isInstanceOf(chainWallet, EthereumWallet)) {
+                wallet.setNetworkWallet(chainType, createEthereumWallet(chainWallet, store));
+            }
+        });
+        return createMultiChainWallet(wallet, store);
+    }
+    // Return original wallet if no specific type matches
+    return wallet;
+};

package/esm/proxied-wallets/ethereum-wallet.js

@@ -0,0 +1,24 @@
+import { createAOPProxy } from '../utils';
+export const createEthereumWallet = (target, store) => {
+    return createAOPProxy({
+        target,
+        advice: {
+            sendTransaction: {
+                onError(methodName, target, error, transactionParameters) {
+                    const chain = target.getChainById(transactionParameters.chainId);
+                    store.updateChainWalletState(target.info.name, chain.chainName, { errorMessage: error.message });
+                    throw error; // 重新抛出错误
+                },
+            },
+            signMessage: {
+                onError(methodName, target, error, message) {
+                    target.getCurrentChainId().then(chainId => {
+                        const chain = target.getChainById(chainId);
+                        store.updateChainWalletState(target.info.name, chain.chainName, { errorMessage: error.message });
+                    });
+                    throw error; // 重新抛出错误
+                }
+            },
+        }
+    });
+};

package/esm/proxied-wallets/index.js

@@ -0,0 +1,5 @@
+export * from './cosmos-wallet';
+export * from './create-proxied-wallet';
+export * from './ethereum-wallet';
+export * from './multi-chain-wallet';
+// export * from './wc-wallet'; // No longer needed - handled by generic AOP system

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

@@ -0,0 +1,27 @@
+import { WalletState } from '@interchain-kit/core';
+import { createAOPProxy } from '../utils/aop';
+export const createMultiChainWallet = (target, store) => {
+    return createAOPProxy({
+        target,
+        advice: {
+            connect: {
+                async around(methodName, target, originalMethod, chainId) {
+                    const chain = target.getChainById(chainId);
+                    store.updateChainWalletState(target.info.name, chain.chainName, { walletState: WalletState.Connecting });
+                    await originalMethod(chainId);
+                    const account = await target.getAccount(chainId);
+                    store.updateChainWalletState(target.info.name, chain.chainName, {
+                        walletState: WalletState.Connected,
+                        account
+                    });
+                }
+            },
+            disconnect: {
+                after(methodName, target, result, chainId) {
+                    const chain = target.getChainById(chainId);
+                    store.updateChainWalletState(target.info.name, chain.chainName, { walletState: WalletState.Disconnected });
+                },
+            },
+        }
+    });
+};

package/esm/store/index.js

@@ -0,0 +1,125 @@
+import { WalletState } from '@interchain-kit/core';
+export 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: 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}`);
+    }
+}

package/esm/types/index.js

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

package/esm/types/store.js

@@ -0,0 +1 @@
+export {};

package/esm/utils/aop.js

@@ -0,0 +1,172 @@
+/**
+ * AOP (Aspect-Oriented Programming) implementation similar to Java AOP
+ * Using Object.create, Object.getOwnPropertyNames, and Object.getPrototypeOf
+ */
+export 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
+        });
+    }
+}
+/**
+ * Utility function to create AOP proxy with type safety
+ */
+export function createAOPProxy(config) {
+    const aopProxy = new AOPProxy(config);
+    return aopProxy.createProxy();
+}
+/**
+ * Utility function to apply advice to an existing object
+ */
+export function applyAdvice(target, advice, defaultAdvice) {
+    return createAOPProxy({ target, advice, defaultAdvice });
+}

package/esm/utils/index.js

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

package/esm/utils/local-storage.js

@@ -0,0 +1,9 @@
+const INTERCHAIN_KIT_STORAGE_KEY = 'interchain-kit-store';
+export class LocalStorage {
+    save(value) {
+        localStorage.setItem(INTERCHAIN_KIT_STORAGE_KEY, JSON.stringify(value));
+    }
+    load() {
+        return JSON.parse(localStorage.getItem(INTERCHAIN_KIT_STORAGE_KEY) || '{}');
+    }
+}