@dynamic-labs/multi-wallet 0.17.0-RC.2 → 0.17.0-RC.21

package/src/wallets/cosmos/wcClient.cjs

@@ -1,333 +0,0 @@
-'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');
-
-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

@@ -1,104 +0,0 @@
-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>;
-}