Event testing in Blockchain / Solidity - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an event in blockchain smart contracts?

An event is a way for smart contracts to log information that external applications can listen to and react upon. It helps communicate contract state changes to the outside world.

beginner

Why do we test events in smart contracts?

Testing events ensures that the contract emits the correct information at the right time, which is important for front-end apps or other contracts that rely on these signals.

intermediate

How can you listen for events in a test script?

You can listen for events by calling the contract function in a test and then checking the transaction receipt for the expected event and its parameters.

beginner

What is a common tool used for event testing in Ethereum smart contracts?

Tools like Hardhat or Truffle provide testing frameworks that allow you to assert that events were emitted with expected values during contract execution.

intermediate

What does it mean if an event is not emitted during a test when expected?

It usually means the contract logic did not reach the point where the event should be emitted, indicating a possible bug or incorrect test setup.

What is the main purpose of events in blockchain smart contracts?

A To store data permanently on the blockchain

B To log information for external listeners

C To execute contract functions

D To create new tokens

Events log information that external apps can listen to, helping them react to contract changes.

Which of these is a common framework for testing Ethereum smart contract events?

A Hardhat

B React

C Node.js

D Docker

Hardhat is a popular Ethereum development environment that supports event testing.

When testing events, what do you check in the transaction receipt?

A The gas price

B The block number

C The emitted events and their parameters

D The wallet address

The transaction receipt contains logs of emitted events and their data.

If an expected event is missing in a test, what might be the cause?

A The contract ran out of gas

B The wallet balance is zero

C The blockchain is offline

D The event was never emitted due to logic error

Missing events usually mean the contract logic did not trigger the event.

What is the benefit of testing events in smart contracts?

A To verify contract state changes are communicated

B To create new blockchain nodes

C To reduce gas fees

D To improve contract speed

Testing events confirms that important contract changes are properly signaled.

Explain how you would test that a smart contract emits a specific event with correct data.

Think about how to capture and inspect emitted events after a function call.

Why is event testing important for blockchain applications?

Consider the role of events in connecting smart contracts with external systems.

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