Sending Ether (transfer, send, call) in Blockchain / Solidity - Mini Project: Build & Apply

Sending Ether (transfer, send, call)

📖 Scenario: You are creating a simple smart contract on Ethereum that can send Ether to another address. You will learn three ways to send Ether: transfer, send, and call. This is important for handling payments or sending funds securely.

🎯 Goal: Build a Solidity contract named EtherSender that can send Ether to a recipient address using transfer, send, and call methods. You will set up the contract, add a recipient address, implement the sending functions, and finally test sending Ether.

📋 What You'll Learn

Create a payable contract named EtherSender

Add a public address variable called recipient

Add a function to set the recipient address

Implement three functions to send Ether using transfer, send, and call

Add a function to receive Ether into the contract

Print or return success status for send and call methods

💡 Why This Matters

🌍 Real World

Sending Ether is a core operation in Ethereum smart contracts for payments, refunds, and transfers between users or contracts.

💼 Career

Understanding how to safely send Ether using transfer, send, and call is essential for blockchain developers to build secure and reliable decentralized applications.

1

Create the contract and recipient address

Create a Solidity contract named EtherSender. Inside it, declare a public address variable called recipient to store the address that will receive Ether.

Blockchain / Solidity

contract EtherSender {
    // Your code here
}

Hint

Use contract EtherSender {} to start. Declare address public recipient; inside.

2

Add a function to set the recipient address

Add a public function named setRecipient that takes an address parameter called _recipient and sets the contract's recipient variable to this value.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract EtherSender {
    address public recipient;

    // Your code here
}

Hint

Write a function setRecipient with parameter address _recipient. Inside, assign recipient = _recipient;.

3

Implement functions to send Ether using transfer, send, and call

Add three public payable functions: sendViaTransfer, sendViaSend, and sendViaCall. Each function should send the Ether sent to the contract to the recipient address using the respective method. For sendViaSend and sendViaCall, return a bool indicating success.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract EtherSender {
    address public recipient;

    function setRecipient(address _recipient) public {
        recipient = _recipient;
    }

    // Your code here
}

Hint

Use payable(recipient).transfer(msg.value); in sendViaTransfer. For sendViaSend, use bool sent = payable(recipient).send(msg.value); return sent;. For sendViaCall, use (bool sent, ) = payable(recipient).call{value: msg.value}(""); return sent;.

4

Add a receive function and test sending Ether

Add a receive external payable function to allow the contract to accept Ether. Then add a public view function named getBalance that returns the contract's Ether balance. Finally, print the balance after sending Ether using any of the sending functions.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract EtherSender {
    address public recipient;

    function setRecipient(address _recipient) public {
        recipient = _recipient;
    }

    function sendViaTransfer() public payable {
        payable(recipient).transfer(msg.value);
    }

    function sendViaSend() public payable returns (bool) {
        bool sent = payable(recipient).send(msg.value);
        return sent;
    }

    function sendViaCall() public payable returns (bool) {
        (bool sent, ) = payable(recipient).call{value: msg.value}("");
        return sent;
    }

    // Your code here
}

Hint

Add receive() external payable {} to accept Ether. Add getBalance() to return address(this).balance.

Practice

1.

Which Solidity function automatically reverts the transaction if sending Ether fails?

easy

A. approve

B. send

C. call

D. transfer

Solution

1. Step 1: Understand transfer behavior

   transfer sends Ether and automatically reverts if the transfer fails.

2. Step 2: Compare with other methods

   send returns false on failure without reverting; call requires manual check; approve is unrelated to sending Ether.

3. Final Answer:

   transfer -> Option D

4. Quick Check:

   Automatic revert on failure = transfer [OK]

Hint: transfer always reverts on failure, no manual check needed [OK]

Common Mistakes:

• Confusing send with transfer behavior
• Thinking call auto-reverts on failure
• Mixing approve with Ether sending

2.

Which of the following is the correct syntax to send 1 Ether using send in Solidity?

recipient.?{value: 1 ether}();

easy

A. send

B. transfer

C. call

D. approve

Solution

1. Step 1: Recall send syntax

   send is called as recipient.send{value: amount}() in Solidity 0.6+.

2. Step 2: Match syntax with options

   Only send matches send method usage for sending Ether.

3. Final Answer:

   send -> Option A

4. Quick Check:

   send syntax = recipient.send{value: 1 ether}() [OK]

Hint: send uses .send{value: amount}() syntax [OK]

Common Mistakes:

• Using transfer syntax with send
• Confusing call syntax with send
• Using approve which is unrelated

3.

What will be the output of the following Solidity code snippet?

bool success = recipient.send{value: 1 ether}();
if (!success) {
    revert("Send failed");
}

medium

A. Transaction reverts if send fails

B. Transaction always succeeds without revert

C. Compilation error due to syntax

D. Transaction succeeds but ignores failure

Solution

1. Step 1: Analyze send return value

   send returns false if sending Ether fails, but does not revert automatically.

2. Step 2: Check revert condition

   The code checks !success and calls revert manually, so transaction reverts on failure.

3. Final Answer:

   Transaction reverts if send fails -> Option A

4. Quick Check:

   send returns false + manual revert = revert on failure [OK]

Hint: send returns bool; revert manually on false [OK]

Common Mistakes:

• Assuming send auto-reverts
• Ignoring manual revert check
• Thinking code always succeeds

4.

Identify the error in this Solidity code snippet that uses call to send Ether:

(bool sent, ) = recipient.call{value: 1 ether}();
require(sent, "Failed to send Ether");

medium

A. Missing gas parameter in call

B. Incorrect syntax for call

C. No error; code is correct

D. Should use send instead of call

Solution

1. Step 1: Review call syntax

   The syntax recipient.call{value: 1 ether}() is correct for sending Ether with call.

2. Step 2: Check error handling

   The code checks sent boolean and reverts if false, which is proper error handling.

3. Final Answer:

   No error; code is correct -> Option C

4. Quick Check:

   call with value + require check = correct usage [OK]

Hint: call needs manual success check; this code does it [OK]

Common Mistakes:

• Thinking gas parameter is mandatory
• Confusing call syntax with send or transfer
• Ignoring manual success check

5.

You want to send Ether to a contract that might consume more than 2300 gas on fallback. Which method should you use to ensure the transfer succeeds?

hard

A. transfer

B. call

C. approve

D. send

Solution

1. Step 1: Understand gas limits of transfer and send

   transfer and send forward only 2300 gas, which may be insufficient for complex fallback functions.

2. Step 2: Use call for flexible gas forwarding

   call allows forwarding all available gas, ensuring the receiving contract can execute complex logic.

3. Final Answer:

   call -> Option B

4. Quick Check:

   call forwards all gas, suitable for complex fallback [OK]

Hint: Use call to forward all gas for complex fallback [OK]

Common Mistakes:

• Using transfer or send which limit gas to 2300
• Confusing approve with sending Ether
• Ignoring fallback gas requirements