@dynamic-labs/cosmos 3.0.0-alpha.8 → 3.0.0

package/_virtual/_tslib.cjs

@@ -0,0 +1,36 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+exports.__awaiter = __awaiter;

package/_virtual/_tslib.js

@@ -0,0 +1,32 @@
+'use client'
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+export { __awaiter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/cosmos",
-  "version": "3.0.0-alpha.8",
+  "version": "3.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/dynamic-labs/dynamic-auth.git",
@@ -26,7 +26,11 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@dynamic-labs/keplr": "3.0.0-alpha.8"
+    "@keplr-wallet/types": "0.12.121",
+    "@dynamic-labs/types": "3.0.0",
+    "@dynamic-labs/utils": "3.0.0",
+    "@dynamic-labs/wallet-book": "3.0.0",
+    "@dynamic-labs/wallet-connector-core": "3.0.0"
   },
   "peerDependencies": {}
 }

package/src/connectors/CosmosWalletConnector.cjs

@@ -0,0 +1,73 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var CosmosWallet = require('../wallet/CosmosWallet.cjs');
+
+class CosmosWalletConnector extends walletConnectorCore.WalletConnectorBase {
+    constructor(opts) {
+        super(opts);
+        this.ChainWallet = CosmosWallet.CosmosWallet;
+        this.connectedChain = 'COSMOS';
+        this.supportedChains = ['COSMOS'];
+        this.evmNetworks = utils.parseEvmNetworks(opts.cosmosNetworks);
+        this.chainIdMapping = this.evmNetworks.map((network) => ({
+            cosmosNetworkId: network.name,
+            dynamicChainId: utils.parseChainId(network.networkId),
+            evmNetwork: network,
+        }));
+    }
+    getSelectedNetwork() {
+        const selectedNetwork = this.chainIdMapping.find((mapping) => mapping.cosmosNetworkId === this.getChainId());
+        return selectedNetwork === null || selectedNetwork === void 0 ? void 0 : selectedNetwork.evmNetwork;
+    }
+    getNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = this.getSelectedNetwork()) === null || _a === void 0 ? void 0 : _a.chainId;
+        });
+    }
+    getLcdUrl() {
+        var _a;
+        return (_a = this.getSelectedNetwork()) === null || _a === void 0 ? void 0 : _a.lcdUrl;
+    }
+    getDenom() {
+        var _a;
+        return (_a = this.getSelectedNetwork()) === null || _a === void 0 ? void 0 : _a.nativeCurrency.denom;
+    }
+    getBalance(address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield fetch(`${this.getLcdUrl()}/cosmos/bank/v1beta1/balances/${address}`).then((res) => res.json());
+                const balance = response.balances.reduce((acc, cur) => {
+                    if (cur.denom === this.getDenom()) {
+                        return Number(cur.amount) / 1e6;
+                    }
+                    return acc;
+                }, 0);
+                return balance.toString();
+            }
+            catch (e) {
+                walletConnectorCore.logger.error(e);
+                return '0';
+            }
+        });
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddress();
+            return [address];
+        });
+    }
+    endSession() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            this.setChainId(null);
+        });
+    }
+}
+
+exports.CosmosWalletConnector = CosmosWalletConnector;

package/src/connectors/CosmosWalletConnector.d.ts

