SDKs are Dead; Long Live Capabilities

Building with AA is great… or is it? While the benefits of Account Abstraction (AA) are well-known, people who have actually tried to build with AA know that the developer experience is far from optimal.

Luckily, a paradigm shift is coming, and it will forever change the developer experience of AA for the better. In this blog post, I will explain:

• The issues with using AA right now.
• How the new paradigm, aka “capabilities,” will vastly improve the developer experience.
• What you as a developer can do today to get ready for this paradigm shift.

Why Building with AA Sucks Right Now

Today, to build with AA means doing the following two things:

1. Creating an embedded AA wallet inside your application for the user.
2. Interacting with the embedded AA wallet through vendor-specific APIs.

This coupling happens because, until now, it had not been possible for DApps to communicate with AA wallets through standardized APIs. If a DApp wanted to leverage a feature like gas sponsorship, it couldn't use any AA wallet the user might bring; the DApp MUST control the wallet itself by embedding it.

To make matters worse, DApps become tightly coupled with vendors at multiple levels:

• Smart Accounts: Different execution and module interfaces (e.g., 7579 and 6900 are incompatible).
• Paymasters: Use different APIs, so even sponsoring gas requires a vendor-specific interface.
• Bundlers: Even here, common features like estimating gas prices lack standardized APIs.

The upshot is that, as a DApp developer, using AA today means being coupled with multiple AA vendors at different layers of the stack. This is like a Web2 world where your DApp only works with MetaMask and only with Infura. This is insanity—and yet that’s the state of AA today.

Existing solutions (like ZeroDev and Permissionless) aggregate multiple vendors but still limit you to the providers they integrate with. Crucially, none of these solutions let your user just bring an arbitrary AA wallet to your DApp—you still must use AA through an embedded wallet.

Bye-bye SDKs, Hello Capabilities

Back in 2022, Moody Salem proposed the innocuous ERC-5792. The original ERC was only meant to provide a transaction batching API. It became stagnant until recently, when contributions from projects like Base and WalletConnect expanded 5792 to become a general “capabilities ERC.”

Through 5792, a DApp can discover the “capabilities” of the connected wallet through a new RPC wallet_getCapabilities. The DApp can then use those capabilities through a new wallet_sendCalls RPC.

What are Capabilities?

Simply put, capabilities are smart wallet features that DApps can use through standardized APIs. Each capability is identified by a unique key.

So far, the following capabilities have been proposed:

• atomicBatch (Transaction Batching): Defined in 5792 itself.
• paymasterService (Sponsoring Paymasters): Allows DApps to sponsor gas for users (ERC-7677).
• auxiliaryFunds (Magic Spend): Indicates the wallet can pull funds "just-in-time" from other sources (like a user’s Coinbase account), so the DApp shouldn’t block transactions if the on-chain balance appears insufficient (ERC-7682).
• permissions (Session Keys): Allows DApps to request permissions to execute specific transactions, even without an active wallet connection (enabling subscriptions, automated trading) (ERC-7715).

Note: Not all smart wallet features are capabilities. Features like Passkeys or Multisig are not capabilities because the DApp doesn't and shouldn't care about how the user signs transactions. Capabilities are only the features DApps can use.

How Do You Use Capabilities?

It is a simple two-step process:

1. Step 1: Discovering Capabilities with wallet_getCapabilities. The DApp calls this RPC to see which capabilities the wallet supports on each chain.
   • Example: A wallet returns that it supports atomicBatch on Ethereum (0x1), and both atomicBatch and paymasterService on Base (0x2105).
2. Step 2: Sending Transactions with wallet_sendCalls, indicating the capabilities you want to use.
   • The DApp includes the desired capabilities (e.g., paymasterService and permissions) in the capabilities field of the request parameters.
   • The atomicBatch capability is implicitly implied with wallet_sendCalls.

Why Capabilities Are Great

With capabilities, DApps no longer have to be tightly coupled with specific AA wallets or infra.

• DApps can leverage AA features through standardized APIs.
• Whether the user brings an embedded AA wallet or their own standalone wallet, the DApp communicates via the same API, maintaining a single code path.

The capabilities paradigm is all the more important because the upcoming Pectra upgrade will give EOA wallets smart features thanks to EIP-7702 (the successor of EIP-3074). DApps that can leverage capabilities will have a significant edge, and the biggest winner will be users who enjoy improved UX.

Why Capabilities Now?

It took time for AA builders to understand what the most important, commonly used "AA features" are (primarily gas sponsorship, batching, and permissions). More importantly, it took projects with significant weight—notably Coinbase and WalletConnect—to drive this paradigm and break the local maximum of every builder focusing on their own closed ecosystem.

What Does This Mean for ZeroDev?

ZeroDev has always prioritized interoperability (e.g., creating the ERC-7579 modular account standard). We are once again tearing down the moat we’ve built in favor of this new standard because we believe good products win by providing the most value.

• ZeroDev has been fully updated with the capabilities API.
• If you are building a wallet with ZeroDev, DApps will be able to communicate with it through the capabilities API.
• If you are building a DApp using ZeroDev as an embedded wallet, you can now interact with it via the capabilities API using Viem and Wagmi, ensuring your DApp works with any smart wallet, not just the embedded one.

To learn more about ZeroDev’s capabilities support, read this doc.

Conclusion

DApps today communicate with smart wallets through vendor-specific SDKs, but that will become a thing of the past. With the capabilities API, DApps can now leverage smart wallet features without being locked-in with any specific smart wallet or AA infra provider.

By integrating with the capabilities API, DApps not only improve UX today but also set themselves up for the future where more wallets become smart via ERC-4337 and EIP-7702. The fact that capabilities are now supported in Viem and Wagmi makes integrating with them a no-brainer.

If you want to get started with capabilities today, try using ZeroDev with Wagmi!

If you enjoyed this blog post, you can amplify it here.