@dynamic-labs/multi-wallet 0.16.0 → 0.16.2

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.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.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.js → BloctoEvm.cjs}

@@ -3,10 +3,10 @@
 var tslib = require('tslib');
 var BloctoSDK = require('@blocto/sdk');
 var ethers = require('ethers');
-var normalizeWalletName = require('../../utils/normalizeWalletName/normalizeWalletName.cjs.js');
-var logger = require('../../utils/logger.cjs.js');
-var ethProvider = require('./ethProvider.cjs.js');
-var ethProviderHelper = require('./ethProviderHelper.cjs.js');
+var normalizeWalletName = require('../../utils/normalizeWalletName/normalizeWalletName.cjs');
+var logger = require('../../utils/logger.cjs');
+var ethProvider = require('./ethProvider.cjs');
+var ethProviderHelper = require('./ethProviderHelper.cjs');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 

package/src/wallets/ethereum/{BloctoEvm.es.js → BloctoEvm.js}

@@ -1,10 +1,10 @@
 import { __awaiter } from 'tslib';
 import BloctoSDK from '@blocto/sdk';
 import { ethers } from 'ethers';
-import { normalizeWalletName } from '../../utils/normalizeWalletName/normalizeWalletName.es.js';
-import { logger } from '../../utils/logger.es.js';
-import { EthProvider } from './ethProvider.es.js';
-import { EthProviderHelper } from './ethProviderHelper.es.js';
+import { normalizeWalletName } from '../../utils/normalizeWalletName/normalizeWalletName.js';
+import { logger } from '../../utils/logger.js';
+import { EthProvider } from './ethProvider.js';
+import { EthProviderHelper } from './ethProviderHelper.js';
 
 class BloctoEvm extends EthProvider {
     constructor({ evmNetworks }) {

package/src/wallets/ethereum/MagicConnector/EmailMagicWalletConnector/{EmailMagicWalletConnector.cjs.js → EmailMagicWalletConnector.cjs}

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
-var MagicWalletConnector = require('../MagicWalletConnector/MagicWalletConnector.cjs.js');
+var MagicWalletConnector = require('../MagicWalletConnector/MagicWalletConnector.cjs');
 
 class EmailMagicWalletConnector extends MagicWalletConnector.MagicWalletConnector {
     constructor() {

package/src/wallets/ethereum/MagicConnector/EmailMagicWalletConnector/{EmailMagicWalletConnector.es.js → EmailMagicWalletConnector.js}

@@ -1,5 +1,5 @@
 import { __awaiter } from 'tslib';
-import { MagicWalletConnector } from '../MagicWalletConnector/MagicWalletConnector.es.js';
+import { MagicWalletConnector } from '../MagicWalletConnector/MagicWalletConnector.js';
 
 class EmailMagicWalletConnector extends MagicWalletConnector {
     constructor() {

package/src/wallets/ethereum/MagicConnector/EmailOTPMagicWalletConnector/{EmailOTPMagicWalletConnector.cjs.js → EmailOTPMagicWalletConnector.cjs}

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
-var logger = require('../../../../utils/logger.cjs.js');
-var EmailMagicWalletConnector = require('../EmailMagicWalletConnector/EmailMagicWalletConnector.cjs.js');
+var logger = require('../../../../utils/logger.cjs');
+var EmailMagicWalletConnector = require('../EmailMagicWalletConnector/EmailMagicWalletConnector.cjs');
 
 class EmailOTPMagicWalletConnector extends EmailMagicWalletConnector.EmailMagicWalletConnector {
     verifyOneTimePassword(otp) {

package/src/wallets/ethereum/MagicConnector/EmailOTPMagicWalletConnector/{EmailOTPMagicWalletConnector.es.js → EmailOTPMagicWalletConnector.js}

@@ -1,6 +1,6 @@
 import { __awaiter } from 'tslib';
-import { logger } from '../../../../utils/logger.es.js';
-import { EmailMagicWalletConnector } from '../EmailMagicWalletConnector/EmailMagicWalletConnector.es.js';
+import { logger } from '../../../../utils/logger.js';
+import { EmailMagicWalletConnector } from '../EmailMagicWalletConnector/EmailMagicWalletConnector.js';
 
 class EmailOTPMagicWalletConnector extends EmailMagicWalletConnector {
     verifyOneTimePassword(otp) {

package/src/wallets/ethereum/MagicConnector/MagicWalletConnector/{MagicWalletConnector.cjs.js → MagicWalletConnector.cjs}

@@ -4,11 +4,11 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
 var ethers = require('ethers');
-var errors = require('../../../../errors.cjs.js');
-var logger = require('../../../../utils/logger.cjs.js');
-var assignConfirmationScreenToProvider = require('../../../../utils/assignConfirmationScreenToProvider/assignConfirmationScreenToProvider.cjs.js');
-var CancellablePromise = require('../../../../utils/CancellablePromise/CancellablePromise.cjs.js');
-var MagicClientNetworkHandler = require('../MagicClientNetworkHandler/MagicClientNetworkHandler.cjs.js');
+var errors = require('../../../../errors.cjs');
+var logger = require('../../../../utils/logger.cjs');
+var assignConfirmationScreenToProvider = require('../../../../utils/assignConfirmationScreenToProvider/assignConfirmationScreenToProvider.cjs');
+var CancellablePromise = require('../../../../utils/CancellablePromise/CancellablePromise.cjs');
+var MagicClientNetworkHandler = require('../MagicClientNetworkHandler/MagicClientNetworkHandler.cjs');
 
 const storedAddressKey = 'dynamic_magic_address';
 class MagicWalletConnector extends MagicClientNetworkHandler.MagicClientNetworkHandler {

package/src/wallets/ethereum/MagicConnector/MagicWalletConnector/{MagicWalletConnector.es.js → MagicWalletConnector.js}

@@ -1,10 +1,10 @@
 import { __awaiter } from 'tslib';
 import { ethers } from 'ethers';
-import { DynamicError } from '../../../../errors.es.js';
-import { logger } from '../../../../utils/logger.es.js';
-import { assignConfirmationScreenToProvider } from '../../../../utils/assignConfirmationScreenToProvider/assignConfirmationScreenToProvider.es.js';
-import { CancellablePromise } from '../../../../utils/CancellablePromise/CancellablePromise.es.js';
-import { MagicClientNetworkHandler } from '../MagicClientNetworkHandler/MagicClientNetworkHandler.es.js';
+import { DynamicError } from '../../../../errors.js';
+import { logger } from '../../../../utils/logger.js';
+import { assignConfirmationScreenToProvider } from '../../../../utils/assignConfirmationScreenToProvider/assignConfirmationScreenToProvider.js';
+import { CancellablePromise } from '../../../../utils/CancellablePromise/CancellablePromise.js';
+import { MagicClientNetworkHandler } from '../MagicClientNetworkHandler/MagicClientNetworkHandler.js';
 
 const storedAddressKey = 'dynamic_magic_address';
 class MagicWalletConnector extends MagicClientNetworkHandler {

package/src/wallets/ethereum/{coinbase.cjs.js → coinbase.cjs}

@@ -2,10 +2,10 @@
 
 var tslib = require('tslib');
 var ethers = require('ethers');
-var coinbase = require('../clients/coinbase/coinbase.cjs.js');
-var normalizeWalletName = require('../../utils/normalizeWalletName/normalizeWalletName.cjs.js');
-var ethProviderHelper = require('./ethProviderHelper.cjs.js');
-var ethProvider = require('./ethProvider.cjs.js');
+var coinbase = require('../clients/coinbase/coinbase.cjs');
+var normalizeWalletName = require('../../utils/normalizeWalletName/normalizeWalletName.cjs');
+var ethProviderHelper = require('./ethProviderHelper.cjs');
+var ethProvider = require('./ethProvider.cjs');
 
 class Coinbase extends ethProvider.EthProvider {
     constructor({ appName, appLogoUrl, evmNetworks, }) {

package/src/wallets/ethereum/{coinbase.es.js → coinbase.js}

@@ -1,9 +1,9 @@
 import { __awaiter } from 'tslib';
 import { ethers } from 'ethers';
-import { getCoinbaseProvider, fetchPublicAddress, signMessage, killCoinbaseSession } from '../clients/coinbase/coinbase.es.js';
-import { normalizeWalletName } from '../../utils/normalizeWalletName/normalizeWalletName.es.js';
-import { EthProviderHelper } from './ethProviderHelper.es.js';
-import { EthProvider } from './ethProvider.es.js';
+import { getCoinbaseProvider, fetchPublicAddress, signMessage, killCoinbaseSession } from '../clients/coinbase/coinbase.js';
+import { normalizeWalletName } from '../../utils/normalizeWalletName/normalizeWalletName.js';
+import { EthProviderHelper } from './ethProviderHelper.js';
+import { EthProvider } from './ethProvider.js';
 
 class Coinbase extends EthProvider {
     constructor({ appName, appLogoUrl, evmNetworks, }) {

package/src/wallets/ethereum/{ethProvider.cjs.js → ethProvider.cjs}

@@ -4,9 +4,9 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
 var ethers = require('ethers');
-var errors = require('../../errors.cjs.js');
-var rpcProviders = require('../../rpcProviders.cjs.js');
-var evmNetwork = require('./evm-network.cjs.js');
+var errors = require('../../errors.cjs');
+var rpcProviders = require('../../rpcProviders.cjs');
+var evmNetwork = require('./evm-network.cjs');
 
 class EthProvider {
     getDeepLink() {

package/src/wallets/ethereum/{ethProvider.es.js → ethProvider.js}

@@ -1,8 +1,8 @@
 import { __awaiter } from 'tslib';
 import { ethers } from 'ethers';
-import { DynamicError } from '../../errors.es.js';
-import { getEvmDefaultRpcProvider, getEvmRpcProviderByChainId } from '../../rpcProviders.es.js';
-import { findEvmNetwork } from './evm-network.es.js';
+import { DynamicError } from '../../errors.js';
+import { getEvmDefaultRpcProvider, getEvmRpcProviderByChainId } from '../../rpcProviders.js';
+import { findEvmNetwork } from './evm-network.js';
 
 class EthProvider {
     getDeepLink() {

package/src/wallets/ethereum/{ethProviderHelper.cjs.js → ethProviderHelper.cjs}

@@ -4,10 +4,10 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
 var ethers = require('ethers');
-var normalizeWalletName = require('../../utils/normalizeWalletName/normalizeWalletName.cjs.js');
-var ProviderLookup = require('../ProviderLookup.cjs.js');
-var isUnsupportedProviderError = require('../../utils/isUnsupportedProviderError/isUnsupportedProviderError.cjs.js');
-var logger = require('../../utils/logger.cjs.js');
+var normalizeWalletName = require('../../utils/normalizeWalletName/normalizeWalletName.cjs');
+var ProviderLookup = require('../ProviderLookup.cjs');
+var isUnsupportedProviderError = require('../../utils/isUnsupportedProviderError/isUnsupportedProviderError.cjs');
+var logger = require('../../utils/logger.cjs');
 
 class EthProviderHelper {
     constructor() {

package/src/wallets/ethereum/{ethProviderHelper.es.js → ethProviderHelper.js}

@@ -1,9 +1,9 @@
 import { __awaiter } from 'tslib';
 import { ethers, utils } from 'ethers';
-import { normalizeWalletName } from '../../utils/normalizeWalletName/normalizeWalletName.es.js';
-import { ProviderLookup } from '../ProviderLookup.es.js';
-import { isUnsupportedProviderError } from '../../utils/isUnsupportedProviderError/isUnsupportedProviderError.es.js';
-import { logger } from '../../utils/logger.es.js';
+import { normalizeWalletName } from '../../utils/normalizeWalletName/normalizeWalletName.js';
+import { ProviderLookup } from '../ProviderLookup.js';
+import { isUnsupportedProviderError } from '../../utils/isUnsupportedProviderError/isUnsupportedProviderError.js';
+import { logger } from '../../utils/logger.js';
 
 class EthProviderHelper {
     constructor() {

package/src/wallets/ethereum/{fortmatic.cjs.js → fortmatic.cjs}

@@ -3,11 +3,11 @@
 var tslib = require('tslib');
 var ethers = require('ethers');
 var FortmaticClient = require('fortmatic');
-var normalizeWalletName = require('../../utils/normalizeWalletName/normalizeWalletName.cjs.js');
-var errors = require('../../errors.cjs.js');
-var logger = require('../../utils/logger.cjs.js');
-var ethProviderHelper = require('./ethProviderHelper.cjs.js');
-var ethProvider = require('./ethProvider.cjs.js');
+var normalizeWalletName = require('../../utils/normalizeWalletName/normalizeWalletName.cjs');
+var errors = require('../../errors.cjs');
+var logger = require('../../utils/logger.cjs');
+var ethProviderHelper = require('./ethProviderHelper.cjs');
+var ethProvider = require('./ethProvider.cjs');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }