@exodus/web3-ethereum 1.1.0 → 1.3.0

package/lib/provider/provider.js

@@ -38,30 +38,30 @@ export class EthereumProvider extends BaseProvider {
         const prefix = this.#chainId;
         return super._callRpcMethod(`${prefix}_${method}`, params);
     }
-    #assertConnected() {
+    #assertConnected = () => {
         if (!this.isConnected()) {
             throw ethErrors.provider.disconnected({
                 message: 'The Provider is disconnected from all chains.',
             });
         }
-    }
-    #assertChainSupported(chainId) {
+    };
+    #assertChainSupported = (chainId) => {
         if (!this.#supportedChainIds.includes(chainId)) {
             throw ethErrors.provider.custom({
                 message: 'The Provider does not support the requested chain.',
                 code: 4902,
             });
         }
-    }
-    async #getChainId() {
+    };
+    #getChainId = async () => {
         const storedChainId = await this.#storage.getChainId();
         const defaultChainId = this.#supportedChainIds[0];
         return storedChainId ?? defaultChainId;
-    }
-    async #getAccounts() {
+    };
+    #getAccounts = async () => {
         return this._callRpcMethod('eth_accounts', []);
-    }
-    async #initialize() {
+    };
+    #initialize = async () => {
         const chainId = await this.#getChainId();
         this.#handleConnect(chainId);
         this.#handleChainChanged(chainId);
@@ -69,19 +69,19 @@ export class EthereumProvider extends BaseProvider {
         this.#handleAccountsChanged(accounts);
         this.#initialized = true;
         this.#initializePromise = null;
-    }
-    async #awaitInitialized() {
+    };
+    #awaitInitialized = async () => {
         if (this.#initializePromise) {
             await this.#initializePromise;
         }
-    }
-    #handleConnect(chainId) {
+    };
+    #handleConnect = (chainId) => {
         if (!this.#isConnected) {
             this.#isConnected = true;
             this.emit('connect', { chainId });
         }
-    }
-    #handleChainChanged(chainId) {
+    };
+    #handleChainChanged = (chainId) => {
         if (!chainId || typeof chainId !== 'string' || !chainId.startsWith('0x')) {
             return;
         }
@@ -91,8 +91,8 @@ export class EthereumProvider extends BaseProvider {
                 this.emit('chainChanged', chainId);
             }
         }
-    }
-    #handleAccountsChanged(accounts) {
+    };
+    #handleAccountsChanged = (accounts) => {
         // `accounts` is always going to have a single account (or none) for the time being.
         if (this.#accounts[0] !== accounts[0]) {
             this.#accounts = accounts;
@@ -101,8 +101,8 @@ export class EthereumProvider extends BaseProvider {
                 this.emit('accountsChanged', accounts);
             }
         }
-    }
-    async #requestAccounts() {
+    };
+    #requestAccounts = async () => {
         const permissions = { eth_accounts: {} };
         await this._callRpcMethod('wallet_requestPermissions', [permissions]);
         const accounts = await this._callRpcMethod('eth_accounts', []);
@@ -115,21 +115,21 @@ export class EthereumProvider extends BaseProvider {
             }
         }
         return accounts;
-    }
-    async #addChain(chainId) {
+    };
+    #addChain = async (chainId) => {
         // Exodus does not support the addition of custom chains.
         // If the requested chain is supported, the provider will switch to that chain.
         // This matches MetaMask's behavior.
         // See: https://github.com/MetaMask/metamask-extension/blob/d92936475a942fed060bb36f810ee6bfd901f4f4/app/scripts/lib/rpc-method-middleware/handlers/add-ethereum-chain.js#L167-L183.
         return this.#switchChain(chainId);
-    }
-    async #switchChain(chainId) {
+    };
+    #switchChain = async (chainId) => {
         const lowerCaseChainId = chainId.toLowerCase();
         this.#assertChainSupported(lowerCaseChainId);
         this.#handleChainChanged(lowerCaseChainId);
         await this.#storage.setChainId(lowerCaseChainId);
         return null;
-    }
+    };
     isConnected() {
         return this.#isConnected;
     }

package/lib/rpc-handlers/exposeHandlers.d.ts

