Ethernauta is a tree-shakable Ethereum library plus a Chrome MV3 wallet. Every method is a small curried function consumed by one of four resolver shapes (Readable<T>, Writable<T>, Signable<T>, Callable<T>) — pay only for what you import, drop in the wallet only when you need to sign.

Install

pnpm add @ethernauta/chain @ethernauta/eth @ethernauta/transport

Read the chain in 12 lines

import { eip155_11155111 } from "@ethernauta/chain"
import { eth_blockNumber } from "@ethernauta/eth"
import { create_reader, encode_chain_id, http } from "@ethernauta/transport"

const SEPOLIA = encode_chain_id({
  namespace: "eip155",
  reference: eip155_11155111.chainId,
})

const reader = create_reader([{
  chainId: SEPOLIA,
  transports: [http("https://ethereum-sepolia-rpc.publicnode.com")],
}])

const head = await eth_blockNumber()(reader({ chain_id: SEPOLIA }))

Signing, writing, contract reads and EIP-6963 wallet discovery follow the same method(args)(resolver({ chain_id, …ctx })) shape — see @ethernauta/eth and @ethernauta/transport.

Why Ethernauta

• Tiny bundles. Architected per Valibot's thesis for aggressive tree-shaking — a dapp that only reads eth_blockNumber ships almost none of the library.
• No hosted services, no coordinated rollouts. Public RPC endpoints, the wallet extension, and dapp code is the entire dependency surface. Adding an EIP / ERC is a folder-shaped operation.
• ESM-only, Web APIs only. Runs anywhere the web platform runs — no Node-API leakage, no polyfills.
• Two consumer paths, both first-class. Pre-sign and broadcast (eth_signTransaction + eth_sendRawTransaction, no wallet needed for the broadcast step), or hand the whole flow to the wallet (eth_sendTransaction). The library never forces a choice.
• Standards-compliant by construction. EIP-1193 / EIP-6963 / EIP-5792 / EIP-7702 — any Ethernauta dapp talks to any standards-compliant wallet, and the Ethernauta wallet serves any standards-compliant dapp.
• Schemas at every boundary. Every value crossing a boundary is validated with a Valibot schema. The schema is the type (type X = InferOutput<typeof xSchema>).

What's in the box

Capability	Package
500+ EIP-155 chain consts (CAIP-2 ready)	@ethernauta/chain
Every eth_* JSON-RPC method, three shapes	@ethernauta/eth
Resolver factories + HTTP / WebSocket / Multicall transports + EIP-1193 adapter	@ethernauta/transport
EIPs 55 / 191 / 712 / 1014 / 1102 / 1193 / 1271 / 2255 / 3085 / 3326 / 4337 / 4361 / 4844 / 5792 / 6492 / 6963 / 7702	@ethernauta/eip
ERCs 20 / 137 / 165 / 181 / 634 / 721 / 1155 / 1577 / 2304 / 2612 / 2981 / 3156 / 4494 / 4626 / 5564 / 5805 / 6372 / 7683	@ethernauta/erc
ENS resolution + ENSIP-15 normalisation	@ethernauta/ens
ABI codec + code generator (Callable / Signable methods)	@ethernauta/abi
CLI — ethernauta abi (walker mode), ethernauta registry	@ethernauta/cli
Cross-spec signature / SIWE verification + key derivation	@ethernauta/crypto
Lifecycle tracker (pending → mined / reverted)	@ethernauta/transaction
OP-Stack — predeploys, fees, op-node RPC, per-chain L1 deploys, deposit / withdraw / prove / execute / get_status bridge verbs	@ethernauta/op
Arbitrum — 16 precompiles, arb_* RPC, orbit registry, L1 deploys, retryable lifecycle + bridge verbs, timeboost	@ethernauta/arbitrum
zkSync Era — system contracts, zks_* RPC, 0x71 (EIP-712) tx encoder + signer, L1 deploys, deposit / withdraw / claim bridge verbs	@ethernauta/zksync
React hooks (useProvider, useProviderDetail)	@ethernauta/react
Chrome MV3 wallet	@ethernauta/wallet

Modules

• abi [NPM]
• arbitrum [NPM]
• chain [NPM]
• cli [NPM]
• core [NPM]
• crypto [NPM]
• eip [NPM]
• ens [NPM]
• erc [NPM]
• eth [NPM]
• op [NPM]
• react [NPM]
• transaction [NPM]
• transport [NPM]
• utils [NPM]
• wallet
• zksync [NPM]

A real production dapp: Animatronik

Animatronik is a production NFT dApp built end-to-end on Ethernauta. It uses the ABI generator for its contract methods, create_contract for view reads, and create_provider(provider).signer + create_writer for state changes (the provider comes from an EIP-6963 announce). The source is the most complete public reference for consuming the library.

Use Ethernauta with your AI agent

Drop skills/ethernauta/SKILL.md into your agent's context and it will know — without visiting these docs — how to wire chains, read state, connect a wallet, sign transactions, and call contracts the Ethernauta way. The skill is concept-by-concept (WHAT it is, WHEN to reach for it) and links to a self-contained, copy-pasteable example for every section under skills/ethernauta/examples/. Every pattern is lifted from real code in Animatronik or the in-repo playground — nothing speculative.