@exodus/web3-ethereum 11.8.0 → 11.10.0

package/lib/provider/provider.d.ts

@@ -1,6 +1,6 @@
 import { BaseProvider } from '@exodus/web3-provider';
 import type { ChainId, Deps, JsonRpcCallback, JsonRpcRequest, JsonRpcResult, ProviderConnectInfo, RequestArguments } from './types.js';
-interface EthereumProviderEvents {
+export interface EthereumProviderEvents {
     accountsChanged(accounts: string[]): void;
     chainChanged(chainId: ChainId): void;
     connect(providerConnectInfo: ProviderConnectInfo): void;
@@ -13,10 +13,26 @@ export declare class EthereumProvider extends BaseProvider<EthereumProviderEvent
     protected _callRpcMethod<Params, Response>(method: string, params: Params): Promise<Response>;
     isConnected(): boolean;
     request: (args: RequestArguments) => Promise<unknown>;
+    /**
+     * Experimental API
+     */
+    _metamask: {
+        /**
+         * Determines if MetaMask is unlocked by the user.
+         *
+         * @returns Promise resolving to true if MetaMask is currently unlocked.
+         */
+        isUnlocked: () => Promise<boolean>;
+        /**
+         * Make a batch RPC request.
+         *
+         * @param requests - The RPC requests to make.
+         */
+        requestBatch: (requests: RequestArguments[]) => Promise<unknown[]>;
+    };
     get chainId(): ChainId | null;
     get selectedAddress(): string | null;
     enable: () => Promise<string[]>;
     send: (methodOrPayload: string | JsonRpcRequest, paramsOrCallback: unknown[] | JsonRpcCallback) => Promise<void | JsonRpcResult>;
     sendAsync: (payload: JsonRpcRequest, callback: JsonRpcCallback) => void;
 }
-export {};

package/lib/provider/provider.js

@@ -190,6 +190,37 @@ export class EthereumProvider extends BaseProvider {
         }
         return this._callRpcMethod(method, revisedParams);
     };
