Hegotá Is Coming: The Ethereum Upgrade Wallets and DeFi Devs Can’t Ignore

Glamsterdam was about making Ethereum faster. Hegotá is about making it harder to push you around.

The short version

Hegotá is where Ethereum stops only chasing TPS headlines and starts putting real weight behind fair inclusion and accounts that can think for themselves. FOCIL and Frame Transactions are the scheduled stars. Scope can still wiggle. The builder agenda cannot: measure inclusion, modernize wallet tx handling, and keep pressure-testing on live testnets.

If you would rather spend that energy on product instead of node babysitting, wire Ethereum through Tatum’s RPC Gateway, Data API, WebSockets, and Notifications. Same path as Hegotá client releases land. Fewer 3am Discord scrolls.

If you build wallets, DeFi, privacy flows, or anything that lives or dies by transaction inclusion, this is the fork that actually changes your product story. Not another “gas got slightly cheaper” release. The two scheduled headliners, FOCIL and Frame Transactions, hit censorship resistance and account UX at the protocol layer.

Mainnet is still penciled in for Q2 2027. Specs can still move. That is exactly why the teams that win this cycle start measuring, testing, and shipping around Hegotá now, not the week Sepolia forks.

So… what is Hegotá, really?

Hegotá (also written Hegota) is the Ethereum upgrade after Glamsterdam. Same naming ritual as usual: Bogotá for the execution layer, Heze for consensus. Stick them together and you get Hegotá.

Per ethereum.org, the network is still in planning:

• Q2 2027 expected mainnet window (not locked)
• Sepolia forks first once client teams pick dates
• Hoodi and mainnet follow after that

Only two EIPs are Scheduled for Inclusion right now: EIP-7805 (FOCIL) and EIP-8141 (Frame Transactions). Everything else is still in the argument phase. Treat SFI as “these are the must-ships,” not “the PDF is frozen forever.”

Click the rows: Hegotá vs the upgrades you already shipped through

Scroll fatigue is real, so here is the cheat sheet as an interactive table. Tap a filter, click a row, get the punchline.

Glamsterdam widens the highway. Hegotá decides who gets to force a car into traffic. That combo is why this fork feels different if you actually ship user-facing crypto products.

FOCIL: the “you can’t ghost my transaction” upgrade

Right now, a small club of block builders has a lot of say over what lands on chain. Pay enough attention (or ignore the wrong people) and a perfectly valid transaction can sit in limbo.

Users “solve” that by waiting, overpaying, or hopping into private order flow. That is not exactly the cypherpunk brochure.

FOCIL (Fork-choice enforced Inclusion Lists, EIP-7805) spreads that power. A committee of validators publishes inclusion lists. The fork-choice rules expect builders to honor them. Ignore the lists and your block gets a lot less love from attesters, which means it is a lot less likely to become canonical.

Your Solidity probably does not need a rewrite. Your product narrative might:

• Wallets and relays can stop treating inclusion as pure vibes
• Privacy apps get a stronger baseline without special-case relays
• RPC and infra teams need clients that speak inclusion-list engine surfaces

If you care about UX during the transition, start tracking pending-to-confirmed timing now. Subscribe to newPendingTransactions over Ethereum WebSockets, and back that up with address-level Notifications so a dropped socket does not mean a missed inclusion. Discovering lag in production is a bad time.

Frame Transactions: accounts that refuse to stay dumb

Ethereum transactions still mostly assume one signature style and one gas payer. Smart accounts paper over that with bundlers, paymasters, and a pile of moving parts. It works. It is also a lot of machinery for something that should feel native.

Frame Transactions (EIP-8141) introduce a new typed transaction, usually discussed as type 0x06. It splits into frames for validation, gas approval, and execution. The account runs its own checks.

That is how you get closer to stuff that feels obvious to users:

• Sponsored gas (yes, even the “I only hold USDC” dream)
• Batching and spending limits
• Multisig-ish flows and social recovery patterns
• Signature schemes that are not stuck on today’s ECDSA forever

