A crypto transfer can look almost trivial on a phone.
Choose an asset. Enter an address. Type an amount. Press Send.
The blockchain sees something very different.
On Ethereum, a transaction is a signed instruction that can contain a recipient address, value, nonce, gas parameters and input data. Once signed and broadcast, it enters the transaction pool and waits for a validator to include it in a block. Eventually, the block can become finalized.
The interesting part is that the blockchain cannot tell whether the user meant to send the funds to that particular address.
That decision happens before the transaction reaches the network.
This makes the wallet interface more than a convenient way to access a blockchain. It is one of the last places where a human can catch a mistake.
The address is not enough
Wallet addresses are not exactly designed for humans.
An Ethereum address is a hexadecimal string. Copying one from a previous transaction is easier than trying to read it character by character. That convenience creates an opportunity for attackers.
A technique known as address poisoning exploits this behavior.
An attacker creates an address that looks similar to one the victim has used before and sends a transaction designed to make the malicious address appear in the victim's transaction history. If the victim later copies the wrong address from that history, the funds go somewhere else.
A 2025 study that measured address poisoning on Ethereum and BSC over two years identified 270 million attack attempts targeting 17 million victims. The researchers linked 6,633 incidents to at least $83.8 million in losses.
That's a useful reminder that "the user entered the wrong address" is not always a user problem.
Sometimes the interface has made the wrong address too easy to trust.
A wallet should make the recipient difficult to misread.
That can mean showing a recognizable name when one is available, making the beginning and end of the address easy to compare, supporting verified address books, and warning users when a destination looks suspicious or has not been used before.
The final confirmation screen should also show the actual destination, not just a shortened label.
The network should be impossible to miss
"Send USDT" is not enough information.
The asset and the network are separate pieces of information, and the same token can exist across multiple networks.
A useful confirmation screen should therefore make the combination explicit:
500 USDT
Ethereum
To: 0x71...92F4
That seems like a small interface decision, but it removes an entire category of ambiguity.
The same principle applies to mobile apps. A smaller screen creates pressure to hide information behind menus, but transaction confirmation is probably the wrong place to optimize for minimalism.
For a practical look at how mobile crypto apps combine wallet access, transfers, QR codes and transaction management, the ChangeNOW guide to mobile crypto app features is a useful reference.
The goal isn't to show every technical detail.
It is to show the details that can change the outcome.
Show what the transaction will actually cost
Fees are another part of the transaction that should not be left for the user to decode.
On Ethereum, gas measures the computational work required to execute a transaction. A simple ETH transfer requires 21,000 units of gas, while interactions with smart contracts can require considerably more.
The fee also isn't just an arbitrary number produced by the wallet.
Ethereum's fee model includes a base fee and a priority fee. The amount a user ultimately pays depends on gas used and the applicable fee parameters.
A good interface should translate that into something a person can understand:
Sending: 1 ETH
Network fee: 0.00025 ETH
Total deducted: 1.00025 ETH
The user shouldn't have to understand maxFeePerGas before sending money.
That's the wallet's job.
"What am I signing?" is a better question
There is another problem that becomes more important once a wallet does more than simple transfers.
A transaction doesn't necessarily mean:
Send this amount to this person.
It can also mean:
Interact with this smart contract.
Ethereum documentation distinguishes ordinary transfers from transactions that execute deployed smart contracts. In the latter case, the to address can belong to a contract, while the transaction's input data determines what the contract is asked to do.
That changes the UX problem.
Showing a contract address and a button labeled Sign doesn't tell most users much.
For a swap, approval, DeFi interaction or other contract call, the wallet should explain the intended effect in human-readable terms whenever it can.
For example:
You are authorizing:
Swap 500 USDC for ETH
Estimated result:
≈ 0.18 ETH
Network fee:
≈ $1.40
Contract:
Verified contract name, if available
That is much more useful than presenting a wall of hexadecimal data.
Simulation is useful, but it isn't magic
Transaction simulation is becoming an important part of wallet security.
Instead of asking the user to sign first and find out what happened later, a wallet can simulate the transaction and estimate the expected balance changes or contract effects before broadcasting it.
That is a significant improvement in the user experience.
But simulation shouldn't be treated as a guarantee.
A 2026 study of transaction simulation phishing found more than 4,000 phishing contracts deployed between August 2024 and June 2025. The researchers identified more than 5,700 victims and approximately $3.48 million in losses, with 91.5% of those losses occurring on Ethereum.
The problem is subtle.
Some malicious contracts can behave differently during simulation and actual execution because their behavior depends on changing blockchain state. A simulation can therefore show a benign result while the eventual transaction behaves differently.
So the lesson isn't that simulation doesn't work.
It's that one security signal shouldn't become the entire security model.
Simulation is one layer. Address checks, contract reputation, readable signing information and user confirmation are other layers.
Warnings need to tell the user what to do
A red warning isn't automatically a useful warning.
Compare these two messages:
⚠️ Suspicious transaction
and:
⚠️ This is the first time you've sent funds to this address. Verify the full address before continuing.
The second one gives the user a decision to make.
That's important because security warnings often appear at exactly the moment when the user wants to finish the task. If the warning is vague, people are more likely to treat it as another piece of interface noise.
Research on wallet usability shows that this is still a real problem.
A 2025 study evaluated 53 popular Ethereum wallets specifically in the context of address poisoning. The researchers found that 16 wallets created a high risk by displaying fake token phishing transfers, while only three wallets displayed an explicit warning when users attempted to transfer funds to a phishing address.
That doesn't mean those three wallets are universally safe or that the other wallets are universally insecure.
It does show how much room there is for improvement in the way wallets communicate transaction risk.
The confirmation screen is a security feature
The best confirmation screen doesn't need to expose every blockchain parameter.
It needs to answer the questions a user actually has before signing:
What am I sending?
500 USDC
Which network?
Ethereum
Where is it going?
Alice
0x71...92F4
What will it cost?
Estimated network fee: $2.14
What am I authorizing?
Transfer / swap / approval / contract interaction
Did the wallet detect anything unusual?
First-time recipient / suspicious contract / simulation result
Then comes the final action:
Review and Sign
This is a better model than treating confirmation as the last visual step before a button click.
It is a checkpoint.
Good crypto UX should slow you down at the right moment
Most of the time, a wallet should feel fast.
You shouldn't need three screens to send funds to an address you've verified dozens of times.
But when something changes – a new address, a different network, an unusual contract interaction or a potentially risky approval – the interface should become more deliberate.
That's where good crypto UX differs from simply making transactions faster.
The objective isn't to remove friction everywhere.
It is to remove unnecessary friction while keeping the friction that helps a user catch an expensive mistake.
A blockchain will execute a valid signed transaction because the signature is valid. It doesn't know what the user intended to do.
The wallet sits between those two worlds.
That makes the Send screen one of the most important security surfaces in a crypto application.
The best crypto app isn't necessarily the one that gets you from balance to transaction hash in the fewest taps.
It's the one that gives you a good reason to pause before the tap that actually matters.
Top comments (1)
)