@@ -0,0 +1,4 @@
+import type RPC from '@exodus/json-rpc';
+import type { AppDeps, WalletDeps } from '@exodus/web3-types';
+import type { EVMDeps } from '../types.js';
+export declare function exposeHandlers(rpc: typeof RPC, deps: AppDeps & EVMDeps & WalletDeps): void;

package/lib/rpc-handlers/exposeHandlers.js

@@ -0,0 +1,215 @@
+import { getTransactionId, signMessage, signTransaction, signTypedData, } from '@exodus/web3-ethereum-utils';
+import { AssetNotSupportedError, InvalidInputError, UnauthorizedError, UserRejectedRequestError, } from '@exodus/web3-errors';
+import { SignTypedDataVersion } from '@metamask/eth-sig-util';
+import { parseAndValidateTypedData } from './parseAndValidateTypedData.js';
+// See: https://eips.ethereum.org/EIPS/eip-2255.
+const ETH_ACCOUNTS_PERMISSION = 'eth_accounts';
+const PROXIED_METHODS = [
+    'eth_blockNumber',
+    'eth_call',
+    'eth_coinbase',
+    'eth_createAccessList',
+    'eth_estimateGas',
+    'eth_feeHistory',
+    'eth_gasPrice',
+    'eth_getBalance',
+    'eth_getBlockByHash',
+    'eth_getBlockByNumber',
+    'eth_getBlockTransactionCountByHash',
+    'eth_getBlockTransactionCountByNumber',
+    'eth_getCode',
+    'eth_getCompilers',
+    'eth_getLogs',
+    'eth_getProof',
+    'eth_getStorageAt',
+    'eth_getTransactionByBlockHashAndIndex',
+    'eth_getTransactionByBlockNumberAndIndex',
+    'eth_getTransactionByHash',
+    'eth_getTransactionCount',
+    'eth_getTransactionReceipt',
+    'eth_getUncleByBlockHashAndIndex',
+    'eth_getUncleByBlockNumberAndIndex',
+    'eth_getUncleCountByBlockHash',
+    'eth_getWork',
+    'eth_hashrate',
+    'eth_pendingTransactions',
+    'eth_sendRawTransaction',
+    'eth_submitWork',
+    'net_version',
+    // TODO: Should we handle the response like MetaMask, e.g. "MetaMask/v10.14.7"?
+    'web3_clientVersion',
+];
+function typedDataToMessage(typedData, 
+// TODO: Remove eslint-disable comment when implementing.
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+version) {
+    // TODO: Return human-readable message from typed data.
+    return typedData.toString();
+}
+export function exposeHandlers(rpc, deps) {
+    const { chainId, isTrusted, isAutoApproved, ensureTrusted, approveConnection, approveMessage, approveTransactions, forwardRequest, getAddress, getPrivateKey, getEstimatedGas, getFeeData, getNonce, sendRawTransaction, onTransactionsSigned = () => { }, onEthWalletWatchAssetRequest = () => { }, isUnlocked = () => true, ensureUnlocked = () => true, } = deps;
+    const network = `evm:${chainId}`;
+    async function assertTrusted() {
+        const trusted = await isTrusted();
+        if (!trusted) {
+            throw new UnauthorizedError();
+        }
+    }
+    async function prepareTransaction(transaction) {
+        const { gasPrice, maxFeePerGas, maxPriorityFeePerGas } = await getFeeData();
+        const preparedTransaction = { ...transaction };
+        preparedTransaction.nonce = await getNonce(transaction.from);
+        if (!transaction.value) {
+            preparedTransaction.value = '0x0';
+        }
+        if (!transaction.gasPrice) {
+            preparedTransaction.gasPrice = gasPrice;
+        }
+        if (!transaction.maxFeePerGas && maxFeePerGas) {
+            preparedTransaction.maxFeePerGas = maxFeePerGas;
+        }
+        if (!transaction.maxPriorityFeePerGas && maxPriorityFeePerGas) {
+            preparedTransaction.maxPriorityFeePerGas = maxPriorityFeePerGas;
+        }
+        if (!transaction.data) {
+            preparedTransaction.data = '0x';
+        }
+        // NOTE: Keep this at the end as other parameters can affect gas estimation.
+        if (!transaction.gas) {
+            preparedTransaction.gas = await getEstimatedGas(preparedTransaction);
+        }
+        return preparedTransaction;
+    }
+    function validateTransaction(transaction) {
+        const gasKeys = [
+            'gas',
+            'gasPrice',
+            'maxFeePerGas',
+            'maxPriorityFeePerGas',
+        ];
+        for (const key of gasKeys) {
+            if (transaction[key] === '0x') {
+                throw new InvalidInputError();
+            }
+        }
+    }
+    async function approve(approvalFn, ...args) {
+        const autoApproved = await isAutoApproved();
+        if (autoApproved) {
+            return;
+        }
+        const approved = await approvalFn(...args);
+        if (!approved) {
+            throw new UserRejectedRequestError();
+        }
+    }
+    async function approveAndSignTransaction(transaction) {
+        await assertTrusted();
+        const preparedTransaction = await prepareTransaction(transaction);
+        validateTransaction(preparedTransaction);
+        await approve(approveTransactions, network, [preparedTransaction]);
+        const privateKey = await getPrivateKey();
+        const signedTransaction = signTransaction({ ...preparedTransaction, chainId }, privateKey);
+        const isEIP1559Enabled = !!preparedTransaction.maxFeePerGas;
+        const transactionId = getTransactionId(signedTransaction, isEIP1559Enabled);
+        onTransactionsSigned(network, [transactionId]);
+        return `0x${signedTransaction.toString('hex')}`;
+    }
+    async function approveAndSignMessage(message) {
+        await assertTrusted();
+        await approve(approveMessage, network, message);
+        const privateKey = await getPrivateKey();
+        return signMessage(message, privateKey);
+    }
+    async function approveAndSignTypedData(typedData) {
+        await assertTrusted();
+        const parsedTypedData = parseAndValidateTypedData(typedData, { chainId });
+        const message = typedDataToMessage(typedData, SignTypedDataVersion.V4);
+        await approve(approveMessage, network, message);
+        const privateKey = await getPrivateKey();
+        return signTypedData(parsedTypedData, privateKey, SignTypedDataVersion.V4);
+    }
+    function exposeEvmFunction(name, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    fn) {
+        return rpc.exposeFunction(`${chainId}_${name}`, fn);
+    }
+    PROXIED_METHODS.forEach((method) => {
+        exposeEvmFunction(method, async (...params) => {
+            // TODO: Do we need to check `assertTrusted` here?
+            // See: https://eips.ethereum.org/EIPS/eip-1193#connectivity.
+            // TODO: Check support for named params (i.e. object).
+            const args = { method, params };
+            return forwardRequest(args);
+        });
+    });
+    exposeEvmFunction('eth_accounts', async () => {
+        const unlocked = await isUnlocked();
+        if (!unlocked) {
+            return [];
+        }
+        const trusted = await isTrusted();
+        if (!trusted) {
+            return [];
+        }
+        const address = await getAddress();
+        return [address];
+    });
+    exposeEvmFunction('eth_signTransaction', approveAndSignTransaction);
+    exposeEvmFunction('eth_sendTransaction', async (transaction) => {
+        const rawTransaction = await approveAndSignTransaction(transaction);
+        return sendRawTransaction(rawTransaction);
+    });
+    exposeEvmFunction('personal_sign', approveAndSignMessage);
+    exposeEvmFunction('eth_sign', async (account, message) => 
+    // Should we really be using `personalSign` here?
+    // See: https://docs.metamask.io/guide/signing-data.html#a-brief-history.
+    approveAndSignMessage(message));
+    exposeEvmFunction('eth_signTypedData_v1', async (typedData) => {
+        await assertTrusted();
+        const message = typedDataToMessage(typedData, SignTypedDataVersion.V1);
+        await approve(approveMessage, network, message);
+        const privateKey = await getPrivateKey();
+        return signTypedData(typedData, privateKey, SignTypedDataVersion.V1);
+    });
+    exposeEvmFunction('eth_signTypedData_v3', async (account, typedData) => approveAndSignTypedData(typedData));
+    exposeEvmFunction('eth_signTypedData_v4', async (account, typedData) => approveAndSignTypedData(typedData));
+    exposeEvmFunction('eth_signTypedData', async (account, typedData) => approveAndSignTypedData(typedData));
+    exposeEvmFunction('wallet_getPermissions', async () => {
+        const permissions = [];
+        const trusted = await isTrusted();
+        if (trusted) {
+            permissions.push({ parentCapability: ETH_ACCOUNTS_PERMISSION });
+        }
+        return permissions;
+    });
+    exposeEvmFunction('wallet_requestPermissions', async (requestedPermissions) => {
+        const parentCapability = Object.keys(requestedPermissions)[0];
+        if (parentCapability !== ETH_ACCOUNTS_PERMISSION) {
+            // `eth_accounts` is currently the only permission.
+            // See: https://docs.metamask.io/guide/rpc-api.html#restricted-methods.
+            throw new InvalidInputError();
+        }
+        const unlocked = await ensureUnlocked();
+        if (!unlocked) {
+            throw new UserRejectedRequestError();
+        }
+        const trusted = await isTrusted();
+        if (!trusted) {
+            const approved = await approveConnection(network);
+            if (!approved) {
+                throw new UserRejectedRequestError();
+            }
+            await ensureTrusted();
+        }
+        return [{ parentCapability: ETH_ACCOUNTS_PERMISSION }];
+    });
+    exposeEvmFunction('wallet_watchAsset', async (assetDetails) => {
+        await assertTrusted();
+        const assetAdded = await onEthWalletWatchAssetRequest(assetDetails);
+        if (!assetAdded) {
+            throw new AssetNotSupportedError(assetDetails.type);
+        }
+        return true;
+    });
+}

