A standard that makes onchain UX feel like the internet. And yet, almost no one is using it.
Today, signing a simple transaction onchain can feel like disarming a bomb.
Click, approve. Click again. Oh wait, gas? Another signature? The screen glitches. The wallet times out. Start over.
We’ve spent years solving this, with login flows, onramps, in-app wallets, and more. But one of the most overlooked unlocks in the onchain UX stack is something far simpler: batch transactions. EIP-5792 standardizes how apps send multiple calls in a single flow. And it’s ready today.
It’s the biggest upgrade to wallet UX in years.
Yet right now, only a few wallet supports it.
Before and after: the batch transaction shift
Let’s take a typical DeFi interaction: a token swap that requires token approval, then execution. In most wallets, this means two separate pop-ups/interactions. One to approve, another to execute. Each can fail, time out, or confuse the user.
With EIP-5792, both calls are packaged into a single payload. The wallet receives a single request, displays one prompt, and signs everything together. That reduces:
- Signature fatigue
- Modal errors
- Flow drop-offs
- Non-atomicity of transactions leading to failed transactions
Instead of treating each transaction as an isolated event, apps can now create a session of intent, where the full action is visible to the user, and executed atomically.
How wallet_sendCalls works
At a technical level, EIP-5792 defines a structured JSON-RPC method that lets apps send multiple payloads e.g. eth_sendTransaction in one request. The wallet receives this bundle, presents the grouped actions to the user, and signs once.
Each call in the array includes:
- The target contract
- Encoded calldata
- Optional value (ETH to send)
- A human-readable description (optional, for display)
Wallets can use this metadata to present the intent clearly: “You’re swapping 50 USDC for ETH,” instead of two disconnected approval and swap dialogs.
It’s not just cleaner, it’s safer. Users can see the full scope of what they’re signing.
Wallet support: only Safe is live
Right now, Safe is the only wallet that has added support for wallet_sendCalls via WalletConnect.
That means:
- Apps can already be built with it using WalletConnect
- Most wallets will still fail or ignore the request
This mismatch creates a frustrating reality. The UX improvement is real. The infra is ready. But until more wallets integrate EIP-5792, developers are forced to build fallback flows or avoid batching entirely.
It’s a problem we’ve seen before: standardization exists, but adoption lags.
The data confirms the gap
Reown’s tracking of WalletConnect method usage shows that wallet_sendCalls accounts for a tiny fraction of daily transactions. Legacy methods like eth_sendTransaction and personal_sign still dominate.
That’s despite the fact that:
- The 5792 spec is finalized
- It’s fully supported in WalletConnect
- It unlocks cleaner, safer, and a greater UX, not just for your average user but also for institutions and businesses.
We’ve seen similar trends in the past, EIP-712 (typed data signing) took years to gain wallet support, despite clear security wins. The difference this time? Wallets, apps, and frameworks can integrate EIP-5792 in hours, not months.
What developers get from EIP-5792
For engineers, the benefits go beyond UX. Batching unlocks more stable, testable, and modular application architecture.
With EIP-5792:
- Flows are testable: Developers can simulate full bundles without waiting for real wallet interactions.
- Failure is atomic: If one call in the batch fails, the entire transaction can be aborted.
- Less modal logic: Apps don’t need to manage state across multiple async user interactions.
Example Usage:
provider.request({
method: 'wallet_sendCalls',
params: [{
version: '1.0',
id: '0x123...',
chainId: '0x01',
from: '0xd46e8dd67c5d32be8058bb8eb970870f07244567',
atomicRequired: true,
calls: [
{
to: '0xd46e8dd67c5d32be8058bb8eb970870f07244567',
value: '0x9184e72a',
data: '0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675'
},
{
to: '0xd46e8dd67c5d32be8058bb8eb970870f07244567',
value: '0x182183',
data: '0xfbadbaf01'
}
],
capabilities: {
paymasterService: {
url: "https://...",
optional: true
}
}
}]
})
This opens up the design space for more complex DeFi and multistep app logic, without adding user complexity.
Why this matters for real people, not just developers
For the average onchain user, EIP-5792 means fewer confusing pop-ups, fewer failed transactions, and fewer moments of doubt. Instead of tapping “Confirm” multiple times and wondering what each step actually does, users get one clear prompt that shows the full picture. No surprises, no fragmented flows, and no stress over whether they’ve approved the wrong contract or missed a step.
This kind of predictability makes it easier for people to trust and use onchain apps in everyday life, from swapping tokens to minting NFTs to bridging assets. It feels less like programming and more like interacting with a product that just works.
For institutions: smoother workflows, lower support burden
Institutions aren’t just thinking about UX, they’re thinking about reliability, compliance, and operational efficiency. EIP-5792 helps reduce risk at every layer.
With batch transactions, teams can standardize flows for treasury management, automated asset rebalancing, and secure multi-step execution, all without relying on custom scripts or manual multi-sig juggling. It also simplifies audit trails, because each user action maps cleanly to a single intent.
And because the user experience is smoother and easier to understand, customer support teams spend less time explaining what went wrong and more time driving growth. It’s a UX win that becomes an ops win.
Low Adoption? WalletConnect Certified to the rescue
The WalletConnect Certified programme will foster EIP-5792 as participating apps and wallets will need to supprt EIP-5792 as we have teased here. Not all types of accounts will be able to support this but either way this will significantly boost the EIP-5792 adoption of both apps and wallets.
A blocker to adoption
https://dune.com/wintermute_research/eip7702
To support EIP-5792, most wallets first need to implement EIP-7702. Introduced in 2025, EIP-7702 enables existing EVM accounts to perform batched transactions - a long-awaited capability. So far, only a handful of wallets have adopted it, and the user experience for enabling it still needs refinement. In practice, wallets typically roll out EIP-7702 first, improve the UX, and then layer on EIP-5792 support via WalletConnect.
Ecosystem interest is building
Multiple teams are already exploring EIP-5792 integration. Here’s what some early adopters are saying:
As more wallets and apps go live, we’ll be updating this post and showcasing the new flows.
Why this matters now
Wallet UX is evolving. Users expect more, not just safety, but clarity. Not just decentralization, but predictability. EIP-5792 delivers all of that without introducing new risk or breaking changes.
And it fits into a larger trend: the app-native onchain experience.
AppKit already powers:
- Embedded wallets
- Wallet-native logins
- Crypto payments (even directly from exchanges)
EIP-5792 is the next layer. It gives apps fine-grained control over transaction intent, enabling powerful UX without waiting on protocol-level changes.
Think of it like HTML for onchain actions: a way to express multi-step behavior in a single, open standard.
What’s next for adoption
We’re working with ecosystem partners to drive adoption in three ways:
- Wallet integration: Safe is live. Trust, Ledger, and others are in testing.
- Developer tooling: WalletConnect already supports 5792. Reown is adding CLI tools, test harnesses, and debugger support.
- Ecosystem visibility: Expect a session at WalletCon featuring live demos, before/after comparisons, and launch timelines from top wallets and apps.
Final word: use it!
EIP-5792 is not a research paper or a half-baked idea. It’s a live, deployed, working standard. If you’re building in DeFi, gaming, payments, or any onchain UX, this belongs in your stack.
It gives users a smoother experience. It gives teams fewer edge cases. And it gives wallets a way to build trust through clarity.
If you're ready to integrate or want early access to Reown’s testing tools, head to the Reown Dashboard.
This is how onchain should feel. Clean. Clear. Connected.