What is Clear Signing (ERC-7730 Broken Down)

The status quo

It’s no secret that for years now, crypto users have been asked to approve transactions they most likely couldn't understand.

You attempt a swap and have to approve an amount, and a wall of technical data appears. At this point, you’re expected to decide if it’s safe to click “Confirm”. Most of the time, you trust that the app is doing what it claims to do. Sometimes, that trust is misplaced.

This practice, also known as blind signing, is one of the biggest reasons users become victims of phishing attacks, malicious approvals, and wallet-draining scams that have cost the industry billions, including the Bybit hack in February 2025, which resulted in losses of around $1.5 billion.

To improve the user experience and enhance security, the Ethereum ecosystem is rallying around a new standard, ERC-7730, commonly known as clear signing.

The goal is very simple: to help users understand exactly what they're signing before they sign it.

Why do we need to fix blind signing

Now, imagine your online banking app asked you to approve a payment and showed you this:

0x035a21d4971e5f5a4c7025816eb0dc6151ab4145be83dd46dcf24e3a637db837

Function: approve(address token,address spender,uint160 amount,uint48 expiration)

MethodID: 0x87517c45

[0]: 000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7

[1]: 00000000000000000000000066a9893cc07d91d95644aedd05d03f95e1dba8af

[2]: 000000000000000000000000ffffffffffffffffffffffffffffffffffffffff

[3]: 000000000000000000000000000000000000000000000000000000006a58d55e

There is no recipient on the screen, no amount, and no explanation about this transaction. Would you approve it? Probably not. Yet this is effectively what is happening all the time in crypto.

For almost every swap, bridge, staking action, or token approval, a smart contract interaction is required. And while computers understand these interactions perfectly, humans don't. Wallets usually receive the transaction data in a format that's easy for machines to process but difficult for people to read and understand.

This is why users frequently approve transactions without fully understanding what they're authorizing, and unfortunately, attackers know this. Many crypto scams don't even require stealing private keys or exploiting vulnerabilities. Instead, they simply rely on convincing users to sign transactions that grant excessive permissions, approve unlimited token spending, or interact with malicious contracts.

When users can't clearly see what they're signing, they're forced to trust the website in front of them. That's not a great security model.

What is clear signing?

Clear signing is a way for crypto wallets to display transactions in plain language, showing the actual recipient, amount, and action, so users can verify what they're signing before they actually do.

Instead of showing raw calldata, hashes, or obscure function names, if wallets, as well as apps and protocols, implement this standard, they can display a clear description of what a transaction will actually do.

For example, rather than seeing:

approve(address spender, uint256 amount)

A wallet could display:

Approve Uniswap to spend up to 100 USDC from your wallet.

Or instead of a complex smart contract call:

Swap 0.5 ETH for approximately 1,250 USDC.

The goal is to help users make informed decisions based on their actual intent, rather than technical implementation details. Here, it is important to note that clear signing doesn't actually change how transactions work; it just changes how they're presented to users.

This principle is sometimes called WYSIWYS (What You See Is What You Sign): the guarantee that the transaction on your screen is exactly the one you're authorizing.

Breaking down ERC-7730 for clear signing

ERC-7730 is the Ethereum standard that enables clear signing. In a nutshell, it lets protocols provide structured metadata, a.k.a. descriptors, that tell wallets how to display contract interactions in human-readable form. 

Think of it as a translation layer between machine-readable smart contract interactions and human-readable explanations.

Traditionally, wallets have had to reverse-engineer transaction data and guess how best to display it, something Ambire has been doing whenever possible for a while. Unfortunately, this works for common interactions, but becomes increasingly difficult as protocols become more complex.

With ERC-7730, you could say this is done in reverse. Instead of wallets having to interpret everything themselves each time, protocols publish descriptors explaining how their contract interactions should be presented to users.

Wallets can then use this information to generate clear and consistent signing screens. The end result is a more understandable experience, regardless of the protocol a user uses.

So how does it work?

At a high level, the process looks like this:

1. A protocol publishes descriptors

Protocol teams create structured descriptions of their contract functions.

These descriptors explain: what a function does, what each parameter represents, how values should be formatted, and which fields are important to display to users

2. Wallets retrieve the metadata

When a user initiates a transaction, the wallet looks for an ERC-7730 descriptor associated with the contract. If one exists, the wallet can use it to interpret the transaction.

3. The transaction is translated into human language

Instead of showing raw technical data, the wallet generates a clear summary.

For example:

• Deposit 500 USDC into Aave
• Bridge 1 ETH from Ethereum to Base
• Approve spending of 100 USDC by Uniswap

4. The user reviews and signs

The user can now verify whether the action matches their intention before approving it. This adds an additional layer of transparency without changing the underlying transaction itself.

Here is an example of what clear signing looks like:

Why this matters: security & usability

Clear signing is not a miracle cure for scams. Bad actors can still try to trick users, and they will continue to find new ways to deceive people.