package/lib/rpc-handlers/index.d.ts

@@ -0,0 +1,12 @@
+import type RPC from '@exodus/json-rpc';
+import type { Dependencies } from '../types.js';
+import type { Transport } from '@exodus/web3-types';
+interface RpcConstructor {
+    new (...options: unknown[]): typeof RPC;
+}
+export declare const registerRPCHandlers: ({ deps, RPC, transport, }: {
+    deps: Dependencies;
+    RPC: RpcConstructor;
+    transport: Transport;
+}) => any;
+export {};

package/lib/rpc-handlers/index.js

@@ -0,0 +1,48 @@
+import { validate as validateDeps, validateCommonDeps, } from '@exodus/web3-rpc-handlers';
+import { RPC_REQUEST_TIMEOUT } from '@exodus/web3-constants';
+import { exposeHandlers } from './exposeHandlers.js';
+import { validateRequest } from './validator.js';
+const validateEVMDeps = (evm) => {
+    const requiredKeys = [
+        'chainId',
+        'forwardRequest',
+        'getAddress',
+        'getPrivateKey',
+        'getEstimatedGas',
+        'getFeeData',
+        'getNonce',
+        'sendRawTransaction',
+    ];
+    const optionalKeys = ['onEthWalletWatchAssetRequest'];
+    validateDeps(evm, requiredKeys, optionalKeys);
+};
+function validateEVMsDeps(evms) {
+    const chainIds = evms.map(({ chainId }) => chainId);
+    const uniqueChainIds = [...new Set(chainIds)];
+    if (chainIds.length !== uniqueChainIds.length) {
+        throw new Error('EVMs must have unique chain IDs');
+    }
+    evms.forEach(validateEVMDeps);
+}
+export const registerRPCHandlers = ({ deps, RPC, transport, }) => {
+    validateCommonDeps(deps, ['evms']);
+    validateEVMsDeps(deps.evms);
+    if (!RPC) {
+        throw new Error('"RPC" constructor parameter is required');
+    }
+    if (!transport) {
+        throw new Error('"transport" parameter is required');
+    }
+    const rpc = new RPC({
+        transport,
+        parse: validateRequest,
+        getIsDevelopmentMode: () => app.isDevelopmentEnvironment?.() ?? false,
+        requestTimeout: RPC_REQUEST_TIMEOUT,
+    });
+    const { app, evms = [], wallet } = deps;
+    for (const evm of evms) {
+        const evmDeps = { ...app, ...evm, ...wallet };
+        exposeHandlers(rpc, evmDeps);
+    }
+    return rpc;
+};

