Track 4 · Solidity foundations · lesson 11

Receiving and sending ETH

11 min

Until now your contracts have moved numbers. This one moves money.

Wallet.solComplete

Loading editor…

Record who sent ETH, and how much.

Run the code to see what happens.

Nudge

Two values are already available to you inside the function. You do not need any arguments.

Show me the approach

`msg.value` is the ETH attached to the call, in wei. `msg.sender` is who sent it.

Show me the code

Add `deposits[msg.sender] += msg.value;`.

Explain the solution

Note the ETH arrives whether or not you record it — the contract's balance goes up the moment the call succeeds. Forgetting this line does not lose the ETH, it loses the *record* of who owns it, which is arguably worse.

Notice what the second test checks: the contract's actual ETH balance. The deposit is not bookkeeping — real value moved.

A contract's ETH balance goes up the instant a payable call succeeds, whether or not you write anything down. Forgetting deposits[msg.sender] += msg.value; does not lose the ETH — it loses the record of who owns it, which means nobody can ever withdraw it.

Money in a contract with no way out is the most common form of permanent loss on Ethereum.

Getting ETH back out

Three ways to send ETH, and the differences matter:

payable(who).transfer(amount);   // 2300 gas, reverts on failure
payable(who).send(amount);       // 2300 gas, returns false
(bool ok, ) = who.call{value: amount}("");   // all gas, returns false

Use call, and check the result. transfer and send forward only 2300 gas, which was once a reentrancy safeguard but now breaks legitimately — any recipient that is a contract doing more than the bare minimum will fail.

(bool ok, ) = msg.sender.call{value: amount}("");
require(ok, "transfer failed");

Predict

`transfer` forwards only 2300 gas to protect against reentrancy. Why is that advice now considered harmful?

Gas costs changed, so 2300 no longer covers what it used toReentrancy is no longer possible in modern Soliditytransfer was removed from the language

receive and fallback

A plain ETH transfer with no data goes to receive(). A call to a function that does not exist goes to fallback().

receive() external payable {}
fallback() external payable {}

Without one of these, sending plain ETH to your contract reverts. That is usually the right default — it stops funds arriving somewhere nothing is prepared to handle them.

Check

Which is the recommended way to send ETH from a contract in 2026?

`transfer`, because it reverts automatically on failure`call` with the returned success flag checked`send`, because returning false is safer than reverting

Worth remembering

A function must be `payable` to receive ETH; `msg.value` is the amount, in wei.
The contract's balance rises on a successful payable call whether or not you record it.
Prefer `call{value: x}("")` and always check the returned success flag.
`transfer` and `send` forward only 2300 gas and now break against legitimate recipients.
`receive()` handles plain ETH; without it, sending ETH to your contract reverts.