
## What are smart contract events?

**Events** allow a smart contract to log a change of state to the blockchain in a specific format to allow the VM (virtual machine) to easily retrieve and filter them. In StarkNet, when a transaction occurs, the smart contract can emit certain **events** which your front-end client application can listen to.

In simpler words: **events** are ways to communicate with a client application that something has happened on the blockchain.


## Events In Cairo

To create an event in Cairo we need the
`@event` decorator.

For example, the most common event in smart contracts is the Transfer event that is emitted by ERC20 tokens when someone transfers tokens.


```
@eventfunc Transfer(from: felt, to: felt, value: Uint256) {}
```

As you can see, we start by declaring an **event** decorator. Then we specify a function **Transfer** that emits three arguments: the address of the sender, `(from)`, the address of the receiver `(to)`, and the amount being sent.

The **event** signature is usually declared at the top of the contract code and can be emitted in any function within the contract using the `emit` keyword like this:


```
Transfer.emit(from, to, amount);
```


## Why Use Events?

Here are three reasons as for why you should use events:

-To communicate return values to the front-end client.

-As a cheaper means of storage.

-More transparency.

What are events in Cairo Language? What purpose do events serve?

Can you explain it so that everyone can understand?

What are events in Cairo Language?



# Why use events in Cairo?

## To communicate return values to the front-end client

One of the caveats of external functions is the fact that **your returned values are not accessible outside the contract.**

This means that when you make state changes within your external functions you can’t easily access the newly returned state from your front-end client. However thanks to events we can easily emit the new states which are stored in logs and available to our UI.

**Below is an example:**


```
// Event declaration
@event
func stored_name(caller: felt, name: felt, status: felt) {}
// External function that emits event
@external
func store_name{
    syscall_ptr: felt*,
    pedersen_ptr: HashBuiltin*,
    range_check_ptr
    } (_name: felt) -> (status: felt)
{
         let (caller) = get_caller_address();
         names.write(caller, _name);
         stored_name.emit(caller, _name, 1);
         return (1);
}
```

By default we cannot have direct access to the returned value “status”, but through events we can emit and access it from our front-end client.

## As a cheaper means of storage

Whenever an event is emitted the corresponding logs are written to the blockchain.

These logs contain useful information which can further be accessed by the front-end client, which is way cheaper than normal storage.


## More transparency

Event logs contain the historical data for all emitted events. This can be accessed at any point in time by anyone on StarkNet.

Our contracts are a great example of this. **We leverage events to provide transparent and verifiable oracle data**.

Why will I use events in the Cairo language? Can I use it on a front-end client application side?

Why will I use events in Cairo language?


# Event Indexers

If you come from Solidity, you’ll know that Solidity allows you to create indexed parameters in your contract events. The indexed parameters allow you to search for these events using the parameters as filters.

