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

package/src/wallets/cosmos/wcClient.js

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

package/src/wallets/ethereum/BloctoEvm.cjs

@@ -1,111 +0,0 @@
-'use strict';
-
-var tslib = require('tslib');
-var BloctoSDK = require('@blocto/sdk');
-var ethers = require('ethers');
-var logger = require('../../utils/logger.cjs');
-var EthWalletConnector = require('./EthWalletConnector.cjs');
-var ethProviderHelper = require('./ethProviderHelper.cjs');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var BloctoSDK__default = /*#__PURE__*/_interopDefaultLegacy(BloctoSDK);
-
-class BloctoEvm extends EthWalletConnector.EthWalletConnector {
-    constructor({ evmNetworks }) {
-        var _a, _b;
-        // Taken from : https://docs.blocto.app/blocto-sdk/javascript-sdk/evm-sdk/provider
-        const BLOCTO_SUPPORTED_CHAIN_IDS = [1, 4, 56, 97, 137, 80001, 43114, 43113];
-        const bloctoSupportedNetworks = evmNetworks.filter((n) => BLOCTO_SUPPORTED_CHAIN_IDS.includes(n.chainId));
-        super({ evmNetworks: bloctoSupportedNetworks });
-        this.LOCAL_STORAGE_KEY = 'dynamic_blocto_evm_chain_id';
-        this.name = 'bloctoevm';
-        this.canConnectViaCustodialService = true;
-        this.connectedChain = 'EVM';
-        this.supportedChains = ['EVM', 'ETH'];
-        this.ethProviderHelper = new ethProviderHelper.EthProviderHelper();
-        this.supportsNetworkSwitching = () => false;
-        this.chainId =
-            Number(localStorage.getItem(this.LOCAL_STORAGE_KEY)) ||
-                ((_a = bloctoSupportedNetworks.find((n) => n.chainId === 137)) === null || _a === void 0 ? void 0 : _a.chainId) ||
-                ((_b = bloctoSupportedNetworks[0]) === null || _b === void 0 ? void 0 : _b.chainId);
-    }
-    getClient() {
-        if (!this.client) {
-            const network = this.evmNetworks.find((n) => n.chainId === this.chainId);
-            if (network) {
-                this.client = new BloctoSDK__default["default"]({
-                    ethereum: {
-                        chainId: `0x${this.chainId.toString(16)}`,
-                        rpc: network.rpcUrls[0],
-                    },
-                });
-            }
-            else {
-                logger.logger.error("Couldn't find a configured network for Blocto EVM");
-            }
-        }
-        return this.client;
-    }
-    getWeb3Provider() {
-        const client = this.getClient();
-        // If there are no accounts yet, we shouldn't wrap the provider in ethers
-        if (client && client.ethereum && client.ethereum.accounts.length > 0) {
-            return new ethers.ethers.providers.Web3Provider(client.ethereum);
-        }
-        else {
-            return undefined;
-        }
-    }
-    // We are calling the client directly and not via Web3Provider because if we will wrap it in Ethers,
-    // Ethers will be making retries on failure. This becomes an issue on the connect step.
-    // When Blocto's modal closes prior to receiving a response with the address on the connect step,
-    // then ethers would retry and the modal will open again.
-    fetchPublicAddress() {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            try {
-                const client = this.getClient();
-                if (client && client.ethereum) {
-                    const addresses = yield client.ethereum.request({
-                        method: 'eth_requestAccounts',
-                    });
-                    if (addresses.length > 0) {
-                        return addresses[0];
-                    }
-                }
-                return undefined;
-            }
-            catch (e) {
-                logger.logger.error(e);
-                return Promise.reject(e);
-            }
-        });
-    }
-    signMessage(messageToSign) {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            try {
-                const signer = yield this.getSigner();
-                return yield (signer === null || signer === void 0 ? void 0 : signer.signMessage(messageToSign));
-            }
-            catch (e) {
-                if (e.message === 'User declined the signing request') {
-                    return Promise.reject({ code: '4001' });
-                }
-                else {
-                    return Promise.reject(e);
-                }
-            }
-        });
-    }
-    endSession() {
-        return tslib.__awaiter(this, void 0, void 0, function* () {
-            const client = this.getClient();
-            localStorage.removeItem('sdk.session');
-            if (client && client.ethereum && client.ethereum.accounts.length > 0) {
-                yield client.ethereum.request({ method: 'wallet_disconnect' });
-            }
-        });
-    }
-}
-
-module.exports = BloctoEvm;

package/src/wallets/ethereum/BloctoEvm.d.ts

