Why events communicate contract activity in Blockchain / Solidity - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Solidity event emission?

Consider this Solidity contract snippet that emits an event when a value is updated. What will be logged in the transaction receipt's event logs after calling updateValue(42)?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Example {
    event ValueChanged(address indexed author, uint256 oldValue, uint256 newValue);
    uint256 public value;

    function updateValue(uint256 newValue) public {
        uint256 old = value;
        value = newValue;
        emit ValueChanged(msg.sender, old, newValue);
    }
}

A An event log with author address, oldValue = 0, newValue = 42

B An event log with author address, oldValue = 42, newValue = 42

C No event log is created because events are not stored

D A runtime error occurs because events cannot have indexed parameters

💡 Hint

Events record the state before and after the change and include the sender's address.

When updateValue is called, the event ValueChanged is emitted with the sender's address, the old value (initially 0), and the new value (42). Events are stored in transaction logs and can be accessed off-chain.

🧠 Conceptual

intermediate

Why do smart contracts use events to communicate activity?

Which of the following best explains why smart contracts emit events to communicate contract activity?

A Events automatically update contract storage variables for faster access.

B Events allow off-chain applications to efficiently track contract state changes without reading all contract storage.

C Events prevent other contracts from calling the emitting contract.

D Events encrypt contract data to secure it from public view.

💡 Hint

Think about how external apps listen to blockchain changes.

Events are stored in transaction logs and can be indexed, allowing off-chain apps to listen and react to contract changes efficiently without expensive storage reads.

🔧 Debug

advanced

Identify the error in this event emission code

This Solidity function is supposed to emit an event when a user deposits Ether. What error will occur when compiling or running this code?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Deposit {
    event DepositMade(address indexed user, uint amount);

    function deposit() public payable {
        emit DepositMade(msg.sender, msg.value);
    }

    function getBalance() public view returns (uint) {
        return address(this).balance;
    }
}

A Compilation error: event parameters must be non-indexed.

B SyntaxError: 'indexed' keyword cannot be used in event parameters.

C No error; the code compiles and runs correctly emitting the event.

D Runtime error: msg.value is not accessible in non-payable functions.

💡 Hint

Check the use of 'indexed' and payable function modifiers.

The code correctly declares an event with an indexed parameter and emits it inside a payable function. This is valid Solidity syntax and behavior.

❓ Predict Output

advanced

What is the output of this event filter query?

Given a contract that emits this event multiple times, what will be the result of filtering logs for ValueChanged events where author equals a specific address?

Blockchain / Solidity

event ValueChanged(address indexed author, uint256 oldValue, uint256 newValue);

// Assume events emitted:
// ValueChanged(0xABC..., 0, 10)
// ValueChanged(0xDEF..., 10, 20)
// ValueChanged(0xABC..., 20, 30)

// Filter query: author == 0xABC...

A Two event logs: one with oldValue 0 newValue 10, and one with oldValue 20 newValue 30

B All three event logs regardless of author

C No event logs because filtering by indexed parameters is not supported

D Only the first event log with oldValue 0 newValue 10

💡 Hint

Indexed parameters allow filtering events by that value.

Events with indexed parameters can be filtered by those values. Here, filtering by author address 0xABC... returns the two events where that address emitted the event.

🧠 Conceptual

expert

Why are events preferred over contract storage for communicating activity to off-chain systems?

Which reason best explains why blockchain developers prefer emitting events instead of writing data to contract storage to communicate contract activity to off-chain systems?

A Events automatically trigger off-chain code execution, while storage changes do not.

B Contract storage is private and cannot be read by off-chain systems, so events are the only way to share data.

C Writing to contract storage is slower because it requires consensus, but events do not require consensus.

D Events are cheaper in gas and provide an efficient, indexed log that off-chain systems can easily monitor without expensive storage reads.

💡 Hint

Think about gas costs and how off-chain apps listen to blockchain data.

Events are stored in transaction logs which are cheaper to write than contract storage and can be indexed for fast filtering. Off-chain systems use these logs to track contract activity efficiently.