Accounts (EOA vs contract accounts) in Blockchain / Solidity - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Solidity code snippet?

Consider the following Solidity code that checks if an address is a contract or an externally owned account (EOA). What will be the output when calling checkAccountType with an EOA address?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract AccountChecker {
    function isContract(address account) public view returns (bool) {
        uint32 size;
        assembly {
            size := extcodesize(account)
        }
        return (size > 0);
    }

    function checkAccountType(address account) public view returns (string memory) {
        if (isContract(account)) {
            return "Contract Account";
        } else {
            return "Externally Owned Account";
        }
    }
}

A "Externally Owned Account"

B Runtime error due to extcodesize usage

C Compilation error due to assembly block

D "Contract Account"

💡 Hint

Remember that EOAs have no code, so extcodesize returns zero for them.

The assembly instruction extcodesize returns the size of the code at the given address. EOAs have no code, so the size is zero, making the function return false and the string "Externally Owned Account".

🧠 Conceptual

intermediate

Which statement correctly describes EOAs and contract accounts?

Select the statement that accurately distinguishes between externally owned accounts (EOAs) and contract accounts in Ethereum.

A Both EOAs and contract accounts have private keys controlling them.

B EOAs have associated code and can execute functions, while contract accounts cannot.

C Contract accounts have associated code and can execute functions, while EOAs are controlled by private keys and have no code.

D Contract accounts are controlled by users via private keys, EOAs are controlled by smart contracts.

💡 Hint

Think about who controls EOAs and what code means for contract accounts.

EOAs are controlled by private keys and have no code. Contract accounts contain code and execute it when called. EOAs initiate transactions, contract accounts respond to them.

🔧 Debug

advanced

Why does this Solidity function always return false for contract addresses?

This Solidity function is intended to detect if an address is a contract. However, it always returns false even for contract addresses. Identify the reason.

Blockchain / Solidity

function isContract(address account) public view returns (bool) {
    uint size;
    assembly {
        size := extcodesize(account)
    }
    return (size == 0);
}

A The assembly block syntax is invalid, causing the function to always return false.

B The function incorrectly returns true when size is zero, so it returns false for contracts.

C The variable 'size' is not initialized, causing unpredictable results.

D The function should use extcodehash instead of extcodesize to detect contracts.

💡 Hint

Check the return condition comparing size to zero.

The function returns true when size == 0, meaning it returns true for EOAs and false for contracts. This is the opposite of the intended logic.

📝 Syntax

advanced

Which option correctly compiles and returns the number of contract accounts in an array?

Given an array of addresses, which code snippet correctly counts how many are contract accounts using extcodesize?

Blockchain / Solidity

address[] memory accounts = new address[](3);
accounts[0] = 0x123...;
accounts[1] = 0x456...;
accounts[2] = 0x789...;

uint count = 0;
// Count contract accounts here

A

for (uint i = 0; i < accounts.length; i++) {
    uint size;
    assembly { size := extcodesize(accounts[i]) }
    if (size > 0) {
        count += 1;
    }
}

B

for (uint i = 0; i < accounts.length; i++) {
    uint size = extcodesize(accounts[i]);
    if (size > 0) {
        count++;
    }
}

C

for (uint i = 0; i < accounts.length; i++) {
    uint size;
    assembly { size := extcodesize(accounts[i]) }
    if (size == 0) {
        count += 1;
    }
}

D

for (uint i = 0; i < accounts.length; i++) {
    uint size;
    assembly { size := extcodesize(accounts[i]) }
    if (size > 0) {
        count = count + 1
    }
}

💡 Hint

Remember to use assembly correctly and check for size > 0.

Option A uses assembly correctly, checks if size > 0, and increments count properly with semicolons. Option A is invalid because extcodesize is not a Solidity function. Option A counts EOAs instead of contracts. Option A misses a semicolon causing syntax error.

🚀 Application

expert

What is the value of result after executing this Solidity code?

Given the following Solidity contract, what is the value of result after calling test()?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract TestContract {
    address public eoa;
    address public contractAddr;

    constructor(address _eoa, address _contractAddr) {
        eoa = _eoa;
        contractAddr = _contractAddr;
    }

    function isContract(address account) internal view returns (bool) {
        uint size;
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    function test() public view returns (string memory result) {
        if (isContract(eoa) && isContract(contractAddr)) {
            result = "Both are contracts";
        } else if (isContract(eoa)) {
            result = "EOA is contract";
        } else if (isContract(contractAddr)) {
            result = "Contract address is contract";
        } else {
            result = "Neither is contract";
        }
    }
}

A "Both are contracts"

B "Neither is contract"

C "EOA is contract"

D "Contract address is contract"

💡 Hint

EOAs have no code, contract addresses do.

The eoa address is an externally owned account with no code, so isContract(eoa) returns false. The contractAddr is a contract address, so isContract(contractAddr) returns true. Thus, the function returns "Contract address is contract".