Accounts (EOA vs contract accounts) in Blockchain / Solidity - When to Use Which

The Big Idea

What if your money and contracts could work for you automatically, without you lifting a finger?

The Scenario

Imagine you want to send money or instructions on a blockchain. You try to do it all by hand, managing keys and rules yourself, like writing checks and contracts on paper for every transaction.

The Problem

Doing this manually is slow and risky. You might lose keys, make mistakes in contracts, or forget steps. It's like handling all your bank and legal work without any digital help--errors and delays happen often.

The Solution

Blockchain accounts split into two types: Externally Owned Accounts (EOA) controlled by private keys, and Contract Accounts that run code automatically. This setup makes sending money and running programs safe, fast, and reliable without manual hassle.

Before vs After

✗ Before

Send transaction by manually signing and verifying keys every time.

✓ After

Use EOA to sign and Contract Account to run code automatically on blockchain.

What It Enables

This lets you build secure, automated applications on blockchain that handle money and logic without constant manual control.

Real Life Example

Think of a vending machine on blockchain: your EOA pays money, and the Contract Account automatically delivers the product without a person involved.

Key Takeaways

Manual blockchain operations are slow and error-prone.

EOA and Contract Accounts split control and automation clearly.

This makes blockchain apps secure, fast, and easy to use.

Practice

1. Which of the following best describes an Externally Owned Account (EOA) on a blockchain?

easy

A. An account that can only receive tokens but not send them.

B. An account that only stores data but cannot send transactions.

C. An account that automatically executes code when called.

D. An account controlled by a private key, used by people to send transactions.

Solution

1. Step 1: Understand what an EOA is

   An EOA is controlled by a private key and represents a user or person on the blockchain.

2. Step 2: Identify EOA capabilities

   EOAs can send transactions and initiate actions, unlike contract accounts which run code.

3. Final Answer:

   An account controlled by a private key, used by people to send transactions. -> Option D

4. Quick Check:

   EOA = user-controlled account [OK]

Hint: EOAs are user accounts with private keys [OK]

Common Mistakes:

• Confusing EOAs with contract accounts
• Thinking EOAs run code automatically
• Believing EOAs cannot send transactions

2. Which syntax correctly represents a contract account address in Solidity?

easy

A. address payable contractAddr = 0x1234567890abcdef1234567890abcdef12345678;

B. contractAddr = '0x1234567890abcdef1234567890abcdef12345678';

C. address contractAddr = 1234567890abcdef1234567890abcdef12345678;

D. address contractAddr = 0xGHIJKL7890abcdef1234567890abcdef12345678;

Solution

1. Step 1: Check Solidity address syntax

   Addresses must be hexadecimal starting with 0x and enclosed in proper type declaration.

2. Step 2: Validate each option

   The declaration 'address payable contractAddr = 0x1234567890abcdef1234567890abcdef12345678;' uses correct type and hex format. String assignments without type declaration are invalid, missing 0x prefix fails, and invalid hex characters like 'GHI' are not allowed.

3. Final Answer:

   address payable contractAddr = 0x1234567890abcdef1234567890abcdef12345678; -> Option A

4. Quick Check:

   Valid Solidity address syntax = address payable contractAddr = 0x1234567890abcdef1234567890abcdef12345678; [OK]

Hint: Solidity addresses start with 0x and use 'address' type [OK]

Common Mistakes:

• Omitting 0x prefix
• Using invalid hex characters
• Assigning address as a plain string without type

3. Consider the following Solidity code snippet:

address sender = msg.sender;
bool isContract = sender.code.length > 0;

What does isContract indicate?

medium

A. True if sender is an EOA, false if contract.

B. True if sender is a contract account, false if EOA.

C. Always true because msg.sender is a contract.

D. Always false because msg.sender has no code.

Solution

1. Step 1: Understand msg.sender.code.length

   This checks the length of the code at the sender's address; contracts have code, EOAs do not.

2. Step 2: Interpret the boolean value

   If code length > 0, sender is a contract account; otherwise, it's an EOA.

3. Final Answer:

   True if sender is a contract account, false if EOA. -> Option B

4. Quick Check:

   Code length > 0 means contract [OK]

Hint: Check code length to distinguish contract vs EOA [OK]

Common Mistakes:

• Assuming msg.sender is always EOA
• Confusing code length meaning
• Thinking EOAs have code

4. You have this Solidity function:

function sendEther(address recipient) public {
    recipient.transfer(1 ether);
}

When calling this function with an EOA address, it fails with an error. What is the likely cause?

medium

A. The recipient address is not payable, so transfer fails.

B. EOA addresses cannot receive ether.

C. The function lacks the payable modifier.

D. transfer() only works with contract accounts.

Solution

1. Step 1: Understand transfer() requirements

   transfer() requires the recipient address to be payable to receive ether.

2. Step 2: Analyze recipient type

   If recipient is declared as address (not address payable), transfer will fail even if it's an EOA.

3. Final Answer:

   The recipient address is not payable, so transfer fails. -> Option A

4. Quick Check:

   Use address payable for ether transfers [OK]

Hint: Use address payable to send ether [OK]

Common Mistakes:

• Thinking EOAs can't receive ether
• Missing payable keyword on function
• Assuming transfer only works with contracts

5. You want to write a Solidity function that sends 1 ether only if the recipient is an EOA (not a contract). Which code snippet correctly implements this check?

hard

A. require(recipient.balance > 0, "Recipient must have balance"); recipient.transfer(1 ether);

B. require(recipient.code.length > 0, "Recipient must be contract"); payable(recipient).transfer(1 ether);

C. require(recipient.code.length == 0, "Recipient must be EOA"); payable(recipient).transfer(1 ether);

D. require(msg.sender == recipient, "Sender must be recipient"); recipient.transfer(1 ether);

Solution

1. Step 1: Check recipient code length to identify EOA

   EOAs have no code, so recipient.code.length == 0 confirms EOA.

2. Step 2: Use require to enforce condition and transfer ether

   If recipient is EOA, convert to payable and transfer 1 ether safely.

3. Final Answer:

   require(recipient.code.length == 0, "Recipient must be EOA"); payable(recipient).transfer(1 ether); -> Option C

4. Quick Check:

   Code length 0 means EOA, then transfer [OK]

Hint: Check code length == 0 to confirm EOA before sending [OK]

Common Mistakes:

• Checking for code length > 0 to find EOAs
• Not converting address to payable before transfer
• Using balance check instead of code length