Table of Contents

• Defining an Event in Solidity
• Emitting Events in Functions
• Understanding Event Signatures
• Exploring Event Topic Hashes
• Event Parameters and Indexed Parameters
• Overview of Anonymous Events
• Emitting Events in Assembly with the LOG Opcode
• The Check-Event-Interaction Pattern
• Best Practices for Emitting Events

Section 1.1: Defining an Event in Solidity

Events in Solidity can be declared using the event keyword, as illustrated below:

event RegisteredSuccessfully(address user);

When using dynamic types or multi-value types, such as bytes, string, or arrays like T[], you don't need to specify the data location for parameters in the event definition. It’s important to note that events can only be defined within contracts, libraries, or interfaces. However, starting from version 0.8.22, events can also be defined at the file level.

Events defined in one contract can be accessed from another contract. Fully qualified access to events has been available since Solidity version 0.8.15. For instance:

interface ILight {

event SwitchedON();

event SwitchedOFF();

event BulbReplaced();

}

To access an event from another contract, use the fully qualified name of the contract followed by the event name:

import {ILight} from "ILight.sol";

contract LightHouse {

function lightTowardsDirections(uint256 latitude, uint256 longitude) public {

// code logic

emit ILight.SwitchedON();

}

}

Section 1.2: Emitting Events in Functions

You can emit an event within a function using the emit keyword. If a function emits an event, it cannot be declared as view or pure since emitting an event writes data to the blockchain logs.

Description: This video provides a tutorial on using events in Solidity, detailing their significance and practical applications.

Section 1.3: Understanding Event Signatures

The signature of an event in Solidity is constructed similarly to a function signature. It consists of the event name followed by the parameter types enclosed in parentheses. For our earlier example:

event RegisteredSuccessfully(address user);

The corresponding event signature would be:

RegisteredSuccessfully(address);

Section 1.4: Exploring Event Topic Hashes

When listening for contract events, they are filtered using the event topic hash. This hash corresponds to the keccak256 hash of the event signature. Using our previous example:

event RegisteredSuccessfully(address user);

The event topic hash would be:

keccak256("RegisteredSuccessfully(address)")

= 0x2a5fc519cb1ec56867d94a911a7ba739c06c6772c4841545feb12cea840ab90c

You can access the event topic hash in Solidity as follows:

bytes32 topicHash = RegisteredSuccessfully.selector;

Note that the .selector feature for events is available starting from Solidity v0.8.15. In blockchain logs, the first entry at index 0 for the topics corresponds to the event topic hash, which enables filtering for specific events within a smart contract at a particular address or across the entire blockchain.

Section 1.5: Event Parameters and Indexed Parameters

Events can accept parameters of any type, including value types (e.g., uintN, bytesN, bool, address), structs, enums, and user-defined value types. However, internal function types are not permitted. For instance:

// This is valid

event SomeEvent(function () external callableFunction);

// This will not compile

event AnotherEvent(function () internal someInternalParameter);

Parameters in Solidity events can be designated as indexed, allowing for more precise filtering based on specific emitted values. Standard Solidity events can have up to three indexed parameters, while anonymous events can have up to four.

Section 1.6: Overview of Anonymous Events

Anonymous events are a special category in Solidity, as they cannot be filtered by name, but only by the contract address. This means you can listen to all events emitted by a smart contract, but you cannot subscribe specifically to an anonymous event by its name.

To define an event as anonymous, use the anonymous keyword after the event definition:

// SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8.0;

contract AnonymousEvents {

event SecretPasswordHashUpdated(bytes32 secretPasswordHash) anonymous;

}

The benefit of anonymous events is that they reduce deployment costs and gas usage. They are particularly useful for contracts that only emit a single event.

Description: This video covers events and logging in Solidity, demonstrating how to effectively use events in smart contracts.

References