@interchain-kit/store 0.3.47

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

@@ -0,0 +1,111 @@
+import { BaseWallet, CosmosWallet, getWalletByType, isInstanceOf, WalletState, WCWallet } from '@interchain-kit/core';
+export class ChainWalletStore extends 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 || 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 === WalletState.NotExist) {
+            return Promise.resolve();
+        }
+        if (isInstanceOf(this.wallet, 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: 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: WalletState.Connected, account });
+        }
+        catch (error) {
+            this.store.updateChainWalletState(this.wallet.info.name, this.chain.chainName, { walletState: WalletState.Disconnected, errorMessage: error.message });
+        }
+    }
+    async disconnect() {
+        if (isInstanceOf(this.wallet, WCWallet)) {
+            this.wallet.events.on('disconnect', () => {
+                this.store.updateChainWalletState(this.wallet.info.name, this.chain.chainName, { walletState: WalletState.Disconnected, account: undefined });
+            });
+        }
+        try {
+            await this.wallet.disconnect(this.chain.chainId);
+            this.store.updateChainWalletState(this.wallet.info.name, this.chain.chainName, { walletState: 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: 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 = getWalletByType(this.wallet, 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 getWalletByType(this.wallet, WalletClass);
+    }
+}

package/esm/wallet-manager/index.js

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

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

@@ -0,0 +1,230 @@
+import { WalletManager, WalletState } from '@interchain-kit/core';
+import { createCosmosQueryClient } from '@interchainjs/cosmos';
+import { getSigner } from 'interchainjs';
+import { createProxiedWallet } from '../proxied-wallets';
+import { InterchainStore } from '../store';
+import { LocalStorage } from '../utils/local-storage';
+import { WalletStore } from './wallet-store';
+export class WalletManagerStore {
+    wallets;
+    store;
+    walletManager;
+    chains;
+    assetLists;
+    localStorage;
+    constructor(chains, assetLists, wallets, signerOptions, endpointOptions) {
+        this.localStorage = new LocalStorage();
+        this.store = new InterchainStore();
+        const proxiedWallets = wallets.map(wallet => {
+            wallet.setChainMap(chains);
+            wallet.setAssetLists(assetLists);
+            return createProxiedWallet(wallet, this.store);
+        });
+        this.walletManager = new WalletManager(chains, assetLists, proxiedWallets, signerOptions, endpointOptions);
+        this.chains = chains;
+        this.assetLists = assetLists;
+        this.wallets = proxiedWallets.map(proxiedWallet => new 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: 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 createCosmosQueryClient(rpcEndpoint),
+                addressPrefix: chain.bech32Prefix,
+                chainId: chain.chainId,
+                ...defaultSignerOptions,
+            };
+            if (preferredSignType === 'direct') {
+                return getSigner(offlineSigner, {
+                    preferredSignType: 'direct',
+                    signerOptions,
+                });
+            }
+            else {
+                return getSigner(offlineSigner, {
+                    preferredSignType: 'amino',
+                    signerOptions,
+                });
+            }
+        }
+        catch (error) {
+            console.log(error);
+            throw error;
+        }
+    }
+    getEnv() {
+        return this.walletManager.getEnv();
+    }
+    getDownloadLink(walletName) {
+        return this.walletManager.getDownloadLink(walletName);
+    }
+}

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

@@ -0,0 +1,99 @@
+import { BaseWallet, WalletState } from '@interchain-kit/core';
+import { ChainWalletStore } from './chain-wallet-store';
+export class WalletStore extends 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 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 === WalletState.NotExist)) {
+            return WalletState.NotExist;
+        }
+        if (chainWalletStates.some(ws => ws === WalletState.Connected)) {
+            return WalletState.Connected;
+        }
+        if (chainWalletStates.some(ws => ws === WalletState.Connecting)) {
+            return WalletState.Connecting;
+        }
+        return 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: 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();
+    }
+}

package/index.d.ts

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

package/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"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./store"), exports);

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@interchain-kit/store",
+  "version": "0.3.47",
+  "author": "Hyperweb  <developers@hyperweb.io>",
+  "description": "interchain-kit wallet connector store package",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/interchain-kit/store",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/interchain-kit/store"
+  },
+  "bugs": {
+    "url": "https://github.com/interchain-kit/interchain-kit/issues"
+  },
+  "scripts": {
+    "copy": "copyfiles -f ../../LICENSE README.md package.json dist",
+    "clean": "rimraf dist/**",
+    "prepare": "npm run build",
+    "build": "npm run clean; tsc; tsc -p tsconfig.esm.json; npm run copy",
+    "build:dev": "npm run clean; tsc --declarationMap; tsc -p tsconfig.esm.json; npm run copy",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "watch:dev": "tsc -w -p tsconfig.esm.json & tsc -w"
+  },
+  "keywords": [],
+  "gitHead": "4583b572672abd85a0918f39f534a5bf9312c261"
+}

