Events In Solidity


An advanced object-oriented programming language called Solidity is used to create smart contracts for the Ethereum Blockchain. The behaviour of the accounts within the Ethereum Blockchain is controlled by smart contracts, which are used to influence the Ethereum Blockchain.

You may build intriguing Web 3.0 applications with Solidity, such as a crowdfunding platform, blind auctions, and multi-signature wallets. Solidity continues to get numerous regular upgrades. Therefore, you must quickly become used to the latest version. Version 0.8x of Solidity is the most recent.


A contract's inheritable component, known as an event, recordsthe parameters supplied when issued in the transaction logs.

Other languages are comparable to Solidity. Let's examine what events are in other languages and compare them to events in Solidity.

The main difference is how events in Solidity operate, since they are on the blockchain and follow a slightly different logic. Let's examine how Solidity's Events function. Occurrences work in conjunction with the user interface to ensure that the user is informed of any events that need notification, such as a transaction passing or failing, deposits failing, etc. Events provide users with information about Blockchain events to enhance user-friendliness when using dApps.


pragma solidity.0.8 .0 <= 0.9 .0;
contract SimpleAuction {
    event HighestBidIncreased(address bidder, uint amount); // Event
    function bid() public payable {
        // ...
        emit HighestBidIncreased(msg.sender, msg.value);

Events are present inside a log, which allows us to print information to the logging structure in a way that’s more gas efficient than actually saving it to something like a storage variable.

Events and smart contracts live in a special data structure that isn’t accessible to the smart contract. Events are incredibly powerful, and they boast a range of uses. They’re also good for testing and some other things.

In events, we use a new keyword called indexed, which is quite important. In the events, we have indexed parameters and the non-indexed parameters.

We can have up to three indexed parameters in an event’s arguments. These are known as topics. These indexed parameters are much easier to search for and much easier to query than non-indexed parameters. Non-indexed parameters are harder to search, because they get abi encoded. So, we have to know the abi in order to decode it.

We need to actually emit that event in order to store that data into the logging data structure of EVM.


pragma solidity > 0.8 .0 <= 0.9 .0;
contract Allowance {
    event AllowanceChanged(address indexed _forwho, address indexed _towhom, uint oldAmount, uint newAmount);

    function allowance public payable {
        // ...
        emit AllowanceChanged(_who, msg.sender, allowance[_who], allowance[who] - amount); //EMIT

This is how it looks when we emit an event. This is done by emit and then event name and the parameters.


  • To test particular variables in your smart contracts
  • Index variables to rebuild storage state
  • To modify a front end, pay attention to events
  • To speed up data reading, create subgraphs


  • Solidity event parameters come in two varieties: indexed and not indexed.
  • Events are utilised as inexpensive data storage, and for transaction return values.
  • Blockchain tracks transactions with event parameters. Events may be filtered by contract address and by name.
Next Recommended Reading Mapping And Structure In Solidity