@@ -0,0 +1,47 @@
+import { EvmNetwork, GenericNetwork } from '@dynamic-labs/types';
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import { Chain, WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
+import { ICosmosOfflineSigner, ICosmosProvider } from '../types';
+import { CosmosWallet } from '../wallet';
+export interface IFetchBalanceResponse {
+    balances: IFetchBalanceBalance[];
+    pagination: IFetchBalancePagination;
+}
+export interface IFetchBalanceBalance {
+    amount: string;
+    denom: string;
+}
+export interface IFetchBalancePagination {
+    next_key: any;
+    total: string;
+}
+export type CosmosWalletConnectorOpts = {
+    cosmosNetworks: GenericNetwork[];
+    walletBook: WalletBookSchema;
+};
+type CosmosChainIDMapObject = {
+    dynamicChainId: number;
+    cosmosNetworkId: string;
+    evmNetwork: EvmNetwork;
+};
+export declare abstract class CosmosWalletConnector extends WalletConnectorBase {
+    evmNetworks: EvmNetwork[];
+    ChainWallet: typeof CosmosWallet;
+    connectedChain: Chain;
+    supportedChains: Chain[];
+    chainIdMapping: CosmosChainIDMapObject[];
+    constructor(opts: CosmosWalletConnectorOpts);
+    abstract getChainId(): string;
+    abstract setChainId(chainId: string | null): void;
+    abstract getProvider(): Promise<ICosmosProvider | undefined>;
+    abstract getOfflineSigner(): Promise<ICosmosOfflineSigner>;
+    getSelectedNetwork(): EvmNetwork | undefined;
+    getNetwork(): Promise<number | undefined>;
+    getLcdUrl(): string | undefined;
+    getDenom(): string | undefined;
+    getBalance(address: string): Promise<string | undefined>;
+    abstract getAddress(): Promise<string>;
+    getConnectedAccounts(): Promise<string[]>;
+    endSession(): Promise<void>;
+}
+export {};

package/src/connectors/CosmosWalletConnector.js

@@ -0,0 +1,69 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { parseEvmNetworks, parseChainId } from '@dynamic-labs/utils';
+import { WalletConnectorBase, logger } from '@dynamic-labs/wallet-connector-core';
+import { CosmosWallet } from '../wallet/CosmosWallet.js';
+
+class CosmosWalletConnector extends WalletConnectorBase {
+    constructor(opts) {
+        super(opts);
+        this.ChainWallet = CosmosWallet;
+        this.connectedChain = 'COSMOS';
+        this.supportedChains = ['COSMOS'];
+        this.evmNetworks = parseEvmNetworks(opts.cosmosNetworks);
+        this.chainIdMapping = this.evmNetworks.map((network) => ({
+            cosmosNetworkId: network.name,
+            dynamicChainId: parseChainId(network.networkId),
+            evmNetwork: network,
+        }));
+    }
+    getSelectedNetwork() {
+        const selectedNetwork = this.chainIdMapping.find((mapping) => mapping.cosmosNetworkId === this.getChainId());
+        return selectedNetwork === null || selectedNetwork === void 0 ? void 0 : selectedNetwork.evmNetwork;
+    }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = this.getSelectedNetwork()) === null || _a === void 0 ? void 0 : _a.chainId;
+        });
+    }
+    getLcdUrl() {
+        var _a;
+        return (_a = this.getSelectedNetwork()) === null || _a === void 0 ? void 0 : _a.lcdUrl;
+    }
+    getDenom() {
+        var _a;
+        return (_a = this.getSelectedNetwork()) === null || _a === void 0 ? void 0 : _a.nativeCurrency.denom;
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield fetch(`${this.getLcdUrl()}/cosmos/bank/v1beta1/balances/${address}`).then((res) => res.json());
+                const balance = response.balances.reduce((acc, cur) => {
+                    if (cur.denom === this.getDenom()) {
+                        return Number(cur.amount) / 1e6;
+                    }
+                    return acc;
+                }, 0);
+                return balance.toString();
+            }
+            catch (e) {
+                logger.error(e);
+                return '0';
+            }
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddress();
+            return [address];
+        });
+    }
+    endSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setChainId(null);
+        });
+    }
+}
+
+export { CosmosWalletConnector };

package/src/connectors/KeplrWalletConnector.cjs

@@ -0,0 +1,138 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var CosmosWalletConnector = require('./CosmosWalletConnector.cjs');
+
+const DYNAMIC_KEPLR_NETWORK_ID = 'dynamic_keplr_network_id';
+class KeplrWalletConnector extends CosmosWalletConnector.CosmosWalletConnector {
+    constructor(opts) {
+        super(opts);
+        this.switchNetworkOnlyFromWallet = true;
+        this.name = 'Keplr';
+        this.overrideKey = 'keplr';
+        this._handleAccountChange = this._handleAccountChange.bind(this);
+    }
+    getDefaultChainId() {
+        if (this.chainIdMapping.length === 0) {
+            return 'cosmoshub-4';
+        }
+        if (this.chainIdMapping.find((chain) => chain.cosmosNetworkId === 'cosmoshub-4')) {
+            return 'cosmoshub-4';
+        }
+        else {
+            return this.chainIdMapping[0].cosmosNetworkId;
+        }
+    }
+    getChainId() {
+        const defaultChainId = this.getDefaultChainId();
+        const storedChainId = localStorage.getItem(DYNAMIC_KEPLR_NETWORK_ID);
+        return storedChainId !== null && storedChainId !== void 0 ? storedChainId : defaultChainId;
+    }
+    setChainId(chainId) {
+        if (!chainId) {
+            localStorage.removeItem(DYNAMIC_KEPLR_NETWORK_ID);
+        }
+        else {
+            localStorage.setItem(DYNAMIC_KEPLR_NETWORK_ID, chainId);
+        }
+    }
+    getAccount() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const accountsList = yield this.keplr
+                .getOfflineSigner(this.getChainId())
+                .getAccounts();
+            if (!accountsList)
+                throw new Error('No accounts found');
+            const [account] = accountsList;
+            return account;
+        });
+    }
+    get keplr() {
+        if (typeof window === 'undefined')
+            throw new Error('Keplr is not available');
+        // @ts-expect-error keplr is not defined if extension is not installed
+        return window.keplr;
+    }
+    connect() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.keplr.enable(this.chainIdMapping.map((mapping) => mapping.cosmosNetworkId));
+        });
+    }
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.connect();
+            const account = yield this.getAccount();
+            return account.address;
+        });
+    }
+    getProvider() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.keplr;
+        });
+    }
+    getOfflineSigner() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.keplr.getOfflineSigner(this.getChainId());
+        });
+    }
+    isInstalledOnBrowser() {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore window.keplr is provided by extension
+        return typeof window.keplr !== 'undefined';
+    }
+    _handleAccountChange() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddress();
+            this.emit('accountChange', { accounts: [address] });
+        });
+    }
+    setupEventListeners() {
+        window.addEventListener('keplr_keystorechange', this._handleAccountChange);
+    }
+    teardownEventListeners() {
+        window.removeEventListener('keplr_keystorechange', this._handleAccountChange);
+        this.setChainId(null);
+    }
+    // SignDoc used for signAmin method;
+    getSignDoc(message) {
+        return {
+            account_number: '0',
+            chain_id: this.getChainId(),
+            fee: { amount: [], gas: '0' },
+            memo: '',
+            msgs: [{ type: 'custom/MsgSignText', value: { text: message } }],
+            sequence: '0',
+        };
+    }
+    signMessage(messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const signDoc = this.getSignDoc(messageToSign);
+            const address = yield this.getAddress();
+            const signatureResponse = yield this.keplr.signAmino(this.getChainId(), address, signDoc);
+            if (!signatureResponse)
+                throw new Error('Could not sign message');
+            return JSON.stringify(signatureResponse);
+        });
+    }
+    supportsNetworkSwitching() {
+        return true;
+    }
+    switchNetwork(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ networkChainId, }) {
+            if (!networkChainId)
+                return;
+            this.chainIdMapping.forEach((mapping) => {
+                if (mapping.dynamicChainId === networkChainId) {
+                    this.setChainId(mapping.cosmosNetworkId);
+                    this.emit('chainChange', { chain: networkChainId.toString() });
+                }
+            });
+        });
+    }
+}
+
+exports.DYNAMIC_KEPLR_NETWORK_ID = DYNAMIC_KEPLR_NETWORK_ID;
+exports.KeplrWalletConnector = KeplrWalletConnector;

package/src/connectors/KeplrWalletConnector.d.ts

