Why Ethereum enables programmable money in Blockchain / Solidity

Introduction

Ethereum lets people create money that can do things by itself. This means money can follow rules automatically without needing a person to control it.

You want to make a digital contract that pays money only when certain things happen.

You want to build a game where players earn and spend digital money automatically.

You want to create a system where money moves between people without a bank.

You want to make a savings account that gives interest based on rules you set.

You want to build a voting system where votes are counted and rewarded with tokens.

Syntax

Blockchain / Solidity

contract MyContract {
    // code that controls money and rules
}

Ethereum uses smart contracts which are like computer programs that run on the blockchain.

These contracts can hold and send digital money automatically based on code.

Examples

This contract lets the owner send money to others following the rules coded inside.

Blockchain / Solidity

contract SimpleWallet {
    address owner;
    
    constructor() {
        owner = msg.sender;
    }
    
    function sendEther(address payable to, uint amount) public {
        require(msg.sender == owner, "Only owner can send");
        to.transfer(amount);
    }
}

This contract holds money until a certain time, then lets anyone withdraw it.

Blockchain / Solidity

contract TimeLock {
    uint unlockTime;
    
    constructor(uint _unlockTime) {
        unlockTime = _unlockTime;
    }
    
    function withdraw() public {
        require(block.timestamp >= unlockTime, "Too early to withdraw");
        payable(msg.sender).transfer(address(this).balance);
    }
}

Sample Program

This simple contract acts like a piggy bank. Anyone can send money to it, but only the owner can take it out.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract PiggyBank {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    // Function to receive money
    receive() external payable {}

    // Owner can withdraw all money
    function withdraw() public {
        require(msg.sender == owner, "Only owner can withdraw");
        payable(owner).transfer(address(this).balance);
    }
}

Important Notes

Smart contracts run exactly as programmed without downtime or interference.

Once deployed, contracts cannot be changed, so code must be tested carefully.

Ethereum uses its own digital money called Ether to pay for running contracts.

Summary

Ethereum lets money follow rules automatically using smart contracts.

This makes money programmable and able to do tasks without middlemen.

Smart contracts are the key to creating programmable money on Ethereum.

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