@dynamic-labs/multi-wallet 0.16.0 → 0.16.1

package/CHANGELOG.md

@@ -1,4 +1,11 @@
 
+### [0.16.1](https://github.com/dynamic-labs/DynamicAuth/compare/v0.16.0...v0.16.1) (2023-04-15)
+
+
+### Bug Fixes
+
+* stream polyfill error that impacted some setups ([#1876](https://github.com/dynamic-labs/DynamicAuth/issues/1876)) ([7e4ef90](https://github.com/dynamic-labs/DynamicAuth/commit/7e4ef90f372f61f8961f8e6a5dd2a22f06e3d8ba))
+
 ## [0.16.0](https://github.com/dynamic-labs/DynamicAuth/compare/v0.15.0...v0.16.0) (2023-04-14)
 It is has been a bit over a month since our last stable launch, and here comes V0.16.0!
 We have some cool features for you and one breaking change that you should be aware of (We try our best to minimize these, but we gotta keep on cleaning legacy stuff).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/multi-wallet",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/dynamic-labs/DynamicAuth.git",
@@ -8,6 +8,7 @@
   },
   "dependencies": {
     "buffer": "^6.0.3",
+    "deepmerge": "^4.3.1",
     "@dynamic-labs/sdk-api": "0.0.174",
     "@dynamic-labs/wallet-book": "^0.0.11",
     "starknet": "^3.19.0",
@@ -16,6 +17,7 @@
     "@solana/web3.js": "^1.70.1",
     "@coinbase/wallet-sdk": "^3.6.4",
     "@walletconnect/client": "^1.8.0",
+    "@walletconnect/utils": "^1.8.0",
     "@blocto/sdk": "^0.3.3",
     "fortmatic": "^2.4.0",
     "@onflow/fcl": "^1.3.2",
@@ -24,10 +26,10 @@
     "@walletconnect/universal-provider": "^2.4.2",
     "tslib": "^2.4.1",
     "magic-sdk": "^16.0.1",
-    "@keplr-wallet/wc-client": "^0.11.53",
+    "@keplr-wallet/provider": "0.11.56",
     "@keplr-wallet/types": "^0.11.51",
-    "@dynamic-labs/logger": "0.16.0",
-    "@dynamic-labs/wallet-connector-core": "0.16.0"
+    "@dynamic-labs/logger": "0.16.1",
+    "@dynamic-labs/wallet-connector-core": "0.16.1"
   },
   "devDependencies": {
     "@walletconnect/types": "^2.2.1"

package/src/wallets/clients/walletConnect/walletConnect.d.ts

@@ -1,7 +1,7 @@
 import Client from '@walletconnect/client';
-import { KeplrWalletConnectV1 } from '@keplr-wallet/wc-client';
 import { FetchPublicAddressOpts, PayloadParams, WalletEventListeners } from '@dynamic-labs/wallet-connector-core';
 import { WalletSchema } from '@dynamic-labs/wallet-book';
+import { KeplrWalletConnectV1 } from '../../cosmos/wcClient';
 export declare const initClient: (name: string, settings?: any) => Client;
 /**
  * Attach event handlers to WalletConnect events.

package/src/wallets/cosmos/keplrWalletConnect.cjs.js

@@ -1,12 +1,12 @@
 'use strict';
 
 var tslib = require('tslib');
-var wcClient = require('@keplr-wallet/wc-client');
 var walletBook = require('@dynamic-labs/wallet-book');
 var walletConnect = require('../clients/walletConnect/walletConnect.cjs.js');
 var isMobile = require('../../utils/isMobile.cjs.js');
 var logger = require('../../utils/logger.cjs.js');
 var normalizeWalletName = require('../../utils/normalizeWalletName/normalizeWalletName.cjs.js');
+var wcClient = require('./wcClient.cjs.js');
 
 const DYNAMIC_KEPLR_NETWORK_ID = 'dynamic_keplr_wc_network_id';
 class KeplrWalletConnect {

package/src/wallets/cosmos/keplrWalletConnect.d.ts

@@ -1,9 +1,9 @@
-import { KeplrWalletConnectV1 } from '@keplr-wallet/wc-client';
 import Client from '@walletconnect/client';
 import { OfflineAminoSigner } from '@keplr-wallet/types';
 import { Chain, FetchPublicAddressOpts, WalletConnector, WalletEventListeners } from '@dynamic-labs/wallet-connector-core';
 import { EvmNetwork } from '../ethereum/evm-network';
 import { SwitchNetworkOps } from '../ethereum/ethProvider';
+import { KeplrWalletConnectV1 } from './wcClient';
 declare class KeplrWalletConnect implements WalletConnector {
     constructor({ evmNetworks }: {
         evmNetworks: EvmNetwork[];

package/src/wallets/cosmos/keplrWalletConnect.es.js

@@ -1,10 +1,10 @@
 import { __awaiter } from 'tslib';
-import { KeplrWalletConnectV1 } from '@keplr-wallet/wc-client';
 import { getWalletBookWallet } from '@dynamic-labs/wallet-book';
 import { initClient, fetchWalletConnectCosmosPublicAddress, killWalletConnectSession, getDeepLink, setupWalletConnectEventListeners, teardownWalletConnectEventListeners } from '../clients/walletConnect/walletConnect.es.js';
 import { isMobile, isIOS } from '../../utils/isMobile.es.js';
 import { logger } from '../../utils/logger.es.js';
 import { normalizeWalletName } from '../../utils/normalizeWalletName/normalizeWalletName.es.js';
+import { KeplrWalletConnectV1 } from './wcClient.es.js';
 
 const DYNAMIC_KEPLR_NETWORK_ID = 'dynamic_keplr_wc_network_id';
 class KeplrWalletConnect {

package/src/wallets/cosmos/utils/indexDB.cjs.js

@@ -0,0 +1,97 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+
+/* eslint-disable  */
+class IndexedDBKVStore {
+    constructor(_prefix) {
+        this._prefix = _prefix;
+    }
+    get(key) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const tx = (yield this.getDB()).transaction([this.prefix()], 'readonly');
+            const store = tx.objectStore(this.prefix());
+            return new Promise((resolve, reject) => {
+                const request = store.get(key);
+                request.onerror = (event) => {
+                    event.stopPropagation();
+                    reject(event.target);
+                };
+                request.onsuccess = () => {
+                    if (!request.result) {
+                        resolve(undefined);
+                    }
+                    else {
+                        resolve(request.result.data);
+                    }
+                };
+            });
+        });
+    }
+    set(key, data) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            if (data === null) {
+                const tx = (yield this.getDB()).transaction([this.prefix()], 'readwrite');
+                const store = tx.objectStore(this.prefix());
+                return new Promise((resolve, reject) => {
+                    const request = store.delete(key);
+                    request.onerror = (event) => {
+                        event.stopPropagation();
+                        reject(event.target);
+                    };
+                    request.onsuccess = () => {
+                        resolve();
+                    };
+                });
+            }
+            else {
+                const tx = (yield this.getDB()).transaction([this.prefix()], 'readwrite');
+                const store = tx.objectStore(this.prefix());
+                return new Promise((resolve, reject) => {
+                    const request = store.put({
+                        key,
+                        data,
+                    });
+                    request.onerror = (event) => {
+                        event.stopPropagation();
+                        reject(event.target);
+                    };
+                    request.onsuccess = () => {
+                        resolve();
+                    };
+                });
+            }
+        });
+    }
+    prefix() {
+        return this._prefix;
+    }
+    getDB() {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.cachedDB) {
+                return this.cachedDB;
+            }
+            return new Promise((resolve, reject) => {
+                const request = window.indexedDB.open(this.prefix());
+                request.onerror = (event) => {
+                    event.stopPropagation();
+                    reject(event.target);
+                };
+                request.onupgradeneeded = (event) => {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    const db = event.target.result;
+                    db.createObjectStore(this.prefix(), { keyPath: 'key' });
+                };
+                request.onsuccess = () => {
+                    this.cachedDB = request.result;
+                    resolve(request.result);
+                };
+            });
+        });
+    }
+}
+
+exports.IndexedDBKVStore = IndexedDBKVStore;

