Why Ethereum enables programmable money in Blockchain / Solidity - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Solidity smart contract function?

Consider this simple Solidity function that returns the balance of an address in a token contract. What will be the output when calling getBalance() if the balance mapping has balances[msg.sender] = 100?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Token {
    mapping(address => uint) balances;

    constructor() {
        balances[msg.sender] = 100;
    }

    function getBalance() public view returns (uint) {
        return balances[msg.sender];
    }
}

A 0

B Revert error at runtime

C Compilation error

D 100

💡 Hint

Think about what the constructor does when the contract is deployed.

The constructor sets the balance of the deployer (msg.sender) to 100. Calling getBalance() from the deployer's address returns 100.

🧠 Conceptual

intermediate

Why does Ethereum enable programmable money?

Which of the following best explains why Ethereum allows money to be programmable?

A Ethereum uses a blockchain that supports smart contracts, which are self-executing code that can control digital assets automatically.

B Ethereum stores all money in a single centralized database controlled by one company.

C Ethereum only supports simple transactions without any code execution.

D Ethereum requires manual approval for every transaction by a central authority.

💡 Hint

Think about what smart contracts do on Ethereum.

Ethereum's blockchain supports smart contracts, which are programs that run automatically and can manage money based on rules coded into them.

🔧 Debug

advanced

Identify the error in this Solidity function for transferring tokens

This function is intended to transfer tokens from the sender to a recipient. What error will occur when this code runs?

Blockchain / Solidity

function transfer(address to, uint amount) public {
    require(balances[msg.sender] >= amount);
    balances[msg.sender] -= amount;
    balances[to] += amount;
}

A No error, the function works correctly.

B Revert error if balances[msg.sender] is less than amount.

C Compilation error due to missing return type.

D Runtime error if balances[to] overflows uint limit.

💡 Hint

Look at the require statement and what it checks.

The require statement causes the transaction to revert if the sender's balance is less than the amount, preventing the transfer.

📝 Syntax

advanced

Which option correctly declares a payable function in Solidity?

You want to write a function that can receive Ether. Which of these function declarations is syntactically correct?

A function deposit() payable public {}

B function deposit() public payble {}

C function deposit() public payable {}

D function deposit() public payable returns (uint) {}

💡 Hint

Check the spelling and order of keywords.

The correct syntax is function deposit() public payable {}. The keyword 'payable' must be spelled correctly and placed after visibility.

🚀 Application

expert

How does Ethereum ensure that smart contract code runs the same on all nodes?

Ethereum uses a special system to make sure every node runs smart contract code identically. Which mechanism achieves this?

A Ethereum uses the Ethereum Virtual Machine (EVM) which executes bytecode deterministically on all nodes.

B Ethereum relies on each node running different code versions to increase diversity.

C Ethereum nodes execute smart contracts using local machine instructions that vary by hardware.

D Ethereum uses a centralized server to run all smart contract code and broadcast results.

💡 Hint

Think about how Ethereum achieves consensus on contract execution.

The EVM is a virtual computer that runs the same bytecode on every node, ensuring consistent results and trustless execution.

Practice

1. Why does Ethereum enable money to be programmable?

easy

A. Because it uses smart contracts that run code automatically

B. Because it stores money only in physical wallets

C. Because it requires banks to approve transactions

D. Because it uses paper currency for transactions

Solution

1. Step 1: Understand Ethereum's core feature

   Ethereum uses smart contracts, which are pieces of code that run automatically on the blockchain.

2. Step 2: Connect smart contracts to programmable money

   Smart contracts can control money by following rules written in code, making money programmable without middlemen.

3. Final Answer:

   Because it uses smart contracts that run code automatically -> Option A

4. Quick Check:

   Smart contracts = Programmable money [OK]

Hint: Smart contracts run code to control money automatically [OK]

Common Mistakes:

• Thinking Ethereum uses physical wallets only
• Assuming banks approve Ethereum transactions
• Confusing Ethereum with paper currency systems

2. Which of the following is the correct way to define a simple smart contract function in Solidity that sends Ether?

easy

A. function sendEther(payable recipient) public payable { recipient.send(msg.value); }

