@injectivelabs/wallet-cosmostation 1.16.38-alpha.7 → 1.16.38

package/dist/esm/index.js

@@ -1,263 +1,3 @@
-import { InstallError, cosmos } from "@cosmostation/extension-client";
-import { CosmosWalletException, ErrorType, TransactionException, UnspecifiedErrorCode } from "@injectivelabs/exceptions";
-import { makeSignDoc } from "@cosmjs/proto-signing";
-import { CosmosChainId } from "@injectivelabs/ts-types";
-import { CosmosTxV1Beta1TxPb } from "@injectivelabs/sdk-ts";
-import { getOfflineSigner } from "@cosmostation/cosmos-client";
-import { SEND_TRANSACTION_MODE } from "@cosmostation/extension-client/cosmos.js";
-import { createSignDocFromTransaction, createTxRawFromSigResponse } from "@injectivelabs/sdk-ts/core/tx";
-import { stringToUint8Array, toUtf8, uint8ArrayToBase64, uint8ArrayToHex } from "@injectivelabs/sdk-ts/utils";
-import { BaseConcreteStrategy, WalletAction, WalletDeviceType } from "@injectivelabs/wallet-base";
-
-//#region src/utils/index.ts
-const isCosmosStationWalletInstalled = () => {
-	return (typeof window !== "undefined" ? window : {}).cosmostation !== void 0;
-};
-
-//#endregion
-//#region \0@oxc-project+runtime@0.98.0/helpers/typeof.js
-function _typeof(o) {
-	"@babel/helpers - typeof";
-	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
-		return typeof o$1;
-	} : function(o$1) {
-		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
-	}, _typeof(o);
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.98.0/helpers/toPrimitive.js
-function toPrimitive(t, r) {
-	if ("object" != _typeof(t) || !t) return t;
-	var e = t[Symbol.toPrimitive];
-	if (void 0 !== e) {
-		var i = e.call(t, r || "default");
-		if ("object" != _typeof(i)) return i;
-		throw new TypeError("@@toPrimitive must return a primitive value.");
-	}
-	return ("string" === r ? String : Number)(t);
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.98.0/helpers/toPropertyKey.js
-function toPropertyKey(t) {
-	var i = toPrimitive(t, "string");
-	return "symbol" == _typeof(i) ? i : i + "";
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.98.0/helpers/defineProperty.js
-function _defineProperty(e, r, t) {
-	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-		value: t,
-		enumerable: !0,
-		configurable: !0,
-		writable: !0
-	}) : e[r] = t, e;
-}
-
-//#endregion
-//#region src/wallet.ts
-var CosmostationWallet = class CosmostationWallet {
-	constructor(chainId) {
-		_defineProperty(this, "chainId", void 0);
-		this.chainId = chainId;
-	}
-	static async isChainIdSupported(chainId) {
-		return new CosmostationWallet(chainId).checkChainIdSupport();
-	}
-	async checkChainIdSupport() {
-		const { chainId: actualChainId } = this;
-		const provider = await this.getCosmostationWallet();
-		const chainName = actualChainId.split("-");
-		try {
-			return !!(await provider.getSupportedChainIds()).official.find((chainId) => chainId === actualChainId);
-		} catch (_unused) {
-			throw new CosmosWalletException(/* @__PURE__ */ new Error(`Cosmostation doesn't support ${chainName[0] || actualChainId} network. Please use another Cosmos wallet`));
-		}
-	}
-	async getCosmostationWallet() {
-		try {
-			return await cosmos();
-		} catch (e) {
-			if (e instanceof InstallError) throw new CosmosWalletException(/* @__PURE__ */ new Error("Please install the Cosmostation extension"), {
-				code: UnspecifiedErrorCode,
-				type: ErrorType.WalletNotInstalledError
-			});
-			throw new CosmosWalletException(new Error(e.message), { code: UnspecifiedErrorCode });
-		}
-	}
-};
-
-//#endregion
-//#region src/strategy/strategy.ts
-const getChainNameFromChainId = (chainId) => {
-	const [chainName] = chainId.split("-");
-	if (chainName.includes("cosmoshub")) return "cosmos";
-	if (chainName.includes("core")) return "persistence";
-	if (chainName.includes("evmos")) return "evmos";
-	if (chainId.includes("ssc") || chainId.includes("fetch")) return chainId;
-	return chainName;
-};
-var Cosmostation = class extends BaseConcreteStrategy {
-	constructor(args) {
-		super(args);
-		_defineProperty(this, "cosmostationWallet", void 0);
-		_defineProperty(this, "chainName", void 0);
-		this.chainId = args.chainId || CosmosChainId.Injective;
-		this.chainName = getChainNameFromChainId(this.chainId);
-	}
-	async getWalletDeviceType() {
-		return Promise.resolve(WalletDeviceType.Browser);
-	}
-	async enable() {
-		return Promise.resolve(true);
-	}
-	async getAddresses() {
-		const cosmostationWallet = await this.getCosmostationWallet();
-		try {
-			return [(await cosmostationWallet.requestAccount(this.chainName)).address];
-		} catch (e) {
-			if (e.code === 4001) throw new CosmosWalletException(/* @__PURE__ */ new Error("The user rejected the request"), {
-				code: UnspecifiedErrorCode,
-				context: WalletAction.GetAccounts
-			});
-			throw new CosmosWalletException(new Error(e.message), {
-				code: UnspecifiedErrorCode,
-				context: WalletAction.GetAccounts
-			});
-		}
-	}
-	async getAddressesInfo() {
-		throw new CosmosWalletException(/* @__PURE__ */ new Error("getAddressesInfo is not implemented"), {
-			code: UnspecifiedErrorCode,
-			context: WalletAction.GetAccounts
-		});
-	}
-	async getSessionOrConfirm(address) {
-		return Promise.resolve(`0x${uint8ArrayToHex(stringToUint8Array(`Confirmation for ${address} at time: ${Date.now()}`))}`);
-	}
-	async sendEvmTransaction(_transaction, _options) {
-		throw new CosmosWalletException(/* @__PURE__ */ new Error("sendEvmTransaction is not supported. Cosmostation only supports sending cosmos transactions"), {
-			code: UnspecifiedErrorCode,
-			context: WalletAction.SendEvmTransaction
-		});
-	}
-	async sendTransaction(transaction, _options) {
-		const cosmostationWallet = await this.getCosmostationWallet();
-		const txRaw = createTxRawFromSigResponse(transaction);
-		try {
-			const response = await cosmostationWallet.sendTransaction(this.chainName, CosmosTxV1Beta1TxPb.TxRaw.toBinary(txRaw), SEND_TRANSACTION_MODE.SYNC);
-			return {
-				...response.tx_response,
-				gasUsed: parseInt(response.tx_response.gas_used || "0", 10),
-				gasWanted: parseInt(response.tx_response.gas_wanted || "0", 10),
-				height: parseInt(response.tx_response.height || "0", 10),
-				txHash: response.tx_response.txhash,
-				rawLog: response.tx_response.raw_log
-			};
-		} catch (e) {
-			if (e instanceof TransactionException) throw e;
-			throw new TransactionException(new Error(e.message), {
-				code: UnspecifiedErrorCode,
-				context: WalletAction.SendTransaction
-			});
-		}
-	}
-	async signAminoCosmosTransaction(_transaction) {
-		throw new CosmosWalletException(/* @__PURE__ */ new Error("This wallet does not support signing using amino"), {
-			code: UnspecifiedErrorCode,
-			context: WalletAction.SendTransaction
-		});
-	}
-	async signCosmosTransaction(transaction) {
-		const { chainId } = this;
-		const cosmostationWallet = await this.getCosmostationWallet();
-		const signDoc = createSignDocFromTransaction(transaction);
-		try {
-			const signDirectResponse = await cosmostationWallet.signDirect(this.chainName, {
-				chain_id: chainId,
-				body_bytes: signDoc.bodyBytes,
-				auth_info_bytes: signDoc.authInfoBytes,
-				account_number: signDoc.accountNumber.toString()
-			}, {
-				fee: true,
-				memo: true
-			});
-			return {
-				signed: makeSignDoc(signDirectResponse.signed_doc.body_bytes, signDirectResponse.signed_doc.auth_info_bytes, signDirectResponse.signed_doc.chain_id, parseInt(signDirectResponse.signed_doc.account_number, 10)),
-				signature: { signature: signDirectResponse.signature }
-			};
-		} catch (e) {
-			throw new CosmosWalletException(new Error(e.message), {
-				code: UnspecifiedErrorCode,
-				context: WalletAction.SendTransaction
-			});
-		}
-	}
-	async getPubKey() {
-		const cosmostationWallet = await this.getCosmostationWallet();
-		try {
-			return uint8ArrayToBase64((await cosmostationWallet.requestAccount(this.chainName)).publicKey);
-		} catch (e) {
-			if (e.code === 4001) throw new CosmosWalletException(/* @__PURE__ */ new Error("The user rejected the request"), {
-				code: UnspecifiedErrorCode,
-				context: WalletAction.GetAccounts
-			});
-			throw new CosmosWalletException(new Error(e.message), {
-				code: UnspecifiedErrorCode,
-				context: WalletAction.GetAccounts
-			});
-		}
-	}
-	async signEip712TypedData(_eip712TypedData, _address) {
-		throw new CosmosWalletException(/* @__PURE__ */ new Error("This wallet does not support signing Evm transactions"), {
-			code: UnspecifiedErrorCode,
-			context: WalletAction.SendTransaction
-		});
-	}
-	async signArbitrary(signer, data) {
-		try {
-			return (await (await this.getCosmostationWallet()).signMessage(this.chainName, signer, toUtf8(data))).signature;
-		} catch (e) {
-			throw new CosmosWalletException(new Error(e.message), {
-				code: UnspecifiedErrorCode,
-				context: WalletAction.SignArbitrary
-			});
-		}
-	}
-	async getEthereumChainId() {
-		throw new CosmosWalletException(/* @__PURE__ */ new Error("getEthereumChainId is not supported on Cosmostation"), {
-			code: UnspecifiedErrorCode,
-			context: WalletAction.GetChainId
-		});
-	}
-	async getEvmTransactionReceipt(_txHash) {
-		throw new CosmosWalletException(/* @__PURE__ */ new Error("getEvmTransactionReceipt is not supported on Cosmostation"), {
-			code: UnspecifiedErrorCode,
-			type: ErrorType.WalletError,
-			context: WalletAction.GetEvmTransactionReceipt
-		});
-	}
-	async getOfflineSigner(chainId) {
-		return await getOfflineSigner(chainId);
-	}
-	async getCosmostationWallet() {
-		if (this.cosmostationWallet) return this.cosmostationWallet;
-		const cosmostationWallet = new CosmostationWallet(this.chainId);
-		try {
-			const provider = await cosmostationWallet.getCosmostationWallet();
-			this.cosmostationWallet = provider;
-			return provider;
-		} catch (e) {
-			if (e instanceof InstallError) throw new CosmosWalletException(/* @__PURE__ */ new Error("Please install the Cosmostation extension"), {
-				code: UnspecifiedErrorCode,
-				type: ErrorType.WalletNotInstalledError
-			});
-			throw new CosmosWalletException(new Error(e.message), { code: UnspecifiedErrorCode });
-		}
-	}
-};
-
-//#endregion
-export { CosmostationWallet, Cosmostation as CosmostationWalletStrategy, isCosmosStationWalletInstalled };
+export { CosmostationWallet } from './wallet.js';
+export { Cosmostation as CosmostationWalletStrategy } from './strategy/strategy.js';
+export * from './utils/index.js';