package/lib/rpc-handlers/parseAndValidateTypedData.d.ts

@@ -0,0 +1,5 @@
+import type { MessageTypes, TypedDataV1, TypedMessage } from '@metamask/eth-sig-util';
+export declare function convertChainIdToHex(chainId: string): string;
+export declare function parseAndValidateTypedData(typedData: string, { chainId: activeChainId }: {
+    chainId: string;
+}): TypedDataV1 | TypedMessage<MessageTypes> | never;

package/lib/rpc-handlers/parseAndValidateTypedData.js

@@ -0,0 +1,30 @@
+import { validateAndParseEthereumTypedData } from '@exodus/web3-validation';
+import { InvalidInputError } from '@exodus/web3-errors';
+export function convertChainIdToHex(chainId) {
+    if (typeof chainId !== 'string') {
+        throw new Error(`'chainId' should be a string, got: ${typeof chainId}`);
+    }
+    // `chainId` can be a stringified decimal
+    if (!chainId.startsWith('0x')) {
+        return '0x' + parseInt(chainId, 10).toString(16).toLowerCase();
+    }
+    return chainId.toLowerCase();
+}
+// Returns the parsed typed data object if it is valid
+// Otherwise throws the InvalidInputError
+export function parseAndValidateTypedData(typedData, { chainId: activeChainId }) {
+    let parsedTypedData;
+    try {
+        parsedTypedData = validateAndParseEthereumTypedData(typedData);
+    }
+    catch (e) {
+        throw new InvalidInputError();
+    }
+    if (parsedTypedData.domain?.chainId) {
+        const suppliedChainIdHex = convertChainIdToHex(`${parsedTypedData.domain.chainId}`);
+        if (activeChainId.toLowerCase() !== suppliedChainIdHex) {
+            throw new InvalidInputError();
+        }
+    }
+    return parsedTypedData;
+}

