@exodus/web3-ethereum 0.1.0 → 1.0.0

package/lib/index.d.ts

@@ -1 +1,2 @@
+export * from './provider/index.js';
 export * from './simulation/index.js';

package/lib/index.js

@@ -1 +1,2 @@
+export * from './provider/index.js';
 export * from './simulation/index.js';

package/lib/provider/index.d.ts

@@ -0,0 +1,2 @@
+export { EthereumProvider } from './provider.js';
+export * from './types.js';

package/lib/provider/index.js

@@ -0,0 +1,2 @@
+export { EthereumProvider } from './provider.js';
+export * from './types.js';

package/lib/provider/provider.d.ts

@@ -0,0 +1,22 @@
+import { BaseProvider } from '@exodus/web3-provider';
+import type { ChainId, Deps, JsonRpcCallback, JsonRpcRequest, JsonRpcResult, ProviderConnectInfo, RequestArguments } from './types.js';
+interface EthereumProviderEvents {
+    accountsChanged(accounts: string[]): void;
+    chainChanged(chainId: ChainId): void;
+    connect(providerConnectInfo: ProviderConnectInfo): void;
+    disconnect(): void;
+    message(): void;
+}
+export declare class EthereumProvider extends BaseProvider<EthereumProviderEvents> {
+    #private;
+    constructor({ accountsObservable, storage, supportedChainIds, transport, getDefaultChainId, }: Deps);
+    protected _callRpcMethod<Params, Response>(method: string, params: Params): Promise<Response>;
+    isConnected(): boolean;
+    request(args: 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

@@ -0,0 +1,236 @@
+import { BaseProvider } from '@exodus/web3-provider';
+import { ethErrors } from 'eth-rpc-errors';
+import { createStorageWrapper } from './storage.js';
+export class EthereumProvider extends BaseProvider {
+    #storage;
+    #supportedChainIds = [];
+    #getDefaultChainId;
+    #initializePromise = null;
+    #initialized = false;
+    #isConnected = false;
+    #chainId = null;
+    #accounts = [];
+    #selectedAddress = null;
+    constructor({ accountsObservable, storage, supportedChainIds, transport, getDefaultChainId, }) {
+        if (!supportedChainIds?.length) {
+            throw new Error('At least one supported chain must be provided');
+        }
+        super({ transport });
+        this.#storage = createStorageWrapper(storage);
+        this.#supportedChainIds = supportedChainIds.map((chainId) => chainId.toLowerCase());
+        // Observe account changes.
+        this.on('connect', () => {
+            const unobserve = accountsObservable.observe((accounts) => {
+                this.#handleAccountsChanged(accounts);
+            });
+            this.on('disconnect', unobserve);
+        });
+        this.on('connect', () => {
+            this.#isConnected = true;
+        });
+        this.#initializePromise = this.#initialize();
+        this.#getDefaultChainId =
+            typeof getDefaultChainId === 'function'
+                ? getDefaultChainId
+                : async () => null;
+    }
+    _callRpcMethod(method, params) {
+        const prefix = this.#chainId;
+        return super._callRpcMethod(`${prefix}_${method}`, params);
+    }
+    #assertConnected() {
+        if (!this.isConnected()) {
+            throw ethErrors.provider.disconnected({
+                message: 'The Provider is disconnected from all chains.',
+            });
+        }
+    }
+    #assertChainSupported(chainId) {
+        if (!this.#supportedChainIds.includes(chainId)) {
+            throw ethErrors.provider.custom({
+                message: 'The Provider does not support the requested chain.',
+                code: 4902,
+            });
+        }
+    }
+    async #getChainId() {
+        const storedChainId = await this.#storage.getChainId();
+        const defaultChainId = this.#supportedChainIds[0];
+        return storedChainId ?? defaultChainId;
+    }
+    async #getAccounts() {
+        return this._callRpcMethod('eth_accounts', []);
+    }
+    async #initialize() {
+        const chainId = await this.#getChainId();
+        this.#handleConnect(chainId);
+        this.#handleChainChanged(chainId);
+        const accounts = await this.#getAccounts();
+        this.#handleAccountsChanged(accounts);
+        this.#initialized = true;
+        this.#initializePromise = null;
+    }
+    async #awaitInitialized() {
+        if (this.#initializePromise) {
+            await this.#initializePromise;
+        }
+    }
+    #handleConnect(chainId) {
+        if (!this.#isConnected) {
+            this.#isConnected = true;
+            this.emit('connect', { chainId });
+        }
+    }
+    #handleChainChanged(chainId) {
+        if (!chainId || typeof chainId !== 'string' || !chainId.startsWith('0x')) {
+            return;
+        }
+        if (chainId !== this.#chainId) {
+            this.#chainId = chainId;
+            if (this.#initialized) {
+                this.emit('chainChanged', chainId);
+            }
+        }
+    }
+    #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;
+            this.#selectedAddress = accounts[0] ?? null;
+            if (this.#initialized) {
+                this.emit('accountsChanged', accounts);
+            }
+        }
+    }
+    async #requestAccounts() {
+        const permissions = { eth_accounts: {} };
+        await this._callRpcMethod('wallet_requestPermissions', [permissions]);
+        const accounts = await this._callRpcMethod('eth_accounts', []);
+        this.#handleAccountsChanged(accounts);
+        if (!(await this.#storage.getChainId())) {
+            // Get default chain Id from remote config
+            const defaultChainId = await this.#getDefaultChainId();
+            if (defaultChainId) {
+                this.#handleChainChanged(defaultChainId);
+            }
+        }
+        return accounts;
+    }
+    async #addChain(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) {
+        const lowerCaseChainId = chainId.toLowerCase();
+        this.#assertChainSupported(lowerCaseChainId);
+        this.#handleChainChanged(lowerCaseChainId);
+        await this.#storage.setChainId(lowerCaseChainId);
+        return null;
+    }
+    isConnected() {
+        return this.#isConnected;
+    }
+    async request(args) {
+        await this.#awaitInitialized();
+        this.#assertConnected();
+        const { method, params = [] } = args;
+        if (typeof method !== 'string' || method.length === 0) {
+            throw ethErrors.rpc.invalidRequest({
+                message: "'args.method' must be a non-empty string.",
+                data: args,
+            });
+        }
+        if (!Array.isArray(params) &&
+            (typeof params !== 'object' || params === null)) {
+            throw ethErrors.rpc.invalidRequest({
+                message: "'args.params' must be an object or array if provided.",
+                data: args,
+            });
+        }
+        /**
+         * Intercepted requests.
+         */
+        // EIP-695
+        // See: https://eips.ethereum.org/EIPS/eip-695.
+        if (method === 'eth_chainId') {
+            return this.#chainId;
+        }
+        // EIP-2255.
+        // See: https://eips.ethereum.org/EIPS/eip-2255.
+        if (method === 'eth_requestAccounts') {
+            return this.#requestAccounts();
+        }
+        // EIP-3085
+        // See: https://eips.ethereum.org/EIPS/eip-3085.
+        if (method === 'wallet_addEthereumChain') {
+            const { chainId } = params[0];
+            return this.#addChain(chainId);
+        }
+        // EIP-3326.
+        // See: https://eips.ethereum.org/EIPS/eip-3326.
+        if (method === 'wallet_switchEthereumChain') {
+            const { chainId } = params[0];
+            return this.#switchChain(chainId);
+        }
+        /**
+         * Request.
+         */
+        let revisedParams = params;
+        if (method === 'personal_sign') {
+            // Omit `password` parameter if passed.
+            // See: https://github.com/ethereum/go-ethereum/pull/2940.
+            revisedParams = params.slice(0, 2);
+        }
+        return this._callRpcMethod(method, revisedParams);
+    }
+    /*
+     * Legacy API.
+     */
+    get chainId() {
+        console.warn('Exodus: "ethereum.chainId" is deprecated and may be removed in the future. Please use "ethereum.request({ method: \'eth_chainId\' })" instead.');
+        return this.#chainId;
+    }
+    get selectedAddress() {
+        console.warn('Exodus: "ethereum.selectedAddress" is deprecated and may be removed in the future. Please use "ethereum.request({ method: \'eth_accounts\' })" instead.');
+        return this.#selectedAddress;
+    }
+    async enable() {
+        console.warn('Exodus: "ethereum.enable()" is deprecated and may be removed in the future. Please use "ethereum.request({ method: \'eth_requestAccounts\' })" instead.\nFor more information, see: https://eips.ethereum.org/EIPS/eip-1102.');
+        this.#assertConnected();
+        return this.#requestAccounts();
+    }
+    async send(methodOrPayload, paramsOrCallback) {
+        console.warn('Exodus: "ethereum.send()" is deprecated and may be removed in the future. Please use "ethereum.request()" instead.');
+        const hasMethod = typeof methodOrPayload === 'string';
+        const hasParams = Array.isArray(paramsOrCallback);
+        if (hasMethod && (!paramsOrCallback || hasParams)) {
+            const method = methodOrPayload;
+            const params = paramsOrCallback;
+            return new Promise((resolve, reject) => this.request({ method, params })
+                .then((result) => resolve({ id: '1', jsonrpc: '2.0', result }))
+                .catch((err) => reject({ id: '1', jsonrpc: '2.0', error: err })));
+        }
+        const payload = methodOrPayload;
+        const callback = paramsOrCallback;
+        this.sendAsync(payload, callback);
+    }
+    sendAsync(payload, callback) {
+        console.warn('Exodus: "ethereum.sendAsync()" is deprecated and may be removed in the future. Please use "ethereum.request()" instead.');
+        const { id, jsonrpc, method, params } = payload;
+        const hasCallback = callback && typeof callback === 'function';
+        this.request({ method, params })
+            .then((result) => {
+            if (hasCallback) {
+                callback(null, { id, jsonrpc, result });
+            }
+        })
+            .catch((err) => {
+            if (hasCallback) {
+                callback(err, { id, jsonrpc, error: err });
+            }
+        });
+    }
+}