@@ -0,0 +1,45 @@
+import { Keplr as KeplrWallet } from '@keplr-wallet/types';
+import { CosmosWalletConnector, CosmosWalletConnectorOpts } from './CosmosWalletConnector';
+export type SwitchNetworkOps = {
+    networkChainId?: number;
+    networkName?: string;
+};
+export declare const DYNAMIC_KEPLR_NETWORK_ID = "dynamic_keplr_network_id";
+export declare class KeplrWalletConnector extends CosmosWalletConnector {
+    switchNetworkOnlyFromWallet: boolean;
+    name: string;
+    overrideKey: string;
+    constructor(opts: CosmosWalletConnectorOpts);
+    getDefaultChainId(): string;
+    getChainId(): string;
+    setChainId(chainId: string | null): void;
+    protected getAccount(): Promise<import("@keplr-wallet/types").AccountData>;
+    get keplr(): KeplrWallet;
+    connect(): Promise<void>;
+    getAddress(): Promise<string>;
+    getProvider(): Promise<KeplrWallet>;
+    getOfflineSigner(): Promise<import("@keplr-wallet/types").OfflineAminoSigner & import("@keplr-wallet/types").OfflineDirectSigner>;
+    isInstalledOnBrowser(): boolean;
+    _handleAccountChange(): Promise<void>;
+    setupEventListeners(): void;
+    teardownEventListeners(): void;
+    protected getSignDoc(message: string): {
+        account_number: string;
+        chain_id: string;
+        fee: {
+            amount: never[];
+            gas: string;
+        };
+        memo: string;
+        msgs: {
+            type: string;
+            value: {
+                text: string;
+            };
+        }[];
+        sequence: string;
+    };
+    signMessage(messageToSign: string): Promise<string | undefined>;
+    supportsNetworkSwitching(): boolean;
+    switchNetwork({ networkChainId, }: SwitchNetworkOps): Promise<void>;
+}

package/src/connectors/KeplrWalletConnector.js

@@ -0,0 +1,133 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { CosmosWalletConnector } from './CosmosWalletConnector.js';
+
+const DYNAMIC_KEPLR_NETWORK_ID = 'dynamic_keplr_network_id';
+class KeplrWalletConnector extends CosmosWalletConnector {
+    constructor(opts) {
+        super(opts);
+        this.switchNetworkOnlyFromWallet = true;
+        this.name = 'Keplr';
+        this.overrideKey = 'keplr';
+        this._handleAccountChange = this._handleAccountChange.bind(this);
+    }
+    getDefaultChainId() {
+        if (this.chainIdMapping.length === 0) {
+            return 'cosmoshub-4';
+        }
+        if (this.chainIdMapping.find((chain) => chain.cosmosNetworkId === 'cosmoshub-4')) {
+            return 'cosmoshub-4';
+        }
+        else {
+            return this.chainIdMapping[0].cosmosNetworkId;
+        }
+    }
+    getChainId() {
+        const defaultChainId = this.getDefaultChainId();
+        const storedChainId = localStorage.getItem(DYNAMIC_KEPLR_NETWORK_ID);
+        return storedChainId !== null && storedChainId !== void 0 ? storedChainId : defaultChainId;
+    }
+    setChainId(chainId) {
+        if (!chainId) {
+            localStorage.removeItem(DYNAMIC_KEPLR_NETWORK_ID);
+        }
+        else {
+            localStorage.setItem(DYNAMIC_KEPLR_NETWORK_ID, chainId);
+        }
+    }
+    getAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accountsList = yield this.keplr
+                .getOfflineSigner(this.getChainId())
+                .getAccounts();
+            if (!accountsList)
+                throw new Error('No accounts found');
+            const [account] = accountsList;
+            return account;
+        });
+    }
+    get keplr() {
+        if (typeof window === 'undefined')
+            throw new Error('Keplr is not available');
+        // @ts-expect-error keplr is not defined if extension is not installed
+        return window.keplr;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.keplr.enable(this.chainIdMapping.map((mapping) => mapping.cosmosNetworkId));
+        });
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.connect();
+            const account = yield this.getAccount();
+            return account.address;
+        });
+    }
+    getProvider() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.keplr;
+        });
+    }
+    getOfflineSigner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.keplr.getOfflineSigner(this.getChainId());
+        });
+    }
+    isInstalledOnBrowser() {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore window.keplr is provided by extension
+        return typeof window.keplr !== 'undefined';
+    }
+    _handleAccountChange() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddress();
+            this.emit('accountChange', { accounts: [address] });
+        });
+    }
+    setupEventListeners() {
+        window.addEventListener('keplr_keystorechange', this._handleAccountChange);
+    }
+    teardownEventListeners() {
+        window.removeEventListener('keplr_keystorechange', this._handleAccountChange);
+        this.setChainId(null);
+    }
+    // SignDoc used for signAmin method;
+    getSignDoc(message) {
+        return {
+            account_number: '0',
+            chain_id: this.getChainId(),
+            fee: { amount: [], gas: '0' },
+            memo: '',
+            msgs: [{ type: 'custom/MsgSignText', value: { text: message } }],
+            sequence: '0',
+        };
+    }
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signDoc = this.getSignDoc(messageToSign);
+            const address = yield this.getAddress();
+            const signatureResponse = yield this.keplr.signAmino(this.getChainId(), address, signDoc);
+            if (!signatureResponse)
+                throw new Error('Could not sign message');
+            return JSON.stringify(signatureResponse);
+        });
+    }
+    supportsNetworkSwitching() {
+        return true;
+    }
+    switchNetwork(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ networkChainId, }) {
+            if (!networkChainId)
+                return;
+            this.chainIdMapping.forEach((mapping) => {
+                if (mapping.dynamicChainId === networkChainId) {
+                    this.setChainId(mapping.cosmosNetworkId);
+                    this.emit('chainChange', { chain: networkChainId.toString() });
+                }
+            });
+        });
+    }
+}
+
+export { DYNAMIC_KEPLR_NETWORK_ID, KeplrWalletConnector };