package/dist/esm/package.json

@@ -1,3 +1,3 @@
 {
-  "type": "module"
-}
+    "type": "module"
+}

package/dist/esm/strategy/strategy.d.ts

@@ -0,0 +1,43 @@
+import { CosmosChainId } from '@injectivelabs/ts-types';
+import { CosmosTxV1Beta1Tx } from '@injectivelabs/sdk-ts';
+import { WalletDeviceType, BaseConcreteStrategy } from '@injectivelabs/wallet-base';
+import type { OfflineSigner } from '@cosmjs/proto-signing';
+import type { ChainId, EvmChainId, AccountAddress } from '@injectivelabs/ts-types';
+import type { StdSignDoc, ConcreteWalletStrategy } from '@injectivelabs/wallet-base';
+import type { TxResponse, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
+export declare class Cosmostation extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+    private cosmostationWallet?;
+    chainName: string;
+    constructor(args: {
+        chainId: ChainId | CosmosChainId;
+    });
+    getWalletDeviceType(): Promise<WalletDeviceType>;
+    enable(): Promise<boolean>;
+    getAddresses(): Promise<string[]>;
+    getSessionOrConfirm(address?: AccountAddress): Promise<string>;
+    sendEvmTransaction(_transaction: unknown, _options: {
+        address: AccountAddress;
+        evmChainId: EvmChainId;
+    }): Promise<string>;
+    sendTransaction(transaction: DirectSignResponse | CosmosTxV1Beta1Tx.TxRaw, _options: {
+        address: AccountAddress;
+        chainId: ChainId;
+    }): Promise<TxResponse>;
+    signAminoCosmosTransaction(_transaction: {
+        address: string;
+        signDoc: StdSignDoc;
+    }): Promise<AminoSignResponse>;
+    signCosmosTransaction(transaction: {
+        txRaw: CosmosTxV1Beta1Tx.TxRaw;
+        chainId: string;
+        address: string;
+        accountNumber: number;
+    }): Promise<DirectSignResponse>;
+    getPubKey(): Promise<string>;
+    signEip712TypedData(_eip712TypedData: string, _address: AccountAddress): Promise<string>;
+    signArbitrary(signer: string, data: string | Uint8Array): Promise<string>;
+    getEthereumChainId(): Promise<string>;
+    getEvmTransactionReceipt(_txHash: string): Promise<string>;
+    getOfflineSigner(chainId: string): Promise<OfflineSigner>;
+    private getCosmostationWallet;
+}

