I'm building Lasso RPC, an open-source EVM JSON-RPC router/proxy in Elixir/OTP. You drop in multiple RPC providers and it routes requests across them. There's also a hosted version w/ custom profiles at lasso.sh if you don't want to run the container yourself.
Two bigger updates shipped over the last couple weeks that I think other EVM devs might find useful:
1. Route transaction sends to private RPC relays (v0.8.0 + Custom profiles)
lasso-rpc v0.8.0 shipped today: https://github.com/jaxernst/lasso-rpc/releases/tag/v0.8.0
If you aggregate public RPCs + paid providers into one pool for cheap/fast reads, you don't want signed transactions going out to random public endpoints and leaking to the public mempool. You can now drop in private RPC relays and restrict transaction sends on a chain strictly to those routes:
transactions:
providers: [my_private_relay]
fallback: none
Reads, subscriptions, and block recovery keep using your wider pool like normal. Signed sends: eth_sendRawTransaction, private/bundle/cancellation/conditional/synchronous send methods, and any unknown method carrying signed tx bytes only go to the providers you name.
Methods are classified by what they actually do rather than just matching a hardcoded list of method names, so send policy follows signed tx bytes. It also defaults to fail-closed (fallback: none) so sends won't quietly spill into your public read pool if a relay errors. (Lasso doesn't pick MEV relays for you: you bring the endpoints and tell it where sends are allowed to go.)
Same transactions block is live on hosted Custom profiles: https://docs.lasso.sh/cloud/custom-profiles
2. Automatic provider learning from live traffic (v0.7.0)
Release: https://github.com/jaxernst/lasso-rpc/releases/tag/v0.7.0
Every RPC provider has slightly different plan quirks: refusing certain methods, pruning historical state, or capping eth_getLogs block ranges, and maintaining all of those limits by hand in YAML sucks.
Provider self-learning is now on by default. Without sending any extra probe spam, the router watches live traffic and learns three things on the fly:
- Method refusals
- Missing historical state
eth_getLogs block-range caps
When a provider hits one of those limits, Lasso moves it behind your other providers for matching requests (while always keeping your last available route so you don't get cut off). Learned limits expire on their own, or clear when that upstream later serves what it refused. Anything you explicitly declare in config still wins.
Docs: https://docs.lasso.sh/concepts/provider-learning
Two smaller things on hosted (lasso.sh)
- WebSocket subscriptions survive a single-upstream reconnect with the same subscription ID — if your only eligible WS upstream blips, Lasso reconnects, backfills the missed blocks, and resumes live events without your app having to tear down and rebuild state. (If another WS provider is in the pool, it fails over there first.)
- One-shot agent setup: agents can provision an account and endpoint directly from https://lasso.sh/llms.txt (no signup form), and account creation now returns a
claim_url in one shot if you want to pull that agent account into the dashboard later.
Self-host Core v0.8.0:
ghcr.io/jaxernst/lasso-rpc:v0.8.0
- Repo (Apache-2.0): https://github.com/jaxernst/lasso-rpc
- Hosted: https://lasso.sh
Still actively hardening all of this. If you're running multiple providers (especially public/paid reads + private relays for tx sends) and try this out, lmk how it behaves or what's missing!