package/src/connectors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './KeplrWalletConnector';
+export * from './CosmosWalletConnector';

package/src/index.cjs

@@ -3,10 +3,15 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var keplr = require('@dynamic-labs/keplr');
+var KeplrWalletConnector = require('./connectors/KeplrWalletConnector.cjs');
+require('../_virtual/_tslib.cjs');
+require('@dynamic-labs/utils');
+require('@dynamic-labs/wallet-connector-core');
+var CosmosWallet = require('./wallet/CosmosWallet.cjs');
+var isCosmosWallet = require('./wallet/isCosmosWallet/isCosmosWallet.cjs');
 
-const CosmosWalletConnectors = (props) => [
-    ...keplr.KeplrWalletConnectors(props),
-];
+const CosmosWalletConnectors = () => [KeplrWalletConnector.KeplrWalletConnector];
 
+exports.CosmosWallet = CosmosWallet.CosmosWallet;
+exports.isCosmosWallet = isCosmosWallet.isCosmosWallet;
 exports.CosmosWalletConnectors = CosmosWalletConnectors;

package/src/index.d.ts

@@ -1 +1,5 @@
-export declare const CosmosWalletConnectors: (props: any) => typeof import("@dynamic-labs/keplr").KeplrWalletConnector[];
+import { KeplrWalletConnector } from './connectors';
+export * from './wallet';
+export { type ICosmosOfflineSigner, type ICosmosProvider } from './types';
+export { type CosmosWalletConnector } from './connectors/CosmosWalletConnector';
+export declare const CosmosWalletConnectors: () => (typeof KeplrWalletConnector)[];

package/src/index.js

@@ -1,8 +1,11 @@
 'use client'
-import { KeplrWalletConnectors } from '@dynamic-labs/keplr';
+import { KeplrWalletConnector } from './connectors/KeplrWalletConnector.js';
+import '../_virtual/_tslib.js';
+import '@dynamic-labs/utils';
+import '@dynamic-labs/wallet-connector-core';
+export { CosmosWallet } from './wallet/CosmosWallet.js';
+export { isCosmosWallet } from './wallet/isCosmosWallet/isCosmosWallet.js';
 
-const CosmosWalletConnectors = (props) => [
-    ...KeplrWalletConnectors(props),
-];
+const CosmosWalletConnectors = () => [KeplrWalletConnector];
 
 export { CosmosWalletConnectors };

package/src/types.d.ts

@@ -0,0 +1,7 @@
+import { type Window as KeplrWindow, type Keplr as KeplrWallet, type OfflineAminoSigner, type OfflineDirectSigner } from '@keplr-wallet/types';
+declare global {
+    interface Window extends KeplrWindow {
+    }
+}
+export type ICosmosOfflineSigner = OfflineAminoSigner & OfflineDirectSigner;
+export type ICosmosProvider = KeplrWallet;