@exodus/web3-ethereum 1.0.0 → 1.2.0

package/lib/index.d.ts

@@ -1,2 +1,3 @@
-export * from './provider/index.js';
-export * from './simulation/index.js';
+export { EthereumProvider } from './provider/index.js';
+export { simulateTransaction } from './simulation/index.js';
+export { ExodusEthereumWallet } from './wallet-standard/index.js';

package/lib/index.js

@@ -1,2 +1,3 @@
-export * from './provider/index.js';
-export * from './simulation/index.js';
+export { EthereumProvider } from './provider/index.js';
+export { simulateTransaction } from './simulation/index.js';
+export { ExodusEthereumWallet } from './wallet-standard/index.js';

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/simulation/constant.d.ts

@@ -1,5 +1 @@
-import type { EVMConstants } from './types.js';
-export declare const CHAIN_IDS: {
-    [key: string]: number;
-};
-export declare const ENABLED_EVMS: EVMConstants[];
+export declare const SIMULATION_SUPPORTED_ASSET_NAMES: string[];

package/lib/simulation/constant.js

@@ -1,32 +1 @@
-export const CHAIN_IDS = {
-    avalanchec: 43114,
-    bsc: 56,
-    ethereum: 1,
-    ethereumclassic: 61,
-    ethereumgoerli: 5,
-    fantommainnet: 250,
-    harmonymainnet: 1666600000,
-    matic: 137,
-};
-export const ENABLED_EVMS = [
-    {
-        assetName: 'ethereum',
-        shouldSimulate: true,
-    },
-    {
-        assetName: 'matic',
-        shouldSimulate: false,
-    },
-    {
-        assetName: 'bsc',
-        shouldSimulate: false,
-    },
-    {
-        assetName: 'avalanchec',
-        shouldSimulate: false,
-    },
-    {
-        assetName: 'fantommainnet',
-        shouldSimulate: false,
-    },
-];
+export const SIMULATION_SUPPORTED_ASSET_NAMES = ['ethereum']; // just ethereum for now

package/lib/simulation/index.d.ts

@@ -1,16 +1 @@
-import type { EthTransaction } from '@exodus/web3-ethereum-utils';
-import type { Asset, EthBalanceChanges } from './types.js';
-export declare const simulateTransaction: (assets: Record<string, Asset>, transaction: EthTransaction, network: string) => Promise<{
-    assetName: string;
-    advancedDetails: never[];
-    balanceChanges: EthBalanceChanges;
-    displayInfo: {
-        title: string;
-    };
-    txFee: unknown;
-    txFeeDetails: {
-        gasLimit: number;
-        maxFeePerGas: number | undefined;
-        gasPrice: number;
-    };
-}>;
+export { simulateTransaction } from './simulation.js';

package/lib/simulation/index.js

@@ -1,70 +1 @@
-import { retrieveSideEffects } from '@exodus/ethereum-api';
-import { createCurrency, formatAccounts, getEthereumDisplayInfo, supportedNetworkEvms, hexToBN, isEthTransferTx, } from './utils.js';
-const computeBalanceChanges = async (asset, shouldSimulate, transaction) => {
-    const assetName = asset.name;
-    let balanceChanges = {
-        willReceive: [],
-        willSend: [],
-        willApprove: [],
-    };
-    if (isEthTransferTx(transaction)) {
-        const txValue = hexToBN(transaction.value).toString();
-        balanceChanges.willSend.push({
-            balance: createCurrency({
-                amount: txValue,
-                denominator: asset.currency.defaultUnit.power,
-                symbol: asset.displayTicker,
-            }),
-        });
-    }
-    else {
-        try {
-            const sideEffect = await retrieveSideEffects({
-                assetName,
-                shouldSimulate,
-                transaction,
-            });
-            if (sideEffect) {
-                balanceChanges = formatAccounts(sideEffect);
-            }
-        }
-        catch (error) {
-            console.error('Ethereum transaction simulation failed.', error);
-        }
-    }
-    return balanceChanges;
-};
-const getTxFeeDetails = (asset, transaction) => {
-    const maxFeePerGasBn = transaction.maxFeePerGas
-        ? hexToBN(transaction.maxFeePerGas)
-        : undefined;
-    const gasPriceBn = hexToBN(transaction.gasPrice);
-    const gasBn = hexToBN(transaction.gas);
-    return {
-        txFee: asset.currency.baseUnit(gasBn.mul(maxFeePerGasBn || gasPriceBn).toString()),
-        txFeeDetails: {
-            gasLimit: gasBn.toNumber(),
-            maxFeePerGas: maxFeePerGasBn?.toNumber(),
-            gasPrice: gasPriceBn.toNumber(),
-        },
-    };
-};
-export const simulateTransaction = async (assets, transaction, network) => {
-    const evm = supportedNetworkEvms.get(network);
-    if (!evm) {
-        throw new Error(`unsupported network, ${network}`);
-    }
-    const { assetName, shouldSimulate } = evm;
-    const asset = assets[assetName];
-    const balanceChanges = await computeBalanceChanges(asset, shouldSimulate, transaction);
-    const { txFee, txFeeDetails } = getTxFeeDetails(asset, transaction);
-    const displayInfo = getEthereumDisplayInfo(balanceChanges);
-    return {
-        assetName,
-        advancedDetails: [],
-        balanceChanges,
-        displayInfo,
-        txFee,
-        txFeeDetails,
-    };
-};
+export { simulateTransaction } from './simulation.js';

