Event testing in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Solidity event emission?

Consider the following Solidity contract snippet that emits an event. What will be the output when the triggerEvent function is called?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract EventTest {
    event NumberSet(uint indexed number);

    function triggerEvent() public {
        emit NumberSet(42);
    }
}

A A compilation error occurs because the event is not declared correctly.

B The function returns the number 42 as output.

C The event NumberSet with number 42 is emitted and logged on the blockchain.

D The event NumberSet is emitted but with number 0 instead of 42.

💡 Hint

Events in Solidity are used to log information on the blockchain and do not return values from functions.

The emit keyword triggers the event NumberSet with the value 42. This event is logged on the blockchain and can be listened to by external applications. The function itself does not return any value.

🧠 Conceptual

intermediate

Which statement about blockchain event testing is true?

When testing events emitted by smart contracts, which of the following is correct?

A Events automatically revert the transaction if the event data is incorrect.

B Events are returned as function return values and can be asserted directly.

C Events cannot be tested because they are not stored on the blockchain.

D Events can be tested by checking transaction logs after the transaction is mined.

💡 Hint

Think about how events are stored and accessed after a transaction.

Events are stored in the transaction logs on the blockchain. Testing frameworks can access these logs after the transaction is mined to verify that the correct events were emitted with expected data.

🔧 Debug

advanced

Why does this event test fail to detect the emitted event?

Given the following test code snippet for a Solidity contract event, why does the test fail to detect the event?

Blockchain / Solidity

const tx = await contract.triggerEvent();
const receipt = await tx.wait();
const event = receipt.events.find(e => e.event === 'NumberSet');
assert(event.args.number === 42);

A The event argument is accessed incorrectly; it should be <code>event.args[0]</code> instead of <code>event.args.number</code>.

B The transaction receipt does not contain events because <code>wait()</code> was not called.

C The contract does not emit any event named 'NumberSet' because the event is not declared.

D The event name is case-sensitive and 'NumberSet' does not match the emitted event name.

💡 Hint

Check the exact spelling and capitalization of the event name in the contract and test.

Event names in Solidity are case-sensitive. If the emitted event is named 'Numberset' but the test looks for 'NumberSet', the event will not be found, causing the test to fail.

📝 Syntax

advanced

Which option correctly declares and emits an event with two parameters in Solidity?

Choose the correct Solidity code snippet that declares an event with two parameters and emits it properly.

A

event DataSet(uint id, string value)
function setData() public {
  emit DataSet(1, "hello");
}

B

event DataSet(uint indexed id, string value);
function setData() public {
  emit DataSet(1, "hello");
}

C

event DataSet(uint id, string value);
function setData() public {
  DataSet(1, "hello");
}

D

event DataSet(uint indexed id, string value);
function setData() public {
  emit DataSet(1);
}

💡 Hint

Remember that events must be declared with a semicolon and emitted with the emit keyword including all parameters.

Option B correctly declares the event with a semicolon and emits it with both parameters using emit. Option B misses the semicolon after the event declaration. Option B does not use emit. Option B emits the event with missing parameters.

🚀 Application

expert

How many events are emitted and what are their values after this function call?

Given the following Solidity function, how many events are emitted and what are their values when multiEmit() is called?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract MultiEvent {
    event Log(uint indexed id, string message);

    function multiEmit() public {
        for (uint i = 1; i <= 3; i++) {
            emit Log(i, string(abi.encodePacked("Event", uint2str(i))));
        }
    }

    function uint2str(uint _i) internal pure returns (string memory str) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len;
        while (_i != 0) {
            k = k-1;
            uint8 temp = (48 + uint8(_i - _i / 10 * 10));
            bstr[k] = bytes1(temp);
            _i /= 10;
        }
        str = string(bstr);
    }
}

A Three events are emitted with values: (1, "Event1"), (2, "Event2"), (3, "Event3").

B Three events are emitted but all have the same value: (3, "Event3").

C No events are emitted because string concatenation is invalid.

D One event is emitted with value: (3, "Event3").

💡 Hint

Look at the loop and how the event is emitted each iteration with the current index.

The function emits the Log event three times with the index from 1 to 3 and the message "Event" concatenated with the index number. The helper function uint2str converts the number to a string correctly.

Practice

1.

What is the main purpose of event testing in blockchain smart contracts?

easy

A. To verify that the contract emits the correct events during execution

B. To check the contract's gas usage

C. To test the contract's user interface

D. To optimize the contract's storage

Solution