package/dist/esm/strategy/strategy.js

@@ -0,0 +1,201 @@
+import { makeSignDoc } from '@cosmjs/proto-signing';
+import { CosmosChainId } from '@injectivelabs/ts-types';
+import { CosmosTxV1Beta1Tx } from '@injectivelabs/sdk-ts';
+import { InstallError } from '@cosmostation/extension-client';
+import { getOfflineSigner } from '@cosmostation/cosmos-client';
+import { SEND_TRANSACTION_MODE } from '@cosmostation/extension-client/cosmos.js';
+import { toUtf8, createTxRawFromSigResponse, createSignDocFromTransaction, } from '@injectivelabs/sdk-ts';
+import { ErrorType, UnspecifiedErrorCode, CosmosWalletException, TransactionException, } from '@injectivelabs/exceptions';
+import { WalletAction, WalletDeviceType, BaseConcreteStrategy, } from '@injectivelabs/wallet-base';
+import { CosmostationWallet } from './../wallet.js';
+const getChainNameFromChainId = (chainId) => {
+    const [chainName] = chainId.split('-');
+    if (chainName.includes('cosmoshub')) {
+        return 'cosmos';
+    }
+    if (chainName.includes('core')) {
+        return 'persistence';
+    }
+    if (chainName.includes('evmos')) {
+        return 'evmos';
+    }
+    if (chainId.includes('ssc') || chainId.includes('fetch')) {
+        return chainId;
+    }
+    return chainName;
+};
+export class Cosmostation extends BaseConcreteStrategy {
+    cosmostationWallet;
+    chainName;
+    constructor(args) {
+        super(args);
+        this.chainId = args.chainId || CosmosChainId.Injective;
+        this.chainName = getChainNameFromChainId(this.chainId);
+    }
+    async getWalletDeviceType() {
+        return Promise.resolve(WalletDeviceType.Browser);
+    }
+    async enable() {
+        return Promise.resolve(true);
+    }
+    async getAddresses() {
+        const cosmostationWallet = await this.getCosmostationWallet();
+        try {
+            const accounts = await cosmostationWallet.requestAccount(this.chainName);
+            return [accounts.address];
+        }
+        catch (e) {
+            if (e.code === 4001) {
+                throw new CosmosWalletException(new Error('The user rejected the request'), {
+                    code: UnspecifiedErrorCode,
+                    context: WalletAction.GetAccounts,
+                });
+            }
+            throw new CosmosWalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                context: WalletAction.GetAccounts,
+            });
+        }
+    }
+    async getSessionOrConfirm(address) {
+        return Promise.resolve(`0x${Buffer.from(`Confirmation for ${address} at time: ${Date.now()}`).toString('hex')}`);
+    }
+    async sendEvmTransaction(_transaction, _options) {
+        throw new CosmosWalletException(new Error('sendEvmTransaction is not supported. Cosmostation only supports sending cosmos transactions'), {
+            code: UnspecifiedErrorCode,
+            context: WalletAction.SendEvmTransaction,
+        });
+    }
+    async sendTransaction(transaction, _options) {
+        const cosmostationWallet = await this.getCosmostationWallet();
+        const txRaw = createTxRawFromSigResponse(transaction);
+        try {
+            const response = await cosmostationWallet.sendTransaction(this.chainName, CosmosTxV1Beta1Tx.TxRaw.encode(txRaw).finish(), SEND_TRANSACTION_MODE.SYNC);
+            return {
+                ...response.tx_response,
+                gasUsed: parseInt((response.tx_response.gas_used || '0'), 10),
+                gasWanted: parseInt((response.tx_response.gas_wanted || '0'), 10),
+                height: parseInt((response.tx_response.height || '0'), 10),
+                txHash: response.tx_response.txhash,
+                rawLog: response.tx_response.raw_log,
+            };
+        }
+        catch (e) {
+            if (e instanceof TransactionException) {
+                throw e;
+            }
+            throw new TransactionException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                context: WalletAction.SendTransaction,
+            });
+        }
+    }
+    async signAminoCosmosTransaction(_transaction) {
+        throw new CosmosWalletException(new Error('This wallet does not support signing using amino'), {
+            code: UnspecifiedErrorCode,
+            context: WalletAction.SendTransaction,
+        });
+    }
+    async signCosmosTransaction(transaction) {
+        const { chainId } = this;
+        const cosmostationWallet = await this.getCosmostationWallet();
+        const signDoc = createSignDocFromTransaction(transaction);
+        try {
+            /* Sign the transaction */
+            const signDirectResponse = await cosmostationWallet.signDirect(this.chainName, {
+                chain_id: chainId,
+                body_bytes: signDoc.bodyBytes,
+                auth_info_bytes: signDoc.authInfoBytes,
+                account_number: signDoc.accountNumber.toString(),
+            }, { fee: true, memo: true });
+            return {
+                signed: makeSignDoc(signDirectResponse.signed_doc.body_bytes, signDirectResponse.signed_doc.auth_info_bytes, signDirectResponse.signed_doc.chain_id, parseInt(signDirectResponse.signed_doc.account_number, 10)),
+                signature: {
+                    signature: signDirectResponse.signature,
+                },
+            };
+        }
+        catch (e) {
+            throw new CosmosWalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                context: WalletAction.SendTransaction,
+            });
+        }
+    }
+    async getPubKey() {
+        const cosmostationWallet = await this.getCosmostationWallet();
+        try {
+            const account = await cosmostationWallet.requestAccount(this.chainName);
+            return Buffer.from(account.publicKey).toString('base64');
+        }
+        catch (e) {
+            if (e.code === 4001) {
+                throw new CosmosWalletException(new Error('The user rejected the request'), {
+                    code: UnspecifiedErrorCode,
+                    context: WalletAction.GetAccounts,
+                });
+            }
+            throw new CosmosWalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                context: WalletAction.GetAccounts,
+            });
+        }
+    }
+    async signEip712TypedData(_eip712TypedData, _address) {
+        throw new CosmosWalletException(new Error('This wallet does not support signing Evm transactions'), {
+            code: UnspecifiedErrorCode,
+            context: WalletAction.SendTransaction,
+        });
+    }
+    async signArbitrary(signer, data) {
+        try {
+            const cosmostationWallet = await this.getCosmostationWallet();
+            const signature = await cosmostationWallet.signMessage(this.chainName, signer, toUtf8(data));
+            return signature.signature;
+        }
+        catch (e) {
+            throw new CosmosWalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                context: WalletAction.SignArbitrary,
+            });
+        }
+    }
+    async getEthereumChainId() {
+        throw new CosmosWalletException(new Error('getEthereumChainId is not supported on Cosmostation'), {
+            code: UnspecifiedErrorCode,
+            context: WalletAction.GetChainId,
+        });
+    }
+    async getEvmTransactionReceipt(_txHash) {
+        throw new CosmosWalletException(new Error('getEvmTransactionReceipt is not supported on Cosmostation'), {
+            code: UnspecifiedErrorCode,
+            type: ErrorType.WalletError,
+            context: WalletAction.GetEvmTransactionReceipt,
+        });
+    }
+    async getOfflineSigner(chainId) {
+        return (await getOfflineSigner(chainId));
+    }
+    async getCosmostationWallet() {
+        if (this.cosmostationWallet) {
+            return this.cosmostationWallet;
+        }
+        const cosmostationWallet = new CosmostationWallet(this.chainId);
+        try {
+            const provider = await cosmostationWallet.getCosmostationWallet();
+            this.cosmostationWallet = provider;
+            return provider;
+        }
+        catch (e) {
+            if (e instanceof InstallError) {
+                throw new CosmosWalletException(new Error('Please install the Cosmostation extension'), {
+                    code: UnspecifiedErrorCode,
+                    type: ErrorType.WalletNotInstalledError,
+                });
+            }
+            throw new CosmosWalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+            });
+        }
+    }
+}