package/lib/rpc-handlers/validator.d.ts

@@ -0,0 +1 @@
+export declare const validateRequest: () => never;

package/lib/rpc-handlers/validator.js

@@ -0,0 +1,3 @@
+export const validateRequest = () => {
+    throw new Error('Should be replaced with the generated code');
+};

package/lib/types.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { EthTransaction, EthTransactionHash, EthWalletWatchAsset } from '@exodus/web3-ethereum-utils';
+import type { CommonDeps } from '@exodus/web3-rpc-handlers';
+/**
+ * EVM-compatible chains.
+ */
+export interface EthRequestArguments {
+    method: string;
+    params?: unknown[] | Record<string, unknown>;
+}
+interface FeeData {
+    gasPrice: string;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+}
+export declare type EVMDeps = {
+    chainId: string;
+    getAddress: () => Promise<string>;
+    getPrivateKey: () => Promise<Buffer>;
+    sendRawTransaction: (rawTransaction: string) => Promise<EthTransactionHash>;
+    getEstimatedGas: (transaction: EthTransaction) => Promise<string>;
+    getFeeData: () => Promise<FeeData>;
+    getNonce: (account: string) => Promise<string>;
+    forwardRequest: (args: EthRequestArguments) => Promise<unknown>;
+    onEthWalletWatchAssetRequest?: (assetDetails: EthWalletWatchAsset) => Promise<boolean>;
+};
+export declare type Dependencies = {
+    evms: EVMDeps[];
+} & CommonDeps;
+export {};

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@exodus/web3-ethereum",
   "description": "Apps connectivity library for EVM-compatible chains.",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "type": "module",
   "sideEffects": false,
   "module": "lib/index.js",
@@ -39,12 +39,14 @@
   },
   "devDependencies": {
     "@exodus/assets": "^8.0.72",
+    "@exodus/json-rpc": "^1.11.0",
     "@exodus/schemasafe": "^1.0.0-rc.7",
     "@exodus/web3-types": "^1.6.0",
+    "@exodus/web3-validation": "^1.27.0",
     "@wallet-standard/base": "^1.0.1"
   },
   "peerDependencies": {
     "@exodus/assets": "^8.0.72"
   },
-  "gitHead": "75254d697e3ffd2d95759e30425c30c7fb7fa654"
+  "gitHead": "91de31ee30652f2f8acc66f6e1d909fd27174a36"
 }