Ethereum Provider API

The provider's core function is to request access to user accounts and detect the connected blockchain network. Key methods include:

• eth_requestAccounts: The primary method to trigger a wallet connection modal and request account access.
• eth_accounts: Returns a list of accounts the caller is permitted to access.
• net_version / eth_chainId: Identifies the connected network (e.g., Mainnet = 1, Goerli = 5).
• wallet_switchEthereumChain: Requests the wallet to switch to a specified chain.

The provider enables DApps to request users to sign and broadcast transactions to the network. The primary method is eth_sendTransaction, which submits a transaction object for the user to approve in their wallet. This object includes critical parameters:

• from: The sender's address (must be a connected account).
• to: The recipient address (or contract).
• value: Amount of ETH to send, in wei.
• data: Encoded contract call data for smart contract interactions.

Beyond transactions, the provider allows DApps to request cryptographic signatures from the user's private key for authentication or data verification. Key methods include:

• personal_sign: Signs a UTF-8 message, commonly used for login authentication.
• eth_signTypedData_v4: Signs structured data according to EIP-712, providing human-readable signing prompts for complex data like permit approvals or off-chain orders.
• eth_getEncryptionPublicKey / eth_decrypt: (Less common) For public key encryption workflows.

The provider offers JSON-RPC methods to query the blockchain's current and historical state without requiring a user signature. These are read-only calls. Essential methods include:

• eth_call: Executes a message call (e.g., a contract view function) immediately without creating a transaction.
• eth_getBalance: Gets the ETH balance of a given address.
• eth_getBlockByNumber: Returns information about a block by number.
• eth_getTransactionReceipt: Gets the receipt of a transaction by hash, including logs (events).

The provider supports a subscription model for listening to real-time blockchain events, though not all providers implement it fully. Key subscription types include:

• newHeads: Emits an event for each new block header.
• logs: Emits logs (events) that match a specified filter.
• pendingTransactions: Emits transaction hashes for pending transactions. Methods: eth_subscribe to create a subscription and eth_unsubscribe to remove it. Many DApps use polling or external indexers due to limited provider support.

EIP-1193 is the formal specification that defines the Ethereum Provider JavaScript API. It standardizes:

• The provider object as window.ethereum.
• A request method (ethereum.request({ method, params })) for all operations.
• Events like accountsChanged, chainChanged, and disconnect for reactive updates. This standardization allows DApps to work interoperably with any compliant wallet (MetaMask, Coinbase Wallet, etc.) without wallet-specific code.

The method for signing and broadcasting a transaction to the network. It requests the wallet to create, sign, and submit a transaction object.

• Takes a transaction object with fields like to, value, gas, and data.
• The user must confirm the transaction details and gas fees in their wallet.
• Returns a transaction hash, which can be used to track its status.

The global window.ethereum object is injected into a webpage by browser extensions like MetaMask or Coinbase Wallet. It exposes the Ethereum Provider API, enabling the dApp to request blockchain access, read data, and send transactions. Its presence is the first check for wallet detection.

• Detection: if (typeof window.ethereum !== 'undefined')
• Standard: Defined by EIP-1193, which specifies the event-driven JSON-RPC interface.

While window.ethereum is injected by wallets, developers often use libraries to streamline interaction, add fallbacks, and improve type safety.

• ethers.js: new ethers.BrowserProvider(window.ethereum)
• web3.js: new Web3(window.ethereum)
• viem: createWalletClient with a custom transport. These libraries wrap the raw provider calls, handling BigNumber conversions, ABI encoding, and error parsing.

The Provider interface is not limited to browser extensions. Any service that can fulfill JSON-RPC requests can be a provider.

• Node Providers: Services like Infura, Alchemy, and QuickNode provide HTTP and WebSocket endpoints that act as remote providers for backend services or read-heavy dApps.
• Mobile SDKs: WalletConnect and embedded wallet SDKs expose the same Provider API within mobile applications.
• Test Frameworks: Hardhat and Foundry provide a JSON-RPC Provider for local development and testing.

The JSON-RPC protocol is the transport layer for the Ethereum Provider API. It defines the standard request-response format for invoking blockchain methods. Key points:

• Uses HTTP, WebSocket, or IPC for communication.
• Core methods include eth_sendTransaction, eth_getBalance, and eth_blockNumber.
• Every Provider API call is ultimately a JSON-RPC request to a node.

EIP-1193 is the Ethereum Improvement Proposal that standardizes the Ethereum Provider JavaScript interface. It defines the window.ethereum object for browser environments. Key aspects:

• Specifies the request({ method, params }) method as the primary interface.
• Standardizes event listeners for account/chain changes (accountsChanged, chainChanged).
• Created to unify provider behavior across wallets like MetaMask, Coinbase Wallet, and WalletConnect.

MetaMask is the most widely used browser extension and mobile wallet that implements the Ethereum Provider API. It acts as both a wallet and a provider bridge. Key features:

• Injects the window.ethereum provider object into dApp web pages.
• Manages private keys, signs transactions, and interacts with the Ethereum JSON-RPC API.
• Serves as the reference implementation for many Provider API behaviors.

WalletConnect is an open protocol for connecting decentralized applications to mobile wallets using end-to-end encryption. It provides an alternative to the injected provider model. How it works:

• Uses QR codes or deep links to establish a secure connection.
• Relays JSON-RPC payloads between a dApp and a user's wallet app.
• Enables dApp connectivity without browser extensions, crucial for mobile environments.

The Ethereum Virtual Machine (EVM) is the runtime environment for smart contracts. The Provider API is the primary mechanism for interacting with it. Key connections:

• Provider methods like eth_call execute read-only code on the EVM.
• eth_estimateGas predicts the computational cost (gas) of an EVM operation.
• eth_sendTransaction submits transactions that the EVM will process and record on-chain.

Web3.js and ethers.js are the two dominant JavaScript libraries that provide high-level abstractions over the low-level Ethereum Provider API. They simplify development by:

• Wrapping raw JSON-RPC calls into intuitive functions and classes.
• Managing ABI encoding/decoding, contract interaction, and big number handling.
• While the Provider API handles communication, these libraries manage the application logic.