Why Ethereum enables programmable money in Blockchain / Solidity - See It in Action

Why Ethereum Enables Programmable Money

📖 Scenario: Imagine you want to create a simple digital wallet that can hold money and send it to others automatically based on rules you set. Ethereum lets you do this by using smart contracts, which are like small programs that run on the blockchain.

🎯 Goal: You will build a simple program that shows how Ethereum can hold money and send it automatically when a condition is met. This is the basic idea behind programmable money.

📋 What You'll Learn

Create a dictionary called wallet with an initial balance of 100

Create a variable called send_amount and set it to 30

Write an if statement that checks if wallet['balance'] is greater than or equal to send_amount

Inside the if, subtract send_amount from wallet['balance'] and print a message showing the new balance

If the balance is not enough, print a message saying 'Insufficient funds'

💡 Why This Matters

🌍 Real World

Ethereum lets people write small programs called smart contracts that can hold and send money automatically based on rules. This is useful for things like automatic payments, loans, or games.

💼 Career

Understanding programmable money is important for jobs in blockchain development, fintech, and software engineering where automation and smart contracts are used.

1

Create the wallet with initial balance

Create a dictionary called wallet with a key 'balance' set to the integer 100.

Blockchain / Solidity

# Create a dictionary called wallet with 'balance' set to 100
# Your code here

Hint

Use curly braces {} to create a dictionary and set the key 'balance' to 100.

2

Set the amount to send

Create a variable called send_amount and set it to the integer 30.

Blockchain / Solidity

wallet = {'balance': 100}
# Create a variable send_amount and set it to 30
# Your code here

Hint

Just write send_amount = 30 to create the variable.

3

Check if wallet has enough balance

Write an if statement that checks if wallet['balance'] is greater than or equal to send_amount.

Blockchain / Solidity

wallet = {'balance': 100}
send_amount = 30
# Write an if statement to check if wallet['balance'] >= send_amount
# Your code here

Hint

Use if wallet['balance'] >= send_amount: to start the condition.

4

Send money if enough balance, else show error

Inside the if, subtract send_amount from wallet['balance'] and print "Sent {send_amount}. New balance: {wallet['balance']}". Use an else to print "Insufficient funds" if balance is not enough.

Blockchain / Solidity

wallet = {'balance': 100}
send_amount = 30
if wallet['balance'] >= send_amount:
    # Subtract send_amount from wallet['balance'] and print the new balance
    # Your code here
else:
    # Print 'Insufficient funds'
    # Your code here

Hint

Use wallet['balance'] -= send_amount to subtract. Use print(f"Sent {send_amount}. New balance: {wallet['balance']}") to show the message.

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