While StarkNet does not currently allow you to create indexed parameters by default in Cairo you can index your events using some available indexers such as **[Apibara](https://www.apibara.com/)** and **[StarkNet Indexer](https://github.com/olegabu/starknet-archive-docs#starknet-indexer)**.


## StarkNet Indexer

**StarkNet indexer** is a service created to listen to blockchain events and decode and persist the emitted data, making it available for analysis with SQL, GraphQL, and HTTP queries.

They’ve also created a **[GraphQL console](https://summary.dev/console/)** that enables developers to query blockchain data for events, transactions and their inputs, as well as to filter, aggregate, and sum up values easily.


## Apibara


**Apibara** is a framework and protocol that helps you build real-time, composable streams of Web3 and Web2 data. Apibara solves the challenge of streaming blockchain data: blocks are not immutable, and their data can be invalidated in response to a chain reorganization.

There’s an amazing template to help you get started indexing events [**here**](https://github.com/apibara/python-indexer-template) and a tutorial guide [**here**](https://www.apibara.com/docs/tutorials/indexing-starknet-nft-events).

What are Event Indexers in Cairo lang? What is a StarkNet indexer?
Can you explain more about how it work and is there any difference between StarkNet indexer and Solidity once?

What are Event Indexers in Cairo lang? What is a StarkNet indexer?


# Verifying Empiric’s Data Entries Using Events

Every time a publisher sends new data to Empiric, the smart contract emits a **SubmittedEntry** event, which anyone can inspect on the blockchain. We will attempt to inspect this below using the GraphQL console by StarkNet Indexer.

*Before we proceed, I want to specify that these codes are in line with Empiric’s source code before the audit. So there might be changes to the existing contract address or the Event names.*


## Indexing Empiric’s SubmittedEntry Event

Here is the event we are looking for:


```
@eventfunc SubmittedEntry(new_entry: Entry){}
```


### **To return the last 3 submitted Entries:**


**Open the console in your browser [**here**](https://summary.dev/console/).** You should be greeted by an interface like this.

 ![](https://i.imgur.com/h3ssvR9.png)


---

**Copy this piece of code and paste it in the console.**


```
{
  starknet_goerli_event(where: 
    {
        name: {_eq: "SubmittedEntry"}, 
        transmitter_contract: {_eq: "0x12fadd18ec1a23a160cc46981400160fbf4a7a5eed156c4669e39807265bcd4"}
    }, 
    limit: 5) {
    name
    arguments {
      name
      type
      value
      decimal
    }
    transaction_hash
  }
}
```

What’s happening here is that we create a query, `starknet_goerli_event`, specifying the event name we’ll be indexing and the contract address it’s being transmitted from. We also limit our query to just the last 3 emitted events.

---

**Run the query.**

And finally, we can see our output in the right-hand part of the console, like this.

 ![](https://i.imgur.com/6aj9bLO.png)


The returned data is an event with the name `SubmittedEntry`, which has a single argument `new_entry` of data type `Entry`.

The data type Entry is a struct consisting of a key, value, source, publisher, and timestamp.


```
struct Entry{
    key: felt,
    value: felt,
    source: felt,
    publisher: felt,
    timestamp: felt,
}
```

It lastly returns the transaction hash of the transaction that emitted the event.

*PS: Make sure to remove the redundant zero that begins the contract address or you’ll get an empty return value. What I mean is, rather than 0x012, use 0x12.*

---


## Verifying Empiric’s Price Feed Data

Having understood the roles events play in transparency, we can now take a detailed look at Empiric’s price feeds with respect to data frequency, reliability, and precision by indexing and analyzing the emitted events.

Here’s a quick analysis of the **ETH/USD** price feed from Empiric, by querying all events emitted each time the price feed was updated.


### **Crawling through the events**

For this analysis, Empiric provides a script **[here](https://github.com/42labs/Empiric/blob/master/analytics/crawl_events.py)** which you can run to crawl through our emitted events.

You can also do something similar with the GraphQL console from earlier. To do that:

**Open the GraphQL console, and paste this piece of code below.**

```
query arguments_new_entry($jsonFilter: jsonb) {
  starknet_goerli_argument(
    limit: 100
    where: {event: {name: {_eq: "SubmittedEntry"}, transmitter_contract: {_eq: "0x12fadd18ec1a23a160cc46981400160fbf4a7a5eed156c4669e39807265bcd4"}}, value: {_contains: $jsonFilter}}
    order_by: {id: desc}
  ) {
    name
    type
    value
  }
}
```

**In the `Query variables` bottom window, paste the code for the jsonFilter.**


```
{
  "jsonFilter": {
    "key": "0x6574682f757364"
  }
}
```

Here we are creating a query similar to the one from earlier, but this time passing in a filter for only results with the **ETH/USD** key.

The console generates the data in JSON format, but using Empiric’s script we can generate a more human-readable CSV format **[as shown in this table.](https://gist.github.com/Darlington02/f64ff67dbe0652f9576ba94822d6036d#file-empiric-csv)** This table shows the number of times Empiric’s **ETH/USD** price feed pair was updated between **11:50:00** and **12:02:10** on **2022–10–11**.

One thing that stands out is the number of updates within such a short period — which we can attribute to the large number of publishers submitting their data to Empiric Network.


### **Analysing the data**



> * In total, the ETH/USD price feed updated **100 times** in approximately **12.167 minutes** or **730 seconds**.
> * The **shortest time between updates**, which occurred repeatedly, was **less than a second**.
> * The **longest time between updates**, which occurred just once, was **58 seconds**.
> * The **median time between two price updates** when considering all publishers was **less than 5 seconds**.
> * In general, **all updates happened in less than a minute**.
> * Not only was the feed **frequently updated**, but the prices were also **remarkably close to the reported prices of our data providers**.



## Conclusion

Having read through the series of questions we answered, you should now possess a better understanding of how events on StarkNet work, and **how you can leverage them to trustlessly audit and verify Empiric Network’s data**. For infrastructure as critical as oracles it is very important to be able to **independently verify past performance**, and there is no better way than using an indexer to access historical events yourself! **This represents a significant leap in the oracle stack — replacing intransparent black boxes with publicly available, verifiable data.**




How to verify Empiric’s Data Entries Using Events?

Popular tags

Profile

Swagtimus.eth

Wallet address: 0x377A5D7E35Aa22645b8382182B88C1df6700427D

Recent questions

Recent answers