package/lib/simulation/simulation.d.ts

@@ -0,0 +1,16 @@
+import type { EthTransaction } from '@exodus/web3-ethereum-utils';
+import type { Asset, EthBalanceChanges } from './types.js';
+export declare const simulateTransaction: (asset: Asset, transaction: EthTransaction) => Promise<{
+    assetName: string;
+    advancedDetails: never[];
+    balanceChanges: EthBalanceChanges;
+    displayInfo: {
+        title: string;
+    };
+    txFee: unknown;
+    txFeeDetails: {
+        gasLimit: number;
+        maxFeePerGas: number | undefined;
+        gasPrice: number;
+    };
+}>;

package/lib/simulation/simulation.js

@@ -0,0 +1,67 @@
+import { retrieveSideEffects } from '@exodus/ethereum-api';
+import { SIMULATION_SUPPORTED_ASSET_NAMES } from './constant.js';
+import { createCurrency, formatAccounts, getEthereumDisplayInfo, hexToBN, isEthTransferTx, } from './utils.js';
+const computeBalanceChanges = async (asset, shouldSimulate, transaction) => {
+    const assetName = asset.name;
+    let balanceChanges = {
+        willReceive: [],
+        willSend: [],
+        willApprove: [],
+    };
+    if (isEthTransferTx(transaction)) {
+        const txValue = hexToBN(transaction.value).toString();
+        balanceChanges.willSend.push({
+            balance: createCurrency({
+                amount: txValue,
+                denominator: asset.currency.defaultUnit.power,
+                symbol: asset.displayTicker,
+            }),
+        });
+    }
+    else {
+        try {
+            const sideEffect = await retrieveSideEffects({
+                assetName,
+                shouldSimulate,
+                transaction,
+            });
+            if (sideEffect) {
+                balanceChanges = formatAccounts(sideEffect);
+            }
+        }
+        catch (error) {
+            console.error('Ethereum transaction simulation failed.', error);
+        }
+    }
+    return balanceChanges;
+};
+const getTxFeeDetails = (asset, transaction) => {
+    const maxFeePerGasBn = transaction.maxFeePerGas
+        ? hexToBN(transaction.maxFeePerGas)
+        : undefined;
+    const gasPriceBn = hexToBN(transaction.gasPrice);
+    const gasBn = hexToBN(transaction.gas);
+    return {
+        txFee: asset.currency.baseUnit(gasBn.mul(maxFeePerGasBn || gasPriceBn).toString()),
+        txFeeDetails: {
+            gasLimit: gasBn.toNumber(),
+            maxFeePerGas: maxFeePerGasBn?.toNumber(),
+            gasPrice: gasPriceBn.toNumber(),
+        },
+    };
+};
+export const simulateTransaction = async (asset, transaction) => {
+    const assetName = asset.name;
+    const shouldSimulate = SIMULATION_SUPPORTED_ASSET_NAMES.includes(assetName);
+    const balanceChanges = await computeBalanceChanges(asset, shouldSimulate, transaction);
+    const { txFee, txFeeDetails } = getTxFeeDetails(asset, transaction);
+    const displayInfo = getEthereumDisplayInfo(balanceChanges);
+    return {
+        assetName,
+        advancedDetails: [],
+        balanceChanges,
+        displayInfo,
+        txFee,
+        txFeeDetails,
+    };
+};

package/lib/simulation/types.d.ts

