@injectivelabs/wallet-cosmos 1.16.38 → 1.16.39-alpha.1

package/dist/cjs/wallet.js

@@ -1,266 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CosmosWallet = void 0;
-const utils_1 = require("@injectivelabs/utils");
-const stargate_1 = require("@cosmjs/stargate");
-const sdk_ts_1 = require("@injectivelabs/sdk-ts");
-const wallet_base_1 = require("@injectivelabs/wallet-base");
-const exceptions_1 = require("@injectivelabs/exceptions");
-const $window = (typeof window !== 'undefined' ? window : {});
-class CosmosWallet {
-    wallet;
-    chainId;
-    constructor({ wallet, chainId, }) {
-        this.wallet = wallet;
-        this.chainId = chainId;
-    }
-    async isChainIdSupported(chainId) {
-        const { wallet } = this;
-        return new CosmosWallet({ chainId, wallet }).checkChainIdSupport();
-    }
-    async getCosmosWallet() {
-        const { chainId } = this;
-        const cosmos = this.getCosmos();
-        try {
-            await cosmos.enable(chainId);
-            return cosmos;
-        }
-        catch (e) {
-            throw new exceptions_1.CosmosWalletException(new Error(e.message));
-        }
-    }
-    async chainNotSupported() {
-        const { chainId, wallet } = this;
-        const chainName = chainId.split('-');
-        const context = wallet === wallet_base_1.Wallet.Keplr
-            ? 'https://chains.keplr.app/'
-            : wallet === wallet_base_1.Wallet.OWallet
-                ? 'https://owallet.io/'
-                : undefined;
-        throw new exceptions_1.CosmosWalletException(new Error(`${(0, utils_1.capitalize)(wallet)} may not support ${chainName[0] || chainId} network. Please check if the chain can be added.`), context ? { context } : {});
-    }
-    async getAccounts() {
-        const { chainId } = this;
-        const cosmos = this.getCosmos();
-        try {
-            return cosmos.getOfflineSigner(chainId).getAccounts();
-        }
-        catch (e) {
-            throw new exceptions_1.CosmosWalletException(new Error(e.message), {
-                contextModule: exceptions_1.WalletErrorActionModule.GetAccounts,
-            });
-        }
-    }
-    async getKey() {
-        const { wallet, chainId } = this;
-        const cosmosWallet = await this.getCosmosWallet();
-        try {
-            return cosmosWallet.getKey(chainId);
-        }
-        catch (e) {
-            throw new exceptions_1.CosmosWalletException(new Error(e.message), {
-                contextModule: wallet,
-            });
-        }
-    }
-    async getOfflineSigner(chainId) {
-        const { wallet } = this;
-        try {
-            return this.getCosmos().getOfflineSigner(chainId || this.chainId);
-        }
-        catch (e) {
-            throw new exceptions_1.CosmosWalletException(new Error(e.message), {
-                contextModule: wallet,
-            });
-        }
-    }
-    async getOfflineAminoSigner() {
-        const { chainId, wallet } = this;
-        if (![wallet_base_1.Wallet.Keplr, wallet_base_1.Wallet.OWallet].includes(wallet)) {
-            throw new exceptions_1.CosmosWalletException(new Error(`getOfflineAminoSigner is not support on ${(0, utils_1.capitalize)(wallet)}`));
-        }
-        const cosmosWallet = await this.getCosmosWallet();
-        try {
-            return cosmosWallet.getOfflineSignerOnlyAmino(chainId);
-        }
-        catch (e) {
-            throw new exceptions_1.CosmosWalletException(new Error(e.message), {
-                context: wallet,
-            });
-        }
-    }
-    /**
-     * This method is used to broadcast a transaction to the network.
-     * Since it uses the `Sync` mode, it will not wait for the transaction to be included in a block,
-     * so we have to make sure the transaction is included in a block after its broadcasted
-     *
-     * @param txRaw - raw transaction to broadcast
-     * @returns tx hash
-     */
-    async broadcastTx(txRaw) {
-        const { chainId, wallet } = this;
-        const cosmosWallet = await this.getCosmosWallet();
-        try {
-            const result = await cosmosWallet.sendTx(chainId, sdk_ts_1.CosmosTxV1Beta1Tx.TxRaw.encode(txRaw).finish(), wallet_base_1.BroadcastMode.Sync);
-            if (!result || result.length === 0) {
-                throw new exceptions_1.TransactionException(new Error('Transaction failed to be broadcasted'), { contextModule: wallet });
-            }
-            return Buffer.from(result).toString('hex');
-        }
-        catch (e) {
-            if (e instanceof exceptions_1.TransactionException) {
-                throw e;
-            }
-            throw new exceptions_1.CosmosWalletException(new Error(e.message), {
-                context: 'broadcast-tx',
-                contextModule: wallet,
-            });
-        }
-    }
-    /**
-     * This method is used to broadcast a transaction to the network.
-     * Since it uses the `Block` mode, and it will wait for the transaction to be included in a block,
-     *
-     * @param txRaw - raw transaction to broadcast
-     * @returns tx hash
-     */
-    async broadcastTxBlock(txRaw) {
-        const { chainId, wallet } = this;
-        const cosmosWallet = await this.getCosmosWallet();
-        try {
-            const result = await cosmosWallet.sendTx(chainId, sdk_ts_1.CosmosTxV1Beta1Tx.TxRaw.encode(txRaw).finish(), wallet_base_1.BroadcastMode.Block);
-            if (!result || result.length === 0) {
-                throw new exceptions_1.TransactionException(new Error('Transaction failed to be broadcasted'), { contextModule: wallet });
-            }
-            return Buffer.from(result).toString('hex');
-        }
-        catch (e) {
-            if (e instanceof exceptions_1.TransactionException) {
-                throw e;
-            }
-            throw new exceptions_1.CosmosWalletException(new Error(e.message), {
-                context: 'broadcast-tx',
-                contextModule: wallet,
-            });
-        }
-    }
-    async signAndBroadcastAminoUsingCosmjs(messages, stdFee, endpoints) {
-        const { chainId, wallet } = this;
-        const cosmosWallet = await this.getCosmosWallet();
-        if (![wallet_base_1.Wallet.Keplr, wallet_base_1.Wallet.OWallet].includes(wallet)) {
-            throw new exceptions_1.CosmosWalletException(new Error(`signAndBroadcastAminoUsingCosmjs is not support on ${(0, utils_1.capitalize)(wallet)}`));
-        }
-        if (!endpoints.rpc) {
-            throw new exceptions_1.GeneralException(new Error(`Please provide rpc endpoint`));
-        }
-        const offlineSigner = cosmosWallet.getOfflineSignerOnlyAmino(chainId);
-        const [account] = await offlineSigner.getAccounts();
-        const client = await stargate_1.SigningStargateClient.connectWithSigner(endpoints.rpc, offlineSigner);
-        const txResponse = await client.signAndBroadcast(account.address, messages, stdFee);
-        return txResponse;
-    }
-    async signArbitrary({ data, signer, }) {
-        const { chainId, wallet } = this;
-        const cosmosWallet = await this.getCosmosWallet();
-        if (wallet !== wallet_base_1.Wallet.Keplr) {
-            throw new exceptions_1.CosmosWalletException(new Error(`signArbitrary is not supported on ${(0, utils_1.capitalize)(wallet)}`));
-        }
-        try {
-            const signature = await cosmosWallet.signArbitrary(chainId, signer, data);
-            return signature.signature;
-        }
-        catch (e) {
-            throw new exceptions_1.CosmosWalletException(new Error(e.message), {
-                context: wallet,
-                contextModule: 'sign-arbitrary',
-            });
-        }
-    }
-    async signEIP712CosmosTx({ eip712, signDoc, }) {
-        const { chainId, wallet } = this;
-        const cosmosWallet = await this.getCosmosWallet();
-        const key = await this.getKey();
-        try {
-            return cosmosWallet.experimentalSignEIP712CosmosTx_v0(chainId, key.bech32Address, eip712, signDoc);
-        }
-        catch (e) {
-            throw new exceptions_1.CosmosWalletException(new Error(e.message), {
-                context: wallet,
-                contextModule: 'sign-eip712-cosmos-tx',
-            });
-        }
-    }
-    async checkChainIdSupport() {
-        const { chainId, wallet } = this;
-        const cosmos = this.getCosmos();
-        const chainName = chainId.split('-');
-        try {
-            return !!(await cosmos.getKey(chainId));
-        }
-        catch {
-            throw new exceptions_1.CosmosWalletException(new Error(`${(0, utils_1.capitalize)(wallet)} doesn't support ${chainName[0] || chainId} network. Please use another Cosmos wallet`));
-        }
-    }
-    getCosmos() {
-        const { wallet } = this;
-        if (!$window) {
-            throw new exceptions_1.CosmosWalletException(new Error(`Please install ${(0, utils_1.capitalize)(wallet)} extension`), {
-                code: exceptions_1.UnspecifiedErrorCode,
-                type: exceptions_1.ErrorType.WalletNotInstalledError,
-                contextModule: wallet,
-            });
-        }
-        let cosmos = undefined;
-        if (wallet === wallet_base_1.Wallet.OWallet) {
-            cosmos = $window.owallet;
-        }
-        if (wallet === wallet_base_1.Wallet.Keplr) {
-            cosmos = $window.keplr;
-        }
-        if (wallet === wallet_base_1.Wallet.Ninji) {
-            cosmos = $window.ninji;
-        }
-        if (wallet === wallet_base_1.Wallet.Leap) {
-            cosmos = $window.leap;
-        }
-        if (!cosmos) {
-            throw new exceptions_1.CosmosWalletException(new Error(`Please install ${(0, utils_1.capitalize)(wallet)} extension`), {
-                code: exceptions_1.UnspecifiedErrorCode,
-                type: exceptions_1.ErrorType.WalletNotInstalledError,
-                contextModule: wallet,
-            });
-        }
-        return cosmos;
-    }
-    async disableGasCheck() {
-        const { wallet } = this;
-        const cosmosWallet = await this.getCosmosWallet();
-        if (![wallet_base_1.Wallet.Keplr, wallet_base_1.Wallet.OWallet].includes(wallet)) {
-            throw new exceptions_1.CosmosWalletException(new Error(`disableGasCheck is not support on ${(0, utils_1.capitalize)(wallet)}`));
-        }
-        // Temporary disable tx gas check for fee delegation purposes
-        cosmosWallet.defaultOptions = {
-            ...cosmosWallet.defaultOptions,
-            sign: {
-                ...cosmosWallet.defaultOptions.sign,
-                disableBalanceCheck: true,
-            },
-        };
-    }
-    async enableGasCheck() {
-        const { wallet } = this;
-        const cosmosWallet = await this.getCosmosWallet();
-        if (![wallet_base_1.Wallet.Keplr, wallet_base_1.Wallet.OWallet].includes(wallet)) {
-            throw new exceptions_1.CosmosWalletException(new Error(`EnableGasCheck is not support on ${(0, utils_1.capitalize)(wallet)}`));
-        }
-        // Temporary disable tx gas check for fee delegation purposes
-        cosmosWallet.defaultOptions = {
-            ...cosmosWallet.defaultOptions,
-            sign: {
-                ...cosmosWallet.defaultOptions.sign,
-                disableBalanceCheck: false,
-            },
-        };
-    }
-}
-exports.CosmosWallet = CosmosWallet;

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

