Introducing Eureka Labs: A New Execution Environment for Ethereum
Ethereum is the world’s most powerful financial computer.
Today it still feels like we’re trying to run a modern trading firm over a dial-up line.
High gas, stale data, and the chaos of mem-pool ordering force teams to simplify what should be sophisticated strategies. That’s not an inevitability - it’s an artifact of treating blocks as passive containers instead of as the programmable surfaces they can be.
Eureka Labs is building the new rules of on-chain execution.
We are not tuning or optimizing old primitives. We are reimagining the block, turning it into a programmable execution environment where capital, computation, external context and deterministic control are first-class, block-time primitives.
This is not incremental. It is a leap: the block becomes a high-performance workspace where your code finally gets the tools it needs to run at full power.
So, what is it that we’re building?
The four primitives - a single, unified workspace
In short: Intra-Block Loans, Builder Execution Extension (BEX), Builder Execution Oracle, and Deterministic Block Placement.
Alone, each is powerful. Together, they let a single bundle borrow capital, run large searches against live mid-block state, resolve external context, and land exactly where it must - all inside the same block.
Intra-Block Loans
Uncollateralized capital for the duration of a block.
Flash loans made borrowing atomic. They did not make capital mobile across the block. Intra-Block Loans change that. A builder can lend assets at the start of a bundle, your strategy can use them across multiple transactions in the same block, and repayment is enforced at sequencing time - if repayment fails, the builder simply excludes the bundle.
Why this matters: capital that used to sit idle becomes instantly productive and precisely timed. No upfront inventory. No permanent exposure. Just the power to borrow exactly when and where it’s useful.
Concrete example: imagine $10M of ETH/USDC liquidity idle in a Uniswap v2 pool while a large swap will hit a v3 pool later in the same block. With Intra-Block Loans you can borrow that capital, insert it into the v3 pool immediately before the swap to capture fees, then unwind and repay - all inside one block. Capital stops being static; it becomes responsive.
Builder Execution Extension (BEX)
Heavy computation at block time, minimal execution on-chain.
On-chain, brute force is expensive. Off-chain, state drifts. BEX solves both problems by splitting strategies into preCompute() and execute(output). During block construction the builder runs the heavy preCompute() against the exact mid-block state, returns a compact ABI result, and the chain then executes only the minimal execute(output) step.
But there’s something much bigger here. Today a typical Ethereum block exposes on the order of 60 million gas. The Ethereum Foundation’s roadmap contemplates blocks on the order of ~1 billion gas. BEX changes the unit of account: by doing the exploration inside the builder’s simulation environment we enable effective, bounded compute budgets at orders of magnitude beyond on-chain gas limits. Think tera-scale compute (≈10¹² gas-equivalent) available to the builder during construction. That’s roughly 1,000× the Foundation’s 1-Giga target and ~16,000× today’s blocks in effective compute power. In plain terms: searches and numerical work that would take years of on-chain innovation become practical now.
We’re front-running the Ethereum Foundation roadmap.
The Ethereum Foundation talks about expanding today’s 60M-gas block toward 1 Giga-gas by 2029. Eureka is front-running that roadmap: by moving expensive search into builder-side simulation we enable the effective capacity to run multiple 100-Giga-gas computations during block construction and settle only the winning result - TODAY
Concrete example: end-of-block DEX rebalancing. The builder evaluates thousands of multi-hop permutations after earlier trades, finds the optimal rebalancing set and sizes, and the chain executes only the final trades. The chain never pays for the losing alternatives.
Builder Execution Oracle
The right off-chain data at the exact moment it matters.
A recurring failure mode is stale context: you fetch a price, assemble a transaction, and by the time it lands the world has moved. The Builder Execution Oracle eliminates that desynchronization. During block construction the builder can query live external sources - CEX prices, RFQ quotes, cross-chain state, secure randomness, or heavy off-chain models - and inject the results deterministically into the execute leg.
Why this matters: execution is no longer blind to the world outside the EVM. You get fresh external context at settlement time, while maintaining on-chain invariants and safety checks.
Examples:
Secure randomness injected deterministically for auctions and games.
CEX vs DEX price comparisons resolved at block time and then settled atomically.
Off-chain risk or derivative pricing models feeding final execution parameters.
Deterministic Block Placement
Execute where it actually matters.
Many strategies don’t fail because the logic is wrong - they fail because they landed in the wrong spot. Today ordering is a probabilistic, adversarial race in the mempool. Deterministic Block Placement removes that uncertainty: a bundle can declare the addresses or state transitions it depends on (watchedAddresses) and the builder will place the bundle only after those touches have occurred during block construction.
Why this matters: no more mempool lottery. Arbitrage, liquidations, settlements and maintenance routines can now rely on precise, predictable placement instead of hope or overpayment.
Concrete example: Run an arbitrage only after a specific pool reserve update and an oracle change in the same block - the builder ensures the bundle runs in that exact state context, or not at all.
The Bigger Picture
Each of these primitives is powerful alone, but together they represent a paradigm shift. A single strategy can now borrow capital, run complex state-aware computations, pull in real-time external data, and execute at a precise position
all within one block.
At this point, the block stops being just a list of transactions. It becomes a programmable execution environment that finally matches the sophistication of the minds building on Ethereum.
Why this is huge & why now
Each primitive is important. Together they change the unit of on-chain programming. No longer is a block a passive ledger; it becomes an execution surface that can host coordinated capital, computation and context within a single atomic window.
Put simply: we are delivering builder-layer capabilities the Ethereum Foundation suggested would materialize years from now. We are doing today what many expected would take another three years. That’s not hyperbole - it’s the pace at which infrastructure can change markets.
The payoff:
Capital becomes programmable
Computation becomes practical
External context becomes fresh
Ordering becomes deterministic
Together those capabilities unlock entirely new classes of DeFi, trading systems, and on-chain financial products that weren’t practical before.
Ready to build with us? Get in touch.