@@ -1,7 +1,3 @@
-export interface EVMConstants {
-    assetName: string;
-    shouldSimulate: boolean;
-}
 export interface CurrencyParams {
     amount: string;
     symbol: string;

package/lib/simulation/utils.d.ts

@@ -2,12 +2,6 @@ import BN from 'bn.js';
 import type { CurrencyParams, EthBalanceChange, EthBalanceChanges } from './types.js';
 import type { EthTransaction } from '@exodus/web3-ethereum-utils';
 export declare const hexToBN: (hexValue?: string) => BN;
-export declare const supportedNetworkEvms: Map<string, {
-    chainId: string;
-    network: string;
-    assetName: string;
-    shouldSimulate: boolean;
-}>;
 export declare const isEthTransferTx: (transaction: EthTransaction) => boolean;
 export declare function getEthereumDisplayInfo(balanceChanges: EthBalanceChanges): {
     title: string;

package/lib/simulation/utils.js

@@ -1,13 +1,6 @@
 import { UnitType } from '@exodus/currency';
 import BN from 'bn.js';
-import { CHAIN_IDS, ENABLED_EVMS } from './constant.js';
 export const hexToBN = (hexValue) => new BN((hexValue || '').slice(2), 'hex');
-const getEvmNetwork = (chainId) => `evm:${chainId}`;
-export const supportedNetworkEvms = new Map(ENABLED_EVMS.map((constant) => {
-    const chainId = '0x' + CHAIN_IDS[constant.assetName].toString(16);
-    const network = getEvmNetwork(chainId);
-    return [network, { ...constant, chainId, network }];
-}));
 export const isEthTransferTx = (transaction) => {
     return (['0x', null, undefined].includes(transaction.data) &&
         [undefined, '0x5208'].includes(transaction.gas));

package/lib/types.d.ts

@@ -1,13 +1,30 @@
-import type { EthereumProvider } from './provider/provider.js';
-export interface WalletStandardAccountParams {
-    address: string;
-    chains?: ChainId[];
-    publicKey?: string;
-    label?: string;
-    icon?: string;
+/// <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>;
 }
-export interface ExodusProvider {
-    ethereum: EthereumProvider;
+interface FeeData {
+    gasPrice: string;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
 }
-export declare type ChainId = string;
-export declare type UnknownFunction = (...args: unknown[]) => unknown;
+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/wallet-standard/icon.d.ts

@@ -0,0 +1,2 @@
+import type { WalletIcon } from '@wallet-standard/base';
+export declare const icon: WalletIcon;

package/lib/wallet-standard/icon.js

@@ -0,0 +1,2 @@
+import { EXODUS_ICON } from '@exodus/web3-constants';
+export const icon = EXODUS_ICON;

package/lib/wallet-standard/wallet.d.ts

@@ -0,0 +1,17 @@
+import type { Wallet } from '@wallet-standard/base';
+import type { EthereumProvider } from '../provider/provider.js';
+export declare type EthereumProviderFeature = {
+    'ethereum:provider': {
+        provider: EthereumProvider;
+    };
+};
+export declare class ExodusEthereumWallet implements Wallet {
+    #private;
+    get version(): "1.0.0";
+    get name(): "Exodus";
+    get icon(): `data:image/svg+xml;base64,${string}` | `data:image/webp;base64,${string}` | `data:image/png;base64,${string}` | `data:image/gif;base64,${string}`;
+    get chains(): never[];
+    get features(): EthereumProviderFeature;
+    get accounts(): never[];
+    constructor(ethereumProvider: EthereumProvider);
+}

package/lib/wallet-standard/wallet.js

@@ -0,0 +1,35 @@
+import { icon } from './icon.js';
+export class ExodusEthereumWallet {
+    #version = '1.0.0';
+    #name = 'Exodus';
+    #icon = icon;
+    #provider = null;
+    get version() {
+        return this.#version;
+    }
+    get name() {
+        return this.#name;
+    }
+    get icon() {
+        return this.#icon;
+    }
+    get chains() {
+        return [];
+    }
+    get features() {
+        return {
+            'ethereum:provider': {
+                provider: this.#provider,
+            },
+        };
+    }
+    get accounts() {
+        return [];
+    }
+    constructor(ethereumProvider) {
+        if (!ethereumProvider) {
+            throw new Error('Ethereum Provider is required!');
+        }
+        this.#provider = ethereumProvider;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@exodus/web3-ethereum",
   "description": "Apps connectivity library for EVM-compatible chains.",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "type": "module",
   "sideEffects": false,
   "module": "lib/index.js",
@@ -12,7 +12,7 @@
     "./provider": "./lib/provider/index.js",
     "./rpc": "./lib/rpc-handlers/index.js",
     "./simulation": "./lib/simulation/index.js",
-    "./utils": "./lib/rpc-handlers/index.js"
+    "./wallet-standard": "./lib/wallet-standard/index.js"
   },
   "react-native": "./lib/index.js",
   "files": [
@@ -39,11 +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-types": "^1.6.0",
+    "@exodus/web3-validation": "^1.26.0",
+    "@wallet-standard/base": "^1.0.1"
   },
   "peerDependencies": {
     "@exodus/assets": "^8.0.72"
   },
-  "gitHead": "c220026347ce27cfc25bacc083d61b1aae5c876b"
+  "gitHead": "39137384d78bfa3e008b92e47e106a7be1df071e"
 }

package/lib/provider/wallet-standard/account.d.ts

@@ -1,11 +0,0 @@
-import type { WalletStandardAccountParams } from '../../types.js';
-export declare class ExodusEthereumWalletAccount {
-    #private;
-    get address(): string;
-    get publicKey(): string | undefined;
-    get chains(): string[] | undefined;
-    get features(): string[];
-    get label(): string | undefined;
-    get icon(): string | undefined;
-    constructor({ address, publicKey, label, icon, chains, }: WalletStandardAccountParams);
-}

package/lib/provider/wallet-standard/account.js

@@ -1,36 +0,0 @@
-// This file is copied with modification from @wallet-standard/util
-const features = ['ethereum:request'];
-export class ExodusEthereumWalletAccount {
-    #address;
-    #publicKey;
-    #chains;
-    #features;
-    #label;
-    #icon;
-    get address() {
-        return this.#address;
-    }
-    get publicKey() {
-        return this.#publicKey?.slice();
-    }
-    get chains() {
-        return this.#chains?.slice();
-    }
-    get features() {
-        return this.#features?.slice();
-    }
-    get label() {
-        return this.#label;
-    }
-    get icon() {
-        return this.#icon;
-    }
-    constructor({ address, publicKey, label, icon, chains, }) {
-        this.#address = address;
-        this.#publicKey = publicKey;
-        this.#chains = chains;
-        this.#features = features;
-        this.#label = label;
-        this.#icon = icon;
-    }
-}

package/lib/provider/wallet-standard/chains.d.ts

@@ -1,9 +0,0 @@
-import type { ChainId } from '../../types.js';
-/** Ethereum Mainnet, e.g. https://ethereum.publicnode.com */
-export declare const ETHEREUM_MAINNET = "ethereum:1";
-/** Array of Ethereum chains supported by Exodus */
-export declare const ETHEREUM_CHAINS: string[];
-/**
- * Converts a hexadecimal chain ID to a [human-readable format](https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-2.md)
- */
-export declare function convertChainIdToCanonicalBlockchainIdentifier(chainId: ChainId): string;

package/lib/provider/wallet-standard/chains.js

@@ -1,11 +0,0 @@
-/** Ethereum Mainnet, e.g. https://ethereum.publicnode.com */
-export const ETHEREUM_MAINNET = 'ethereum:1';
-/** Array of Ethereum chains supported by Exodus */
-export const ETHEREUM_CHAINS = [ETHEREUM_MAINNET];
-/**
- * Converts a hexadecimal chain ID to a [human-readable format](https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-2.md)
- */
-export function convertChainIdToCanonicalBlockchainIdentifier(chainId) {
-    chainId = chainId.replace('0x', '');
-    return `ethereum:${chainId}`;
-}

package/lib/provider/wallet-standard/wallet.d.ts

@@ -1,37 +0,0 @@
-import { ExodusEthereumWalletAccount } from './account.js';
-import type { ChainId, ExodusProvider, UnknownFunction } from '../../types.js';
-import type { EthereumProvider } from '../provider.js';
-export declare class ExodusEthereumWallet {
-    #private;
-    get version(): string;
-    get name(): string;
-    get icon(): string;
-    get chains(): string[];
-    get features(): {
-        'standard:connect': {
-            version: string;
-            connect: ({ silent }?: {
-                silent: boolean;
-            }) => Promise<{
-                accounts: ExodusEthereumWalletAccount[];
-            }>;
-        };
-        'standard:disconnect': {
-            version: string;
-            disconnect: () => Promise<void>;
-        };
-        'standard:events': {
-            version: string;
-            on: (event: string, listener: UnknownFunction) => () => void;
-        };
-        'ethereum:provider': {
-            version: string;
-            provider: EthereumProvider | null;
-        };
-        'exodus:': {
-            exodus: ExodusProvider | null;
-        };
-    };
-    get accounts(): ExodusEthereumWalletAccount[];
-    constructor(exodusProvider: ExodusProvider, supportedChainIds: ChainId[]);
-}

package/lib/provider/wallet-standard/wallet.js

@@ -1,123 +0,0 @@
-import { EXODUS_ICON } from '@exodus/web3-constants';
-import { ExodusEthereumWalletAccount } from './account.js';
-import { convertChainIdToCanonicalBlockchainIdentifier } from './chains.js';
-export class ExodusEthereumWallet {
-    #exodus = null;
-    #provider = null;
-    #listeners = {};
-    #version = '1.0.0';
-    #name = 'Exodus';
-    #icon = EXODUS_ICON;
-    #account = null;
-    #chains;
-    get version() {
-        return this.#version;
-    }
-    get name() {
-        return this.#name;
-    }
-    get icon() {
-        return this.#icon;
-    }
-    get chains() {
-        return this.#chains?.slice() ?? [];
-    }
-    get features() {
-        return {
-            'standard:connect': {
-                version: '1.0.0',
-                connect: this.#connect,
-            },
-            'standard:disconnect': {
-                version: '1.0.0',
-                disconnect: this.#disconnect,
-            },
-            'standard:events': {
-                version: '1.0.0',
-                on: this.#on,
-            },
-            'ethereum:provider': {
-                version: '1.0.0',
-                provider: this.#provider,
-            },
-            'exodus:': {
-                exodus: this.#exodus,
-            },
-        };
-    }
-    get accounts() {
-        return this.#account ? [this.#account] : [];
-    }
-    constructor(exodusProvider, supportedChainIds) {
-        if (!exodusProvider) {
-            throw new Error('Exodus Provider is required!');
-        }
-        if (!exodusProvider.ethereum) {
-            throw new Error('Exodus Provider must include Ethereum Provider!');
-        }
-        if (!supportedChainIds?.length) {
-            throw new Error('At least one supported chain must be provided!');
-        }
-        this.#exodus = exodusProvider;
-        this.#provider = exodusProvider.ethereum;
-        this.#chains = supportedChainIds.map(convertChainIdToCanonicalBlockchainIdentifier);
-        this.#provider.on('accountsChanged', this.#reconnected, this);
-        this.#connected();
-    }
-    #on = (event, listener) => {
-        this.#listeners[event]?.push(listener) ||
-            (this.#listeners[event] = [listener]);
-        return () => this.#off(event, listener);
-    };
-    #emit = (event, ...args) => {
-        // eslint-disable-next-line no-unused-expressions,prefer-spread
-        this.#listeners[event]?.forEach((listener) => listener.apply(null, args));
-    };
-    #off = (event, listener) => {
-        this.#listeners[event] = this.#listeners[event]?.filter((existingListener) => listener !== existingListener);
-    };
-    #connected = async () => {
-        const address = await this.#getAddress();
-        if (address) {
-            const account = this.#account;
-            if (!account || account.address !== address) {
-                this.#account = new ExodusEthereumWalletAccount({ address });
-                this.#emit('change', { accounts: this.accounts });
-            }
-        }
-    };
-    #disconnected = () => {
-        if (this.#account) {
-            this.#account = null;
-            this.#emit('change', { accounts: this.accounts });
-        }
-    };
-    #reconnected = async () => {
-        const address = await this.#getAddress();
-        if (address) {
-            this.#connected();
-        }
-        else {
-            this.#disconnected();
-        }
-    };
-    #connect = async ({ silent } = { silent: false }) => {
-        if (!silent) {
-            await this.#requestAddress();
-        }
-        await this.#connected();
-        return { accounts: this.accounts };
-    };
-    #disconnect = async () => {
-        this.#disconnected();
-    };
-    #requestAddress = () => {
-        return this.#provider.request({ method: 'eth_requestAccounts' });
-    };
-    #getAddress = async () => {
-        const [address] = (await this.#provider.request({
-            method: 'eth_accounts',
-        }));
-        return address;
-    };
-}