B. function sendEther(address payable recipient) public payable { recipient.transfer(msg.value); }

C. function sendEther(address recipient) private { recipient.transfer(msg.value); }

D. function sendEther(address recipient) public { recipient.send(msg.value); }

Solution

1. Step 1: Check function signature for sending Ether

   The function must be public and payable to receive and send Ether, and the recipient must be declared payable.

2. Step 2: Verify the transfer method usage

   Using recipient.transfer(msg.value) correctly sends the Ether amount received in the call.

3. Final Answer:

   function sendEther(address payable recipient) public payable { recipient.transfer(msg.value); } -> Option B

4. Quick Check:

   Payable recipient + public payable function + transfer = Correct [OK]

Hint: Use 'address payable' and 'payable' function to send Ether [OK]

Common Mistakes:

• Missing 'payable' keyword on function or address
• Using 'send' without checking return value
• Declaring function as private when it should be public

3. What will be the output of this Solidity code snippet when the function checkBalance() is called after sending 5 Ether to the contract?

contract Wallet {
    uint public balance;
    function deposit() public payable {
        balance += msg.value;
    }
    function checkBalance() public view returns (uint) {
        return balance;
    }
}

medium

A. 5000000000000000000

B. 5

C. 0

D. Compilation error

Solution

1. Step 1: Understand msg.value unit in Solidity

   Ether values in Solidity are handled in wei, where 1 Ether = 10^18 wei.

2. Step 2: Calculate balance after deposit

   Sending 5 Ether means msg.value = 5 * 10^18 wei = 5000000000000000000 wei, which is added to balance.

3. Final Answer:

   5000000000000000000 -> Option A

4. Quick Check:

   5 Ether = 5 * 10^18 wei = 5000000000000000000 [OK]

Hint: Remember Ether is in wei (1 Ether = 10^18 wei) [OK]

Common Mistakes:

• Returning Ether as 5 instead of wei
• Confusing balance with contract's actual Ether balance
• Expecting output in Ether units without conversion

4. Identify the error in this Solidity smart contract code that tries to send Ether to an address:

contract Pay {
    function payTo(address recipient) public payable {
        recipient.transfer(msg.value);
    }
}

medium

A. transfer() cannot be used to send Ether

B. The function should not be payable

C. msg.value cannot be used inside the function

D. The recipient address must be declared payable

Solution

1. Step 1: Check recipient address type

   In Solidity, to send Ether, the recipient address must be declared as payable.

2. Step 2: Identify missing payable keyword

   The code uses 'address recipient' instead of 'address payable recipient', causing a compilation error.

3. Final Answer:

   The recipient address must be declared payable -> Option D

4. Quick Check:

   Address payable needed to send Ether [OK]

Hint: Use 'address payable' for recipients receiving Ether [OK]

Common Mistakes:

• Forgetting 'payable' on recipient address
• Thinking transfer() is invalid
• Removing payable from function incorrectly

5. You want to create a smart contract that automatically sends 1 Ether to a specific address every time it receives at least 2 Ether. Which approach best uses Ethereum's programmable money feature?

hard

A. Use an external script to monitor the contract and send Ether when balance is 2 Ether

B. Manually send Ether from your wallet to the address after receiving 2 Ether

C. Write a payable function that checks if msg.value >= 2 Ether, then sends 1 Ether to the address using transfer()

D. Set a timer outside Ethereum to send Ether every day

Solution

1. Step 1: Use smart contract code to automate sending

   Writing a payable function that checks the amount received and sends Ether automatically uses Ethereum's programmable money feature.

2. Step 2: Avoid manual or external triggers

   Manual sending or external scripts do not leverage Ethereum's automatic, trustless execution.

3. Final Answer:

   Write a payable function that checks if msg.value >= 2 Ether, then sends 1 Ether to the address using transfer() -> Option C

4. Quick Check:

   Smart contract automation = programmable money [OK]

Hint: Automate with payable function and transfer() inside contract [OK]

Common Mistakes:

• Relying on manual or external triggers
• Not using payable functions for receiving Ether
• Ignoring automatic code execution on Ethereum