+    /**
+     * Experimental API
+     */
+    _metamask = {
+        /**
+         * Determines if MetaMask is unlocked by the user.
+         *
+         * @returns Promise resolving to true if MetaMask is currently unlocked.
+         */
+        // TODO: improve this, atm heurestic if we have accounts, assume unlocked
+        isUnlocked: async () => Array.isArray(this.#accounts) && this.#accounts.length > 0,
+        /**
+         * Make a batch RPC request.
+         *
+         * @param requests - The RPC requests to make.
+         */
+        requestBatch: async (requests) => {
+            if (!Array.isArray(requests)) {
+                throw ethErrors.rpc.invalidRequest({
+                    message: 'Batch requests must be made with an array of request objects.',
+                    data: requests,
+                });
+            }
+            const results = [];
+            // for-loop to ensure handling requests one-by-one.
+            for (const request of requests) {
+                results.push(await this.request(request));
+            }
+            return results;
+        },
+    };
     /*
      * Legacy API.
      */

package/lib/provider-proxy/index.d.ts

@@ -0,0 +1 @@
+export { createEthereumProviderProxy } from './proxy.js';

package/lib/provider-proxy/index.js

@@ -0,0 +1 @@
+export { createEthereumProviderProxy } from './proxy.js';

package/lib/provider-proxy/proxy.d.ts

@@ -0,0 +1,20 @@
+import type { EthereumProvider } from '../provider/provider.js';
+import type { ManagementProvider, WalletProviderManager } from '@exodus/web3-management';
+export declare type EthereumProviderProxyDeps = {
+    isWalletNameFlag: string;
+    impersonateOtherWallets?: boolean;
+    getDefaultChainId: () => number;
+    walletProviderManager: WalletProviderManager;
+    getManagementProvider: () => Promise<ManagementProvider>;
+    getEthereumProvider: () => Promise<EthereumProvider>;
+};
+/**
+ * createEthereumProviderProxy creates a light weight proxy that
+ * gets intercepts all calls to the real provider. By default only
+ * the proxy will be loaded and it will instantiate the real provider
+ * once it's being used in order to reduce the memory load of our provider
+ * whenever injected inside a website that doesn't use web3.
+ * @param param0
+ * @returns
+ */
+export declare const createEthereumProviderProxy: ({ isWalletNameFlag, impersonateOtherWallets, getDefaultChainId, walletProviderManager, getManagementProvider, getEthereumProvider, }: EthereumProviderProxyDeps) => import("@exodus/web3-provider").BaseProvider<string | symbol>;

package/lib/provider-proxy/proxy.js

@@ -0,0 +1,131 @@
+import { createProviderProxy } from '@exodus/web3-provider/proxy';
+const ETHEREUM_INIT_METHODS_SET = new Set([
+    'accountsChangedSet',
+    'autoRefreshOnNetworkChange',
+    'chainId',
+    'enable',
+    'isConnected',
+    'isUnlocked',
+    'networkChangedSet',
+    'request',
+    'selectedAddress',
+    'send',
+    'sendAsync',
+]);
+/**
+ * createEthereumProviderProxy creates a light weight proxy that
+ * gets intercepts all calls to the real provider. By default only
+ * the proxy will be loaded and it will instantiate the real provider
+ * once it's being used in order to reduce the memory load of our provider
+ * whenever injected inside a website that doesn't use web3.
+ * @param param0
+ * @returns
+ */
+export const createEthereumProviderProxy = ({ isWalletNameFlag, impersonateOtherWallets, getDefaultChainId, walletProviderManager, getManagementProvider, getEthereumProvider, }) => {
+    let listeners = [];
+    let provider = Object.assign(Object.create(null), {
+        [isWalletNameFlag]: true,
+    });
+    const cacheListener = (event, listener) => {
+        listeners.push([event, listener]);
+        return provider;
+    };
+    const clearCachedListeners = () => {
+        listeners = [];
+        return provider;
+    };
+    const setNameFlags = () => {
+        if (impersonateOtherWallets) {
+            // For compatibility with MetaMask's Ethereum Provider.
+            // See: https://docs.metamask.io/guide/ethereum-provider.html#properties.
+            provider.isMetaMask = true;
+            // For Phantom compatiblity
+            provider.isPhantom = true;
+        }
+        // Dynamically set the wallet name flag to true
+        provider.defineFlag?.(isWalletNameFlag);
+    };
+    const restoreListeners = (provider) => {
+        listeners.forEach(([event, listener]) => provider.on(event, listener));
+        listeners = [];
+    };
+    provider.on = cacheListener;
+    provider.addListener = cacheListener;
+    provider.removeAllListeners = clearCachedListeners;
+    setNameFlags();
+    const initProvider = async () => {
+        provider = await getEthereumProvider();
+        setNameFlags();
+        restoreListeners(provider);
+    };
+    const getActiveChainId = () => provider.request({ method: 'eth_chainId' });
+    const get = (_, property) => {
+        const contextualFunction = (property, shouldInitProvider = false) => {
+            if (provider[property]?.constructor.name === 'Function') {
+                return provider[property].bind(provider);
+            }
+            // Handle async calls
+            return async (...args) => {
+                if (shouldInitProvider) {
+                    await initProvider();
+                }
+                if (property === 'enable' ||
+                    args[0]?.method === 'eth_requestAccounts') {
+                    const managementProvider = await getManagementProvider();
+                    const chainId = (await getActiveChainId()) || (await getDefaultChainId());
+                    await managementProvider.askUserToChooseWallet(`evm:${chainId}`);
+                    const defaultWalletProvider = walletProviderManager.getDefaultWalletProvider();
+                    // Check if the user selected a different wallet when connecting to Exodus wallet.
+                    if (defaultWalletProvider) {
+                        restoreListeners(defaultWalletProvider.provider);
+                        return defaultWalletProvider.provider[property].bind(defaultWalletProvider.provider)(...args);
+                    }
+                }
+                return provider[property].bind(provider)(...args);
+            };
+        };
+        const defaultWalletProvider = walletProviderManager.getDefaultWalletProvider();
+        if (defaultWalletProvider) {
+            restoreListeners(defaultWalletProvider.provider);
+            if (typeof defaultWalletProvider.provider[property] === 'function') {
+                return defaultWalletProvider.provider[property].bind(defaultWalletProvider.provider);
+            }
+            return defaultWalletProvider.provider[property];
+        }
+        if (provider[property] !== undefined) {
+            if (typeof provider[property] === 'function') {
+                return contextualFunction(property);
+            }
+            return provider[property];
+        }
+        if (ETHEREUM_INIT_METHODS_SET.has(property)) {
+            return contextualFunction(property, true);
+        }
+        if (property === '_metamask') {
+            return {
+                isUnlocked: async (...args) => {
+                    if (!provider._metamask) {
+                        await initProvider();
+                    }
+                    return provider._metamask.isUnlocked(...args);
+                },
+                requestBatch: async (...args) => {
+                    if (!provider._metamask) {
+                        await initProvider();
+                    }
+                    return provider._metamask.requestBatch(...args);
+                },
+            };
+        }
+    };
+    const set = (target, prop, value) => {
+        // Allow setting these specific properties as the ecosystem relies on that.
+        if (['autoRefreshOnNetworkChange', 'removeListener'].includes(prop)) {
+            target[prop] = value;
+            return true;
+        }
+        return false;
+    };
+    const has = (_, property) => ETHEREUM_INIT_METHODS_SET.has(property);
+    return createProviderProxy(provider, { get, set, has });
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@exodus/web3-ethereum",
   "description": "Apps connectivity library for EVM-compatible chains.",
-  "version": "11.8.0",
+  "version": "11.10.0",
   "type": "module",
   "sideEffects": false,
   "module": "lib/index.js",
@@ -10,6 +10,7 @@
     ".": "./lib/index.js",
     "./package.json": "./package.json",
     "./provider": "./lib/provider/index.js",
+    "./provider-proxy": "./lib/provider-proxy/index.js",
     "./rpc": "./lib/rpc-handlers/index.js",
     "./wallet-standard": "./lib/wallet-standard/index.js",
     "./eip6963": "./lib/eip6963/index.js"
@@ -35,7 +36,7 @@
     "@exodus/ethereum-api": "^6.3.33",
     "@exodus/web3-constants": "^1.29.0",
     "@exodus/web3-ethereum-utils": "^3.22.0",
-    "@exodus/web3-provider": "^3.12.0",
+    "@exodus/web3-provider": "^3.13.0",
     "@exodus/web3-rpc-handlers": "^2.19.0",
     "@exodus/web3-utils": "^1.42.0",
     "bn.js": "^5.2.0",
@@ -45,6 +46,7 @@
     "@exodus/assets": "^8.0.95",
     "@exodus/json-rpc": "^1.11.0",
     "@exodus/schemasafe": "^1.0.0",
+    "@exodus/web3-management": "0.27.0",
     "@exodus/web3-types": "0.0.0",
     "@exodus/web3-validation": "^1.37.1",
     "@wallet-standard/base": "^1.0.1"
@@ -52,5 +54,5 @@
   "peerDependencies": {
     "@exodus/assets": "^8.0.95"
   },
-  "gitHead": "b33885a025250b22c631ee1008af8aa1f8ce03af"
+  "gitHead": "c88e13bae6cc31906b513d7e17c1b2a989e4768d"
 }