
ethskills
Ethereum development skills — corrects LLM blind spots on gas costs, L2s, DeFi protocols, security, and the current tool landscape.
- version
- 1.0.0
- GitHub stars
- 304
Install
/plugin install ethskills@ethskillsRun it inside Claude Code after adding the marketplace with /plugin marketplace add austintgriffith/ethskills.
Contents
Discovered from sourceSkills 20
Contract Addresses
A wrong address usually does not revert. It reads zero, fills at a terrible price, or takes the funds. Nothing in the build fails, so nothing reminds you: the check has to be a habit, not a reaction.
Confirm every address on the chain you are wiring it for, before it reaches anything that moves funds. A remembered address, a tutorial, a config you inherited, or a dated table — this document included — tells you what to look for. None of them discharges the check, and a "verified" stamp only ever meant "on some chain, on some day, for some deployment".
cast code <address> --rpc-url <RPC FOR THE TARGET CHAIN> # code is here, not just on mainnet
cast call <address> "symbol()(string)" --rpc-url <same rpc> # identity, not just presence:
# symbol() / factory() / typeAndVersion() / owner()
Then settle it against the protocol's own deployment list — its docs, or the deployments/ directory of its repo — and the target chain's explorer. When you hand over code someone else will run, say in the deliverable which addresses must be re-checked before real funds move; whoever runs it did not watch you check.
Four ways a verified address is still the wrong one
Same protocol, different chain. CREATE2 and vanity addresses prove nothing cross-chain. Uniswap v4 lands on a different address on every chain, and v3 is not uniform either — its Base router is a different address from its mainnet one. Treat same-address-everywhere as a claim to verify per chain, never a property a brand has. A vanity address can hold a live contract on one chain and nothing on another. The reverse also holds: nothing at that address is not absence from the chain — the protocol may well be deployed there at an ordinary address, so check its deployment list before telling anyone a chain is unsupported.
Same protocol, older deployment. Deprecated contracts stay live and keep answering symbol(). The classic tell is a balance or state read that returns 0 without reverting: right ABI, right chain, superseded deployment (V1 vs V2 token, legacy vs current pool or router). Getting the symbol you expected is not evidence the deployment is current; the protocol's contract list is.
Right protocol, wrong contract. One brand often runs more than one AMM. Aerodrome's v2-style Router cannot reach Slipstream, its concentrated-liquidity deployment — separate factory, separate router, keyed by tickSpacing rather than fee — and the deeper Base USDC/WETH book sits there rather than in the vAMM pools. Measured 2026-08-12 on one 500k USDC→WETH clip: about −14 bps through Slipstream against about −1,283 bps through the vAMM Router, with both addresses genuine and both calls succeeding. That is one pair on one day, not a standing ranking — for anything size-sensitive, quote each candidate pool at the real clip size and choose from the numbers.
Bridged where you meant native. Many chains carry both a canonical-bridge and an issuer-native version of the same token (USDC vs USDC.e / USDbC, and the same pattern elsewhere). Different address, different liquidity, same ticker in most UIs. Choose deliberately; default to native.
Choosing a venue
Do not route by reflex and do not assert dominance. The deepest venue on an L2 is often not the one you would name on mainnet — Aerodrome on Base, Velodrome on Optimism, Camelot on Arbitrum are genuine contenders — but no venue leads on every metric and the ranking moves month to month. Name the metric you mean: routed volume and depth for the pair being swapped decide execution quality, aggregate chain TVL does not. Back the choice with a live quote, pool reserves, or a current per-venue volume figure rather than a reputation. An aggregator is a legitimate answer when you also show which venues it is sourcing.
Address tables
Checked onchain 2026-10-20/21: code present plus an identity call on each listed chain. A starting point, not a substitute for the check above.
Tokens
| Token | Mainnet | Arbitrum | Optimism | Base |
|---|---|---|---|---|
| USDC (native) | 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48 | 0xaf88d065e77c8cC2239327C5EDb3A432268e5831 | 0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85 | 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 |
| USDT (bridged on Optimism and Base; USD₮0 on Arbitrum) | 0xdAC17F958D2ee523a2206206994597C13D831ec7 | 0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9 | 0x94b008aA00579c1307B0EF2c499aD98a8ce58e58 | 0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2 |
| DAI | 0x6B175474E89094C44Da98b954EedeAC495271d0F | 0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1 | 0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1 | 0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb |
| WETH | 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2 | 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1 | 0x4200000000000000000000000000000000000006 | 0x4200000000000000000000000000000000000006 |
| wstETH | 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0 | 0x5979D7b546E38E414F7E9822514be443A4800529 | 0x1F32b1c2345538c0c6f582fCB022739c4A194Ebb | 0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452 |
| LINK | 0x514910771AF9Ca656af840dff83E8264EcF986CA | 0xf97f4df75117a78c1A5a0DBb814Af92458539FB4 | 0x88Fb150BDc53A65fe94Dea0c9BA0a6dAf8C6e196 |
Native USDC elsewhere: Polygon 0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359, zkSync Era 0x1d17CBcF0D6D143135aE902365D2E5e2A16538D4. Circle-native USDC has 6 decimals. Bridged or pegged USDC can differ (Binance-Peg USDC on BNB Chain has 18); read decimals().
Mainnet only: stETH 0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84 (also the Lido deposit contract), rETH 0xae78736Cd615f374D3085123A210448E74Fc6393, WBTC 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599, UNI 0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984, AAVE 0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9, COMP 0xc00e94Cb662C3520282E6f5717214004A7f26888, MKR 0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2, LDO 0x5A98FcBEA516Cf06857215779Fd812CA3beF1B32, CRV 0xD533a949740bb3306d119CC777fa900bA034cd52.
Uniswap
| Contract | Mainnet | Arbitrum | Optimism | Base |
|---|---|---|---|---|
| V3 Factory | 0x1F98431c8aD98523631AE4a59f267346ea31F984 | 0x1F98431c8aD98523631AE4a59f267346ea31F984 | 0x1F98431c8aD98523631AE4a59f267346ea31F984 | 0x33128a8fC17869897dcE68Ed026d694621f6FDfD |
| V3 SwapRouter02 | 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45 | 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45 | 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45 | 0x2626664c2603336E57B271c5C0b26F421741e481 |
| V4 PoolManager | 0x000000000004444c5dc75cB358380D2e3dE08A90 | 0x360E68faCcca8cA495c1B759Fd9EEe466db9FB32 | 0x9a13F98Cb987694C9F086b1F5eB990EeA8264Ec3 | 0x498581fF718922c3f8e6A244956aF099B2652b2b |
| V4 PositionManager | 0xbD216513d74C8cf14cf4747E6AaA6420FF64ee9e | 0xd88F38F930b7952f2DB2432Cb002E7abbF3dD869 | 0x3C3Ea4B57a46241e54610e5f022E5c45859A1017 | 0x7C5f5A4bBd8fD63184577525326123B519429bDc |
| Universal Router (V4) | 0x66a9893cC07D91D95644AEDD05D03f95e1dBA8Af | 0xA51afAFe0263b40EdaEf0Df8781eA9aa03E381a3 | 0x851116D9223fabED8E56C0E6b8Ad0c31d98B3507 | 0x6fF5693b99212Da76ad316178A184AB56D299b43 |
| Permit2 | 0x000000000022D473030F116dDEE9F6B43aC78BA3 | same | same | same |
Mainnet only: V2 Router 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, V2 Factory 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, V3 QuoterV2 0x61fFE014bA17989E743c5F6cB21bF9697530B21e, V3 NonfungiblePositionManager 0xC36442b4a4522E871399CD717aBDD847Ab11FE88, V4 Quoter 0x52F0E24D1c21C8A0cB1e5a5dD6198556BD9E1203, V4 StateView 0x7fFE42C4a5DEeA5b0feC41C94C136Cf115597227. Legacy: V3 SwapRouter 0xE592427A0AEce92De3Edee1F18E0157C05861564, Universal Router (V3) 0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD.
Lending
| Contract | Mainnet | Arbitrum | Optimism | Base |
|---|---|---|---|---|
| Aave V3 Pool | 0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2 | 0x794a61358D6845594F94dc1DB02A252b5b4814aD | 0x794a61358D6845594F94dc1DB02A252b5b4814aD | 0xA238Dd80C259a72e81d7e4664a9801593F98d1c5 |
| Aave V3 PoolAddressesProvider | 0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e | 0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb | 0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb | 0xe20fCBdBfFC4Dd138cE8b2E6FBb6CB49777ad64D |
| Compound V3 cUSDCv3 (Comet) | 0xc3d688B66703497DAA19211EEdff47f25384cdc3 | 0x9c4ec768c28520B50860ea7a15bd7213a9fF58bf | 0x2e44e174f7D53F0212823acC11C01A11d58c5bCB | 0xb125E6687d4313864e53df431d5425969c15Eb2F |
Morpho Blue: 0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb on mainnet and Base. Mainnet Sky/Maker: Pot (DSR) 0x197E90f9FAD81970bA7976f33CbD77088E5D7cf7, sDAI 0x83F20F44975D03b1b09e64809B757c47f942BEeA. Legacy mainnet: Aave V2 LendingPool 0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9, Compound V2 Comptroller 0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B.
Chainlink price feeds
| Feed | Mainnet | Arbitrum | Optimism | Base |
|---|---|---|---|---|
| ETH/USD | 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419 | 0x639Fe6ab55C921f74e7fac1ee960C0B6293ba612 | 0x13e3Ee699D1909E989722E753853AE30b17e08c5 | 0x71041dddad3595F9CEd3DcCFBe3D1F4b0a16Bb70 |
Mainnet only: BTC/USD 0xF4030086522a5bEEa4988F8cA5B36dbC97BeE88c, USDC/USD 0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6, LINK/USD 0x2c1d072e956AFFC0D435Cb7AC38EF18d24d9127c, stETH/USD 0xCfE54B5cD566aB89272946F602D76Ea879CAb4a8, AAVE/USD 0x547a514d5e3769680Ce22B2361c10Ea13619e8a9. Each feed has its own heartbeat and decimals; read both from the feed.
Bridges and messaging
| Contract | Mainnet | Arbitrum | Optimism | Base |
|---|---|---|---|---|
| Chainlink CCIP Router | 0x80226fc0Ee2b096224EeAc085Bb9a8cba1146f7D | 0x141fa059441E0ca23ce184B6A78bafD2A517DdE8 | 0x881e3A65B4d4a04dD529061dd0071cf975F58bCD | |
| Across SpokePool | 0x5c7BCd6E7De5423a257D81B442095A1a6ced35C5 | 0xe35e9842fceaCA96570B734083f4a58e8F7C5f2A | 0x6f26Bf09B1C792e3228e5467807a900A503c0281 | 0x09aea4b2242abC8bb4BB78D537A67a245A7bEC64 |
Same address on every chain checked
Confirm code on your target chain before relying on it.
| Contract | Address |
|---|---|
| Safe Singleton 1.4.1 | 0x41675C099F32341bf84BFc5382aF534df5C7461a |
| Safe Singleton 1.3.0 | 0xd9Db270c1B5E3Bd161E8c8503c55cEABeE709552 |
| Safe ProxyFactory 1.4.1 | 0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67 |
| Safe MultiSend 1.4.1 | 0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526 |
| Safe ProxyFactory 1.3.0 | 0xa6B71E26C5e0845f74c812102Ca7114b6a896AB2 |
| Safe MultiSend 1.3.0 | 0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761 |
| ERC-4337 EntryPoint v0.7 | 0x0000000071727De22E5E9d8BAf0edAc6f37da032 |
| ERC-4337 EntryPoint v0.6 | 0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789 |
| ERC-8004 IdentityRegistry | 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432 |
| ERC-8004 ReputationRegistry | 0x8004BAa17C55a88189AE136b182e5fdA19dE9b63 |
| 1inch Aggregation Router V6 | 0x111111125421cA6dc452d289314280a0f8842A65 |
| Seaport 1.5 | 0x00000000000000ADc04C56Bf30aC9d3c0aAF14dC |
| Multicall3 | 0xcA11bde05977b3631167028862bE2a173976CA11 |
| Arachnid CREATE2 deployer | 0x4e59b44847b379578588920cA78FbF26c0B4956C |
Other mainnet contracts
| Contract | Address |
|---|---|
| ENS Registry | 0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e |
| ENS Public Resolver | 0x231b0Ee14048e9dCcD1d247744d114a4EB5E8E63 |
| ENS ETHRegistrarController | 0x59E16fcCd424Cc24e280Be16E11Bcd56fb0CE547 |
| Lido WithdrawalQueue | 0x889edC2eDab5f40e902b864aD4d7AdE8E412F9B1 |
| Curve AddressProvider | 0x5ffe7FB82894076ECB99A30D6A32e969e6e35E98 |
| Balancer V2 Vault | 0xBA12222222228d8Ba445958a75a0704d566BF2C8 |
| EigenLayer StrategyManager | 0x858646372CC42E1A627fcE94aa7A7033e7CF075A |
| EigenLayer DelegationManager | 0x39053D51B77DC0d36036Fc1fCc8Cb819df8Ef37A |
| Yearn V3 VaultFactory 3.0.4 | 0x770D0d1Fb036483Ed4AbB6d53c1C88fb277D812F |
L2-native venues
Aerodrome (Base) and Velodrome (Optimism) run two AMMs each; the router below reaches only the v2-style pools, not Slipstream (see above).
| Contract | Address |
|---|---|
| Aerodrome Router (Base) | 0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43 |
| Aerodrome PoolFactory (Base) | 0x420DD381b31aEf6683db6B902084cB0FFECe40Da |
| Aerodrome Voter (Base) | 0x16613524e02ad97eDfeF371bC883F2F5d6C480A5 |
| AERO (Base) | 0x940181a94A35A4569E4529A3CDfB74e38FD98631 |
| Velodrome Router (Optimism) | 0xa062aE8A9c5e11aaA026fc2670B0D65cCc8B2858 |
| Velodrome PoolFactory (Optimism) | 0xF1046053aa5682b4F9a81b5481394DA16BE5FF5a |
| VELO v2 (Optimism) | 0x9560e827aF36c94D2Ac33a39bCE1Fe78631088Db |
| Camelot Router, AMM V2 (Arbitrum) | 0xc873fEcbd354f5A56E00E710B90EF4201db2448d |
| GMX V2 ExchangeRouter (Arbitrum) | 0x7dE39FF2e232A2203196788d37e234cF8F1b83f1 |
| GMX V2 DataStore (Arbitrum) | 0xFD70de6b91282D8017aA4E741e9Ae325CAb992d8 |
| Pendle Router (Arbitrum) | 0x888888888889758F76e7103c6CbF23ABbF58F946 |
| SyncSwap Router V2 (zkSync Era) | 0x9B5def958d0f3b6955cBEa4D5B7809b2fb26b059 |
GMX replaces its ExchangeRouter without moving DataStore, and its repo can lag. Before use, confirm the router holds CONTROLLER in the RoleStore (roleStore(), then hasRole(router, keccak256(abi.encode("CONTROLLER")))).
Robinhood Chain (4663)
Launched July 2026, after most training data, so you will not remember these. Checked onchain with cast 2026-08-20; the live catalog is docs.robinhood.com/chain/contracts.
Stock tokens are 18 decimals; USDG is 6. Every stock token shares one AccessControlsRegistry that can pause, block, mint, confiscate and upgrade with no timelock. Splits and dividends change uiMultiplier() (ERC-8056), never the raw balance — index raw amounts.
| Token | Address |
|---|---|
| NVDA | 0xd0601CE157Db5bdC3162BbaC2a2C8aF5320D9EEC |
| TSLA | 0x322F0929c4625eD5bAd873c95208D54E1c003b2d |
| AAPL | 0xaF3D76f1834A1d425780943C99Ea8A608f8a93f9 |
| MSFT | 0xe93237C50D904957Cf27E7B1133b510C669c2e74 |
| AMZN | 0x12f190a9F9d7D37a250758b26824B97CE941bF54 |
| GOOGL | 0x2e0847E8910a9732eB3fb1bb4b70a580ADAD4FE3 |
| META | 0xc0D6457C16Cc70d6790Dd43521C899C87ce02f35 |
| COIN | 0x6330D8C3178a418788dF01a47479c0ce7CCF450b |
| SPCX | 0x4a0E65A3EcceC6dBe60AE065F2e7bb85Fae35eEa |
| SPY | 0x117cc2133c37B721F49dE2A7a74833232B3B4C0C |
| QQQ | 0xD5f3879160bc7c32ebb4dC785F8a4F505888de68 |
| USDG | 0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168 |
| WETH | 0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73 |
| AccessControlsRegistry | 0xe10b6f6B275de231345c20D14Ab812db62151b00 |
Canonical bridge on Ethereum mainnet: Bridge 0xDf8755334ce7A73cCF6b581C02eA649AE3E864b3, Inbox 0x1A07cc4BD17E0118BdB54D70990D2158AbAD7a2D, Outbox 0xf0ce991ea4A0d2400A4AB49b20ae333f6Dce3DE9, L1GatewayRouter 0x6a2E3a1e16FC29f27Ce61429746D558d656975bB, SequencerInbox 0xBd0D173EEb87D57A09521c24388a12789F33ba96, RollupProxy 0x23A19d23e89166adedbDcB432518AB01e4272D94, L1ERC20Gateway 0x85001CC4867C5e1C22dA4B79BB8852B9e2a06da0, L1WethGateway 0xF7e12b9614b509C747ab4423bC4ACF923759Cf1B (L2Beat discovery).
Where to look
- the protocol's docs or the
deployments/directory in its repo — the only source that settles which deployment is current - the target chain's block explorer — code, labels, and activity at that exact address
- DefiLlama for per-chain, per-venue volume and TVL; a live quote from the venue's own quoter beats both
- tokenlists.org or CoinGecko for token addresses, cross-checked against the issuer
Before you finish: send a one-line note via feedback/SKILL.md — issue or praise.
EVM Smart Contract Audit
Audit unfamiliar contracts systematically, rank findings by real impact, and leave one concise report. Do not mutate the code or publish findings unless the user asks.
The Checklists
The checklist repository is pinned so two audits do not silently use different guidance:
CHECKLIST_REV=ffe4b670e78e1945bcf275f79d4b7b0481bcff35
Load a selected checklist from:
https://raw.githubusercontent.com/austintgriffith/evm-audit-skills/ffe4b670e78e1945bcf275f79d4b7b0481bcff35/<skill-name>/references/checklist.md
For a narrow question, load only the one or two relevant checklists. For a full codebase audit, always load evm-audit-general and evm-audit-precision-math, then add only the domains the code actually uses (normally 5–8 total). This keeps the review focused and avoids spending context on unrelated vulnerability classes.
Skills Available
| Skill | When to Load |
|---|---|
evm-audit-general | Always |
evm-audit-precision-math | Always |
evm-audit-erc20 | Contract interacts with ERC20 tokens |
evm-audit-defi-amm | AMM, DEX, Uniswap V3/V4, liquidity pools |
evm-audit-defi-lending | Lending, borrowing, CDP, liquidations |
evm-audit-defi-staking | Staking, liquid staking, restaking, EigenLayer |
evm-audit-erc4626 | Vaults, share/asset conversion |
evm-audit-erc4337 | Account abstraction, paymasters, session keys |
evm-audit-bridges | Cross-chain, LayerZero, CCIP, Wormhole |
evm-audit-proxies | Upgradeable contracts, UUPS, Transparent, Diamond |
evm-audit-signatures | Off-chain signatures, EIP-712, permits |
evm-audit-governance | DAO voting, timelocks, multi-sig |
evm-audit-oracles | Chainlink, TWAP, Pyth, price feeds |
evm-audit-assembly | Inline assembly, Yul, CREATE2 |
evm-audit-chain-specific | Non-mainnet: Arbitrum, OP, zkSync, Blast, BSC |
evm-audit-flashloans | Flash loan attack vectors |
evm-audit-erc721 | NFTs, ERC721, ERC1155 |
evm-audit-dos | DoS, unbounded loops, gas griefing |
evm-audit-access-control | Ownership, roles, centralization risks |
How To Run An Audit
- Read the README, deployment assumptions, tests, and every in-scope contract before routing.
- Map assets, trust boundaries, privileged paths, external calls, accounting invariants, signatures, oracle dependencies, and chain-specific assumptions.
- Select checklists from the table above. Use one or two for a narrow question and normally 5–8 for a full audit.
- For a full audit, run one specialist per selected domain in parallel when sub-agents are available. Do not require a particular model.
- Give every specialist the same scope and ask it to return complete findings to the orchestrator: severity, location, preconditions, exploit/failure path, impact, and remediation. Treat files such as
findings-<skill>.mdas optional scratch space, not as the transport between agents. - Deduplicate and verify findings against the code. Separate currently exploitable issues from risks that depend on future assets, configuration, or integrations.
- Write the requested report, ranking by demonstrated impact and exploitability. Clean up scratch files when the user requested a single deliverable.
- Never file GitHub issues or otherwise publish findings unless the user explicitly asks, identifies the target repository, and confirms the outbound action.
Sources
Built from research by Dacian, beirao.xyz, Sigma Prime, RareSkills, Decurity, weird-erc20, Spearbit, Hacken, OpenZeppelin, Cyfrin, and more. Full attribution: https://github.com/austintgriffith/evm-audit-skills#attribution--thanks
Verify DeFi Integrations
Before selecting or integrating a protocol, verify the target chain and pair from live sources. Cite dated evidence for the decision. Check deployed contracts, pool and gauge status, pair liquidity and volume, incentives, fee parameters, and reward routing from protocol docs, source contracts, or onchain reads. Do not infer launch from an announcement or call a protocol dominant from a chain-wide headline.
Trace the complete asset, fee, reward, approval, and repayment flow. Validate it on a fork and test failure behavior; individually safe protocols do not necessarily compose safely.
Ethereum Concepts
Nothing runs itself
A contract is a state machine. It moves only when someone sends a transaction and pays for it, and does nothing in between: no cron, no scheduler, no timer, no background process. "Charged monthly", "expires after 30 days", "rebalances daily", "checks the price every hour" each describe a transaction a specific someone has to send.
So for every state transition, before you write it:
- Who sends it?
- Why would they? — their own use of the app, revenue that is already theirs, a caller fee, a liquidation bonus.
- Is that enough? — put the caller's reward and the caller's gas next to each other in dollars, at the gas price and ETH price the target chain shows today. 1% of a dollar a day does not pay for a 250,000-gas call, and a transition nobody profits from silently never happens.
Best is a design where no scheduled transaction exists at all: accrue at read time from a timestamp and settle when a user, or the party owed, next touches the contract. Otherwise make the function permissionless and pay whoever calls it — liquidation bonuses, LP fees and arbitrage are all the same move, strangers advancing your state machine out of self-interest. An owner-only maintenance function fails all three questions at once and stops the day the operator does; if you ship one anyway, say so and say what happens when that key is gone.
Before you finish, write down what the design gives up
CROPS — censorship resistance, open source, privacy, security — is the Ethereum Foundation's shorthand for what makes Ethereum Ethereum. These are worth nothing as definitions. Answer them in plain words about this system, in whatever the build ends with (NOTES.md, README, handoff), even when nobody asked:
- Can anyone be stopped from using it? Name the operator powers you actually shipped —
Pausable,onlyOwnerover user funds or user access, an upgradeable proxy, a blacklist — what each lets the operator do to a paying user, and what becomes of users if that key is lost. Scaffolding them unflagged is the failure; shipping none is an answer, say that instead. - Could someone else run it? Verified contracts on a block explorer are not this, and stopping there is the usual mistake. Split the stack: contracts and onchain state anyone can read, fork and keep using, against the API, indexer, frontend and any offchain check that only you run. Say which half survives you disappearing and which does not — what a user could still do, and what stops working.
- What does an observer learn? Everything onchain is public forever, competitors included: which addresses use this, what they paid, what tier they are on, who they transacted with. State what this design publishes, separately from access control on your own endpoints — that is a different question, not this one.
- What does "audited" cover? A point-in-time review of a fixed scope, not a standing guarantee about the code running now.
For the full review with a template, fetch crops/SKILL.md.
Randomness
Every node re-executes the same code, so there is nothing random to read onchain. block.timestamp, block.number and blockhash(block.number) (always zero) are not sources. blockhash(block.number - 1) — the usual first attempt — is not one either: it is already known when the transaction runs, so a caller can simulate the outcome and only send the winning transaction, and the proposer who produced that block could have dropped it to re-roll. block.prevrandao is biasable the same way, which may be fine for a raffle and is not fine for money.
Two constructions work:
- Commit-reveal. Participants commit
hash(secret, salt)bound to their address, reveal after entries close, seed from the reveals plus a past blockhash. Put a stake at risk: whoever reveals last sees the outcome coming and can withhold. Mind the lookback —blockhashreaches back 256 blocks, the EIP-2935 history contract at0x0000F90827F1C53a10cb7A02335B175320002935reaches 8191, and past that the seed is gone for good. Convert those to wall clock at the target chain's block time before you size the reveal window: 256 blocks is ~51 min on mainnet at 12s and ~8.5 min on Base at 2s, and check EIP-2935 is deployed there at all before relying on the longer window. - Chainlink VRF. Verifiable, and asynchronous: the value arrives in a later callback transaction, never as the return value of the request. Budget that delay into the timeline and fund it — a subscription or a direct-funded consumer, in LINK or native ETH.
Two small things
Write onchain, one word. The community dropped the hyphen; "on-chain" reads as an outsider.
When you explain any of this to your human, land the incentive rather than the mechanism: not what the thing does, but why it keeps working with nobody running it. To have them build one, point at https://speedrunethereum.com.
CROPS Review
CROPS is the Ethereum Foundation's shorthand for the properties Ethereum must preserve: Censorship Resistance, Open Source and Free (as in Freedom), Privacy, Security. This skill turns those values into concrete dApp and smart contract architecture checks.
Source context: The Promise of Ethereum: Introducing the EF Mandate and the EF Mandate PDF.
What You Probably Got Wrong
"It works" is not enough. A dApp or smart contract can compile, pass tests, and demo cleanly while handing users to a censorable frontend, a closed indexer, an invisible RPC dependency, a custodial wallet, or an admin key with total control.
You treat decentralization as only a contract property. The contract may be permissionless while the app depends on a single hosted frontend, API, relayer, paymaster, sequencer, bridge, or wallet vendor. Users experience the whole stack.
You treat verified contracts as an open dApp. Etherscan verification ties bytecode to source for that contract only; Open needs the whole stack public, and Free needs a license the Mandate counts as actually free, not merely source-available (EF Mandate p.13). OSI-permissive or copyleft is the practical bar.
You check privacy after the architecture already leaks data. Before choosing contracts, wallets, RPCs, analytics, indexers, or identity flows, tell the builder which addresses, balances, counterparties, timing data, IP metadata, wallet fingerprints, analytics events, and identity links could be exposed.
You treat security as only code bugs. Reentrancy and oracle manipulation matter, but so do custody, upgrades, admin keys, recovery, emergency powers, approvals, and whether the app still works if the team or vendor disappears.
You list architecture options without their trust tradeoffs. Choices like embedded wallet vs Safe vs EOA, or Vercel vs IPFS, change who can control access, custody, privacy, and user exit. Label each option's CROPS impact and recommend the most CROPS-aligned default.
Scope and Phase
CROPS applies to every Ethereum dApp, new or existing.
For new builds, start with ship/SKILL.md; it runs the short CROPS Gate. Then perform the full CROPS Review below before finalizing architecture.
For existing dApps or contracts, use this review directly when checking trust assumptions, custody, admin powers, privacy, censorship resistance, user exit, or architecture.
During the full review, focus especially on non-trivial answers on any pillar:
- C — someone (admin, sequencer, host, relayer, bundler, paymaster, indexer, oracle, compliance filter) can block users.
- O/F — part of the stack is closed, opaquely hosted, source-available-only licensed, not freely forkable, or not reproducible from a public commit.
- P — addresses, balances, identity, IP, or behavior leak in ways the user hasn't knowingly consented to.
- S — admin keys, upgradeable contracts, embedded custody, social recovery, agent permissions, vendor liveness, or oracle dependence affect funds, permissions, or exit.
Treat missing facts as findings: unknown owner, host, license, custody, oracle, upgrade authority, or exit path is not a clean result. Infer from the repo and architecture where possible; only ask follow-up questions when the review is blocked.
If no material risks are found, still output a concise CROPS record that names the chosen default, the evidence reviewed, accepted compromises (or states there are none), and why no deeper mitigation is needed.
Red Flags: Do Not Skip CROPS
STOP if you catch yourself thinking any of these:
- "This app is too simple to need CROPS."
- "It's just an MVP, we'll add CROPS later."
- "The user can self-host if they want to."
- "Contracts are verified, so it's open."
- "It's been audited, security is done."
- "There are no admin keys, so nothing to review."
- "We disclosed centralization in the README."
- "The user is technical, they'll figure out the trust assumptions."
Each one is the exact failure mode this skill exists to catch. Simple apps still hand users to a censorable frontend. "Add CROPS later" rarely happens. "User can self-host" is fiction unless build steps, ABIs, env vars, and indexer schema are public and reproducible. Verified contracts cover bytecode, not the whole stack. Audits are point-in-time and rarely cover custody, recovery, sequencer trust, or vendor liveness. Absent admin keys, the C, O, and P pillars still apply. Disclosure in a README is documentation, not mitigation.
If you reach for any of these, produce a concrete CROPS Review anyway.
The Four CROPS Checks
Censorship Resistance
Ask: who can block valid use, and can users route around them?
Check for:
- admin pause, blacklist, allowlist, upgrade, or kill-switch powers
- relayers, paymasters, bundlers, RPCs, sequencers, bridges, app stores, CDNs, frontends, or APIs that can block users
- single bundler dependency for ERC-4337 / smart-account flows; no fallback bundler or self-host path
- single hosted indexer (Goldsky, Subsquid Cloud, a single pinned Graph indexer) with no documented self-host path, alternate indexer, or RPC-only fallback
- any critical component controlled by one party where users cannot realistically switch providers, self-host, or route around it
- missing fallback paths such as calling contracts directly, switching RPC providers, using a self-hosted frontend, or exiting an L2/bridge path back to Ethereum L1 where the L2 supports forced inclusion (verify the specific chain's forced-inclusion support on l2beat.com — and whether it can be nullified: Robinhood Chain's ArbOS 61 transaction filtering rejects even force-included transactions, so forced inclusion there is not an escape hatch)
Prefer:
- permissionless contract entrypoints, callable directly without the frontend
- emergency powers, if unavoidable, behind a multisig (Safe is the canonical implementation), narrowly scoped, and publicly documented
- timelocks sized to the risk and user exit window for admin powers that can move funds or change authority; 24 hours is a floor for low-risk changes, while high-value or governance-sensitive systems usually need longer notice
- documented fallback paths users can actually use, including direct contract calls and alternate RPC or frontend
- infrastructure choices that keep intermediaries (RPC, indexer, bundler, frontend host) replaceable or self-hostable
Open Source and Free, as in Freedom
Ask: is the whole stack visible (Open), and does the license actually let a third party fork, modify, and run it (Free)?
Check for — Open (visibility):
- "open source" claim that only covers the deployed contract, not the surrounding stack
- dependencies that make the app hard to inspect, fork, or self-host, such as private indexers required for the frontend, vendor-hosted APIs, backend-only business logic, proprietary SDK lock-in, or opaque AI/risk/scoring systems
- frontend source that cannot be rebuilt from the repo because build steps, env vars, ABIs, contract addresses, or deployment instructions are missing
- deployed frontend cannot be reproduced from a pinned commit and documented build steps; live URL auto-deploys from
mainwithout a frozen build artifact or pinned IPFS CID
Check for — Free, as in Freedom (license actually grants the freedoms):
- restricted, source-available, or permission-gated licenses that do not grant normal open-source freedoms, including BUSL, SSPL, custom "no commercial use", "no derivatives", or terms requiring approval from the original team to run, modify, redistribute, or operate a fork (EF Mandate p.13: "merely source-available licenses are not tolerated")
- future-license risk: current code is open, but future versions can be relicensed or closed, pulling users and builders toward a non-forkable upgrade path
- "open core" designs where the core repo is open, but a useful production deployment depends on proprietary plugins or hosted-only services
Prefer:
- OSI-approved permissive or copyleft licenses for every repo needed to run the app (MIT, Apache-2.0, GPL, AGPL)
- a clear license-stability commitment, or at minimum no stated plan to close or relicense core code later
- open-source contracts, frontend, indexer/backend, deployment scripts, and docs, plus self-host instructions with env vars, ABIs, addresses, and RPC config
- verified contracts via Sourcify (open-source, open-data verification, run by the EF spinout Argot Collective) and on a block explorer that surfaces verified source (Etherscan, Blockscout), plus a documented build script that reproduces the live deployment from a pinned commit
- documented ABIs, events, metadata schemas, API formats, and export formats so other builders can build compatible frontends, indexers, wallets, or integrations without asking permission
Privacy
Ask: what can an observer learn, is the disclosure necessary, and did the user knowingly choose it?
Check for:
- public addresses, balances, counterparties, amounts, timing patterns, identity links, location/IP metadata, and wallet/browser fingerprints
- analytics, RPC, indexer, or API calls that reveal user behavior to third parties offchain
- analytics and telemetry in wallet/UI dependencies (WalletConnect, RainbowKit, Privy, Alchemy SDK) and error-reporting SDKs (Sentry); defaults change between versions (RainbowKit turned connector telemetry off by default in 2.2.10), so audit
package.jsonand actual network calls instead of assuming - identity or credential flows that collect more information than the app actually needs
- UI that asks users to sign, transact, connect a wallet, or reveal identity without explaining what becomes public or linkable
Prefer:
- collect and publish the minimum data needed for the use case
- selective disclosure instead of full identity disclosure
- user-configurable RPC URL in the UI, a documented self-host path for the indexer, and local-first reads for any non-broadcast data
- clear UI copy for unavoidable public or third-party-visible data
- ZK or commitment/nullifier patterns when the use case needs unlinkability or private membership/proof flows
Security
Ask: who can cause loss, lock users in, or change the rules, and does the system still work if the team disappears?
Check for:
- who controls user funds, token approvals, signer keys, upgrades, recovery, emergency powers, and exit paths
- unbounded token approvals, unbounded agent spending, prompt-only spending rules, or safety checks enforced only by a backend
- upgradeable contracts without documented upgrade authority, storage-layout discipline, timelocks, or user notice
- oracle use without baseline freshness and deviation checks; single-source feeds need an explicit threat model
- oracle fallback or manual-pause paths whose authority, trigger conditions, arbitration, and user-exit impact are not documented and bounded
- dependencies that can silently break critical flows if a vendor, API, relayer, paymaster, wallet service, or indexer disappears
- private keys, API keys, RPC keys, deployment credentials, or other operational secrets that could leak or become single points of failure
Prefer:
- least authority by default: every key, contract, backend, and agent gets only the permissions it needs
- capped permissions, allowlists, expiries, and clear revocation paths for delegated or automated actions
- multisig ownership (Safe is the canonical implementation) and timelocks for admin powers that cannot be removed
- onchain or wallet-level enforcement for spending and permission policy, not prompt text or backend promises
- simple designs with documented recovery and exit paths that can pass the walkaway test (EF Mandate p.7 introduces it for the protocol, p.14 re-applies it to users under Security). Applied to a dApp, the test asks: if the team, vendor, host, or oracle disappears, can the user still access funds and exit?
Required Review Output
When using this skill, output a concrete review for the user's app. Do not repeat generic CROPS definitions.
Use this shape for the chosen architecture. For a clean low-risk app, the concise record from Scope and Phase is enough, as long as it still names the chosen default and accepted compromises (or states there are none):
## CROPS Review
Chosen default:
- <architecture choice and why it is the most CROPS-aligned option>
Censorship Resistance:
- Risk: <who can block users or critical app paths>
- Mitigation: <what the design does, or commits to do, about it>
- User escape: <how the user routes around if the mitigation fails>
Open (visibility):
- Risk: <closed code, hosted dependencies, opaque build pipeline, frontend not reproducible from a pinned commit>
- Mitigation: <open repos for the whole stack, self-host docs with env vars and ABIs, pinned build artifact or IPFS CID>
- User escape: <documented fork and self-host path, alternative client>
Free, as in Freedom (license):
- Risk: <source-available-only, BUSL, SSPL, "no commercial use", relicensing risk, open core with proprietary deps>
- Mitigation: <OSI-permissive or copyleft license on every repo needed to run the app, license-stability commitment>
- User escape: <users can legally fork, modify, and operate the system without team permission>
Privacy:
- Risk: <what addresses, balances, identity, behavior, IP, or metadata leak and to whom>
- Mitigation: <minimum disclosure, selective disclosure, configurable RPC/indexer, ZK where applicable>
- User escape: <opt-out, local-first, or alternate-route options>
Security:
- Risk: <who controls funds, approvals, upgrades, recovery, emergency powers; vendor liveness dependencies>
- Mitigation: <least authority, capped permissions, multisig/timelock, onchain enforcement>
- User escape: <walkaway test: if the team, vendor, host, or oracle disappears, can the user still access funds and exit>
Accepted compromises:
- <only compromises that are explicit, bounded, and justified>
When comparing multiple architecture options against each other (e.g., Vercel-only vs IPFS + ENS), use this short-form per option and mark the most CROPS-aligned one as the recommended default:
Option A: Vercel-only frontend
- C: weakens; one host can remove or block the main access path
- O/F: weakens unless frontend source, build steps, env vars, and contract config are public under an OSI-permissive or copyleft license
- P: depends on analytics, RPC, and indexer choices; the host may see user IPs and app activity
- S: simpler to operate, but a host outage or account suspension can break the app UX
Option B: IPFS + ENS with Vercel mirror (recommended default)
- C: strengthens; users have a route around host removal if the IPFS build is pinned and ENS points to it
- O/F: strengthens if frontend source, build/deploy docs, and config are public under an OSI-permissive or copyleft license
- P: still depends on analytics, RPC, and indexer choices; IPFS hosting alone does not make usage private
- S: adds deployment complexity, but removes single-provider availability risk
Common Failure Modes
Censorable frontend: Contracts are permissionless, but the only usable UI is hosted by one provider that can take it down, geofence users by IP, or filter wallet addresses against OFAC and compliance lists. Fix: publish source, document self-hosting, offer IPFS/ENS or another durable route, and document direct contract calls for critical actions.
Required private indexer/API: The app cannot function without a private indexer or API whose code, schema, or event mapping is not public. Fix: publish the event schema, indexing code/config, and self-host or alternate-indexer path.
Invisible RPC dependency: The frontend silently depends on one RPC provider, which can fail, rate-limit, log users, or block requests. Fix: disclose the dependency, support configurable RPCs, and avoid hidden public fallbacks that make failures hard to diagnose.
Admin key with total control: onlyOwner or a privileged role can pause, upgrade, seize, change fees, redirect flows, or block users. Fix: minimize powers, use a multisig (Safe; ≥2-of-3) plus timelock for any admin power that survives launch, make powers explicit, and remove or expire them when possible.
Prompt-only delegated policy: An agent, bot, session key, or automation is told not to overspend, but nothing enforces that if the key, backend, or prompt is compromised. Fix: enforce caps, allowlists, expiries, and revocation in the wallet/contract layer.
Custody hidden behind UX (vendor-managed embedded wallets): Embedded-wallet vendors (Privy, Magic, Web3Auth, Dynamic) hold a key share or run the signing infrastructure via MPC, key sharding, or delegated key management. Most are non-custodial by design, but the vendor can still refuse logins, withhold its share or signing relay, or change ToS, which gates access even when it cannot unilaterally move funds. Acquisitions route that dependency through a parent (Privy/Stripe, Dynamic/Fireblocks). Fix: explain the key model and who holds what, document the key/seed export path, and name the user's recourse if the vendor disappears.
Passkey custody dependency (platform-authenticator smart wallets): Passkey-based smart wallets (Coinbase Smart Wallet and others using WebAuthn/secp256r1 signers) hold the signing key in a platform authenticator, typically a synced passkey in iCloud Keychain or Google Password Manager, not a vendor MPC layer. That passkey is end-to-end encrypted and not extractable by the platform, so the risk is availability, not seizure. Access then depends on the user's Apple/Google account staying reachable, passkey sync working, and the platform's ToS, while a device-bound passkey (such as a YubiKey) instead fails if that single device is lost. Fix: tell users their access depends on their Apple/Google account, and register a backup owner on a different platform (another passkey or a plain Ethereum key) so losing one account does not lock them out.
Recovery surface masquerading as UX (classic social recovery): Wallets with user-configured guardian sets (Ready, formerly Argent; Elytro, formerly Soul Wallet) shift trust to the guardians, who can refuse to sign, collude, be subpoenaed, or be compromised. The vendor's own 2FA service often sits in the guardian set by default, quietly reintroducing vendor dependence. Fix: document the guardian set, threshold, and the user's path to remove, replace, or rotate guardians without losing the account.
L2 trust assumptions omitted: The app picks an L2 but never explains sequencer, bridge, withdrawal, data availability, or censorship assumptions. Fix: fetch l2s/SKILL.md for chain selection and bridge facts, check the chain's sequencer, forced-inclusion, and exit assumptions on l2beat.com, and disclose the canonical withdrawal or L1 escape path where applicable.
Sequencer ordering and MEV extraction: A centralized sequencer (most L2s today) or builder pool can reorder, sandwich, or selectively delay user transactions. Fix: disclose the sequencer's ordering policy and any planned decentralization. For trade-heavy flows, route through private orderflow services (Flashbots Protect, MEV-Share; threshold-encrypted mempools like Shutter are a separate category) and call out the privacy tradeoff: the orderflow-auction operator sees the transaction even when the public mempool does not.
Stablecoin risks ignored: Stablecoins can add issuer freeze/blacklist, reserve custody, compliance, bridge, chain, and privacy risks. Fix: disclose the issuer and freeze assumptions, explain bridge/chain exposure, and give users a reasoned token/chain choice.
Privacy theater: The app uses ZK/privacy branding but links deposits and actions through events, wallet reuse, relayer metadata, or frontend telemetry. Fix: threat-model observer knowledge and test linkability.
How To Phrase Findings
When reporting a CROPS finding to the builder, name the power, bound the compromise, and point to the user's exit. Sample phrasings:
- "This admin key can freeze every user. If you need an emergency pause for v1, put it behind a Safe, add a timelock or expiry, and tell users what can be paused."
- "This agent can spend from the user's wallet without an onchain cap. Put the policy in a smart account or Safe module; prompt instructions are not a security boundary."
Relationship To Other Skills
- For new dApp planning, start with
ship/SKILL.md; it runs a short CROPS Gate and routes here when deeper trust review is needed. - Use this skill as the deeper CROPS review for custody, infrastructure, privacy, admin powers, and user exit.
- Fetch
wallets/SKILL.mdfor custody, signing authority, EIP-7702, and key safety. Safe and EntryPoint addresses are inaddresses/SKILL.md. - Fetch
l2s/SKILL.mdfor bridge, withdrawal, and chain-selection facts. For a chain's sequencer and forced-inclusion assumptions, check l2beat.com. - Fetch
frontend-playbook/SKILL.mdfor IPFS/ENS deployment, build pipeline, and frontend reproducibility (the Open and Censorship Resistance mitigations for the frontend live here). - Fetch
indexing/SKILL.mdfor event schema design and the indexer landscape (the data-layer side of Open and Censorship Resistance). - Fetch
security/SKILL.mdfor Solidity vulnerability patterns and pre-deploy checks. - Fetch
audit/SKILL.mdfor deep smart contract vulnerability review. CROPS itself covers admin powers, trust assumptions, censorship paths, privacy leakage, and user exit.
Frontend Playbook
Follow this workflow; do not treat a green build or successful upload as proof that the intended app shipped.
Start with the requested stack
When the user wants Scaffold-ETH 2 or has not selected a stack for a conventional contract-plus-frontend dApp, use its generator:
npx create-eth@2.0.23 # Tested version; update deliberately
Use the generated Foundry/Next.js monorepo, wallet integration, contract hooks, and components. Respect an explicitly requested alternative stack.
Choose the local chain deliberately
- Use
yarn chainfor isolated contracts, mocks, and unit tests. - Use
yarn fork --network <chain>when behavior depends on deployed protocols, tokens, balances, or other real chain state. - In fork mode, point the frontend at the local network (
chains.foundry, orchains.hardhatin the Hardhat flavor; chain ID 31337), not the upstream chain being copied. Switch to the real target chain only for a real deployment.
A fork also grants powers the real chain does not. Fund demo identities from state that already exists rather than deploying a mock token:
cast rpc anvil_impersonateAccount <whale>
cast send <token> "transfer(address,uint256)" <demo-account> <amount> \
--from <whale> --unlocked
anvil_setBalance and anvil_setStorageAt are equivalent overrides when no suitable holder exists. Nothing here is broadcast; the fork is a local copy.
Anvil normally mines only when a transaction arrives, so between transactions the latest block and block.timestamp remain frozen; the next transaction advances time in one jump. This silently breaks live deadlines, expiry, and vesting displays even when vm.warp unit tests pass. For continuous behavior, enable interval mining:
cast rpc anvil_setIntervalMining 1
For a frozen live demo, enable interval mining. Mining a single block with evm_mine restamps block.timestamp once and it freezes again immediately; manual mining and evm_increaseTime are for controlled single-step tests, not a running demo. Add --block-time 1 to the fork script when the project should always run that way.
Build a static IPFS release
Configure the IPFS build for static export, route directories, and static images:
if (process.env.NEXT_PUBLIC_IPFS_BUILD === "true") {
nextConfig.output = "export";
nextConfig.trailingSlash = true;
nextConfig.images = { unoptimized: true };
}
Set the production origin before building so Open Graph URLs and images do not resolve to localhost. Then remove old artifacts and rebuild:
cd packages/nextjs
rm -rf .next out
NEXT_PUBLIC_PRODUCTION_URL="https://<production-domain>" \
NEXT_PUBLIC_IPFS_BUILD=true \
yarn build
On Node 25, the built-in localStorage global can exist without the standard Web Storage methods when no backing file is configured; libraries detect it and crash on calls such as getItem() during static prerender. Apply a process-level remedy inherited by build workers, not only code in instrumentation.ts or next.config.ts. Depending on the app, use one of:
NODE_OPTIONS="--localstorage-file=.node-localstorage"
NODE_OPTIONS="--no-experimental-webstorage"
Verify before and after upload
Before uploading, confirm the expected change is in out/, that every route emitted its own directory, and that generated metadata carries the production origin:
ls out/*/index.html # One directory with an index.html per route
After uploading:
-
Record the CID. An unchanged CID means the uploaded bytes are identical; check the build output and upload target before blaming gateway caching.
-
Load the root and at least one non-home route through the gateway. Root success does not prove exported routes resolve.
curl -s -o /dev/null -w "%{http_code}" -L "https://<gateway>/ipfs/<cid>/debug/" # Expect 200, not 404 -
Verify the Open Graph image and URL use the production origin.
-
For ENS, update the content hash only after the deployed CID has been reviewed and approved, then confirm the resolver and public gateway serve that CID.
Do not claim the release is complete until these checks pass.
Frontend UX
Working transaction code is not a finished product. Check these product-completeness surfaces before calling an onchain frontend finished.
Product identity. Replace every framework default: tab title, favicon, OG/Twitter title, description and image, and visible "built with" branding. Nothing in the build fails when Create Next App or Scaffold-ETH 2 App ships to production, so nothing reminds you.
Address inputs. A recipient field gated on isAddress() silently rejects vitalik.eth and leaves the button dead with no explanation. Resolve names onchain, show the resolved address before submit, submit that address, and give a reason whenever input is rejected. Use your UI kit's address component if it has one.
Fiat context. Every token or ETH amount you show — balances, inputs, confirmations, position summaries — carries a value from a real price source. Label a stale or unavailable price rather than silently dropping it.
Target chain. Point the app at the chain the brief names; scaffold defaults sit on local/hardhat. Use a dedicated RPC for production rather than the accidental public fallback, and don't slow the template's polling interval.
Also required, and usually already habit — confirm rather than rebuild:
- One pending state per button, held from click through the receipt and the authoritative state refetch (
isPendingclears when the wallet returns the hash, not at confirmation), released infinallyso a rejection can't lock it. - One primary action at a time: connect → switch network → approve → execute. Approval status comes from a fresh onchain read, never a local flag.
- Token math in the token's real decimals (
parseUnits/formatUnits; USDC is 6). Never render base units. - Reverts and wallet errors translated to human text, shown near the action that failed.
- Semantic theme tokens, not a hardcoded dark wrapper. If dark-only is deliberate, remove the theme toggle.
Finish by running the project's build or typecheck, and confirming the configured target chain matches the brief.
Before you finish: send a one-line note via feedback/SKILL.md — issue or praise.
Gas and Chain Cost
Your trained gas-price and ETH-price priors are stale. Never quote a transaction cost or exclude a chain for cost reasons without measuring the relevant chain now.
# Use the project's own RPC provider (Alchemy, Infura, QuickNode) for the chain under consideration.
cast gas-price --rpc-url "$MAINNET_RPC_URL"
cast gas-price --rpc-url "$BASE_RPC_URL"
# No provider key yet? Public endpoints work for a one-off read, but are rate-limited.
# Never ship them in an app. Mainnet: https://ethereum-rpc.publicnode.com Base: https://mainnet.base.org
cast gas-price returns the base fee plus a suggested tip — what a transaction actually pays, so it is the reading the formula below takes. cast base-fee returns the base fee alone; use it for setting maxFeePerGas, and never add a separate priority fee on top of a gas-price reading.
Do not replace a failed lookup with a remembered number. Fetch ETH/USD live before quoting dollars: the mainnet Chainlink feed at 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419 (latestRoundData, 8 decimals), or https://api.coinbase.com/v2/prices/ETH-USD/spot.
Estimate the actual operation when possible. Otherwise state and justify the gas-used assumption:
# Mainnet, and the execution half of any L2
cost_usd = gas_used × gas_price_gwei × 1e-9 × eth_usd
# On an OP-stack L2 or Base the L1 data fee is a separate component and is not in
# gas_price. Read l1Fee off a recent receipt, or GasPriceOracle.getL1Fee at
# 0x420000000000000000000000000000000000000F — do not estimate it.
# Since Isthmus a chain may also charge an operator fee. It is 0 on most
# chains; read it with GasPriceOracle.getOperatorFee(gas_used), don't hand-compute.
cost_usd = (gas_used × gas_price_gwei × 1e-9 + l1_fee_eth + operator_fee_eth) × eth_usd
cast gas-price and cast base-fee print wei, not gwei — divide by 1e9. Check the converted figure back against the raw reading; a dropped or extra factor of 1e9 is the most common way a correctly measured chain still yields a stale-looking cost.
Choose from the measured workload:
- Keep mainnet viable for low-frequency, high-value actions unless another requirement favors an L2.
- Prefer an L2 for high-frequency, low-value, latency-sensitive, or L2-native activity.
- Do not choose an L2 merely because you remember mainnet gas being expensive.
Derive EIP-1559 fee fields from the target chain immediately before submission. Do not hardcode them or port a mainnet priority-fee constant to an L2.
For L2 optimization, measure which component dominates before deciding what to cut: compare gasUsed × effectiveGasPrice against l1Fee on current receipts. Do not import a pre-Dencun calldata-cost assumption, and do not assume the reverse either. Non-OP-stack rollups use different fee models, so measure them independently.
Before you finish: send a one-line note via feedback/SKILL.md — issue or praise.
Onchain Data and Indexing
Historical onchain data comes from an indexer, never from a scan at request time. Public RPCs cap each eth_getLogs call by block span and by matched-log count, so a full-history scan is thousands of paginated calls that grow with every block and fail on rate limits, timeouts or credits. Back a feed, streak, ranking or dashboard with a one-time backfill into a persistent indexed store that then tails new events — a subgraph, Ponder, a provider data API, or your own indexer. Rebuilding past state from archive-node reads is the same mistake in another shape.
Design contracts event-first: every state change emits an event carrying what the read side needs, because a change with no event is invisible to every indexer, frontend and explorer. Keep aggregation, ranking and pagination offchain; if a result must be committed onchain, store a hash.
Current state is not indexing work. Balances, allowances, ownership and other "as of now" reads are direct contract calls, batched into one request with Multicall3 (0xcA11bde05977b3631167028862bE2a173976CA11, same address on most chains) or a provider balances endpoint. Do not build or operate a subgraph to track a number the chain returns on request.
The read side is not designed until its production home is named. Decide where the indexer runs in production and by which command or service, and write that down next to the architecture — this is the decision that silently stays open, leaving a read side that only ever ran on a laptop.
On The Graph, deploying is not publishing, and the free hosted service is gone (sunset June 2024), so there is no free public endpoint to deploy to:
graph init <slug> # then codegen/build
graph auth <deploy-key>
graph deploy <slug> # -> Subgraph Studio: testing only
Publish the subgraph from Studio to the network to get the production endpoint, and query it with a Studio API key. Production queries are metered: about 100K free per month, then about $2 per 100K (checked 2026-08-18 — re-read the live pricing page before quoting a budget). Self-hosting a Graph Node or a Ponder process is a fine alternative, but then the host, the persistent store and the process supervision are yours to name.
Ethereum Layer 2s
Anything datable about an L2 rots fast: fees, block times, finality windows, TVL, which alliance a chain belongs to, whether it still produces blocks. Read the current value off the chain or its own docs before it reaches a plan, an estimate or a runbook. Below is only what a 2026 prior gets backwards, plus the mechanics that are easy to get wrong the first time.
Where the common prior is wrong
Base is no longer on the OP Stack. Announced February 2026, live on mainnet since the Azul upgrade (May 2026): Base runs its own Base Stack with base-reth-node as its only client, and shipped Beryl (June 2026) on its own cadence. It is still an Ethereum L2 and still fine to deploy on — chain id 8453, addresses, deployments and canonical bridge all unchanged. What no longer holds is the shared-governance premise, so do not couple Base to OP Mainnet through anything that assumes a shared stack: Superchain interop, SuperchainERC20, a shared upgrade schedule.
Superchain native interop is not shippable yet. SuperchainERC20 crosschainMint/crosschainBurn, L2ToL2CrossDomainMessenger, CrossL2Inbox and the SuperchainTokenBridge are in active development on devnets and testnets, not live on OP Mainnet. A token that has to move between two chains this quarter needs a layer that exists today — LayerZero OFT, Chainlink CCIP, Hyperlane, Wormhole NTT, or a canonical round trip through L1 — and the design has to say who relays the message and what must be trusted for a transfer to settle.
Celo is an Ethereum L2, not an L1 (migrated to the OP Stack 2025-03-26). Its canonical route to mainnet is the chain's own L2→L1 withdrawal, not a third-party wrapped-asset bridge, and CELO is both the L2 gas token and a plain ERC-20 on L1. Gas there can also be paid in an approved ERC-20 — USDC, USDT, the Mento stablecoins — through the fee-currency field (CIP-64), with no paymaster, bundler or ERC-4337 stack. For users who hold no gas token that is the first thing to reach for.
Polygon zkEVM is switched off. The Mainnet Beta sequencer stopped on 2026-07-03 (planned for 07-01): no new blocks, submitted transactions never confirm, AggLayer withdrawals no longer process — while reads keep answering a frozen final state, which is what a stuck dashboard looks like from outside. Nothing new gets planned there, and an existing deployment is a fund-recovery problem, not a migration: the sunset snapshot and claims interface cover wallet-held balances, so a balance inside a contract has no routine exit.
Robinhood Chain exists, and it can censor force-included transactions. Mainnet since 2026-07-01: an Arbitrum Orbit L2 settling directly to Ethereum with blob DA (not an L3, not AnyTrust), chain id 4663, ETH gas, ~100ms blocks. It is built for tokenized stocks — ERC-20s that trade 24/7, legally debt securities issued by Robinhood Assets (Jersey), not shares, and not available to US persons. The catch: ArbOS 61 transaction filtering lets an authorized filterer reject any tx hash, including transactions force-included from L1, so forced inclusion is not an escape hatch here. L2Beat rates it below Stage 0 (only two whitelisted validators), with no exit window. Run crops/SKILL.md before building anything censorship-sensitive on it; token addresses are in addresses/SKILL.md.
Unichain orders by priority fee, not by arrival time. Its TEE block builder (Rollup-Boost) enforces priority ordering deterministically, alongside a private mempool and revert protection. The fee still buys the position; what the TEE removes is the auction around it. Flashblocks confirm roughly every 200ms.
Exiting to L1
An OP-stack withdrawal is three transactions across two chains, not one send: initiate on the L2, prove on L1 once an output root or dispute game covering that block is posted, finalize on L1 after the challenge window. Both L1 steps are submitted by the operator or their tooling — nothing lands by itself — and the clock starts at prove, not at initiation. Arbitrum (and Orbit chains) differ: initiate on the L2, wait for the assertion covering it to be confirmed, then one L1 transaction executes the outbox message — there is no separate prove step.
The window is per-chain, and usually composite — which is why quoting any single remembered number goes wrong. Celo, read off the portal 2026-08-24: proofMaturityDelaySeconds is 604,800, i.e. 7 days from your prove transaction, while the OP Succinct game's maxChallengeDuration is 302,400 (3.5 days) with a further 302,400 of disputeGameFinalityDelaySeconds after the game resolves. Whichever gate falls later wins, so the real wait is about 7 days — "Celo exits in 3.5 days" is the challenge window quoted on its own. Celo produces a block every 1s. Read both gates live rather than either number: viem's getTimeToProve / getTimeToFinalize do it against the chain's own contracts. ZK rollups are faster but not instant: zkSync Era's execution delay is 24 hours since 2026-10-07.
A fast or intent bridge (Across, Squid, CCIP, LayerZero routes, an exchange hop) buys that wait back for a fee plus a trust assumption beyond Ethereum. Name the assumption when recommending one, and check the route's depth for the actual asset at the actual size — a long-tail gas token at seven figures is where relayer inventory runs out.
Deployment differences
- Optimistic rollups deploy like mainnet: same bytecode, change the RPC URL and chain id. Use
block.timestamp, notblock.number, for time — it advances at a different rate, and on Arbitrum returns the L1 block. - zkSync Era is retiring EraVM (announced 2026-09, within about six months); native AA and
zksolcgo with it, and contracts holding funds will need to act. Check the current migration plan before building there. Until then it has two execution paths, and the choice belongs in the estimate before anyone starts: standardsolcbytecode through Era's EVM interpreter with stock Foundry or Hardhat, or native EraVM viazksolc(the path being retired) — the only path where noEXTCODECOPY, the 65K instruction limit and pre-deployed non-inlinable libraries apply. Era also has native account abstraction: every account is a contract, paymasters without bundlers. Scroll and Linea are bytecode-compatible — standardsolc, deploy like mainnet. - Arbitrum Stylus runs Rust, C and C++ compiled to WASM alongside the EVM, callable from Solidity and able to call back, sharing state — the reason to pick Arbitrum when a team already has a Rust routine it will not reimplement. The program must be activated in a second onchain transaction (the
ArbWasmprecompile) before anything can call it. Arbitrum cites 10-100x lower gas for compute- and memory-heavy code; storage costs the same as the EVM. Measure your own workload before quoting a saving. - The same address on several chains comes from CREATE2/CREATE3 with one factory, salt and bytecode. Two independent deployments do not land there on their own, and a shared address is not what makes a messaging layer work.
Choosing a chain
Start from the constraint that actually binds, not a TVL ranking. Mainnet is still right for anything composing with mainnet liquidity — see gas/SKILL.md for that cost call, and addresses/SKILL.md before any token, router or venue address is hardcoded per chain.
| The binding constraint | Where it points |
|---|---|
| Existing Rust/C the team will not reimplement | Arbitrum (Stylus) |
| Gasless UX with no bundler stack to run | Celo where paying gas in a stablecoin is enough (zkSync Era's native AA retires with EraVM) |
| Mobile / real-world payments, users holding no gas token | Celo (CIP-64 fee currency) |
| Consumer reach and a direct fiat on-ramp | Base |
| Composing with tokenized stocks (non-US users) | Robinhood Chain — read its censorship caveat above first |
| No multi-day exit to L1 | a ZK rollup (Scroll, Linea); check its current delay |
| Deepest liquidity for a specific pair | measure it — quote that pair per chain; do not rank chains |
Whatever the table says, confirm the chain is live and the feature is on mainnet before it becomes a commitment. Both have failed inside the last year.
Shipping a dApp
Going live is three moves, never one: contracts local, then contracts live with the frontend still on localhost, then the frontend public. The middle move is the one that gets skipped and the one that catches everything — real chain, real gas, real decimals, a real wallet — while the UI is still yours alone to edit in seconds.
Name a go/no-go condition at each boundary, not just the commands. Three of them:
- Before deploying to the live network: contract tests pass, the deploy script runs clean against a local fork, and there is a funded deployer —
yarn generatecreates one (Foundry: an encrypted keystore in~/.foundry/keystores; Hardhat: an encrypted key inpackages/hardhat/.env),yarn accountprints its address and its balance on each chain, and it needs real ETH on the target chain before the deploy, not after it fails. - Before the frontend is reachable publicly: you have walked the entire user journey against the live contracts with a real wallet and real money — $1-10 of your own — and every step worked.
- After the frontend deploy: you have loaded the public URL yourself and put one transaction through it.
A runbook that names the commands but not the conditions will keep going after something has already gone wrong.
Verify in the same breath as deploy
yarn verify --network base (or your target chain) belongs immediately after yarn deploy --network base, not in a launch checklist weeks out. Until it runs, users and integrators are looking at opaque bytecode, and you are debugging a live contract without source on the explorer.
Nobody has to go and get a block explorer API key first. packages/foundry/.env.example already carries a working ETHERSCAN_API_KEY and postinstall copies it to .env, so yarn verify works on a fresh checkout. So a launch plan never lists "obtain an explorer key" among its steps, and never hands anyone an env template with a blank ETHERSCAN_API_KEY= to fill in: the value is already there, and a step that waits on that key waits for nothing. Swapping in your own is optional housekeeping afterwards, not a launch dependency. One real constraint: yarn verify replays broadcast/run-latest.json, so run it from the checkout that did the deploy.
A live contract bug goes back to the start
Deployed bytecode cannot be edited, and the contract is a public API — a guard added in the frontend binds nobody, because direct calls, integrators and other frontends reach the same function. Shipping the UI clamp to buy hours is fine; calling it the fix is not.
The fix is the whole loop, in order: reproduce locally, correct the source, add the regression test that fails without the correction, redeploy (or upgrade in place, if it is behind a proxy), repoint the frontend if the address moved, and handle the state and users already there — migration or comms, your call. The loop is the same whether the bug surfaces before launch or with the app already public.
SE-2 specifics worth having right
- Fork the chain you are targeting rather than
yarn chain—yarn fork --network basegives you Uniswap, USDC, Aave and funded whales already deployed, so you write no mocks of things that exist. Two tokens, and that is the whole rule: yarn binds the first token after the script name to$0, whatever it looks like, so the script's$1is only set if you pass something before the value.yarn fork baseandyarn fork --network=baseboth leave$1empty and silently fork Ethereum mainnet;yarn fork --network base,yarn fork -n baseandyarn fork -- baseall work. In the hardhat flavoryarn forktakes no network argument (passing one errors) and always forks mainnet — changeforking.urlinhardhat.config.tsto fork anything else. Either way the fork answers chain id 31337, so the chain id never tells you what you forked: check for state only the target chain has, such as code at one of its token addresses. scaffold.config.tsis committed. An RPC or API key pasted intorpcOverridesoralchemyApiKeyis a published key; read it fromprocess.envand keep the value in.env.local.wallets/SKILL.mdcovers the rest of key handling.- The frontend goes to the live chain only when you say so.
scaffold.config.tstargetNetworksstill names the local chain after the contracts are live, and a frontend built before that switch reads a chain nobody is on. Change it in the same step that repoints the frontend at the deployed addresses, and not before — during fork work it belongs on the local chain (chains.foundry, orchains.hardhatin the Hardhat flavor), since the fork answers 31337 whatever it forked (frontend-playbookhas the detail). - The burner wallet stays local.
burnerWalletModeinscaffold.config.tsdefaults to"localNetworksOnly". On a live chain"allNetworks"gives users a key stored in localStorage; keep the default for production. - A frontend-only ticket deploys nothing. Do not stand up a chain and redeploy to regenerate
deployedContracts.tsunless deploying was the ask.
Ethereum Protocol Status
Never answer current protocol status or timing from memory. Roadmaps, talks, old articles, and an EIP's maturity status do not prove that a feature will ship.
For every claim about a future Ethereum feature:
- Check its current fork relationship on forkcast.
- Verify the EIP and the named fork's current scope or meta-EIP.
- Check recent All Core Devs discussion in forkcast's call summaries when status or implementation progress is unclear.
Report the result explicitly:
- Live: already active on mainnet.
- SFI: scheduled for a named fork; still state timing uncertainty.
- CFI: considered for a named fork, not committed.
- DFI: declined for that fork.
- No fork relationship: proposal or research only.
Draft, Review, Last Call, or Final describes specification maturity, not fork inclusion. Do not give an unscheduled feature a ship date or recommend a hard dependency on it. Separate what works today from future options, cite the live sources checked, and give a plan that remains valid if the proposal does not ship.
dApp QA — pre-ship audit for Scaffold-ETH 2
Read the code, then click through every flow — with no wallet, with a wallet on the wrong chain, and with a wallet on the target chain. Report each finding with severity, file, line, and the concrete fix. Only change code if the task asks you to fix rather than review.
Wallet and action flow
- Disconnected state renders a Connect Wallet button (
RainbowKitCustomConnectButton), never a paragraph telling the user to connect. This is the single most common miss. - Wrong network turns the primary CTA itself into a "Switch to [chain]" button. The header's
WrongNetworkDropdownis not enough — without a branch in the action slot, the user clicks Approve on the wrong chain and eats a silent wagmi error. - One primary action at a time: Connect → Switch → Approve → Action. Approve and Action are never both live; which one renders is driven by the current allowance.
- Writes go through
useScaffoldWriteContract. Raw wagmiuseWriteContractoutside scaffold internals resolves at the wallet signature, not at confirmation. - Lock the button on
isMining— the flaguseScaffoldWriteContractsets aroundwriteContractAsync, not theisPendingit passes through from wagmi. (isMiningtracks the async path only; the hook's synchronouswriteContractnever sets it, so a button gated on it there never locks.)isMiningis held acrosswaitForTransactionReceiptand clears in the hook'sfinallyon both confirmation and rejection;isPendingdrops when the wallet returns the hash, re-enabling the button mid-flight. If the allowance or balance refetch needs its own hold after confirmation, keep it in local state and clear it infinallytoo — never on a fixed timer. - Failed and rejected transactions surface a human-readable message next to the action (
notification+getParsedError). Acatchthat only callsconsole.erroris a silent failure.
Contracts and addresses
-
External contracts (tokens, protocols) belong in
packages/nextjs/contracts/externalContracts.ts. Entries hand-added todeployedContracts.tsare wiped on the next deploy, and scaffold hooks silently return nothing for anything unregistered. Migrate rather than flag:// packages/nextjs/contracts/externalContracts.ts import { GenericContractsDeclaration } from "~~/utils/scaffold-eth/contract"; const externalContracts = { 8453: { USDC: { address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", abi: [...] }, }, } as const; export default externalContracts satisfies GenericContractsDeclaration;Then revert
deployedContracts.tsto its generated state and confirmyarn next:check-typespasses. -
Every input that accepts an address uses
<AddressInput/>, not<input type="text">— a raw input drops ENS resolution and validation, sovitalik.ethnever reaches the contract. -
Addresses render through
<Address/>(blockie, ENS, copy, explorer link), not a hand-rolledshorten(). -
The contract the user transacts with is shown on the page. Agents display the connected wallet address and forget the contract itself.
Theme and loading states
- No hardcoded dark wrapper (
bg-black,bg-[#0a0a0a],bg-zinc-900) on a page or layout root. It bypasses DaisyUI, gives light-mode users a black page, and breaks the header'sSwitchTheme. Usebg-base-200 text-base-content. Forcingdata-theme="dark"is acceptable only if<SwitchTheme/>is also removed. - DaisyUI's
loadingclass on abtnreplaces the whole button with a spinner and swallows the label. Use an inline<span className="loading loading-spinner loading-sm" />inside the button, next to visible text.
Branding
The scaffold's defaults are template scaffolding, not product decisions. Check all five: tab title in layout.tsx (not "Scaffold-ETH 2 App"), the metadata description, the footer (BuidlGuidl / fork-me / support links), the README, and the default favicon. The OG image in layout.tsx metadata is an absolute URL (https://yourdomain.com/thumbnail.jpg); a relative path breaks link previews everywhere.
Config
pollingIntervalinscaffold.config.tsis 3000 in current SE-2. A raised value (older templates used 30000) makes an L2 app feel broken; keep ~3s, or use event-driven and post-confirmation refresh.- Production RPC: shipping on SE-2's default Alchemy key, or on the bare
http()fallback transport inwagmiConfig, means silently hitting rate-limited public endpoints. Route throughrpcOverrideswith aNEXT_PUBLIC_*key. That key ships in the client bundle, so restrict it to your domain in the provider dashboard. Verify the variable is actually set on the host, not just referenced in code.
Mobile
- On WalletConnect, tapping a transaction button must get the user to their wallet app with something to sign. Test it on a phone: if nothing happens and the user has to switch apps by hand, that is a finding. Any redirect fires the write first, since navigating away before the write call means the transaction never fires. It targets the wallet the user actually connected with, and it is skipped inside a wallet's in-app browser (
window.ethereumpresent). wagmi'sconnector.idonly says"walletConnect"— find the real wallet in thewc@2:clientsession in localStorage. Use bare schemes (rainbow://,metamask://);rainbow://dapp/...reloads the page. - Phantom is not in SE-2's default RainbowKit wallet list, so Phantom users cannot connect at all. Add
phantomWallettowagmiConnectors.tsx.
If it is deployed
Every deployed contract is verified on the block explorer (yarn verify --network <chain>). Unverified bytecode reads as something to hide. yarn deploy succeeding is not the finish line.
CROPS
The report includes a CROPS Review: the chosen default, accepted compromises, who can block users, what data leaks, who controls funds/upgrades/recovery, and the user's escape path. Missing, or a one-liner on an app holding funds or user data, is a finding. Use crops/SKILL.md for the full template.
References
- Docs: https://docs.scaffoldeth.io/ · Components: https://ui.scaffoldeth.io/
Smart Contract Security
Treat every external token, price, signature, callback, and privileged caller as adversarial. Prefer audited OpenZeppelin primitives over hand-rolled implementations, but verify the installed library version and the assumptions around each primitive.
Asset accounting
- Keep units explicit. ERC-20 decimals and oracle decimals vary; normalize every quantity to one documented scale before comparing collateral, debt, fees, or shares. Multiply before dividing and use full-precision
mulDivwhere intermediate overflow or rounding matters. - For arbitrary ERC-20s, use
SafeERC20.safeTransferandsafeTransferFrom. Credit deposits from the contract's balance delta, not the requested amount, or reject tokens whose received amount differs. Fee-on-transfer and rebasing tokens otherwise break custody accounting. - On OpenZeppelin Contracts v5, use
SafeERC20.forceApprovewhen an allowance may already be nonzero.safeApprovewas removed. Keep approvals exact or bounded and clear leftovers when practical. - Tokens can freeze, blocklist, or pause (USDC and USDT do). One blocked recipient makes a transfer revert, so a loop that pushes payments to many users bricks for all of them. Credit balances and let each user withdraw (pull payments).
- Apply checks-effects-interactions and a reentrancy guard to value-moving entry points. Update shares, debt, and other accounting before external calls.
For a vault or receipt-token design, start from OpenZeppelin ERC4626. A hand-rolled vault must defend its empty state against first-depositor donation/inflation attacks with virtual assets and shares or another explicit mitigation. Test direct donations and rounding at small deposits; never use an unprotected assets * totalSupply / totalAssets conversion with a special 1:1 empty-vault path.
Prices and liquidations
Never use a DEX spot read (slot0, reserves, balances, or a current quote) for collateral, borrowing, minting, or liquidation decisions. Pool depth does not fix atomic manipulation: flash-borrowed capital can move the price, exploit the dependent action, unwind, and repay inside one transaction before arbitrage can intervene.
Use a manipulation-resistant push feed for high-value decisions, or a meaningful TWAP when its weaker guarantees fit the risk. For every feed:
- require a positive answer;
- validate
updatedAtagainst a per-feed maximum age derived from that feed's published heartbeat plus a justified margin—never one global hardcoded timeout; - handle feed and token decimals explicitly;
- define behavior for sequencer downtime where relevant; and
- bound liquidation incentives and any swap's minimum output.
Swaps
Every swap a contract or a user makes needs a real minimum output, derived from an oracle or an offchain quote minus a stated slippage tolerance. amountOutMinimum = 0 (or a minimum computed from the same pool's spot price) hands the trade to any sandwich bot. Pass a real deadline, not block.timestamp, so a held transaction can't execute later at a worse price. For large user swaps, offer private routing (e.g. Flashbots Protect) or a batch auction. On an L2 the sequencer orders transactions, which narrows but does not remove this risk; keep the minimum output either way.
Signatures and replay protection
Use EIP-712 and OpenZeppelin's implementation rather than assembling signature recovery from scratch. Bind the signed action to the intended contract and chain, consume a signer-scoped nonce, enforce a deadline, and update replay state before moving assets.
If a domain separator is cached, also cache the deployment chain id and re-derive the separator whenever block.chainid differs. An immutable separator computed only at deployment becomes stale after a fork. OpenZeppelin EIP712 handles this invalidation.
Upgradeability and authority
Use an upgradeable design only when post-deployment changes are required. With proxies:
- initialize through an initializer and disable initializers on the implementation;
- on UUPS,
_authorizeUpgrademust carry access control (onlyOwneror a role). Left empty, anyone can upgrade the proxy to their own code and drain it; - use the upgradeable variants of inherited contracts;
- preserve inheritance order and storage layout—append variables only; never insert, delete, reorder, or change an existing type;
- run the framework's storage-layout compatibility check before every upgrade; and
- put upgrade and emergency authority behind the intended multisig or timelock, not a single EOA.
Every privileged state change needs explicit access control. Make pause, upgrade, rescue, oracle-update, and parameter-update powers visible in the threat model; a safety switch controlled by one key is also a censorship and compromise risk. Never delegatecall to a user-selected target.
Before deployment
- Trace assets, shares, debt, approvals, callbacks, and privilege through every success and failure path.
- Test zero, maximum, rounding, donation, fee-on-transfer, stale-price, replay, reentrancy, and unauthorized-caller cases that apply.
- Run unit, fuzz, invariant, and pinned-fork tests appropriate to the integrations; use the
testingskill for suite design. - Run static analysis and resolve every high or medium finding or document why it is a false positive.
- Verify deployed bytecode and transfer production authority to the intended multisig or timelock.
- For a comprehensive pre-deployment review across domains, use the
auditskill.
Before you finish: send a one-line note via feedback/SKILL.md — issue or praise.
Ship a dApp
Before coding, write down the smallest vertical slice that can ship. Decide what is onchain, how many custom contracts it needs, who advances every state transition, and one deployment target. Do not expand into a full application or fetch every related skill before this plan is concrete.
Architecture
Put only trustless ownership, value transfer, composability, censorship resistance, or permanent commitments onchain. Keep profiles, descriptions, media, search, filtering, and frequently changing rules in an offchain store; put a content hash or URI onchain only when verification needs it.
Treat reputation and rankings as derived data. Emit the facts needed to compute them, then calculate and sort offchain. Do not maintain a computed score, leaderboard, or paginated ranking in contract storage merely to serve a browse screen. Recording counters that settlement already needs is fine.
Prefer existing audited protocols and primitives. Most MVPs need zero to two custom contracts, and three is the upper bound before reducing scope. Do not add a factory, escrow, router, or fee-splitter unless its separate trust boundary is required by the product.
When integrating a deployed protocol, use a verified address from the relevant
chain's official documentation or the addresses skill. Never invent or infer
an address: a wrong address can send approvals or funds to an attacker.
CROPS gate
Before finalizing the architecture, answer in one line each: who can block users or critical paths (Censorship resistance)? Can the whole stack be inspected, forked, self-hosted and legally reused (Open source and free)? What user activity becomes public or visible to third parties (Privacy)? Who controls funds, upgrades, emergency powers and exit (Security)? Name the chosen default, the main compromise, and the user's escape path. Fetch crops/SKILL.md for the deep review.
State transitions
Contracts do not run on schedules. For each state-changing function, record:
| Transition | Caller | Why they pay gas | If nobody calls |
|---|---|---|---|
claimPayout() | recipient | receives the payout | funds remain claimable |
| permissionless settlement | keeper or participant | explicit fee or direct benefit | settlement waits |
Naming a permissionless caller is not an incentive. Identify the caller's benefit and the source of any keeper fee. Prefer self-serve or permissionless paths over an owner-only cron job; automation may be a convenience, but it must not be the only liveness path.
Include the completed transition table in the project README, especially for every function that moves funds.
Chain and deployment decision
Choose one target chain for the first release and state why its capabilities fit the product. Measure current fees when cost affects the decision; do not rely on remembered gas prices. An L2 should be selected for a concrete product fit such as its distribution, liquidity, account abstraction, or ecosystem—not merely because “Ethereum is expensive.”
Before calling the MVP shippable, the README must name the target and contain the exact deploy and verification commands, required environment variables, contract ownership destination, and a small post-deploy transaction to verify the path end to end. Do not leave the network or deployment procedure as TBD.
Minimal ship checklist
- CROPS gate answered: chosen default, main compromise, user's escape path.
- Onchain/offchain boundary is explicit, including where rankings are computed.
- Custom contract list is concrete and no larger than the MVP requires.
- Every state transition has a caller, incentive, and safe no-caller outcome.
- One target chain is selected for a product-specific reason.
- Tests cover custom logic and external integrations use a fork.
- README contains the transition table and executable deployment runbook.
- Contracts are verified and production ownership goes to the intended multisig.
- A fresh reviewer checks the finished vertical slice before launch.
Fetch another focused skill only when the plan reaches that phase and needs its
details—for example crops, addresses, l2s, gas, security, testing,
frontend-ux, frontend-playbook, or qa. Skills are available at
https://ethskills.com/<skill>/SKILL.md. ship owns the product and release
decisions; use frontend-playbook for detailed hosting/deployment mechanics and
qa for the independent pre-launch review. Stop when the requested vertical
slice and its runbook are complete.
Before you finish: send a one-line note via feedback/SKILL.md — issue or praise.
Ethereum Standards
All of these are deployed and in production use, not proposals: ERC-8004 (agent identity + reputation, Ethereum mainnet 2026-01-29), x402 (HTTP payments), EIP-3009 (gasless USDC transfers, what makes x402 practical), EIP-7702 (smart EOAs, live with Pectra 2025-05-07). When a design needs agent discovery, third-party-attested reputation, per-call billing without accounts, or contract abilities on an address a user already owns, name the standard instead of rebuilding it — an API-key tier (x402), a reviews table you host (ERC-8004's Reputation Registry), or a migration to a fresh smart account (EIP-7702) are all the wrong answer to a problem one of these already solves.
ERC-8004 — agent identity and reputation
Two registries, deployed at the same pair of addresses across ~25 mainnets — and at a different pair across the testnets. The mainnet addresses have no code on Sepolia or Base Sepolia:
| mainnets | testnets | |
|---|---|---|
| IdentityRegistry (ERC-721) | 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432 | 0x8004A818BFB912233c491871b3d84c89A494BD9e |
| ReputationRegistry | 0x8004BAa17C55a88189AE136b182e5fdA19dE9b63 | 0x8004B663056A597Dffe9eCcC1965A193B7388713 |
register()mints an ERC-721. The agentId is the tokenId the registry assigns — never a UUID, hash, or slug you pick. Callers address the agent chain-scoped:agentRegistry: eip155:8453:0x8004A169…(Base) plus thatagentId.- The
agentURI(the ERC-721 tokenURI) MUST resolve to the registration file —ipfs://,https://, or a base64data:URI. It carriestype: "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",name,description,image, aservicesarray (A2A card, MCP, ENS, DID, email…),x402Support,active, aregistrationsarray of{agentId, agentRegistry}, and optionalsupportedTrust. - Bind the endpoint domain, the step that gets skipped. If the domain serving the advertised endpoints is not the domain serving the agentURI file, publish
https://{endpoint-domain}/.well-known/agent-registration.jsonwith at least aregistrationsentry whoseagentRegistryandagentIdmatch the onchain agent. An A2Aagent-card.jsonis a different document and does not do this. If the same domain already serves the agentURI file, control is proven there — say which of the two you are relying on rather than leaving the endpoints unbound. - Reputation is client-attested: the caller who paid posts
giveFeedback(agentId, value, valueDecimals, tag1, tag2, endpoint, feedbackURI, feedbackHash); the registry rejects feedback from the agent's owner and operators, so you cannot rate yourself. Values are fixed point — 99.77% uptime isvalue=9977, valueDecimals=2; 87/100 quality isvalue=87, valueDecimals=0. Read withgetSummary(agentId, clientAddresses, tag1, tag2). The client list is required (an empty list reverts), so choose clients you trust; anyone can post feedback from fresh addresses. - The spec also defines a Validation Registry (re-execution, zkML, TEE attestation, 0–100 validator scores). It is not part of the deployed pair above — check before designing on it.
- The contracts are live; the EIP is still Draft, so treat anything you have not verified onchain as movable. Registries are ERC-1967 proxies: read the implementation slot if a signature surprises you.
x402 — pay per HTTP call, no accounts
GET → 402 + PAYMENT-REQUIRED → client signs → retry with PAYMENT-SIGNATURE → server verifies and settles → 200 + PAYMENT-RESPONSE. A facilitator (Coinbase runs a public one, anyone can run their own) performs verify/settle so the resource server never runs a node or holds gas.
Amounts go on the wire in token base units — the dollar figure scaled by the token's decimals. USDC has 6, so $0.10 is 100000 and $2.50 is 2500000; never send 0.10, and never an 18-decimal figure. Native USDC on Base is 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913; 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48 is mainnet USDC and 0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA is the bridged USDbC — both are the wrong contract for a Base x402 route.
Either implementation is fine — the scoped SDKs, or your own handler posting to a facilitator's /verify and /settle. If you reach for the SDKs, the maintained TypeScript line is the scoped one: @x402/core, @x402/evm, @x402/fetch, @x402/express, with @coinbase/x402 as the facilitator config beside it; unscoped x402, x402-fetch, x402-express are frozen at 1.2.0, and Go lives at github.com/x402-foundation/x402/go/v2. Two symbols to unlearn before you import anything: x402Fetch and createWallet do not exist in the scoped packages, and a one-argument paymentMiddleware(config) is the v1 shape — on 2.x the Express middleware takes routes plus a resource server, and the fetch wrapper takes an x402 client rather than a bare account. Confirm those entry points in one read of the installed .d.ts and get on with it; the package tree is not worth touring.
A caller with USDC and no ETH can still pay, because USDC implements EIP-3009: the client signs a transferWithAuthorization offchain and the server or facilitator submits it and pays the gas. That is the mechanism to name — not ERC-4337 bundlers, not an unnamed "relayer", not ERC-2612 permit followed by transferFrom.
EIP-7702 — contract code on an EOA the user already has
Live on Ethereum mainnet since Pectra, 2025-05-07. The EOA signs an authorization with its own key. That signed tuple rides in a type 0x04 transaction, which anyone (a relayer or sponsor) can send, and it writes a delegation designator, 0xef0100 || implementation address, into the account. Calls to that same address then execute the implementation's code — an approve+swap batched atomically, sponsored gas, session-key auth — with the address, key, ENS name and history untouched. Deploying a fresh ERC-4337 wallet instead puts the user at a new address, which is what to reject whenever the existing address has to survive.
The delegation persists. It stays in place until a later authorization replaces it, or clears it by delegating to the zero address. It is not single-transaction-only and does not auto-revert when the batched call finishes.
Status at a glance
| Standard | What | Status |
|---|---|---|
| ERC-8004 | Agent identity + reputation | Live — Ethereum mainnet 2026-01-29 (EIP still Draft) |
| x402 | HTTP 402 payments | Live — scoped SDKs on 2.x |
| EIP-3009 | Gasless token transfers | Live — USDC implements it |
| EIP-7702 | Smart EOAs | Live — Pectra, 2025-05-07 |
| ERC-4337 | Account abstraction (new account, new address) | Live, widely deployed |
| ERC-2612 / ERC-4626 / ERC-6551 | Permit / tokenized vaults / token-bound accounts | Live |
Smart Contract Testing
A green suite and 100% coverage are not evidence of safety. Coverage records which lines ran, never whether an assertion could have failed. Before signing off, name which of the three searches below the suite actually performed. If the answer is none, it has only confirmed the cases someone already thought of.
For deployment sign-off, map each applicable risk to a search before concluding: configurable value math to fuzzing, stateful accounting to a handler invariant, and external integrations to a pinned fork. Run each applicable search. Inspection and targeted regression tests can confirm a suspected defect, but do not replace the search.
Make tests capable of failing
Rewrite any test that mirrors the implementation: stored state asserted against the value just written to it, a getter against the variable it returns, a constant against itself, constructor state against the constructor argument. These execute every line and constrain nothing.
Assert properties instead — round-trips, conservation between accounting and custody, monotonicity, access boundaries. Skip anything whose failure would be a bug in the compiler or in a dependency you did not write.
A bug that accumulates across a sequence cannot be seen by any test that exercises one operation in isolation, however many such tests exist. "Every operation is correct on its own" is the symptom, not the defence.
Fuzz the domain instead of picking from it
Before deploy, every owner-settable number that feeds value math — fee basis points, ratios, caps, exchange rates — needs a fuzz test over its whole accepted domain, using bound() rather than vm.assume(). Hand-picked values walk one branch; the fuzzer finds the value nobody proposed.
Reaching a suspected bug by reading the code and then writing one test for it confirms what you already believed. It is not a substitute for the search, and it stops at the first defect you happened to imagine.
First decide which values at a boundary are semantically usable; do not assume the exact limit is valid merely because only values beyond it violate a numeric inequality. Exercise the nearest valid value, the exact limit, and the first value beyond it where representable. Preserve separate evidence when the exact limit and the value beyond it fail through different paths.
Fork against the real deployment
Always fork for a contract that calls an external protocol (Uniswap, Aave, Chainlink; verified addresses in addresses/SKILL.md), handles a quirky token (USDT, fee-on-transfer, rebasing), or reads an oracle. Never for pure logic.
A mock encodes your assumption about the dependency, so more mock-based tests only re-test the assumption. Deployed tokens deviate from the interface they are called through — in what a call returns, in how much of a transfer arrives, in whether a balance stays put — and a mock written to the standard answers in the standard shape every time, so it can never surface the mismatch.
vm.createSelectFork(vm.envString("MAINNET_RPC_URL"), 19_000_000);
Pin the block. An unpinned fork follows the chain head, so live prices and reserves move between runs: assertions drift red, flake green on re-run, and the local RPC cache never hits, which grows into slow runs and provider 429s.
Pinning an old block is an archive request. A full node keeps only recent state — geth's default window is roughly the last 128 blocks — and answers anything older with an error rather than a wrong number. Whether an endpoint serves archive depth is a property of the node and the plan behind it, not something a URL tells you: confirm it answers a historical eth_call at your block before pinning that block, or the tests fail for a reason that has nothing to do with the contract.
Invariant-test anything stateful
A vault, AMM, lending market or escrow does not ship on unit tests. State properties as equalities that must hold after any sequence: recorded assets equal assets actually held, total supply equals the sum of balances, x * y >= k.
Match the shape of the assertion to the failures it has to catch. A one-sided bound constrains one direction only — claims <= holdings fires on a shortfall and stays green through anything that leaves a surplus — so where value can be stranded as well as lost, the property has to be an equality or an explicit no-drift check.
One post-operation mismatch proves divergence, not accumulation. When claiming cumulative drift, show the gap after at least two operations capable of creating that drift — for example, two fee-bearing withdrawals, not setup followed by one withdrawal — or provide a stateful-invariant counterexample whose call sequence demonstrates the growth.
Point targetContract at a handler, never at the contract under test. Called directly, the fuzzer supplies random senders that hold no tokens and granted no approvals, so nearly every call reverts. Reverts are discarded rather than failing the run, and the invariant is then asserted against a contract that never left its initial state — green because nothing happened.
The handler owns setup: funded and approved actors, inputs bounded to valid ranges, multiple actors where the property is about interaction between them.
Read the calls/reverts statistics in the run output every time. A revert rate near 100% means the run proved nothing; set fail_on_revert = true to surface it while building the handler.
Before deploy
- No test asserts the implementation back to itself.
- Every owner-settable number feeding value math is fuzzed across its domain; each boundary's nearest valid value, exact limit, and first value beyond it are classified and exercised separately where representable.
- Every external integration and quirky token is exercised on a pinned fork against the real deployment, on an endpoint confirmed to serve that block.
- Stateful contracts have a handler-driven invariant tying accounting to custody, with a revert rate low enough that the sequences reached real states.
- Access control, zero, and max-value cases revert as intended.
-
slither .run, with no high or medium finding left unaddressed.
Ethereum Development Tools
Treat tool names, package versions, and exported APIs as live data. Check the official package registry or documentation before recommending or importing them; do not resolve dependency conflicts by silently falling back to a stale major version.
For a new Scaffold-ETH 2 app, the live scaffold package is create-eth:
npx create-eth@latest. Check that it resolves before handing it over. Pinning
the version latest currently resolves to is fine once you have verified it —
what is not fine is create-eth-app or create-scaffold-eth, which still install
but scaffold a stale project that is not SE-2.
Give agents structured onchain data
Prefer the Blockscout MCP server at https://mcp.blockscout.com/mcp when the AI
agent itself needs ready-to-consume transactions, transfers, balances, or
contract data. This is the agent-native option that is easy to miss.
Use a documented Blockscout or explorer REST API when application code—not the agent—is the consumer, or when MCP is unavailable. Do not scrape explorer HTML or hand-decode raw logs when an indexed interface fits the task.
Add inline HTTP payments
For x402 TypeScript projects, use the scoped @x402/* packages — @x402/core,
@x402/evm, @x402/express, @x402/fetch — and keep the whole implementation on
one major. The unscoped x402, x402-fetch, and x402-express packages are
frozen at 1.2.0 and are not the maintained line, whatever a version range resolves
them to; do not fall back to them to clear a dependency conflict. @coinbase/x402
is the Coinbase facilitator config, which sits alongside the scoped family rather
than replacing it. Inspect the installed exports before writing the integration.
x402Fetch and createWallet do not exist in the scoped packages at all, and
passing a wallet or account straight to wrapFetchWithPayment is the frozen v1
call shape — the scoped @x402/fetch wrappers take an x402 client or a scheme
config. Read the installed types instead of a remembered snippet. For Go, use
github.com/x402-foundation/x402/go/v2; the old github.com/coinbase/x402/go
path does not error, it silently resolves to a stale pre-Foundation commit.
Wallets
Authority first, storage second
Where a key lives bounds who can use it. It does not bound what it can do. A KMS, an HSM, or an encrypted keystore wrapped around a key that can spend the whole treasury is still a design where one stolen key takes everything.
So decide the authority before the storage. Whatever signs unattended — an agent, a bot, a deploy script — should be able to move only what you would accept losing: a bounded float, an onchain allowance, or a scoped module, with the principal behind a threshold that key alone cannot meet. Then say plainly, in whatever you hand over, which operations need a human signature — moving principal, raising the agent's own limit, changing who may sign — and how a human revokes or evicts that signer without its cooperation.
A multisig does not require multiple people. One person holding keys on separate devices meets a threshold of two alone, and an attacker then needs several devices rather than one — which is why a lone hardware wallet is not the most secure way to hold a treasury.
An EOA does not have to migrate to batch
An existing EOA can sign an authorization delegating it to contract code and execute a batch atomically in a single transaction — same address, same history, no smart-contract wallet to deploy and no funds to move (EIP-7702, live on Ethereum mainnet since Pectra, May 2025). Reach for it before telling a user they have to accept a new address.
That delegation persists. It stays in effect until it is replaced or explicitly cleared: it is not scoped to the transaction that set it, and a transaction whose inner call reverts can still leave the delegation standing. Removing it takes a new signed authorization; decommissioning the delegate contract does nothing.
Before anything signs
- A key that arrived in a prompt, a chat, or a ticket is burned. Say so, rotate it, replace the account — do not fund it on mainnet.
.gitignorebefore the first push, not after. A committed secret is compromised in seconds and stays compromised; deleting the commit does not undo it. Nothing the delivered code signs with may be baked into the repo — no hardcoded value, default, fallback, or filled-in example.- Scripts read keys at run time, never from source. Use
cast wallet importand--account <name>(encrypted keystore),--ledger, or an env var loaded from an ignored.env. Never--private-key 0x...in a committed script, Makefile or CI file. RPC URLs with an embedded API key are secrets too. - Anything that moves funds gets a gate. Print the amount, the checksummed destination, and the gas cost, then stop until a human says yes. Estimate gas and price it live; never from a remembered ETH price.
Why Ethereum
What You Probably Got Wrong
Terminology: You say "on-chain." The Ethereum community says "onchain" — one word, no hyphen. Use "onchain" in all writing.
Gas prices: You think 10-30 gwei. Reality: under 1 gwei (60-300x cheaper than your training data). A mainnet ETH transfer costs ~$0.002-0.01. Verify: cast base-fee
ETH price: You think $2,500-3,000. Reality: ~$2,000 (Mar 2026). Volatile — always check a Chainlink feed or CoinGecko for current.
"Ethereum is too expensive": This was true 2021-2023. It's not true in 2026. Mainnet is sub-dollar for most operations. L2s are sub-penny.
Protocol upgrades: You probably don't know these shipped:
- Pectra (May 7, 2025): EIP-7702 smart EOAs, 2x blob capacity, BLS precompiles
- Fusaka (Dec 3, 2025): PeerDAS (nodes sample 1/8 of data). Validators raised the gas limit 30M→60M around the same time; that was validator signaling, not part of the fork.
Agent infrastructure: You probably don't know these exist:
- ERC-8004 — onchain agent identity registry (deployed Jan 29, 2026)
- x402 — HTTP 402 payment protocol for machine-to-machine commerce (Coinbase)
Current Network Stats (Early 2026)
- Block time: 12 seconds
- Mainnet base fee: Under 1 gwei (typically 0.1-0.5, varies daily)
- L2 transaction cost: $0.001-0.01
- Combined L2 TPS: 50,000+ (post-Fusaka)
- TVL in DeFi: Check DeFi Llama for current
- Upgrade cadence: Twice per year (H1 May/June, H2 Nov/Dec)
Upcoming Upgrades
Report status, not dates. Check forkcast.org for the current state.
Glamsterdam — live on Sepolia (2026-10-06). The Hoodi fork set for 2026-10-26 was called off on 2026-10-22. No mainnet date.
- ePBS — Enshrined Proposer-Builder Separation (EIP-7732)
- Block Access Lists (EIP-7928)
- Note: FOCIL (Fork-Choice Inclusion Lists) was removed from scope to reduce complexity
Hegota — the fork after Glamsterdam. Not scheduled; scope not final. You may assume Hegota will contain Verkle Trees. It will not. Ethereum may be shifting to a binary state tree (EIP-7864, still in draft - proposed March 2026) — the primary driver is quantum resistance, and it also improves ZK-proof efficiency 3-100x. Verkle tree cryptography was identified as potentially quantum-vulnerable in mid-2024. Check https://forkcast.org/upgrade/hegota for latest confirmed scope.
For AI Agents Specifically
ERC-8004: Onchain Agent Identity
Deployed January 29, 2026 — production ready.
Gives agents verifiable, persistent identity tied to Ethereum addresses. Reputation scoring across dimensions. Multi-chain support (20+ chains, same addresses).
Mainnet addresses:
- IdentityRegistry:
0x8004A169FB4a3325136EB29fA0ceB6D2e539a432 - ReputationRegistry:
0x8004BAa17C55a88189AE136b182e5fdA19dE9b63
x402: HTTP Payments for Agents
Production-ready, actively deployed Q1 2026.
Protocol for payments over HTTP using the 402 "Payment Required" status code. Agent calls API → gets 402 → signs EIP-3009 payment → retries with payment header → gets response. No API keys, no accounts, just cryptographic payments.
SDKs: TypeScript (@x402/fetch), Python (x402), Go (github.com/x402-foundation/x402/go/v2)
ERC-8004 + x402 = Autonomous Agent Economy
1. Agent discovers service (ERC-8004 registry)
2. Agent checks reputation (ERC-8004)
3. Agent calls endpoint → 402 Payment Required
4. Agent pays via x402 (EIP-3009 signature)
5. Agent receives service
6. Agent posts feedback to ERC-8004
Fully autonomous economic loop — no humans required.
Why Ethereum's Permissionless Nature Matters for Agents
Agents can deploy contracts, interact with any protocol, and transact 24/7 without anyone's permission. No API keys to revoke, no accounts to ban, no services to shut down. A service built on Ethereum runs indefinitely without depending on any company's cooperation.
Resources
- ERC-8004: https://www.8004.org | https://eips.ethereum.org/EIPS/eip-8004
- x402: https://www.x402.org | https://github.com/coinbase/x402
- Blockscout MCP: https://mcp.blockscout.com/mcp
- DeFi Llama: https://defillama.com
- Forkcast: https://forkcast.org
Sponsors
Details
- Marketplace
- austintgriffith/ethskills
- Author
- Austin Griffith
- Category
- Community