1. Step 1: Understand event testing purpose

   Event testing focuses on confirming that smart contracts emit the right signals (events) when certain actions happen.

2. Step 2: Compare options with event testing goal

   Only To verify that the contract emits the correct events during execution matches this purpose, as it talks about verifying emitted events.

3. Final Answer:

   To verify that the contract emits the correct events during execution -> Option A

4. Quick Check:

   Event testing = Verify emitted events [OK]

Hint: Event testing checks emitted signals, not gas or UI [OK]

Common Mistakes:

• Confusing event testing with gas optimization
• Thinking event testing checks UI elements
• Assuming event testing measures storage use

2.

Which of the following is the correct syntax to listen for an event named Transfer in a Solidity test using JavaScript?

contractInstance.Transfer({fromBlock: 0, toBlock: 'latest'}).???

easy

A. on

B. watch

C. emit

D. listen

Solution

1. Step 1: Recall event listening syntax in Solidity tests

   In older Solidity test frameworks, watch is used to listen for events on contract instances.

2. Step 2: Match options with correct method

   Only watch fits the syntax shown; on, emit, and listen are incorrect here.

3. Final Answer:

   watch -> Option B

4. Quick Check:

   Event listening method = watch [OK]

Hint: Use 'watch' to listen for events in Solidity JS tests [OK]

Common Mistakes:

• Using 'emit' which triggers events, not listens
• Confusing 'on' with event listening in other frameworks
• Using 'listen' which is not a Solidity test method

3.

Given this Solidity event and test snippet, what will be the output of console.log(events.length) after calling transfer() once?

event Transfer(address indexed from, address indexed to, uint amount);

// In test:
const events = await contractInstance.getPastEvents('Transfer', {fromBlock: 0, toBlock: 'latest'});
await contractInstance.transfer(receiver, 100);
console.log(events.length);

medium

A. undefined

B. 1

C. 0

D. 100

Solution

1. Step 1: Understand event fetching timing

   The getPastEvents call happens before transfer(), so it fetches events before the transfer.

2. Step 2: Analyze event count after transfer

   Since events are fetched before the transfer, events.length will be 0 because no Transfer event happened yet.

3. Final Answer:

   0 -> Option C

4. Quick Check:

   Events fetched before transfer = 0 [OK]

Hint: Fetch events after action to see new events [OK]

Common Mistakes:

• Assuming events array updates automatically
• Ignoring async order of calls
• Expecting event count before event occurs

4.

Identify the error in this test code snippet that listens for an event Approval:

contractInstance.Approval().watch((error, event) => {
  if (!error) {
    console.log('Approval event:', event);
  }
});

medium

A. Using watch instead of on

B. Using Approval() instead of Approval without parentheses

C. Incorrect callback function signature

D. Missing event filter parameters in the call

Solution

1. Step 1: Check event listening syntax

   The event constructor requires a filter object parameter (e.g., {fromBlock: 0}) to specify the event scope.

2. Step 2: Identify correct usage

   The correct syntax is contractInstance.Approval({fromBlock: 0}).watch(...); the code uses empty Approval().

3. Final Answer:

   Missing event filter parameters in the call -> Option D

4. Quick Check:

   Event filter params required [OK]

Hint: Include event filter parameters like {fromBlock: 0} [OK]

Common Mistakes:

• Omitting filter parameters in event call
• Confusing callback parameters
• Mixing event listening methods

5.

You want to test that a Deposit event is emitted only when the deposit amount is greater than zero. Which test approach correctly verifies this?

1. Call deposit(0) and check no event emitted
2. Call deposit(100) and check event emitted with amount 100
3. Call deposit(-50) and check event emitted
4. Call deposit(100) and check event emitted with amount 0

hard

A. Only steps 1 and 2 are correct test cases

B. All steps are correct to test event emission

C. Only step 3 is needed to test event emission

D. Only step 4 is correct to test event emission

Solution

1. Step 1: Understand event emission condition

   The event should emit only if deposit amount > 0, so deposit(0) should emit no event, deposit(100) should emit event with amount 100.

2. Step 2: Evaluate test steps

   Step 3 calls deposit(-50), which is invalid (negative deposit), so event emission is not expected. Step 4 expects event with amount 0, which contradicts the condition.

3. Final Answer:

   Only steps 1 and 2 are correct test cases -> Option A

4. Quick Check:

   Test event only for positive deposits [OK]

Hint: Test zero and positive amounts only for event emission [OK]

Common Mistakes:

• Testing negative amounts which are invalid
• Expecting event with zero amount
• Assuming all deposits emit events