GetBlock for GetBlock

Posted on Dec 11 • Originally published at getblock.io

Custom Base op-Erigon Node for AMM Analytics. When Standard Infrastructure Solutions are Not Enough

#web3 #blockchain #go

Most blockchain infrastructure providers offer standard configurations. When a DeFi analytics platform, Revert Finance, needed overlay RPC methods on Base, the capability didn't exist in any production node. They needed a partner who could build custom solutions, not just provision servers.

GetBlock deployed a working solution in under a week.

Why standard RPC infrastructure couldn't work

Revert Finance provides advanced analytics and automation tools for liquidity providers in DeFi, helping them track and optimize their positions across major AMMs, including Uniswap, Pancakeswap, and Sushiswap. By offering real-time insights into yield, fees, rewards, and risks, Revert enables LPs to maximize returns and efficiently manage their DeFi portfolios.

When Revert began integrating Aerodrome, a leading AMM on Base, they hit an unexpected obstacle. They needed additional data points during reward claims and liquidity operations – events that Aerodrome's developers never designed into the original contracts. Standard RPC methods couldn't solve this.

Most Web3 infrastructure needs can be met with reliable RPC services. GetBlock provides full and archive node API access across 100+ blockchains including Base. Browse our supported nodes.

The overlay RPC workaround

Revert's engineering team devised a workaround: use Erigon's overlay RPC namespace to replay historical Aerodrome transactions with modified bytecode that adds the missing event emissions.

The workflow:

Take Aerodrome's contract source code (e.g., CLGauge at 0xF33a96b5932D9E9B9A0eDA447AbD8C9d48d2e0c8)
Add custom event emissions at critical points in the code
Compile the modified contract to get instrumented bytecode
Use overlay_callConstructor to deploy this modified version into a local state overlay
Use overlay_getLogs to replay historical Aerodrome transactions against the instrumented contract and capture the custom events

This approach required an archive Base node with a full historical state running Erigon's op-stack fork with overlays enabled. That's what GetBlock's engineering team stepped in to build.

Production reality check

This combination, the Erigon client with the overlay_* functional on Base, didn't exist in any production infrastructure offering at the time.

While overlay RPC was proven for Ethereum, extending this functionality to op-stack chains was still experimental. The op-erigon community fork maintained by Sunnyside Labs had the code theoretically in place.

When testing op-erigon's overlay methods for production use, we discovered edge cases that needed resolution:

nil pointer crashes
null return values
op-stack execution context gaps

GetBlock collaborated with op-erigon maintainers who addressed the L1 and operator cost function initialization in pull request #259.

Building on that foundation, GetBlock implemented targeted modifications to achieve production stability of the node.

Running into infrastructure limitations with your analytics service or dApp? GetBlock's team can evaluate your requirements and design a solution. Get in touch to explore what's possible for your use case.

Stabilizing overlay RPC execution on GetBlock’s Base op-erigon node

When production testing revealed more complex overlay execution issues that upstream fixes couldn't fully resolve, GetBlock's engineers implemented custom patches in under a week.
The fixes included:

1. Execution context injection

We ensured overlay replays carry full op-stack semantics:

blockCtx := evmtypes.BlockContext{
    BlobBaseFee: blobBaseFee,
    L1CostFunc: opstack.NewL1CostFunc(chainConfig, stateDB),
    OperatorCostFunc: opstack.NewOperatorCostFunc(chainConfig, stateDB),
}

2. CREATE transaction detection

Added isCreateTx flag to properly handle contract deployment overlays:
go

isCreateTx := creationTx.GetTo() == nil && contractAddr == address

3. Deployed bytecode extraction

After CREATE execution, we explicitly read deployed code from intra-block state:

if isCreateTx {
    deployed := evm.IntraBlockState().GetCode(contractAddr)
    if len(deployed) > 0 {
        result.Code = hexutil.Encode(deployed)
        return result, nil
    }
}

4. Tracer integration

Enhanced the tracer to write injected code to state and propagate errors to the RPC layer:

tracer.evm.IntraBlockState().SetCode(tracer.contractAddr, tracer.injectedCode)
tracer.resultCode = tracer.injectedCode

The result

GetBlock's work with Revert demonstrates what's possible when you combine:

Deep client-level expertise
Close collaboration with the customer and developer community
Engineering capability to patch and deploy specialized builds

The result: GetBlock deployed a hardened archive Base node with patched op-erigon that properly implements overlay RPC. Revert launched their Aerodrome analytics on schedule.

What we learned building this

If you're working with overlay RPC or custom Erigon deployments, note:

Overlay requires explicit state override parameter Even for empty overrides, pass {} as the second param to avoid nil dereference:

curl -X POST https://go.getblock.io/<token> \
-H "Content-Type: application/json" \
-d '{
  "jsonrpc":"2.0",
  "method":"overlay_getLogs",
  "params":[
    {"fromBlock":"latest","toBlock":"latest"},
    {}
  ]
}'

Op-stack execution context is non-negotiable: L1 cost functions and operator fees must be initialized or Cancún-era blocks will fail.
CREATE transactions need special handling: Standard execution paths don't automatically expose deployed bytecode in overlay contexts, you must read from intra-block state.

Wrapping up: Infrastructure is an engineering lever

Innovation in blockchain isn’t just about creating smarter contracts; it’s about the infrastructure that makes those possibilities real. Advanced products like Revert’s DeFi analytics don’t fit neatly into standard setups.

At GetBlock, we treat infrastructure as a technical enabler, not a constraint. When the standard toolset runs out, our engineering focus takes over.

For Revert Finance, that meant bringing overlay RPC from theory to production on Base. For your product, it might mean architecting the missing piece between your vision and your data layer.

Need custom blockchain infrastructure?

GetBlock provides high-performance blockchain infrastructure across 100+ blockchains — from RPC node access and dedicated setups to fully customized engineering support for teams building at the frontier.

If your project requires specialized node configurations that standard providers can’t deliver, let’s talk.

Most infrastructure providers say 'that's impossible.' We say, 'give us a week.’

DEV Community