A Detailed Guide to Sending and Receiving ETH with Smart Contracts

Understanding how to handle Ether (ETH) within smart contracts is a fundamental skill for any blockchain developer. This guide breaks down the core methods for receiving and sending ETH programmatically using Solidity.

How a Smart Contract Receives ETH

For a smart contract to accept ETH, it must include a special payable fallback function. This function acts as a default entry point for any incoming Ether sent to the contract's address without a specific function call.

Here is a basic implementation:

pragma solidity ^0.4.24;

contract BasicReceiver {
    function () payable public {}
}

Once ETH is held by the contract, you might eventually want to retrieve it. A common method is to use the selfdestruct function. This opcode effectively deactivates the contract and sends all its remaining Ether to a designated address.

function claim() public {
    selfdestruct(owner); // Sends all contract ETH to the owner
}

Important Note: While selfdestruct is a sure way to extract Ether, it permanently disables the contract, making it unusable for any future interactions.

Creating an Automatic Refund Contract

A common use case is a contract that requires a precise payment, such as for a ticket or service. If a user sends too much ETH, the contract should automatically refund the excess amount.

The following example requires exactly 1 ETH. Any amount over that is immediately sent back to the sender.

pragma solidity ^0.4.24;

contract AutomaticRefund {
    address public owner;
    uint256 public constant TICKET_PRICE = 1 ether;

    constructor() public payable {
        owner = msg.sender;
    }

    function () public payable {
        require(msg.value >= TICKET_PRICE, "Insufficient Ether sent");

        if (msg.value > TICKET_PRICE) {
            uint256 refundAmount = msg.value - TICKET_PRICE;
            msg.sender.transfer(refundAmount);
        }
        // The ticket price (1 ETH) is now held by the contract
    }
}

In this pattern, the gas cost for the refund transfer is paid by the original sender who initiated the transaction.

Forwarding Funds Immediately Upon Receipt

Some contracts are not designed to hold funds. Instead, they act as a payment router, automatically forwarding any received ETH to a predefined owner address.

pragma solidity ^0.4.24;

contract PaymentForwarder {
    address public owner;

    constructor() public payable {
        owner = msg.sender;
    }

    function () payable public {
        owner.transfer(msg.value); // Immediately forward received ETH
    }
}

The key advantage here is that the contract itself holds a zero balance, simplifying accounting and reducing security risks. The gas for the transfer operation is still paid by the original sender of the ETH.

Withdrawing ETH to a Designated Account

For contracts that do hold a balance, a safer pattern than using selfdestruct is to implement a withdrawal function. This allows an authorized account (the owner) to withdraw the accumulated funds to their address at any time.

This method is more flexible and doesn't destroy the contract.

pragma solidity ^0.4.24;

contract SecureWithdrawal {
    address public owner;
    uint public balance;

    modifier onlyOwner() {
        require(msg.sender == owner, "Only the owner can call this function");
        _;
    }

    constructor() public {
        owner = msg.sender;
    }

    function () public payable {
        balance += msg.value; // Safely track the incoming ETH
    }

    function withdraw() onlyOwner public {
        msg.sender.transfer(balance); // Send the entire balance to the owner
        balance = 0; // Reset the balance after withdrawal
    }

    function transferOwnership(address newOwner) onlyOwner public {
        require(newOwner != address(0), "New owner cannot be the zero address");
        owner = newOwner;
    }
}

This contract includes critical features:

A modifier to restrict access to sensitive functions.
A fallback function that safely updates a balance tracker.
A withdraw() function for the owner to claim the funds.
An ownership transfer function for managing contract control.

👉 Explore advanced contract development strategies

Frequently Asked Questions

What is a payable function in Solidity?

A payable function is a special type of function in Solidity that can receive Ether. If a function is not marked as payable, any attempt to send ETH to it will be rejected. The fallback function must also be marked as payable for a contract to accept plain Ether transfers.

What is the difference between .transfer() and .send()?

Both .transfer() and .send() are used to send Ether from a contract. The key difference is error handling. .transfer() automatically reverts the entire transaction if it fails (e.g., if the recipient is a contract that throws an exception), making it safer. .send() simply returns a boolean false on failure, which the calling code must manually check.

Why should I avoid using selfdestruct()?

The selfdestruct function is a drastic measure. It permanently disables the contract, removes its code from the blockchain, and sends all remaining Ether to a target address. It should be avoided for regular withdrawals because it eliminates the contract's functionality and can be a single point of failure if not implemented correctly.

How can I make my fund-handling contract more secure?

Security is paramount. Always use the Checks-Effects-Interactions pattern to prevent reentrancy attacks. Utilize function modifiers like onlyOwner to restrict access to withdrawal functions. Consider using pull-over-push patterns for withdrawals, where users initiate the withdrawal of their own funds, rather than the contract pushing funds to them automatically.

Can a contract receive ETH without a payable fallback function?

No. Without a payable fallback function or another explicitly defined payable function, a smart contract cannot receive Ether through a standard transaction. Any ETH sent to it will be rejected, and the transaction will fail.

What are some best practices for handling ETH in contracts?

Always assume that external calls (like transfer()) can fail. Use address(this).balance cautiously, as it reflects the total balance, which could include funds sent by other means. For any significant value, thoroughly test your contract on a testnet and consider having your code audited by security professionals. For a deeper dive into secure development patterns, 👉 view real-time tools and resources.