package/src/wallets/cosmos/utils/indexDB.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copied from https://github.com/chainapsis/keplr-wallet/blob/master/packages/common/src/kv-store/indexed-db.ts
+ * because of the dependency issue on cipher-base that required a stream polyfill.
+ */
+export interface KVStore {
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    prefix(): string;
+    set<T = unknown>(key: string, data: T | null): Promise<void>;
+}
+export declare class IndexedDBKVStore implements KVStore {
+    protected readonly _prefix: string;
+    protected cachedDB?: IDBDatabase;
+    constructor(_prefix: string);
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    set<T = unknown>(key: string, data: T | null): Promise<void>;
+    prefix(): string;
+    protected getDB(): Promise<IDBDatabase>;
+}

package/src/wallets/cosmos/utils/indexDB.es.js

@@ -0,0 +1,93 @@
+import { __awaiter } from 'tslib';
+
+/* eslint-disable  */
+class IndexedDBKVStore {
+    constructor(_prefix) {
+        this._prefix = _prefix;
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tx = (yield this.getDB()).transaction([this.prefix()], 'readonly');
+            const store = tx.objectStore(this.prefix());
+            return new Promise((resolve, reject) => {
+                const request = store.get(key);
+                request.onerror = (event) => {
+                    event.stopPropagation();
+                    reject(event.target);
+                };
+                request.onsuccess = () => {
+                    if (!request.result) {
+                        resolve(undefined);
+                    }
+                    else {
+                        resolve(request.result.data);
+                    }
+                };
+            });
+        });
+    }
+    set(key, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (data === null) {
+                const tx = (yield this.getDB()).transaction([this.prefix()], 'readwrite');
+                const store = tx.objectStore(this.prefix());
+                return new Promise((resolve, reject) => {
+                    const request = store.delete(key);
+                    request.onerror = (event) => {
+                        event.stopPropagation();
+                        reject(event.target);
+                    };
+                    request.onsuccess = () => {
+                        resolve();
+                    };
+                });
+            }
+            else {
+                const tx = (yield this.getDB()).transaction([this.prefix()], 'readwrite');
+                const store = tx.objectStore(this.prefix());
+                return new Promise((resolve, reject) => {
+                    const request = store.put({
+                        key,
+                        data,
+                    });
+                    request.onerror = (event) => {
+                        event.stopPropagation();
+                        reject(event.target);
+                    };
+                    request.onsuccess = () => {
+                        resolve();
+                    };
+                });
+            }
+        });
+    }
+    prefix() {
+        return this._prefix;
+    }
+    getDB() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.cachedDB) {
+                return this.cachedDB;
+            }
+            return new Promise((resolve, reject) => {
+                const request = window.indexedDB.open(this.prefix());
+                request.onerror = (event) => {
+                    event.stopPropagation();
+                    reject(event.target);
+                };
+                request.onupgradeneeded = (event) => {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    const db = event.target.result;
+                    db.createObjectStore(this.prefix(), { keyPath: 'key' });
+                };
+                request.onsuccess = () => {
+                    this.cachedDB = request.result;
+                    resolve(request.result);
+                };
+            });
+        });
+    }
+}
+
+export { IndexedDBKVStore };