However, clear signing raises the bar since many attacks today depend on users signing something they don't understand.

It’s much harder to disguise a scam when wallets clearly communicate:

1. who will receive assets
2. which tokens are involved
3. how much is being approved
4. what action is being performed

And security is only half the story; the other half is user experience.

Crypto has historically expected us to understand concepts mostly never encountered before: gas fees, approvals, calldata, contract interactions, signatures, and more.

And for experienced users, this can be manageable, but for everyone else, it can be really intimidating. A future where self-custody becomes mainstream requires interfaces that clearly and naturally communicate intent. We shouldn't need to understand Solidity function calls just to use decentralized applications. Clear signing helps move crypto closer to that reality.

What it means for Ambire users

At Ambire, we've always strived to remove complexity while maintaining self-custody. This is why we have been eager to implement these features, which improve the user experience and enhance security without requiring a degree simply to swap some crypto. From account abstraction and gas abstraction, to advanced transaction simulation & human-readable transactions, we have been working towards a simple goal: help users stay in control without requiring them to become blockchain experts.

Clear signing, naturally, fits into that vision. By supporting ERC-7730, Ambire can present transaction details in a way that's easier to understand, easier to verify, and ultimately safer to approve.

That's better for security and for user experience. And ultimately, it's better for the long-term adoption of self-custody.

Clear signing in the wild

Ambire is not the only project in the ecosystem to integrate and support clear signing - Ledger has been a major contributor to the Ethereum Foundation by championing clear signing with early tooling, infrastructure, and educational efforts. Now Ledger is officially transferring governance of ERC-7730 to the Ethereum Foundation, and ERC-7730 v2 provides cross-chain support. Other teams, such as ZKnox, Sourcify, Cyfrin, Zama, WalletConnect, Fireblocks, Trezor, Keycard, MetaMask, Argot, as well as independent contributors across the ecosystem, have been contributing to help with research, library developments, audits, and coordination, too, to ensure that all angles are covered.

You can check out the official clear signing page here and join the initiative yourself to ensure that all apps, protocols, and wallets implement clear signing.

In conclusion

For too long, we have been expected to sign transactions we couldn't always meaningfully read. ERC-7730 changes that by giving wallets a standardized way to translate smart contract interactions into human-readable explanations. Clear signing helps users understand what they're authorizing before they sign.

The future of self-custody isn't just about giving people control over their assets. It's about giving them enough clarity to use that control confidently.

FAQs

What's the difference between clear signing and blind signing?

Blind signing asks you to approve transaction data you cannot read, usually a hash or raw calldata. Clear signing shows the same transaction in plain language first, including the recipient, amount, and action. It does not change what the transaction does, only how it is presented, so you can confirm it matches your intent before approving.

Does clear signing prevent scams?

Clear signing makes scams much harder by showing you what you are approving before you sign, but it is not a guarantee. Attackers still try to trick users, so you should always check that the recipient, amount, and action on screen match what you intended before confirming.

Do I need a hardware wallet for clear signing?

No. Clear signing is often associated with hardware wallets, but it is a wallet feature built on the ERC-7730 standard, not a hardware requirement. Software wallets support it too. Ambire, for example, implements ERC-7730 and shows human-readable transactions without any extra device.

Which wallets support clear signing?

A growing number of wallets support clear signing through ERC-7730, including Ambire. A clear signing wallet reads a protocol's ERC-7730 descriptor and displays exactly what a transaction will do before you approve it, rather than showing raw calldata. Support is expanding as more wallets and protocols adopt the standard.

Which protocols and dApps support clear signing?

Clear signing requires protocols to publish ERC-7730 descriptors that tell wallets how to display their transactions. Adoption is growing across the ecosystem, with a shared registry now maintained under the Ethereum Foundation. Protocols and dApps with published descriptors include Uniswap, Aave, 1inch, Lido, Morpho, ParaSwap, KyberSwap, Ethena, Ondo Finance, Swell, Lombard, SwissBorg, OpenSea, Rarible, POAP, LI.FI, StarkGate, Threshold, Kiln, Figment, Safe, WalletConnect, Tally, OKX, and Hyperliquid, alongside stablecoin issuers Circle (USDC) and Tether (USDT). The list keeps expanding as more protocols submit descriptors.

Does Ambire support ERC-7730 and clear signing?

Yes. Ambire supports ERC-7730, presenting transaction details in plain language so they are easier to verify and safer to approve. This builds on Ambire's existing human-readable transactions and transaction simulation, which already help users understand what they are signing before they confirm.

How do I enable clear signing?

In a wallet that supports ERC-7730, such as Ambire, clear signing works automatically whenever a protocol has published a descriptor for the transaction you are making. There is no setting to switch on. If a descriptor exists, your wallet displays the transaction in plain language before you approve it.

​​Interested in Ambire? Follow us:
Discord | X (Twitter) | Reddit | GitHub | Telegram | Facebook