The EIP is still a draft. Validation budgets and mempool rules are being debated hard. Build toward the destination, keep your ERC-4337 / EIP-7702 paths as a parachute, and do not bet the company on one gas constant from a Magicians thread.

Who feels it first:

• Wallets: new tx type in signing, simulation, and gas estimation. Hit eth_estimateGas / debug traces on Sepolia while client support lands
• dApps: cleaner sponsored and batched UX once Frames stabilize
• Indexers: fresh decoding work for receipts and mempool shapes. The Data API is how you stay readable while formats shift

And if you write verification logic, treat it like production smart contract code. Attackers certainly will.

How to actually use this (without waiting until 2027)

You do not need mainnet activation to start winning.

If liquidations, oracle updates, bridge escapes, or privacy withdrawals are load-bearing for you, FOCIL is your friend. Start logging submit → first seen → confirmed today so you have a before/after when inclusion lists land.

Then clean up the rest of the stack:

• Mark every flow that still needs a bundler, paymaster, or custom relayer (Frame candidates later)
• Keep ERC-4337 around until Frames look real on public testnets
• Make wallets and SDKs tolerant of unknown typed transactions

Test on the right nets. Sepolia for dApps and contracts. Hoodi for staking and protocol behavior. Holesky is done.

Point Hardhat, Foundry, and CI at Tatum gateway URLs so swapping networks is a config change, not a weekend project. When Frames + FOCIL start reshaping mempool behavior, push events instead of polling. That is literally what WebSockets and webhook Notifications are for.

Pick a lane below. The switchboard shows what breaks first, what to instrument, and which Tatum surface covers it.

How Tatum is preparing (so you don’t have to live in Discord)

Upgrades only feel smooth when infra keeps pace with client releases, testnets, and weird new transaction shapes. That is the boring part of Hegotá, and it is the part we obsess over.

• RPC Gateway stays current on mainnet, Sepolia, and Hoodi, with failover when a node gets weird mid-fork
• Data API keeps wallet history, balances, NFTs, and transfers readable while tx formats evolve
• WebSockets and Notifications cover live inclusion and contract events
• Gateway /llms.txt plus the Tatum MCP Server let coding agents query live Ethereum methods while you prototype

Same API key. Same integration. New client releases underneath. That is the point.

Ethereum endpoints worth bookmarking

You already saw the products inline above. Here are the concrete endpoints when you are ready to plug something in. One Dashboard key unlocks all of it.

RPC Gateway

Daily driver for reads, simulations, gas estimates, and broadcasts. Standard eth_* plus debug and trace when you need to dig. Full method list: Ethereum RPC reference.

• Mainnet: https://ethereum-mainnet.gateway.tatum.io
• Sepolia: https://ethereum-sepolia.gateway.tatum.io
• Hoodi: https://ethereum-hoodi.gateway.tatum.io

Beacon, WebSockets, Data API, Notifications

Beacon REST sits on the same hosts under /eth/v1. Live streams: wss://ethereum-mainnet.gateway.tatum.io and wss://ethereum-sepolia.gateway.tatum.io (WebSocket docs). Indexed portfolios, tokens, NFTs, and history live in the Data API. Backend alerts that survive restarts: Notifications.

Production traffic can add Custom RPC Gateways, routing strategies, Bring Your Own RPC, and PowerUps. Coding agents can poke the same surfaces through the MCP server.

What you can already do

These are shippable today, no Hegotá mainnet required:

• Baseline inclusion latency on mainnet (submit → first seen → confirmed)
• Inventory AA / relay dependencies Frames might simplify later
• Make tx-type handling forward compatible in wallets and indexers
• Point CI at Sepolia and Hoodi through Tatum RPC
• Wire WebSockets + Notifications before fork week becomes pager week

Keep reading EIP-7805 and EIP-8141 until client release notes freeze the behavior. And no, you probably do not need to rewrite production contracts tomorrow. EVM compatibility is still the default. Your product and infra roadmap should still move.

FAQ