package/lib/provider/storage.d.ts

@@ -0,0 +1,3 @@
+import type { Storage } from '@exodus/web3-types';
+import type { ProviderStorage } from './types.js';
+export declare function createStorageWrapper(storage: Storage): ProviderStorage;

package/lib/provider/storage.js

@@ -0,0 +1,28 @@
+const chainIdKey = 'exodus:ethereum:chainId';
+export function createStorageWrapper(storage) {
+    async function getChainId() {
+        try {
+            return await storage.getItem(chainIdKey);
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    async function setChainId(chainId) {
+        try {
+            await storage.setItem(chainIdKey, chainId);
+        }
+        catch (err) {
+            // Ignore error.
+        }
+    }
+    async function clearChainId() {
+        try {
+            await storage.removeItem(chainIdKey);
+        }
+        catch (err) {
+            // Ignore error.
+        }
+    }
+    return { getChainId, setChainId, clearChainId };
+}

package/lib/provider/types.d.ts

@@ -0,0 +1,44 @@
+import type { Deps as BaseProviderDeps } from '@exodus/web3-provider';
+import type { Observable, Storage } from '@exodus/web3-types';
+export declare type ChainId = string;
+export interface ProviderConnectInfo {
+    chainId: ChainId;
+}
+export interface ChainParameter {
+    chainId: ChainId;
+}
+export interface RequestArguments {
+    method: string;
+    params?: unknown[] | Record<string, unknown>;
+}
+declare type JsonRpcId = string | undefined;
+export interface JsonRpcRequest {
+    id: JsonRpcId;
+    jsonrpc: '2.0';
+    method: string;
+    params?: unknown[];
+}
+declare type JsonRpcSuccess = {
+    id: JsonRpcId;
+    jsonrpc: '2.0';
+    result: unknown;
+};
+declare type JsonRpcFailure = {
+    id: JsonRpcId;
+    jsonrpc: '2.0';
+    error: Error;
+};
+export declare type JsonRpcResult = JsonRpcSuccess | JsonRpcFailure;
+export declare type JsonRpcCallback = (error: Error | null, result?: JsonRpcResult) => unknown;
+export declare type Deps = BaseProviderDeps & {
+    accountsObservable: Observable;
+    storage: Storage;
+    supportedChainIds: string[];
+    getDefaultChainId?: () => Promise<string | null>;
+};
+export interface ProviderStorage {
+    getChainId: () => Promise<ChainId | null>;
+    setChainId: (chainId: ChainId) => Promise<void>;
+    clearChainId: () => Promise<void>;
+}
+export {};

package/lib/provider/types.js

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

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,36 @@
+// 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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,11 @@
+/** 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/index.d.ts

@@ -0,0 +1 @@
+export { ExodusEthereumWallet } from './wallet.js';

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

@@ -0,0 +1 @@
+export { ExodusEthereumWallet } from './wallet.js';

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

@@ -0,0 +1,37 @@
+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

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

package/lib/types.d.ts

@@ -0,0 +1,13 @@
+import type { EthereumProvider } from './provider/provider.js';
+export interface WalletStandardAccountParams {
+    address: string;
+    chains?: ChainId[];
+    publicKey?: string;
+    label?: string;
+    icon?: string;
+}
+export interface ExodusProvider {
+    ethereum: EthereumProvider;
+}
+export declare type ChainId = string;
+export declare type UnknownFunction = (...args: unknown[]) => unknown;

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": "0.1.0",
+  "version": "1.0.0",
   "type": "module",
   "sideEffects": false,
   "module": "lib/index.js",
@@ -11,6 +11,7 @@
     "./package.json": "./package.json",
     "./provider": "./lib/provider/index.js",
     "./rpc": "./lib/rpc-handlers/index.js",
+    "./simulation": "./lib/simulation/index.js",
     "./utils": "./lib/rpc-handlers/index.js"
   },
   "react-native": "./lib/index.js",
@@ -31,7 +32,10 @@
   "dependencies": {
     "@exodus/currency": "^2.1.2",
     "@exodus/ethereum-api": "3.2.4",
-    "@exodus/web3-ethereum-utils": "1.7.0"
+    "@exodus/web3-constants": "^1.13.1",
+    "@exodus/web3-ethereum-utils": "1.7.0",
+    "@exodus/web3-provider": "^2.9.0",
+    "eth-rpc-errors": "^4.0.3"
   },
   "devDependencies": {
     "@exodus/assets": "^8.0.72",
@@ -41,5 +45,5 @@
   "peerDependencies": {
     "@exodus/assets": "^8.0.72"
   },
-  "gitHead": "9c988db57f3b4a18feb2038480e3466b93f2d06e"
+  "gitHead": "c220026347ce27cfc25bacc083d61b1aae5c876b"
 }