package/src/wallets/cosmos/wcClient.cjs.js

@@ -0,0 +1,333 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var buffer = require('buffer');
+var provider = require('@keplr-wallet/provider');
+var utils = require('@walletconnect/utils');
+var deepmerge = require('deepmerge');
+var indexDB = require('./utils/indexDB.cjs.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var deepmerge__default = /*#__PURE__*/_interopDefaultLegacy(deepmerge);
+
+/* eslint-disable  */
+// VersionFormatRegExp checks if a chainID is in the format required for parsing versions
+// The chainID should be in the form: `{identifier}-{version}`
+const ChainVersionFormatRegExp = /(.+)-([\d]+)/;
+function parseChainId(chainId) {
+    const split = chainId.split(ChainVersionFormatRegExp).filter(Boolean);
+    if (split.length !== 2) {
+        return {
+            identifier: chainId,
+            version: 0,
+        };
+    }
+    else {
+        return { identifier: split[0], version: parseInt(split[1]) };
+    }
+}
+class KeplrWalletConnectV1 {
+    constructor(connector, options = {}) {
+        this.connector = connector;
+        this.options = options;
+        this.version = '0.9.0';
+        this.mode = 'walletconnect';
+        this.defaultOptions = {};
+        this.onCallReqeust = (error, payload) => tslib.__awaiter(this, void 0, void 0, function* () {
+            if (error) {
+                console.log(error);
+                return;
+            }
+            if (!payload) {
+                return;
+            }
+            if (payload.method === 'keplr_keystore_may_changed_event_wallet_connect_v1') {
+                const param = payload.params[0];
+                if (!param) {
+                    return;
+                }
+                const lastSeenKeys = yield this.getAllLastSeenKey();
+                if (!lastSeenKeys) {
+                    return;
+                }
+                const mayChangedKeyMap = {};
+                for (const mayChangedKey of param.keys) {
+                    mayChangedKeyMap[mayChangedKey.chainIdentifier] = {
+                        address: mayChangedKey.address,
+                        algo: param.algo,
+                        bech32Address: mayChangedKey.bech32Address,
+                        isKeystone: param.isKeystone,
+                        isNanoLedger: param.isNanoLedger,
+                        name: param.name,
+                        pubKey: mayChangedKey.pubKey,
+                    };
+                }
+                let hasChanged = false;
+                for (const chainId of Object.keys(lastSeenKeys)) {
+                    const savedKey = lastSeenKeys[chainId];
+                    if (savedKey) {
+                        const { identifier } = parseChainId(chainId);
+                        const mayChangedKey = mayChangedKeyMap[identifier];
+                        if (mayChangedKey) {
+                            if (mayChangedKey.algo !== savedKey.algo ||
+                                mayChangedKey.name !== savedKey.name ||
+                                mayChangedKey.isKeystone !== savedKey.isKeystone ||
+                                mayChangedKey.isNanoLedger !== savedKey.isNanoLedger ||
+                                mayChangedKey.address !== savedKey.address ||
+                                mayChangedKey.bech32Address !== savedKey.bech32Address ||
+                                mayChangedKey.pubKey !== savedKey.pubKey) {
+                                hasChanged = true;
+                                lastSeenKeys[chainId] = mayChangedKey;
+                            }
+                        }
+                    }
+                }
+                if (hasChanged) {
+                    yield this.saveAllLastSeenKey(lastSeenKeys);
+                    window.dispatchEvent(new Event('keplr_keystorechange'));
+                }
+            }
+        });
+        if (!options.kvStore) {
+            options.kvStore = new indexDB.IndexedDBKVStore('keplr_wallet_connect');
+        }
+        connector.on('disconnect', () => {
+            this.clearSaved();
+        });
+        connector.on('call_request', this.onCallReqeust);
+    }
+    clearSaved() {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const kvStore = this.options.kvStore;
+            yield Promise.all([
+                kvStore.set(this.getKeyHasEnabled(), null),
+                kvStore.set(this.getKeyLastSeenKey(), null),
+            ]);
+        });
+    }
+    sendCustomRequest(request, options) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.options.onBeforeSendRequest) {
+                yield this.options.onBeforeSendRequest(request, options);
+            }
+            const res = yield this.connector.sendCustomRequest(request, options);
+            if (this.options.onAfterSendRequest) {
+                yield this.options.onAfterSendRequest(res, request, options);
+            }
+            return res;
+        });
+    }
+    enable(chainIds) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            if (typeof chainIds === 'string') {
+                chainIds = [chainIds];
+            }
+            const hasEnabledChainIds = yield this.getHasEnabledChainIds();
+            let allEnabled = true;
+            for (const chainId of chainIds) {
+                if (hasEnabledChainIds.indexOf(chainId) < 0) {
+                    allEnabled = false;
+                    break;
+                }
+            }
+            if (allEnabled) {
+                return;
+            }
+            yield this.sendCustomRequest({
+                id: utils.payloadId(),
+                jsonrpc: '2.0',
+                method: 'keplr_enable_wallet_connect_v1',
+                params: chainIds,
+            });
+            yield this.saveHasEnabledChainIds(chainIds);
+        });
+    }
+    getKeyHasEnabled() {
+        return `${this.connector.session.handshakeTopic}-enabled`;
+    }
+    getHasEnabledChainIds() {
+        var _a;
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            return ((_a = (yield this.options.kvStore.get(this.getKeyHasEnabled()))) !== null && _a !== void 0 ? _a : []);
+        });
+    }
+    saveHasEnabledChainIds(chainIds) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const hasEnabledChainIds = yield this.getHasEnabledChainIds();
+            for (const chainId of chainIds) {
+                if (hasEnabledChainIds.indexOf(chainId) < 0) {
+                    hasEnabledChainIds.push(chainId);
+                }
+            }
+            yield this.options.kvStore.set(this.getKeyHasEnabled(), hasEnabledChainIds);
+        });
+    }
+    enigmaDecrypt(_chainId, _ciphertext, _nonce) {
+        throw new Error('Not yet implemented');
+    }
+    enigmaEncrypt(_chainId, _contractCodeHash, 
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    _msg) {
+        throw new Error('Not yet implemented');
+    }
+    experimentalSuggestChain(_chainInfo) {
+        throw new Error('Not yet implemented');
+    }
+    getEnigmaPubKey(_chainId) {
+        throw new Error('Not yet implemented');
+    }
+    getEnigmaTxEncryptionKey(_chainId, _nonce) {
+        throw new Error('Not yet implemented');
+    }
+    getEnigmaUtils(_chainId) {
+        throw new Error('Not yet implemented');
+    }
+    getKey(chainId) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const lastSeenKey = yield this.getLastSeenKey(chainId);
+            if (lastSeenKey) {
+                return {
+                    address: buffer.Buffer.from(lastSeenKey.address, 'hex'),
+                    algo: lastSeenKey.algo,
+                    bech32Address: lastSeenKey.bech32Address,
+                    isKeystone: lastSeenKey.isKeystone,
+                    isNanoLedger: lastSeenKey.isNanoLedger,
+                    name: lastSeenKey.name,
+                    pubKey: buffer.Buffer.from(lastSeenKey.pubKey, 'hex'),
+                };
+            }
+            const response = (yield this.sendCustomRequest({
+                id: utils.payloadId(),
+                jsonrpc: '2.0',
+                method: 'keplr_get_key_wallet_connect_v1',
+                params: [chainId],
+            }))[0];
+            yield this.saveLastSeenKey(chainId, response);
+            return {
+                address: buffer.Buffer.from(response.address, 'hex'),
+                algo: response.algo,
+                bech32Address: response.bech32Address,
+                isKeystone: response.isKeystone,
+                isNanoLedger: response.isNanoLedger,
+                name: response.name,
+                pubKey: buffer.Buffer.from(response.pubKey, 'hex'),
+            };
+        });
+    }
+    getKeyLastSeenKey() {
+        return `${this.connector.session.handshakeTopic}-key`;
+    }
+    getLastSeenKey(chainId) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const saved = yield this.getAllLastSeenKey();
+            if (!saved) {
+                return undefined;
+            }
+            return saved[chainId];
+        });
+    }
+    getAllLastSeenKey() {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            return yield this.options.kvStore.get(this.getKeyLastSeenKey());
+        });
+    }
+    saveAllLastSeenKey(data) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.options.kvStore.set(this.getKeyLastSeenKey(), data);
+        });
+    }
+    saveLastSeenKey(chainId, response) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            let saved = yield this.getAllLastSeenKey();
+            if (!saved) {
+                saved = {};
+            }
+            saved[chainId] = response;
+            yield this.saveAllLastSeenKey(saved);
+        });
+    }
+    signArbitrary(_chainId, _signer, _data) {
+        throw new Error('Not yet implemented');
+    }
+    verifyArbitrary(_chainId, _signer, _data, _signature) {
+        throw new Error('Not yet implemented');
+    }
+    signEthereum(_chainId, _signer, _data, _mode) {
+        throw new Error('Not yet implemented');
+    }
+    signICNSAdr36(_chainId, _contractAddress, _owner, _username, _addressChainIds) {
+        throw new Error('Not yet implemented');
+    }
+    getOfflineSigner(chainId) {
+        return new provider.CosmJSOfflineSigner(chainId, this);
+    }
+    getOfflineSignerAuto(chainId) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const key = yield this.getKey(chainId);
+            if (key.isNanoLedger) {
+                return new provider.CosmJSOfflineSignerOnlyAmino(chainId, this);
+            }
+            return new provider.CosmJSOfflineSigner(chainId, this);
+        });
+    }
+    getOfflineSignerOnlyAmino(chainId) {
+        return new provider.CosmJSOfflineSignerOnlyAmino(chainId, this);
+    }
+    getSecret20ViewingKey(_chainId, _contractAddress) {
+        throw new Error('Not yet implemented');
+    }
+    /**
+     * In the extension environment, this API let the extension to send the tx on behalf of the client.
+     * But, in the wallet connect environment, in order to send the tx on behalf of the client, wallet should receive the tx data from remote.
+     * However, this approach is not efficient and hard to ensure the stability and `KeplrWalletConnect` should have the informations of rpc and rest endpoints.
+     * So, rather than implementing this, just fallback to the client sided implementation or throw error of the client sided implementation is not delivered to the `options`.
+     * @param chainId
+     * @param stdTx
+     * @param mode
+     */
+    sendTx(chainId, tx, mode) {
+        if (this.options.sendTx) {
+            return this.options.sendTx(chainId, tx, mode);
+        }
+        throw new Error('send tx is not delivered by options');
+    }
+    signAmino(chainId, signer, signDoc, signOptions = {}) {
+        var _a;
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            return (yield this.sendCustomRequest({
+                id: utils.payloadId(),
+                jsonrpc: '2.0',
+                method: 'keplr_sign_amino_wallet_connect_v1',
+                params: [
+                    chainId,
+                    signer,
+                    signDoc,
+                    deepmerge__default["default"]((_a = this.defaultOptions.sign) !== null && _a !== void 0 ? _a : {}, signOptions),
+                ],
+            }))[0];
+        });
+    }
+    signDirect(_chainId, _signer, _signDoc, _signOptions = {}) {
+        throw new Error('Not yet implemented');
+    }
+    suggestToken(_chainId, _contractAddress, _viewingKey) {
+        throw new Error('Not yet implemented');
+    }
+    experimentalSignEIP712CosmosTx_v0(_chainId, _signer, _eip712, _signDoc, _signOptions = {}) {
+        throw new Error('Not yet implemented');
+    }
+    getChainInfosWithoutEndpoints() {
+        throw new Error('Not yet implemented');
+    }
+    disable(_chainIds) {
+        throw new Error('Not yet implemented');
+    }
+    changeKeyRingName(_opts) {
+        throw new Error('Not yet implemented');
+    }
+}
+
+exports.KeplrWalletConnectV1 = KeplrWalletConnectV1;