@@ -1,2 +0,0 @@
-import type { Wallet as WalletType } from '@injectivelabs/wallet-base';
-export declare const cosmosWallets: WalletType[];

package/dist/esm/data/index.js

@@ -1,7 +0,0 @@
-import { Wallet } from '@injectivelabs/wallet-base';
-export const cosmosWallets = [
-    Wallet.Leap,
-    Wallet.Ninji,
-    Wallet.Keplr,
-    Wallet.OWallet,
-];

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

@@ -1,48 +0,0 @@
-import { Wallet, WalletDeviceType, BaseConcreteStrategy } from '@injectivelabs/wallet-base';
-import { CosmosWallet } from './../wallet.js';
-import type { OfflineSigner } from '@cosmjs/proto-signing';
-import type { ChainId, EvmChainId, CosmosChainId, AccountAddress } from '@injectivelabs/ts-types';
-import type { TxRaw, TxResponse, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
-import type { StdSignDoc, ConcreteWalletStrategy, SendTransactionOptions } from '@injectivelabs/wallet-base';
-export declare class CosmosWalletStrategy extends BaseConcreteStrategy implements ConcreteWalletStrategy {
-    wallet: Wallet;
-    private cosmosWallet;
-    constructor(args: {
-        chainId: ChainId | CosmosChainId;
-        endpoints?: {
-            rest: string;
-            rpc: string;
-        };
-    } & {
-        wallet: Wallet;
-    });
-    getWalletDeviceType(): Promise<WalletDeviceType>;
-    enable(): Promise<boolean>;
-    disconnect(): Promise<void>;
-    getAddresses(): Promise<string[]>;
-    getSessionOrConfirm(address: AccountAddress): Promise<string>;
-    sendEvmTransaction(_transaction: unknown, _options: {
-        address: AccountAddress;
-        evmChainId: EvmChainId;
-    }): Promise<string>;
-    sendTransaction(transaction: DirectSignResponse | TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
-    signAminoCosmosTransaction(transaction: {
-        address: string;
-        signDoc: StdSignDoc;
-    }): Promise<AminoSignResponse>;
-    signCosmosTransaction(transaction: {
-        txRaw: TxRaw;
-        accountNumber: number;
-        chainId: string;
-        address: AccountAddress;
-    }): Promise<DirectSignResponse>;
-    signEip712TypedData(_eip712TypedData: string, _address: AccountAddress): Promise<string>;
-    signArbitrary(signer: string, data: string | Uint8Array): Promise<string>;
-    getEthereumChainId(): Promise<string>;
-    getEvmTransactionReceipt(_txHash: string): Promise<string>;
-    getPubKey(): Promise<string>;
-    onAccountChange(callback: (account: AccountAddress | string[]) => void): Promise<void>;
-    getCosmosWallet(chainId: ChainId): CosmosWallet;
-    getOfflineSigner(chainId?: string): Promise<OfflineSigner>;
-    private getCurrentCosmosWallet;
-}

package/dist/esm/strategy/strategy.js

@@ -1,208 +0,0 @@
-import { capitalize } from '@injectivelabs/utils';
-import { waitTxBroadcasted, createTxRawFromSigResponse, createSignDocFromTransaction, } from '@injectivelabs/sdk-ts';
-import { ErrorType, UnspecifiedErrorCode, CosmosWalletException, TransactionException, } from '@injectivelabs/exceptions';
-import { Wallet, WalletAction, WalletDeviceType, WalletEventListener, BaseConcreteStrategy, createCosmosSignDocFromSignDoc, } from '@injectivelabs/wallet-base';
-import { CosmosWallet } from './../wallet.js';
-const cosmosWallets = [
-    Wallet.Leap,
-    Wallet.Ninji,
-    Wallet.Keplr,
-    Wallet.OWallet,
-];
-export class CosmosWalletStrategy extends BaseConcreteStrategy {
-    wallet;
-    cosmosWallet;
-    constructor(args) {
-        super({ ...args, chainId: args.chainId });
-        if (!cosmosWallets.includes(args.wallet)) {
-            throw new CosmosWalletException(new Error(`Cosmos Wallet for ${capitalize(args.wallet)} is not supported.`));
-        }
-        this.wallet = args.wallet;
-        this.chainId = args.chainId;
-        this.cosmosWallet = new CosmosWallet({
-            wallet: args.wallet,
-            chainId: args.chainId,
-        });
-    }
-    async getWalletDeviceType() {
-        const cosmosWallet = this.getCurrentCosmosWallet();
-        const key = await cosmosWallet.getKey();
-        return key.isNanoLedger
-            ? Promise.resolve(WalletDeviceType.Hardware)
-            : Promise.resolve(WalletDeviceType.Browser);
-    }
-    async enable() {
-        const cosmosWallet = this.getCurrentCosmosWallet();
-        return await cosmosWallet.checkChainIdSupport();
-    }
-    async disconnect() {
-        const { wallet } = this;
-        if (this.listeners[WalletEventListener.AccountChange]) {
-            if (wallet === Wallet.Ninji) {
-                window.ninji.off('accountsChanged', this.listeners[WalletEventListener.AccountChange]);
-            }
-            if ([Wallet.Keplr, Wallet.OWallet].includes(wallet)) {
-                window.removeEventListener('keplr_keystorechange', this.listeners[WalletEventListener.AccountChange]);
-            }
-            if (wallet === Wallet.Leap) {
-                window.removeEventListener('leap_keystorechange', this.listeners[WalletEventListener.AccountChange]);
-            }
-        }
-        this.listeners = {};
-    }
-    async getAddresses() {
-        const cosmosWallet = this.getCurrentCosmosWallet();
-        try {
-            const accounts = await cosmosWallet.getAccounts();
-            return accounts.map((account) => account.address);
-        }
-        catch (e) {
-            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) {
-        const { wallet } = this;
-        throw new CosmosWalletException(new Error(`sendEvmTransaction is not supported. ${capitalize(wallet)} only supports sending cosmos transactions`), {
-            code: UnspecifiedErrorCode,
-            context: WalletAction.SendEvmTransaction,
-        });
-    }
-    async sendTransaction(transaction, options) {
-        const cosmosWallet = this.getCurrentCosmosWallet();
-        const txRaw = createTxRawFromSigResponse(transaction);
-        if (!options.endpoints) {
-            throw new CosmosWalletException(new Error('You have to pass endpoints within the options to broadcast transaction'));
-        }
-        try {
-            const txHash = await cosmosWallet.broadcastTx(txRaw);
-            return await waitTxBroadcasted(txHash, options);
-        }
-        catch (e) {
-            if (e instanceof TransactionException) {
-                throw e;
-            }
-            throw new TransactionException(new Error(e.message), {
-                code: UnspecifiedErrorCode,
-                context: WalletAction.SendTransaction,
-            });
-        }
-    }
-    async signAminoCosmosTransaction(transaction) {
-        const cosmosWallet = this.getCurrentCosmosWallet();
-        const signer = await cosmosWallet.getOfflineAminoSigner();
-        try {
-            return await signer.signAmino(transaction.address, transaction.signDoc);
-        }
-        catch (e) {
-            throw new CosmosWalletException(new Error(e.message), {
-                code: UnspecifiedErrorCode,
-                context: WalletAction.SignTransaction,
-            });
-        }
-    }
-    async signCosmosTransaction(transaction) {
-        const cosmosWallet = this.getCurrentCosmosWallet();
-        const signer = await cosmosWallet.getOfflineSigner(this.chainId);
-        const signDoc = createSignDocFromTransaction(transaction);
-        try {
-            if (!('signDirect' in signer)) {
-                throw new CosmosWalletException(new Error('signDirect not available'), {
-                    code: UnspecifiedErrorCode,
-                    context: WalletAction.SendTransaction,
-                });
-            }
-            return await signer.signDirect(transaction.address, createCosmosSignDocFromSignDoc(signDoc));
-        }
-        catch (e) {
-            throw new CosmosWalletException(new Error(e.message), {
-                code: UnspecifiedErrorCode,
-                context: WalletAction.SendTransaction,
-            });
-        }
-    }
-    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) {
-        const cosmosWallet = this.getCurrentCosmosWallet();
-        try {
-            const signature = await cosmosWallet.signArbitrary({ data, signer });
-            return signature;
-        }
-        catch (e) {
-            throw new CosmosWalletException(new Error(e.message), {
-                code: UnspecifiedErrorCode,
-                context: WalletAction.SignArbitrary,
-            });
-        }
-    }
-    async getEthereumChainId() {
-        const { wallet } = this;
-        throw new CosmosWalletException(new Error(`getEthereumChainId is not supported on ${capitalize(wallet)}`), {
-            code: UnspecifiedErrorCode,
-            context: WalletAction.GetChainId,
-        });
-    }
-    async getEvmTransactionReceipt(_txHash) {
-        const { wallet } = this;
-        throw new CosmosWalletException(new Error(`getEvmTransactionReceipt is not supported on ${capitalize(wallet)}`), {
-            code: UnspecifiedErrorCode,
-            context: WalletAction.GetEvmTransactionReceipt,
-        });
-    }
-    async getPubKey() {
-        const cosmosWallet = this.getCurrentCosmosWallet();
-        const key = await cosmosWallet.getKey();
-        return Buffer.from(key.pubKey).toString('base64');
-    }
-    async onAccountChange(callback) {
-        const { wallet } = this;
-        const listener = async () => {
-            const [account] = await this.getAddresses();
-            callback(account);
-        };
-        this.listeners = {
-            [WalletEventListener.AccountChange]: listener,
-        };
-        if (wallet === Wallet.Ninji) {
-            window.ninji.on('accountsChanged', listener);
-        }
-        if ([Wallet.Keplr, Wallet.OWallet].includes(wallet)) {
-            window.addEventListener('keplr_keystorechange', listener);
-        }
-        if (wallet === Wallet.Leap) {
-            window.addEventListener('leap_keystorechange', listener);
-        }
-    }
-    getCosmosWallet(chainId) {
-        const { wallet, cosmosWallet } = this;
-        return !cosmosWallet ? new CosmosWallet({ chainId, wallet }) : cosmosWallet;
-    }
-    async getOfflineSigner(chainId) {
-        const cosmosWallet = await this.getCosmosWallet(chainId || this.chainId);
-        if (!cosmosWallet) {
-            throw new Error('no cosmos wallet');
-        }
-        return await cosmosWallet.getOfflineSigner(chainId || this.chainId);
-    }
-    getCurrentCosmosWallet() {
-        const { wallet, cosmosWallet } = this;
-        if (!cosmosWallet) {
-            throw new CosmosWalletException(new Error(`Please install the ${capitalize(wallet)} wallet extension`), {
-                code: UnspecifiedErrorCode,
-                type: ErrorType.WalletNotInstalledError,
-                context: WalletAction.SignTransaction,
-            });
-        }
-        return cosmosWallet;
-    }
-}

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

@@ -1,8 +0,0 @@
-import { Wallet } from '@injectivelabs/wallet-base';
-import type { ChainId } from '@injectivelabs/ts-types';
-export declare const isCosmosWalletInstalled: (wallet: Wallet) => boolean;
-export declare const confirmCosmosAddress: ({ wallet, chainId, injectiveAddress, }: {
-    wallet: Wallet;
-    chainId: ChainId;
-    injectiveAddress: string;
-}) => Promise<void>;

package/dist/esm/utils/index.js

@@ -1,33 +0,0 @@
-import { PublicKey } from '@injectivelabs/sdk-ts';
-import { capitalize } from '@injectivelabs/utils';
-import { Wallet } from '@injectivelabs/wallet-base';
-import { CosmosWalletException } from '@injectivelabs/exceptions';
-import { CosmosWallet } from './../wallet.js';
-import { cosmosWallets } from './../data/index.js';
-export const isCosmosWalletInstalled = (wallet) => {
-    const $window = (typeof window !== 'undefined' ? window : {});
-    switch (wallet) {
-        case Wallet.Keplr:
-            return $window.keplr !== undefined;
-        case Wallet.Ninji:
-            return $window.ninji !== undefined;
-        case Wallet.Leap:
-            return $window.leap !== undefined;
-        case Wallet.OWallet:
-            return $window.oWallet !== undefined;
-        default:
-            return false;
-    }
-};
-export const confirmCosmosAddress = async ({ wallet, chainId, injectiveAddress, }) => {
-    if (!cosmosWallets.includes(wallet)) {
-        throw new CosmosWalletException(new Error(`Cosmos Wallet for ${capitalize(wallet)} is not supported.`));
-    }
-    const cosmosWallet = new CosmosWallet({ chainId, wallet });
-    const key = await cosmosWallet.getKey();
-    const publicKey = PublicKey.fromBase64(Buffer.from(key.pubKey).toString('base64'));
-    const { address: derivedAddress } = publicKey.toAddress();
-    if (derivedAddress !== injectiveAddress) {
-        throw new CosmosWalletException(new Error(`Connected ${capitalize(wallet)} address is wrong. Please update Injective on ${capitalize(wallet)}.`));
-    }
-};

package/dist/esm/wallet.d.ts

@@ -1,62 +0,0 @@
-import { CosmosTxV1Beta1Tx } from '@injectivelabs/sdk-ts';
-import { Wallet } from '@injectivelabs/wallet-base';
-import type { StdFee } from '@cosmjs/stargate';
-import type { EncodeObject } from '@cosmjs/proto-signing';
-import type { OfflineSigner } from '@cosmjs/proto-signing';
-import type { ChainId, CosmosChainId, TestnetCosmosChainId } from '@injectivelabs/ts-types';
-import type { Keplr, StdSignDoc, AminoSignResponse, OfflineAminoSigner } from '@keplr-wallet/types';
-export declare class CosmosWallet {
-    wallet: Wallet;
-    private chainId;
-    constructor({ wallet, chainId, }: {
-        wallet: Wallet;
-        chainId: CosmosChainId | TestnetCosmosChainId | ChainId;
-    });
-    isChainIdSupported(chainId: CosmosChainId): Promise<boolean>;
-    getCosmosWallet(): Promise<Keplr>;
-    chainNotSupported(): Promise<void>;
-    getAccounts(): Promise<readonly import("@keplr-wallet/types").AccountData[]>;
-    getKey(): Promise<{
-        name: string;
-        algo: string;
-        isNanoLedger: boolean;
-        pubKey: Uint8Array;
-        address: Uint8Array;
-        bech32Address: string;
-    }>;
-    getOfflineSigner(chainId?: string): Promise<OfflineSigner>;
-    getOfflineAminoSigner(): Promise<OfflineAminoSigner>;
-    /**
-     * This method is used to broadcast a transaction to the network.
-     * Since it uses the `Sync` mode, it will not wait for the transaction to be included in a block,
-     * so we have to make sure the transaction is included in a block after its broadcasted
-     *
-     * @param txRaw - raw transaction to broadcast
-     * @returns tx hash
-     */
-    broadcastTx(txRaw: CosmosTxV1Beta1Tx.TxRaw): Promise<string>;
-    /**
-     * This method is used to broadcast a transaction to the network.
-     * Since it uses the `Block` mode, and it will wait for the transaction to be included in a block,
-     *
-     * @param txRaw - raw transaction to broadcast
-     * @returns tx hash
-     */
-    broadcastTxBlock(txRaw: CosmosTxV1Beta1Tx.TxRaw): Promise<string>;
-    signAndBroadcastAminoUsingCosmjs(messages: EncodeObject[], stdFee: StdFee, endpoints: {
-        rest: string;
-        rpc: string;
-    }): Promise<import("@cosmjs/stargate").DeliverTxResponse>;
-    signArbitrary({ data, signer, }: {
-        signer: string;
-        data: string | Uint8Array;
-    }): Promise<string>;
-    signEIP712CosmosTx({ eip712, signDoc, }: {
-        eip712: any;
-        signDoc: StdSignDoc;
-    }): Promise<AminoSignResponse>;
-    checkChainIdSupport(): Promise<boolean>;
-    private getCosmos;
-    disableGasCheck(): Promise<void>;
-    enableGasCheck(): Promise<void>;
-}