Solidity types - Test | RedDuck Academy

Solidity types - Test

01.

Caller identity at deployment time

A contract has the following constructor:

solidity

contract Vault {
    address public deployer;

    constructor() {
        deployer = msg.sender;
    }
}

Alice's EOA deploys this contract directly from her wallet. After deployment, what does deployer hold?

The address of the deployed Vault contract itself

Alice's EOA address

address(0)

The address of the factory or proxy that processed the deployment

02.

You want to check whether two string memory variables hold the same text. Which expression compiles and works?

s1 == s2

keccak256(bytes(s1)) == keccak256(bytes(s2))

s1.equals(s2)

bytes(s1) == bytes(s2)

03.

Consider this contract:

solidity

contract Order {
    enum Status { Approved, Pending, Rejected, Shipped }
    Status public state;
}

Immediately after deployment, what is the value of state?

Pending, because that's the natural starting state for an order

Approved

Rejected

The variable is uninitialized and reading it reverts

04.

What is the result of compiling this function?

solidity

function build() public pure returns (uint256[] memory) {
    uint256[] memory arr = new uint256[](2);
    arr[0] = 1;
    arr[1] = 2;
    arr.push(3);
    return arr;
}

Compiles; returns [1, 2, 3]

Compiles; reverts at runtime when push is called

Compile error: memory arrays don't support push

Compiles; returns [1, 2] (the push is silently ignored)

05.

Two functions read from data structures using a value that was never written:

solidity

contract A {
    mapping(uint256 => uint256) m;
    uint256[] arr;

    function readMissing() external view returns (uint256, uint256) {
        return (m[999], arr[999]);
    }
}

What happens when readMissing is called on a freshly deployed contract?

Both reads return 0

m[999] returns 0; arr[999] reverts

Both reads revert

m[999] reverts; arr[999] returns 0

06.

A contract starts with a balance of 0. An external caller invokes the following function with 1 ether attached:

solidity

contract Vault {
    function deposit() external payable returns (uint256) {
        return address(this).balance;
    }
}

0, because the deposit is only credited after the function returns

1 ether, because the deposit is credited before the function body runs

Reverts because address(this).balance is not allowed in payable functions

An undefined value; the order is not guaranteed

07.

Two functions both compute "7 percent of x" using integer math:

solidity

function pctA(uint256 x) public pure returns (uint256) {
    return (x * 7) / 100;
}

function pctB(uint256 x) public pure returns (uint256) {
    return (x / 100) * 7;
}

For x = 50, what does each function return?

Both return 3

Both return 0

pctA returns 3, pctB returns 0

pctA returns 0, pctB returns 3

08.

A contract has this code:

solidity

enum Status { A, B, C }

function castFrom(uint8 value) public pure returns (Status) {
    return Status(value);
}

What happens when this function is called with value = 5?

Returns Status.A (5 modulo 3 = 2, but indexing wraps around to A)

Returns Status.C (out-of-range values are clamped to the highest valid value)

Reverts the transaction

Returns an undefined value; behavior depends on the compiler version

09.

Two contracts each declare a single state variable:

solidity

contract A { uint8 public count; }
contract B { uint256 public count; }

Compared to writing to count in contract B, writing to count in contract A costs:

1/32 as much gas (proportional to the bit width)

Roughly 1/4 as much gas

Roughly the same amount of gas

More gas, because the EVM has to mask the value to fit uint8

Structs

Functions

01.Welcome to Ethereum

02.How Ethereum works

03.Solidity basics

04.Token security and EVM internals

05.DeFi tasks and patterns

06.Tokens beyond ERC-20

07.Oracles

08.Advanced DeFi

09.Conclusion

Solidity types - Test