package/proxied-wallets/cosmos-wallet.d.ts

@@ -0,0 +1,3 @@
+import { CosmosWallet } from '@interchain-kit/core';
+import { InterchainStore } from '../store';
+export declare const createCosmosWallet: (target: CosmosWallet, store: InterchainStore) => import("../utils").AOPProxyType<CosmosWallet>;

package/proxied-wallets/cosmos-wallet.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCosmosWallet = void 0;
+const utils_1 = require("../utils");
+const createCosmosWallet = (target, store) => {
+    return (0, utils_1.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; // 重新抛出错误
+                    }
+                },
+            }
+        },
+    });
+};
+exports.createCosmosWallet = createCosmosWallet;

package/proxied-wallets/create-proxied-wallet.d.ts

@@ -0,0 +1,2 @@
+import { InterchainStore } from '../store';
+export declare const createProxiedWallet: <T>(wallet: T, store: InterchainStore) => T;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProxiedWallet = void 0;
+const core_1 = require("@interchain-kit/core");
+const core_2 = require("@interchain-kit/core");
+const cosmos_wallet_1 = require("./cosmos-wallet");
+const ethereum_wallet_1 = require("./ethereum-wallet");
+const multi_chain_wallet_1 = require("./multi-chain-wallet");
+// import { createWCWallet } from './wc-wallet';
+const createProxiedWallet = (wallet, store) => {
+    // WalletConnect wallets are now handled by the generic AOP system
+    // No need for special handling
+    if ((0, core_1.isInstanceOf)(wallet, core_2.CosmosWallet)) {
+        return (0, cosmos_wallet_1.createCosmosWallet)(wallet, store);
+    }
+    if ((0, core_1.isInstanceOf)(wallet, core_2.EthereumWallet)) {
+        return (0, ethereum_wallet_1.createEthereumWallet)(wallet, store);
+    }
+    if ((0, core_1.isInstanceOf)(wallet, core_2.MultiChainWallet)) {
+        Array.from(wallet.networkWalletMap.keys()).forEach(chainType => {
+            const chainWallet = wallet.networkWalletMap.get(chainType);
+            if ((0, core_1.isInstanceOf)(chainWallet, core_2.CosmosWallet)) {
+                wallet.setNetworkWallet(chainType, (0, cosmos_wallet_1.createCosmosWallet)(chainWallet, store));
+            }
+            if ((0, core_1.isInstanceOf)(chainWallet, core_2.EthereumWallet)) {
+                wallet.setNetworkWallet(chainType, (0, ethereum_wallet_1.createEthereumWallet)(chainWallet, store));
+            }
+        });
+        return (0, multi_chain_wallet_1.createMultiChainWallet)(wallet, store);
+    }
+    // Return original wallet if no specific type matches
+    return wallet;
+};
+exports.createProxiedWallet = createProxiedWallet;

package/proxied-wallets/ethereum-wallet.d.ts

@@ -0,0 +1,3 @@
+import { EthereumWallet } from '@interchain-kit/core';
+import { InterchainStore } from '../store';
+export declare const createEthereumWallet: (target: EthereumWallet, store: InterchainStore) => import("../utils").AOPProxyType<EthereumWallet>;

package/proxied-wallets/ethereum-wallet.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEthereumWallet = void 0;
+const utils_1 = require("../utils");
+const createEthereumWallet = (target, store) => {
+    return (0, utils_1.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; // 重新抛出错误
+                }
+            },
+        }
+    });
+};
+exports.createEthereumWallet = createEthereumWallet;

package/proxied-wallets/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cosmos-wallet';
+export * from './create-proxied-wallet';
+export * from './ethereum-wallet';
+export * from './multi-chain-wallet';

package/proxied-wallets/index.js

@@ -0,0 +1,21 @@
+"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("./cosmos-wallet"), exports);
+__exportStar(require("./create-proxied-wallet"), exports);
+__exportStar(require("./ethereum-wallet"), exports);
+__exportStar(require("./multi-chain-wallet"), exports);
+// export * from './wc-wallet'; // No longer needed - handled by generic AOP system

package/proxied-wallets/multi-chain-wallet.d.ts

@@ -0,0 +1,3 @@
+import { MultiChainWallet } from '@interchain-kit/core';
+import { InterchainStore } from '../store';
+export declare const createMultiChainWallet: (target: MultiChainWallet, store: InterchainStore) => import("../utils/aop").AOPProxyType<any>;