package/dist/esm/utils/index.d.ts

@@ -0,0 +1 @@
+export declare const isCosmosStationWalletInstalled: () => boolean;

package/dist/esm/utils/index.js

@@ -0,0 +1,4 @@
+export const isCosmosStationWalletInstalled = () => {
+    const $window = (typeof window !== 'undefined' ? window : {});
+    return $window.cosmostation !== undefined;
+};

package/dist/esm/wallet.d.ts

@@ -0,0 +1,8 @@
+import type { ChainId, CosmosChainId, TestnetCosmosChainId } from '@injectivelabs/ts-types';
+export declare class CosmostationWallet {
+    private chainId;
+    constructor(chainId: CosmosChainId | TestnetCosmosChainId | ChainId);
+    static isChainIdSupported(chainId: CosmosChainId): Promise<boolean>;
+    checkChainIdSupport(): Promise<boolean>;
+    getCosmostationWallet(): Promise<typeof import("@cosmostation/extension-client/cosmos.js")>;
+}

package/dist/esm/wallet.js

@@ -0,0 +1,40 @@
+import { cosmos, InstallError } from '@cosmostation/extension-client';
+import { ErrorType, UnspecifiedErrorCode, CosmosWalletException, } from '@injectivelabs/exceptions';
+export class CosmostationWallet {
+    chainId;
+    constructor(chainId) {
+        this.chainId = chainId;
+    }
+    static async isChainIdSupported(chainId) {
+        return new CosmostationWallet(chainId).checkChainIdSupport();
+    }
+    async checkChainIdSupport() {
+        const { chainId: actualChainId } = this;
+        const provider = await this.getCosmostationWallet();
+        const chainName = actualChainId.split('-');
+        try {
+            const supportedChainIds = await provider.getSupportedChainIds();
+            return !!supportedChainIds.official.find((chainId) => chainId === actualChainId);
+        }
+        catch {
+            throw new CosmosWalletException(new Error(`Cosmostation doesn't support ${chainName[0] || actualChainId} network. Please use another Cosmos wallet`));
+        }
+    }
+    async getCosmostationWallet() {
+        try {
+            const provider = await cosmos();
+            return provider;
+        }
+        catch (e) {
+            if (e instanceof InstallError) {
+                throw new CosmosWalletException(new Error('Please install the Cosmostation extension'), {
+                    code: UnspecifiedErrorCode,
+                    type: ErrorType.WalletNotInstalledError,
+                });
+            }
+            throw new CosmosWalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+            });
+        }
+    }
+}