package/src/wallets/cosmos/wcClient.d.ts

@@ -0,0 +1,104 @@
+import { ChainInfo, EthSignType, Keplr, KeplrIntereactionOptions, KeplrMode, KeplrSignOptions, Key, DirectSignResponse, OfflineDirectSigner, AminoSignResponse, BroadcastMode, OfflineAminoSigner, StdSignature, StdSignDoc, ICNSAdr36Signatures, ChainInfoWithoutEndpoints, SecretUtils } from '@keplr-wallet/types';
+import { KVStore } from './utils/indexDB';
+export type KeplrGetKeyWalletCoonectV1Response = {
+    address: string;
+    algo: string;
+    bech32Address: string;
+    isKeystone: boolean;
+    isNanoLedger: boolean;
+    name: string;
+    pubKey: string;
+};
+export type KeplrKeystoreMayChangedEventParam = {
+    algo: string;
+    isKeystone: boolean;
+    isNanoLedger: boolean;
+    keys: {
+        address: string;
+        bech32Address: string;
+        chainIdentifier: string;
+        pubKey: string;
+    }[];
+    name: string;
+};
+export declare class KeplrWalletConnectV1 implements Keplr {
+    readonly connector: any;
+    readonly options: {
+        kvStore?: KVStore;
+        onAfterSendRequest?: (response: any, request: Partial<any>, options?: any) => Promise<void> | void;
+        onBeforeSendRequest?: (request: Partial<any>, options?: any) => Promise<void> | void;
+        sendTx?: Keplr['sendTx'];
+    };
+    constructor(connector: any, options?: {
+        kvStore?: KVStore;
+        onAfterSendRequest?: (response: any, request: Partial<any>, options?: any) => Promise<void> | void;
+        onBeforeSendRequest?: (request: Partial<any>, options?: any) => Promise<void> | void;
+        sendTx?: Keplr['sendTx'];
+    });
+    readonly version: string;
+    readonly mode: KeplrMode;
+    defaultOptions: KeplrIntereactionOptions;
+    protected readonly onCallReqeust: (error: Error | null, payload: any | null) => Promise<void>;
+    protected clearSaved(): Promise<void>;
+    protected sendCustomRequest(request: Partial<any>, options?: any): Promise<any>;
+    enable(chainIds: string | string[]): Promise<void>;
+    protected getKeyHasEnabled(): string;
+    protected getHasEnabledChainIds(): Promise<string[]>;
+    protected saveHasEnabledChainIds(chainIds: string[]): Promise<void>;
+    enigmaDecrypt(_chainId: string, _ciphertext: Uint8Array, _nonce: Uint8Array): Promise<Uint8Array>;
+    enigmaEncrypt(_chainId: string, _contractCodeHash: string, _msg: object): Promise<Uint8Array>;
+    experimentalSuggestChain(_chainInfo: ChainInfo): Promise<void>;
+    getEnigmaPubKey(_chainId: string): Promise<Uint8Array>;
+    getEnigmaTxEncryptionKey(_chainId: string, _nonce: Uint8Array): Promise<Uint8Array>;
+    getEnigmaUtils(_chainId: string): SecretUtils;
+    getKey(chainId: string): Promise<Key>;
+    protected getKeyLastSeenKey(): string;
+    protected getLastSeenKey(chainId: string): Promise<KeplrGetKeyWalletCoonectV1Response | undefined>;
+    protected getAllLastSeenKey(): Promise<{
+        [chainId: string]: KeplrGetKeyWalletCoonectV1Response | undefined;
+    } | undefined>;
+    protected saveAllLastSeenKey(data: {
+        [chainId: string]: KeplrGetKeyWalletCoonectV1Response | undefined;
+    }): Promise<void>;
+    protected saveLastSeenKey(chainId: string, response: KeplrGetKeyWalletCoonectV1Response): Promise<void>;
+    signArbitrary(_chainId: string, _signer: string, _data: string | Uint8Array): Promise<StdSignature>;
+    verifyArbitrary(_chainId: string, _signer: string, _data: string | Uint8Array, _signature: StdSignature): Promise<boolean>;
+    signEthereum(_chainId: string, _signer: string, _data: string | Uint8Array, _mode: EthSignType): Promise<Uint8Array>;
+    signICNSAdr36(_chainId: string, _contractAddress: string, _owner: string, _username: string, _addressChainIds: string[]): Promise<ICNSAdr36Signatures>;
+    getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner;
+    getOfflineSignerAuto(chainId: string): Promise<OfflineAminoSigner | OfflineDirectSigner>;
+    getOfflineSignerOnlyAmino(chainId: string): OfflineAminoSigner;
+    getSecret20ViewingKey(_chainId: string, _contractAddress: string): Promise<string>;
+    /**
+     * In the extension environment, this API let the extension to send the tx on behalf of the client.
+     * But, in the wallet connect environment, in order to send the tx on behalf of the client, wallet should receive the tx data from remote.
+     * However, this approach is not efficient and hard to ensure the stability and `KeplrWalletConnect` should have the informations of rpc and rest endpoints.
+     * So, rather than implementing this, just fallback to the client sided implementation or throw error of the client sided implementation is not delivered to the `options`.
+     * @param chainId
+     * @param stdTx
+     * @param mode
+     */
+    sendTx(chainId: string, tx: Uint8Array, mode: BroadcastMode): Promise<Uint8Array>;
+    signAmino(chainId: string, signer: string, signDoc: StdSignDoc, signOptions?: KeplrSignOptions): Promise<AminoSignResponse>;
+    signDirect(_chainId: string, _signer: string, _signDoc: {
+        accountNumber?: any | null;
+        authInfoBytes?: Uint8Array | null;
+        bodyBytes?: Uint8Array | null;
+        chainId?: string | null;
+    }, _signOptions?: KeplrSignOptions): Promise<DirectSignResponse>;
+    suggestToken(_chainId: string, _contractAddress: string, _viewingKey?: string): Promise<void>;
+    experimentalSignEIP712CosmosTx_v0(_chainId: string, _signer: string, _eip712: {
+        domain: Record<string, any>;
+        primaryType: string;
+        types: Record<string, {
+            name: string;
+            type: string;
+        }[] | undefined>;
+    }, _signDoc: StdSignDoc, _signOptions?: KeplrSignOptions): Promise<AminoSignResponse>;
+    getChainInfosWithoutEndpoints(): Promise<ChainInfoWithoutEndpoints[]>;
+    disable(_chainIds?: string | string[]): Promise<void>;
+    changeKeyRingName(_opts: {
+        defaultName: string;
+        editable?: boolean | undefined;
+    }): Promise<string>;
+}

