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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a simple Ethereum smart contract that stores a number.

Blockchain / Solidity

contract SimpleStorage {
    uint256 public [1];
}

Drag options to blanks, or click blank then click option'

AstoredData

Bvalue

Cnumber

Ddata

Attempts:

3 left

💡 Hint

Common Mistakes

Using names that are too generic or reserved keywords.

The variable storedData is a common name used to store data in simple contracts.

2fill in blank

medium

Complete the code to create a function that sets the stored number.

Blockchain / Solidity

function set(uint256 x) public {
    [1] = x;
}

Drag options to blanks, or click blank then click option'

AstoredData

Bdata

Cvalue

Dnumber

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name that is not declared in the contract.

The function sets the value of the variable storedData to the input x.

3fill in blank

hard

Fix the error in the function to return the stored number correctly.

Blockchain / Solidity

function get() public view returns (uint256) {
    return [1];
}

Drag options to blanks, or click blank then click option'

Avalue

BstoredData

Cnumber

Ddata

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a variable that is not declared or misspelled.

The function returns the value of storedData, which holds the stored number.

4fill in blank

hard

Fill both blanks to create a mapping that stores balances and a function to update it.

Blockchain / Solidity

mapping(address => uint256) public [1];

function updateBalance(address user, uint256 amount) public {
    [2][user] = amount;
}

Drag options to blanks, or click blank then click option'

Abalances

Baccounts

Dledger

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for the mapping and in the function.

The mapping balances stores the balance for each address, and the function updates it.

5fill in blank

hard

Fill all three blanks to create a function that transfers tokens between users.

Blockchain / Solidity

function transfer(address to, uint256 amount) public {
    require([1][msg.sender] >= amount, "Insufficient balance");
    [2][msg.sender] -= amount;
    [3][to] += amount;
}

Drag options to blanks, or click blank then click option'

Abalances

Baccounts

Dledger

Attempts:

3 left

💡 Hint

Common Mistakes

Using different mapping names causing errors.

The function checks the sender's balance in balances, subtracts the amount, and adds it to the recipient's balance.

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