In Solidity, there are three main ways to send native tokens (ETH) to another contract or address: transfer, send, and call.
All three can move funds, but they behave differently in terms of gas limits and safety.
transfer
payable(receiver).transfer(amount);
The transfer() function forwards a fixed 2300 gas and does not return a value.
If the transfer fails, it will automatically revert, and the entire transaction will be rolled back.
send
bool success = payable(receiver).send(amount);
send is similar to transfer and also forwards a fixed 2300 gas.
The difference is that, on failure, send only returns false. It does not automatically revert, and the whole transaction is not rolled back by default.
You, as the developer, must handle the failure case explicitly based on the success flag.
call
(bool success, ) = receiver.call{value: amount}("");This pattern contains three important pieces of information:
receiver: the address receiving ETH.amount: the amount of ETH to send."": empty data payload, meaning “just send ETH, don’t call any function”.
If you pass function calldata instead of "", you can invoke a function while sending ETH. In pure value transfers, this is usually left empty.
Similar to send, a failed call does not automatically revert and does not roll back the entire transaction by itself. You must check success and handle failures manually.
Unlike send, there is no 2300 gas limit with call, so the receiver can execute more complex logic.
Which One Should You Use?
Because of the 2300 gas limit, transfer and send are more restrictive. They limit what the callee can do, but they can also fail when the receiver needs more gas for its logic.
call is much more flexible and is the currently recommended approach by the community, but it also requires developers to be careful and handle potential security risks explicitly.