package/src/wallets/cosmos/wcClient.es.js

@@ -0,0 +1,325 @@
+import { __awaiter } from 'tslib';
+import { Buffer } from 'buffer';
+import { CosmJSOfflineSigner, CosmJSOfflineSignerOnlyAmino } from '@keplr-wallet/provider';
+import { payloadId } from '@walletconnect/utils';
+import deepmerge from 'deepmerge';
+import { IndexedDBKVStore } from './utils/indexDB.es.js';
+
+/* eslint-disable  */
+// VersionFormatRegExp checks if a chainID is in the format required for parsing versions
+// The chainID should be in the form: `{identifier}-{version}`
+const ChainVersionFormatRegExp = /(.+)-([\d]+)/;
+function parseChainId(chainId) {
+    const split = chainId.split(ChainVersionFormatRegExp).filter(Boolean);
+    if (split.length !== 2) {
+        return {
+            identifier: chainId,
+            version: 0,
+        };
+    }
+    else {
+        return { identifier: split[0], version: parseInt(split[1]) };
+    }
+}
+class KeplrWalletConnectV1 {
+    constructor(connector, options = {}) {
+        this.connector = connector;
+        this.options = options;
+        this.version = '0.9.0';
+        this.mode = 'walletconnect';
+        this.defaultOptions = {};
+        this.onCallReqeust = (error, payload) => __awaiter(this, void 0, void 0, function* () {
+            if (error) {
+                console.log(error);
+                return;
+            }
+            if (!payload) {
+                return;
+            }
+            if (payload.method === 'keplr_keystore_may_changed_event_wallet_connect_v1') {
+                const param = payload.params[0];
+                if (!param) {
+                    return;
+                }
+                const lastSeenKeys = yield this.getAllLastSeenKey();
+                if (!lastSeenKeys) {
+                    return;
+                }
+                const mayChangedKeyMap = {};
+                for (const mayChangedKey of param.keys) {
+                    mayChangedKeyMap[mayChangedKey.chainIdentifier] = {
+                        address: mayChangedKey.address,
+                        algo: param.algo,
+                        bech32Address: mayChangedKey.bech32Address,
+                        isKeystone: param.isKeystone,
+                        isNanoLedger: param.isNanoLedger,
+                        name: param.name,
+                        pubKey: mayChangedKey.pubKey,
+                    };
+                }
+                let hasChanged = false;
+                for (const chainId of Object.keys(lastSeenKeys)) {
+                    const savedKey = lastSeenKeys[chainId];
+                    if (savedKey) {
+                        const { identifier } = parseChainId(chainId);
+                        const mayChangedKey = mayChangedKeyMap[identifier];
+                        if (mayChangedKey) {
+                            if (mayChangedKey.algo !== savedKey.algo ||
+                                mayChangedKey.name !== savedKey.name ||
+                                mayChangedKey.isKeystone !== savedKey.isKeystone ||
+                                mayChangedKey.isNanoLedger !== savedKey.isNanoLedger ||
+                                mayChangedKey.address !== savedKey.address ||
+                                mayChangedKey.bech32Address !== savedKey.bech32Address ||
+                                mayChangedKey.pubKey !== savedKey.pubKey) {
+                                hasChanged = true;
+                                lastSeenKeys[chainId] = mayChangedKey;
+                            }
+                        }
+                    }
+                }
+                if (hasChanged) {
+                    yield this.saveAllLastSeenKey(lastSeenKeys);
+                    window.dispatchEvent(new Event('keplr_keystorechange'));
+                }
+            }
+        });
+        if (!options.kvStore) {
+            options.kvStore = new IndexedDBKVStore('keplr_wallet_connect');
+        }
+        connector.on('disconnect', () => {
+            this.clearSaved();
+        });
+        connector.on('call_request', this.onCallReqeust);
+    }
+    clearSaved() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const kvStore = this.options.kvStore;
+            yield Promise.all([
+                kvStore.set(this.getKeyHasEnabled(), null),
+                kvStore.set(this.getKeyLastSeenKey(), null),
+            ]);
+        });
+    }
+    sendCustomRequest(request, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.options.onBeforeSendRequest) {
+                yield this.options.onBeforeSendRequest(request, options);
+            }
+            const res = yield this.connector.sendCustomRequest(request, options);
+            if (this.options.onAfterSendRequest) {
+                yield this.options.onAfterSendRequest(res, request, options);
+            }
+            return res;
+        });
+    }
+    enable(chainIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof chainIds === 'string') {
+                chainIds = [chainIds];
+            }
+            const hasEnabledChainIds = yield this.getHasEnabledChainIds();
+            let allEnabled = true;
+            for (const chainId of chainIds) {
+                if (hasEnabledChainIds.indexOf(chainId) < 0) {
+                    allEnabled = false;
+                    break;
+                }
+            }
+            if (allEnabled) {
+                return;
+            }
+            yield this.sendCustomRequest({
+                id: payloadId(),
+                jsonrpc: '2.0',
+                method: 'keplr_enable_wallet_connect_v1',
+                params: chainIds,
+            });
+            yield this.saveHasEnabledChainIds(chainIds);
+        });
+    }
+    getKeyHasEnabled() {
+        return `${this.connector.session.handshakeTopic}-enabled`;
+    }
+    getHasEnabledChainIds() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return ((_a = (yield this.options.kvStore.get(this.getKeyHasEnabled()))) !== null && _a !== void 0 ? _a : []);
+        });
+    }
+    saveHasEnabledChainIds(chainIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasEnabledChainIds = yield this.getHasEnabledChainIds();
+            for (const chainId of chainIds) {
+                if (hasEnabledChainIds.indexOf(chainId) < 0) {
+                    hasEnabledChainIds.push(chainId);
+                }
+            }
+            yield this.options.kvStore.set(this.getKeyHasEnabled(), hasEnabledChainIds);
+        });
+    }
+    enigmaDecrypt(_chainId, _ciphertext, _nonce) {
+        throw new Error('Not yet implemented');
+    }
+    enigmaEncrypt(_chainId, _contractCodeHash, 
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    _msg) {
+        throw new Error('Not yet implemented');
+    }
+    experimentalSuggestChain(_chainInfo) {
+        throw new Error('Not yet implemented');
+    }
+    getEnigmaPubKey(_chainId) {
+        throw new Error('Not yet implemented');
+    }
+    getEnigmaTxEncryptionKey(_chainId, _nonce) {
+        throw new Error('Not yet implemented');
+    }
+    getEnigmaUtils(_chainId) {
+        throw new Error('Not yet implemented');
+    }
+    getKey(chainId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lastSeenKey = yield this.getLastSeenKey(chainId);
+            if (lastSeenKey) {
+                return {
+                    address: Buffer.from(lastSeenKey.address, 'hex'),
+                    algo: lastSeenKey.algo,
+                    bech32Address: lastSeenKey.bech32Address,
+                    isKeystone: lastSeenKey.isKeystone,
+                    isNanoLedger: lastSeenKey.isNanoLedger,
+                    name: lastSeenKey.name,
+                    pubKey: Buffer.from(lastSeenKey.pubKey, 'hex'),
+                };
+            }
+            const response = (yield this.sendCustomRequest({
+                id: payloadId(),
+                jsonrpc: '2.0',
+                method: 'keplr_get_key_wallet_connect_v1',
+                params: [chainId],
+            }))[0];
+            yield this.saveLastSeenKey(chainId, response);
+            return {
+                address: Buffer.from(response.address, 'hex'),
+                algo: response.algo,
+                bech32Address: response.bech32Address,
+                isKeystone: response.isKeystone,
+                isNanoLedger: response.isNanoLedger,
+                name: response.name,
+                pubKey: Buffer.from(response.pubKey, 'hex'),
+            };
+        });
+    }
+    getKeyLastSeenKey() {
+        return `${this.connector.session.handshakeTopic}-key`;
+    }
+    getLastSeenKey(chainId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const saved = yield this.getAllLastSeenKey();
+            if (!saved) {
+                return undefined;
+            }
+            return saved[chainId];
+        });
+    }
+    getAllLastSeenKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.options.kvStore.get(this.getKeyLastSeenKey());
+        });
+    }
+    saveAllLastSeenKey(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.options.kvStore.set(this.getKeyLastSeenKey(), data);
+        });
+    }
+    saveLastSeenKey(chainId, response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let saved = yield this.getAllLastSeenKey();
+            if (!saved) {
+                saved = {};
+            }
+            saved[chainId] = response;
+            yield this.saveAllLastSeenKey(saved);
+        });
+    }
+    signArbitrary(_chainId, _signer, _data) {
+        throw new Error('Not yet implemented');
+    }
+    verifyArbitrary(_chainId, _signer, _data, _signature) {
+        throw new Error('Not yet implemented');
+    }
+    signEthereum(_chainId, _signer, _data, _mode) {
+        throw new Error('Not yet implemented');
+    }
+    signICNSAdr36(_chainId, _contractAddress, _owner, _username, _addressChainIds) {
+        throw new Error('Not yet implemented');
+    }
+    getOfflineSigner(chainId) {
+        return new CosmJSOfflineSigner(chainId, this);
+    }
+    getOfflineSignerAuto(chainId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = yield this.getKey(chainId);
+            if (key.isNanoLedger) {
+                return new CosmJSOfflineSignerOnlyAmino(chainId, this);
+            }
+            return new CosmJSOfflineSigner(chainId, this);
+        });
+    }
+    getOfflineSignerOnlyAmino(chainId) {
+        return new CosmJSOfflineSignerOnlyAmino(chainId, this);
+    }
+    getSecret20ViewingKey(_chainId, _contractAddress) {
+        throw new Error('Not yet implemented');
+    }
+    /**
+     * In the extension environment, this API let the extension to send the tx on behalf of the client.
+     * But, in the wallet connect environment, in order to send the tx on behalf of the client, wallet should receive the tx data from remote.
+     * However, this approach is not efficient and hard to ensure the stability and `KeplrWalletConnect` should have the informations of rpc and rest endpoints.
+     * So, rather than implementing this, just fallback to the client sided implementation or throw error of the client sided implementation is not delivered to the `options`.
+     * @param chainId
+     * @param stdTx
+     * @param mode
+     */
+    sendTx(chainId, tx, mode) {
+        if (this.options.sendTx) {
+            return this.options.sendTx(chainId, tx, mode);
+        }
+        throw new Error('send tx is not delivered by options');
+    }
+    signAmino(chainId, signer, signDoc, signOptions = {}) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.sendCustomRequest({
+                id: payloadId(),
+                jsonrpc: '2.0',
+                method: 'keplr_sign_amino_wallet_connect_v1',
+                params: [
+                    chainId,
+                    signer,
+                    signDoc,
+                    deepmerge((_a = this.defaultOptions.sign) !== null && _a !== void 0 ? _a : {}, signOptions),
+                ],
+            }))[0];
+        });
+    }
+    signDirect(_chainId, _signer, _signDoc, _signOptions = {}) {
+        throw new Error('Not yet implemented');
+    }
+    suggestToken(_chainId, _contractAddress, _viewingKey) {
+        throw new Error('Not yet implemented');
+    }
+    experimentalSignEIP712CosmosTx_v0(_chainId, _signer, _eip712, _signDoc, _signOptions = {}) {
+        throw new Error('Not yet implemented');
+    }
+    getChainInfosWithoutEndpoints() {
+        throw new Error('Not yet implemented');
+    }
+    disable(_chainIds) {
+        throw new Error('Not yet implemented');
+    }
+    changeKeyRingName(_opts) {
+        throw new Error('Not yet implemented');
+    }
+}
+
+export { KeplrWalletConnectV1 };