@@ -1,25 +0,0 @@
-import { ethers } from 'ethers';
-import { Chain } from '@dynamic-labs/wallet-connector-core';
-import { EvmNetwork } from './evm-network';
-import { EthWalletConnector } from './EthWalletConnector';
-import { EthProviderHelper } from './ethProviderHelper';
-declare class BloctoEvm extends EthWalletConnector {
-    LOCAL_STORAGE_KEY: string;
-    private client?;
-    name: string;
-    canConnectViaCustodialService: boolean;
-    connectedChain: Chain;
-    supportedChains: Chain[];
-    chainId: number;
-    ethProviderHelper: EthProviderHelper;
-    supportsNetworkSwitching: () => boolean;
-    constructor({ evmNetworks }: {
-        evmNetworks: EvmNetwork[];
-    });
-    private getClient;
-    getWeb3Provider(): ethers.providers.Web3Provider | undefined;
-    fetchPublicAddress(): Promise<string | undefined>;
-    signMessage(messageToSign: string): Promise<string | undefined>;
-    endSession(): Promise<void>;
-}
-export default BloctoEvm;

package/src/wallets/ethereum/BloctoEvm.js

@@ -1,105 +0,0 @@
-import { __awaiter } from 'tslib';
-import BloctoSDK from '@blocto/sdk';
-import { ethers } from 'ethers';
-import { logger } from '../../utils/logger.js';
-import { EthWalletConnector } from './EthWalletConnector.js';
-import { EthProviderHelper } from './ethProviderHelper.js';
-
-class BloctoEvm extends EthWalletConnector {
-    constructor({ evmNetworks }) {
-        var _a, _b;
-        // Taken from : https://docs.blocto.app/blocto-sdk/javascript-sdk/evm-sdk/provider
-        const BLOCTO_SUPPORTED_CHAIN_IDS = [1, 4, 56, 97, 137, 80001, 43114, 43113];
-        const bloctoSupportedNetworks = evmNetworks.filter((n) => BLOCTO_SUPPORTED_CHAIN_IDS.includes(n.chainId));
-        super({ evmNetworks: bloctoSupportedNetworks });
-        this.LOCAL_STORAGE_KEY = 'dynamic_blocto_evm_chain_id';
-        this.name = 'bloctoevm';
-        this.canConnectViaCustodialService = true;
-        this.connectedChain = 'EVM';
-        this.supportedChains = ['EVM', 'ETH'];
-        this.ethProviderHelper = new EthProviderHelper();
-        this.supportsNetworkSwitching = () => false;
-        this.chainId =
-            Number(localStorage.getItem(this.LOCAL_STORAGE_KEY)) ||
-                ((_a = bloctoSupportedNetworks.find((n) => n.chainId === 137)) === null || _a === void 0 ? void 0 : _a.chainId) ||
-                ((_b = bloctoSupportedNetworks[0]) === null || _b === void 0 ? void 0 : _b.chainId);
-    }
-    getClient() {
-        if (!this.client) {
-            const network = this.evmNetworks.find((n) => n.chainId === this.chainId);
-            if (network) {
-                this.client = new BloctoSDK({
-                    ethereum: {
-                        chainId: `0x${this.chainId.toString(16)}`,
-                        rpc: network.rpcUrls[0],
-                    },
-                });
-            }
-            else {
-                logger.error("Couldn't find a configured network for Blocto EVM");
-            }
-        }
-        return this.client;
-    }
-    getWeb3Provider() {
-        const client = this.getClient();
-        // If there are no accounts yet, we shouldn't wrap the provider in ethers
-        if (client && client.ethereum && client.ethereum.accounts.length > 0) {
-            return new ethers.providers.Web3Provider(client.ethereum);
-        }
-        else {
-            return undefined;
-        }
-    }
-    // We are calling the client directly and not via Web3Provider because if we will wrap it in Ethers,
-    // Ethers will be making retries on failure. This becomes an issue on the connect step.
-    // When Blocto's modal closes prior to receiving a response with the address on the connect step,
-    // then ethers would retry and the modal will open again.
-    fetchPublicAddress() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const client = this.getClient();
-                if (client && client.ethereum) {
-                    const addresses = yield client.ethereum.request({
-                        method: 'eth_requestAccounts',
-                    });
-                    if (addresses.length > 0) {
-                        return addresses[0];
-                    }
-                }
-                return undefined;
-            }
-            catch (e) {
-                logger.error(e);
-                return Promise.reject(e);
-            }
-        });
-    }
-    signMessage(messageToSign) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const signer = yield this.getSigner();
-                return yield (signer === null || signer === void 0 ? void 0 : signer.signMessage(messageToSign));
-            }
-            catch (e) {
-                if (e.message === 'User declined the signing request') {
-                    return Promise.reject({ code: '4001' });
-                }
-                else {
-                    return Promise.reject(e);
-                }
-            }
-        });
-    }
-    endSession() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const client = this.getClient();
-            localStorage.removeItem('sdk.session');
-            if (client && client.ethereum && client.ethereum.accounts.length > 0) {
-                yield client.ethereum.request({ method: 'wallet_disconnect' });
-            }
-        });
-    }
-}
-
-export { BloctoEvm as default };