Forem: hideyoshi

Chainsight Indices now available

hideyoshi — Wed, 05 Jun 2024 04:57:54 +0000

Recently, I have been wondering which coins I should invest in as an indivisual investor. And, as a DeFi developer, which product should be developed and which chain should I develop on. To resolve these questions, I have developed a family of indices called Chainsight Indices. The indices are designed to measure the market performance of crypto trading on DEX or CEX. This is available on Chainsight. 16 indices are available now.

One of the best things about this UI is that it allows you to extract some of your own attention from the various evaluation indicators and compare them in a composite chart.
For example, the following image compares the volatility of Chainsight AI (an index of AI coins) with NVIDIA's stock price.

You can also extract indicators of interest to you in this way and save the graphs in a layout so that you can gain insight from these indicators anytime you visit app.chainsight.network).

I hope you find it useful.

The following is an introduction to the indices. More indicators will be added in the future.

Introduction

Index Objective

The Chainsight indices are a family of indices designed to measure the market performance of crypto trading on DEX or CEX. The indices are designed to be used as a benchmark for the performance of the crypto market and as a tool for investors to track the performance of their investments.

Family of Indices

Chainsight AI. The index mesures the performance of projects that aim to use AI and machine learning on blockchain.
Chainsight Meme. The index measures the performance of meme coins.
Chainsight DeFi. The index measures the performance of major DeFi projects.
Chainsight L2. The index measures the performance of Layer 2 scaling solutions.
Chainsight NFT. The index measures the performance of major NFT projects.
Chainsight Metaverse. The index measures the performance of projects that aim to create virtual worlds on blockchain.
Chainsight Stablecoin. The index measures the performance of major stablecoins.
Chainsight DEX. The index measures the performance of major DEX(Decentralized Exchange) projects.
Chainsight Lending. The index measures the performance of major lending protocols.
Chainsight RWA. The index measures the performance of Real World Asset projects.
Chainsight Liquid Staking. The index measures the performance of liquid staking projects. The source is not these project utility or governance tokens but the staked tokens. This index is actually a measure of the performance of the staked tokens.
Chainsight Oracle. The index measures the performance of major oracle products.
Chainsight Infrastructure. The index measures the performance of major infrastructure projects.
Chainsight Ethereum. The index measures the performance of major projects on Ethereum.
Chainsight Solana. The index measures the performance of major projects on Solana.
Chainsight BSC. The index measures the performance of major projects on Binance Smart Chain.

Methodology

The Chainsight indices are weighted by not float-adjusted market capitalization.

Eligibility Criteria

To be eligible for inclusion in the Chainsight indices, a project must meet the following criteria:- Chainsight AI: AI and machine learning projects.

Uniswap
Sushiswap
Pancakeswap
Market Capitalization: The project has a market capitalization of at least $400 million.

Composition

The Chainsight indices are composed of the following assets:

Chainsight AI
Chainsight Meme
- Dogecoin(DOGE)
- Shiba Inu(SHIB)
- Pepe(PEPE)
- dogwifhat(WIF)
- FLOKI(FLOKI)
- Bonk(BONK)
- BOOK OF MEME(BOME)
- CorgiAI(CORGIAI)
- PepeCoin(PEPECOIN)
- Memecoin(MEME)
- MAGA(TRUMP)
Chainsight DeFi
Chainsight L2
Chainsight NFT
Chainsight Metaverse
Chainsight Stablecoin
Chainsight DEX
Chainsight Lending
Chainsight RWA
Chainsight Liquid Staking
Chainsight Oracle
Chainsight Infrastructure
Chainsight Ethereum
Chainsight Solana
- Solana(SOL)
- dogwifhat(WIF)
- Pyth Network(PYTH)
- Jupiter(JUP)
- Zebec Protocol(ZBC)
- BOOK OF MEME(BOME)
- Marinade Staked SOL(MSOL)
- Helium(HNT)
- cat in a dogs world(MEW)
- Jito(JTO)
- Raydium(RAY)
Chainsight BSC

Step-by-step creating an EVM Price Oracle with Chainsight

hideyoshi — Wed, 10 Jan 2024 03:05:55 +0000

When we start a defi project, we might need a price oracle to get the price of the token. Usually we use Chainlink or Band Protocol for a famous token.
But if we want to get the price of a new token or a token that is not famous, we might need to create our own price oracle.
In this article, I will show you how to create an EVM oracle with Chainsight.

What is Chainsight?

Chainsight is a composable-oracle platform that a developer can create an oracle for their own project easily.
It is a permissionless oracle network that anyone can create an oracle for their own project. And its components can be used by other developers to create their own oracle.

Blockchains are state machines and are not designed to handle large amounts of data. DApps running on the blockchain are basically designed to be simple state management. This is quite straightforward in designing the protocol. However, it is difficult when trying to develop slightly more complex applications. As a result, the future that World Computer originally envisioned, where any kind of applications keep working sustainably, has not yet arrived.

Chainsight provides a data processing layer to develop applications that go one step ahead. It is an extension layer that leverages historical data, constantly updated data, and cross-chain data to compute the information you need for your application. A user can use a privacy layer for sensitive transactions, a scaling layer for high-volume transactions, and a data processing layer for computation with large amounts of data. With Chainsight, on-chain applications will be able to address more use cases that were previously difficult to achieve.s

Chainsight's smart contracts is deployed on the Internet Computer and called canisters. Using Internet Computer's Chain key criptography, Chainsight can securely connect to other blockchains and get the data from them. And the data can be used by other canisters on the Internet Computer.

Prerequisite

In this example, we will use the following tools.

Node.js
Yarn
Solidity
Rust
dfx
Make
Some SepoliaETH for executing the contract on the testnet
- Get SepoliaETH

Install Chainsight SDK(csx)

To install Chainsight SDK(csx), run the following command.

git clone https://github.com/horizonx-tech/chainsight-cli.git
cd chainsight-cli
cargo install --path .

Project overview we will create

In this article, we will create a project that gets the price of ETH from a chainlink contract on the Ethereum network and relay it to the Sepolia network.

Create a project

At first, we need to create a Chainsight project. To create a project, run the following command.

csx new price_oracle

This command will create a project named price_oracle in the current directory.

You can see the project structure like this.

price_oracle
├── components
    |── sample_algorithm_indexer.yaml
    |── sample_algorithm_lens.yaml
    |── sample_event_indexer.yaml
    |── sample_relayer.yaml
    |── sample_snapshot_indexer_evm.yaml
    |── sample_snapshot_indexer_https.yaml
    |── sample_snapshot_indexer_icp.yaml
├── interfaces
├── .chainsight
├── .env
├── project.yaml

Not all of the files are necessary for this project. So we will delete some of them.

First of all, let's enter the project directory.

cd price_oracle

Build and deploy the project for the first time

To build the project, run the following command.

csx build

Just as a test, let's deploy the project to dfx local network. To start dfx local network, run the following command.

dfx start --clean

To deploy the project, run the following command.

csx deploy

You can see the log like this.

Jan 09 06:41:11.227 INFO Current deployed status:
Canister Name: __Candid_UI
  Canister Id: {"local": "avqkn-guaaa-aaaaa-qaaea-cai"}
  Controllers: yuk46-o67cx-p3ddo-vzb27-o3cp4-owe4v-u4r3g-htj3u-4v2h6-sne4q-wqe
  Module Hash: 0x934756863c010898a24345ce4842d173b3ea7639a8eb394a0d027a9423c70b5c

Canister Name: sample_algorithm_indexer
  Canister Id: {"local": "bkyz2-fmaaa-aaaaa-qaaaq-cai"}
  Controllers: 7fpuj-hqaaa-aaaal-acg7q-cai bnz7o-iuaaa-aaaaa-qaaaa-cai yuk46-o67cx-p3ddo-vzb27-o3cp4-owe4v-u4r3g-htj3u-4v2h6-sne4q-wqe
  Module Hash: 0x35b7fd5e5a57044b50b44007a4a5a275abe9c88464c6b8848294eb4e90291417

Canister Name: sample_algorithm_lens
  Canister Id: {"local": "bd3sg-teaaa-aaaaa-qaaba-cai"}
  Controllers: 7fpuj-hqaaa-aaaal-acg7q-cai bnz7o-iuaaa-aaaaa-qaaaa-cai yuk46-o67cx-p3ddo-vzb27-o3cp4-owe4v-u4r3g-htj3u-4v2h6-sne4q-wqe
  Module Hash: 0xdf5b0e5a6a61192cc3659ecaddf5f1866b67c8e6ee9544b55cb7b7cf51b7c4b2

Canister Name: sample_event_indexer
  Canister Id: {"local": "be2us-64aaa-aaaaa-qaabq-cai"}
  Controllers: 7fpuj-hqaaa-aaaal-acg7q-cai bnz7o-iuaaa-aaaaa-qaaaa-cai yuk46-o67cx-p3ddo-vzb27-o3cp4-owe4v-u4r3g-htj3u-4v2h6-sne4q-wqe
  Module Hash: 0x06a6afd2c985c268864ec0b2d13e058a24f395d2196db8349e536df17312f733

Canister Name: sample_relayer
  Canister Id: {"local": "br5f7-7uaaa-aaaaa-qaaca-cai"}
  Controllers: 7fpuj-hqaaa-aaaal-acg7q-cai bnz7o-iuaaa-aaaaa-qaaaa-cai yuk46-o67cx-p3ddo-vzb27-o3cp4-owe4v-u4r3g-htj3u-4v2h6-sne4q-wqe
  Module Hash: 0x76de26fc1016eea97d8b342bc60a74eb878a7fee85216b08103fc4855a50ebb8

Canister Name: sample_snapshot_indexer_evm
  Canister Id: {"local": "bw4dl-smaaa-aaaaa-qaacq-cai"}
  Controllers: 7fpuj-hqaaa-aaaal-acg7q-cai bnz7o-iuaaa-aaaaa-qaaaa-cai yuk46-o67cx-p3ddo-vzb27-o3cp4-owe4v-u4r3g-htj3u-4v2h6-sne4q-wqe
  Module Hash: 0x36cfd3c2816d7a27d8d1cfd77953c5404c1c87e42b78363d4114c65b86384fd3

Canister Name: sample_snapshot_indexer_https
  Canister Id: {"local": "b77ix-eeaaa-aaaaa-qaada-cai"}
  Controllers: 7fpuj-hqaaa-aaaal-acg7q-cai bnz7o-iuaaa-aaaaa-qaaaa-cai yuk46-o67cx-p3ddo-vzb27-o3cp4-owe4v-u4r3g-htj3u-4v2h6-sne4q-wqe
  Module Hash: 0x7871ed8328b75f26a51a1587545a67a15a9b9fecc1a1cbfba8a7df5233c8a724

Canister Name: sample_snapshot_indexer_icp
  Canister Id: {"local": "by6od-j4aaa-aaaaa-qaadq-cai"}
  Controllers: 7fpuj-hqaaa-aaaal-acg7q-cai bnz7o-iuaaa-aaaaa-qaaaa-cai yuk46-o67cx-p3ddo-vzb27-o3cp4-owe4v-u4r3g-htj3u-4v2h6-sne4q-wqe
  Module Hash: 0xe5f2c9c5627f668cf52e8d975baf17c56bbab654f61d78a7396815db20c71d80


Jan 09 06:41:11.227 INFO Project 'price_oracle' deployed successfully

Okay, we have deployed the canisters successfully. Next, we will create canisters for our project.

Update the project

Before updating the project, we need to know Chainsight's canister types. There are 7 canister types in Chainsight.

Canister type	Description
Event Indexer	An indexer that indexes smart contract events on EVM blockchains
Snapshot Indexer EVM	An indexer that indexes smart contract states on EVM blockchains. You can call the smart contract's view function from this canister and store the result.
Snapshot Indexer HTTPS	An indexer that indexes data from an external API. You can call the GET Web API from this canister and store the result.
Snapshot Indexer ICP	An indexer that indexes data from other chainsight canisters. You can call other chainsight canister's function from this canister and store the result.
Algorithm Indexer	An indexer that indexes data from other canisters. You can call other chainsight canister's function from this canister and store the result.
Algorithm Lens	A canister that provides a view function for other chainsight canisters. You can call this canister's view function from other chainsight canisters. You can implement any logic in this canister.
Relayer	A canister that relays data from other chainsight canisters to smart contracts on EVM blockchains.

In this project, we will use the following canisters.

Canister type	Usage
Snapshot Indexer EVM	To get the price of ETH from a mock chainlink contract on the Scroll Sepolia network
Algorithm Lens	To get the price from the Snapshot Indexer EVM canister and convert it into one with 18 digits
Relayer	To relay the price to the smart contract on the Sepolia network

Scenario:

Let's update the project.
At first, we will delete the unnecessary canisters.
Canisters that we will deploy is defined in project.yaml and components/*.yaml. So lets' update/delete them.

project.yaml

version: v1
label: price_oracle
components:
- component_path: components/sample_event_indexer.yaml
- component_path: components/sample_algorithm_indexer.yaml
- component_path: components/sample_snapshot_indexer_evm.yaml
- component_path: components/sample_snapshot_indexer_icp.yaml
- component_path: components/sample_relayer.yaml
- component_path: components/sample_algorithm_lens.yaml
- component_path: components/sample_snapshot_indexer_https.yaml

Let's update the project.yaml like this.

version: v1
label: price_oracle
components:
- component_path: components/sample_snapshot_indexer_evm.yaml
- component_path: components/sample_algorithm_lens.yaml
- component_path: components/sample_relayer.yaml

note: components/sample_algorith_lens.yaml needs to be later than components/sample_snapshot_indexer_evm.yaml because components/sample_algorithm_lens.yaml uses components/sample_snapshot_indexer_evm.yaml as a datasource. Also, components/sample_relayer.yaml needs to be later than components/sample_algorithm_lens.yaml for the same reason.

And delete the following files.

rm components/sample_algorithm_indexer.yaml
rm components/sample_event_indexer.yaml
rm components/sample_snapshot_indexer_https.yaml
rm components/sample_snapshot_indexer_icp.yaml
rm -rf src/logics/*

Next, we will update the components/sample_snapshot_indexer_evm.yaml file.
We need to get data from Mock price feed at address 0x9dA09CA893b089774DEb20AA1e375E613BA48cE9 on the Scrol Sepolia network and need to call latestAnswer() function to get a mock price of ETH.
So let's update the file like this.

# yaml-language-server: $schema=https://raw.githubusercontent.com/horizonx-tech/chainsight-cli/main/resources/schema/snapshot_indexer_evm.json
version: v1
metadata:
  label: Sample Snapshot Indexer Evm
  type: snapshot_indexer_evm
  description: ''
  tags:
  - ERC-20
  - Ethereum
  - DAI
datasource:
  location:
    id: 0x9dA09CA893b089774DEb20AA1e375E613BA48cE9 # Mock Chainlink price feed
    args:
      network_id: 534351 # Scroll sepolia network id
      rpc_url: https://sepolia-rpc.scroll.io
  method:
    identifier: latestAnswer():(uint256) # Call latestAnswer() function. 
    interface: MockOracle.json # Interface file. We can get it from https://sepolia.scrollscan.dev/address/0x9dA09CA893b089774DEb20AA1e375E613BA48cE9#code
    args: []
interval: 100 # Interval to call the function
cycles: null

We need a abi file for the mock price feed contract. So let's create a file named MockOracle.json in the interfaces directory and copy the abi from here.

[
    {
      "inputs": [],
      "name": "latestAnswer",
      "outputs": [
        {
          "internalType": "uint256",
          "name": "",
          "type": "uint256"
        }
      ],
      "stateMutability": "pure",
      "type": "function"
    }
  ]

Okay, it's done. Next, let's update the sample_algorithm_lens.
As a default, the datasource of the sample_algorithm_lens is sample_snapshot_indexer_icp. But we will use sample_snapshot_indexer_evm as a datasource. So let's update the sample_algorithm_lens like this.

# yaml-language-server: $schema=https://raw.githubusercontent.com/horizonx-tech/chainsight-cli/main/resources/schema/algorithm_lens.json
version: v1
metadata:
  label: Sample Algorithm Lens
  type: algorithm_lens
  description: ''
  tags:
    - Price
    - Chainlink
datasource:
  methods:
  - id: sample_snapshot_indexer_evm # Use sample_snapshot_indexer_evm as a datasource
    identifier: 'get_last_snapshot_value : () -> (text)' # Function to get the last indexed value from the canister. You can find it in artifacts/sample_snapshot_indexer_evm.did.
    candid_file_path: null
cycles: null

And build the project again:

csx build

Okay, next, le'ts implement the lens calculation function in src/logics/sample_algorithm_lens.rs.

As a default, the function is like this.

use sample_algorithm_lens_accessors::*;
#[derive(Clone, Debug, Default, candid :: CandidType, serde :: Deserialize, serde :: Serialize)]
pub struct LensValue {
    pub dummy: u64,
}
pub async fn calculate(targets: Vec<String>) -> LensValue {
    let _result = get_get_last_snapshot_value_in_sample_snapshot_indexer_evm(
        targets.get(0usize).unwrap().clone(),
    )
    .await;
    todo!()
}

We want to return the price of ETH as u128 and with 18 digits. So let's update the function like this.

use sample_algorithm_lens_accessors::*;
const PRECISION: u32 = 18;
pub type LensValue = u128;
pub async fn calculate(targets: Vec<String>) -> LensValue {
    let ethusd = get_get_last_snapshot_value_in_sample_snapshot_indexer_evm(targets.get(0usize).unwrap().clone())
        .await
        .unwrap()
        .parse::<u128>()
        .unwrap();
    format_ethusd(ethusd)
}

// The raw data is 8 digits precision, so we need to convert it into 18 digits
fn format_ethusd(ethusd: u128) -> u128 {
    ethusd * 10u128.pow(PRECISION - 8)
}

#[cfg(test)]
pub mod tests {
    use super::*;
    #[test]
    fn test_format_ethusd() {
        let ethusd = 2956575400000;
        let formated = format_ethusd(ethusd);
        assert_eq!(formated, 29565754000000000000000);
    }
}

It's almost done. Finally, we need to update the sample_relayer canister.

As a default, the sample_relayer canister has sample_snapshot_indexer_evm as a datasource. But we will use sample_algorithm_lens as a datasource. And, the destination network is polygon-mumbai. We need to update the sample_relayer like this.

# yaml-language-server: $schema=https://raw.githubusercontent.com/horizonx-tech/chainsight-cli/main/resources/schema/relayer.json
version: v1
metadata:
  label: Sample Relayer
  type: relayer
  description: ""
  tags:
    - Oracle
    - Sepolia
datasource:
  location:
    id: sample_algorithm_lens # This is the id of the algorithm lens
  method:
    identifier: "get_result : (vec text) -> (nat)" # This is the function to get the result from the algorithm lens. You can find it in artifacts/sample_algorithm_lens.did.
    interface: null
    args: []
destination:
  network_id: 11155111 # This is the network id of the Sepolia network
  type: uint256
  oracle_address: 0xb6cC49fA578bb155F6811f735437c74495905C1d # This is the address of the oracle contract on the Sepolia network
  rpc_url: https://rpc.sepolia.org # This is the rpc url of the Sepolia network
  method_name: null
  interface: null
interval: 100 # This is the interval to relay the data to the Sepolia network
lens_targets:
  identifiers:
    - sample_snapshot_indexer_evm # This is the id of the snapshot indexer evm canister. The lens canister(Algorithm Lens) will get the data from this canister.
cycles: null

It's done. Let's build the project again.

csx build

Deploy the project again

Re-run the dfx local network and deploy the project again.

dfx stop
dfx start --clean

log:

$ dfx start --clean
Running dfx start for version 0.15.1

csx deploy

You can see the log like this.

Jan 09 08:03:29.922 INFO Current deployed status:
Canister Name: __Candid_UI
  Canister Id: {"local": "br5f7-7uaaa-aaaaa-qaaca-cai"}
  Controllers: yuk46-o67cx-p3ddo-vzb27-o3cp4-owe4v-u4r3g-htj3u-4v2h6-sne4q-wqe
  Module Hash: 0x934756863c010898a24345ce4842d173b3ea7639a8eb394a0d027a9423c70b5c

Canister Name: sample_algorithm_lens
  Canister Id: {"local": "bkyz2-fmaaa-aaaaa-qaaaq-cai"}
  Controllers: 7fpuj-hqaaa-aaaal-acg7q-cai bnz7o-iuaaa-aaaaa-qaaaa-cai yuk46-o67cx-p3ddo-vzb27-o3cp4-owe4v-u4r3g-htj3u-4v2h6-sne4q-wqe
  Module Hash: 0xd19f567c8a783ca7b74c5756ae6e836657390d7e69c5f6d570ec9ebd4e03bd31

Canister Name: sample_relayer
  Canister Id: {"local": "bd3sg-teaaa-aaaaa-qaaba-cai"}
  Controllers: 7fpuj-hqaaa-aaaal-acg7q-cai bnz7o-iuaaa-aaaaa-qaaaa-cai yuk46-o67cx-p3ddo-vzb27-o3cp4-owe4v-u4r3g-htj3u-4v2h6-sne4q-wqe
  Module Hash: 0x327df98ec3bf2f07fb247362edd7ae4f53bef3a9a24abfdc2333900852766b2c

Canister Name: sample_snapshot_indexer_evm
  Canister Id: {"local": "be2us-64aaa-aaaaa-qaabq-cai"}
  Controllers: 7fpuj-hqaaa-aaaal-acg7q-cai bnz7o-iuaaa-aaaaa-qaaaa-cai yuk46-o67cx-p3ddo-vzb27-o3cp4-owe4v-u4r3g-htj3u-4v2h6-sne4q-wqe
  Module Hash: 0x36cfd3c2816d7a27d8d1cfd77953c5404c1c87e42b78363d4114c65b86384fd3


Jan 09 08:03:29.922 INFO Project 'price_oracle' deployed successfully

Run the project

So let's run the project.
To run the project locally, we need to run chainsight-management-canisters locally. To run the canisters, run the following command.

git clone https://github.com/horizonx-tech/chainsight-management-canisters.git
cd chainsight-management-canisters
make local port=${YOUR_DFX_PORT} # The port can be seen in the dfx start log. In this case, it's 39749.
cd ..

This may take a few minutes. After the canisters are deployed, run the following command to run the canisters locally. This also may take a few minutes.

csx exec

Supply the SepoliaETH to the relayer

To relay the data to the Sepolia network, we need to supply the SepoliaETH to the relayer canister. The source EVM account address is determined when the relayer canister is deployed. So at first, let's get the address.

cd artifacts
dfx canister call sample_relayer get_ethereum_address

You can see the address like this

$ dfx canister call sample_relayer get_ethereum_address
("0xe43e266dce52a16be2ae6ad6d10dacf59fc4d659")

This address is the sender address of the relayer canister. Send some SepoliaETH to the address on the Sepolia network. It's sufficient to send about 0.1 SepoliaETH for 1 transaction.
The key of the address is generated by ICP's chain key criptography. So you can't get the private key of the address. If you want to know more about the chain key criptography, please check here.

Get the price from the destination contract

Then, let's get the price from the destination contract on the Sepolia network.
https://sepolia.etherscan.io/address/0xb6cC49fA578bb155F6811f735437c74495905C1d#readContract
Read readAsUint256 with the sample_relayer address as a parameter.

You will see 10000000000000000000000000000 as a result.
This is the relayed price from the mock price feed contract on the Scroll Sepolia network.

Conclusion

In this article, we have created an EVM oracle with Chainsight. We have created a project that gets the price of ETH from a mock chainlink contract on the Scroll Sepolia network and relay it to the Sepolia network.
A complete example can be found here. Please check it out.
As we can see, Chainsight is a very powerful tool for creating an secure and reliable oracle. And it's very easy to use. I hope this article will help you to create your own oracle.
Let's enjoy building a defi project with Chainsight!

Creating a multi-chain voting in 30 minutes with Chainsight

hideyoshi — Sun, 07 Jan 2024 05:53:09 +0000

Hey Fellow Devs 👋

I've been working on a project called ChainSight for the past few months. It's a composable-oracle platform that allows you to create custom oracles for your EVM smart contracts. Using ChainSight, you can create oracles that provide data from any source, including other smart contracts, APIs, and even other blockchains.
Anyone can create an oracle and publish it on the platform. The oracle can be used by anyone who needs the data it provides.

From some points of view, Chainsight can be considered as a SDK for deploying smart contracts on the Internet Computer that interact with other smart contracts on other chains. These contracts are called "canisters" and they are deployed on the Internet Computer's blockchain. Using https-outcalls and threshold ECDSA, important features of the Internet Computer, Chainsight provides a set of tools for creating canisters and deploying them on the Internet Computer easily and securely.. For more details, check out the documentation.

Recently, I have added a new feature to the platform that allows you to execute not only an oracle operation but also any other smart contract execution. This feature allows you to create a little bit more complex use cases. The following are some examples of what you can do with it:

An arbitrage bot: execute a swap on Uniswap when the price of a token is lower than the price on another exchange.
A liquidation bot: execute a liquidation on Compound when the collateralization ratio of a loan is lower than a certain threshold.
A multi-chain voting: submit a proposal on one chain and vote on it on another chain.

These are just a few examples of what you can do with this feature. I'm sure you can come up with many more. In this post, I will show you how to create a multi-chain voting in 30 minutes using ChainSight.
The complete code for this post can be found here.

On this post, I will show you how to create a multi-chain voting in 30 minutes using ChainSight. And the next post, I will deploy the canisters on the Internet Computer and show you how to use them.

What is a multi-chain voting I am talking about?

A multi-chain voting is a voting that takes place on multiple chains. The idea is to submit a proposal on one chain and vote on it on another chain. This is useful when you want to create a DAO that spans across multiple chains. For example, you can create a DAO on Ethereum and vote on proposals on Polygon. In this example, I will show you

How to create a multi-chain voting?

To create a multi-chain voting, you need to create two functions: one for submitting a proposal and one for voting on it. The first contract will be used to synchronize the proposal between the chains. The second one will be used to vote on the proposal.
And how can we synchronize proposals and votes between chains is the issue we are going to solve in this post. We will use ChainSight to do that. ChainSight provides a set of tools for creating canisters and deploying them on the Internet Computer.

Prerequisites

To try out this example, you may want to know a little bit about the Internet Computer and Chainsight. If you are not familiar with them, you can check out the following links:

I'll write about overview of Chainsight and hello world example in future posts. So, stay tuned.

Project Overview

The project consists of two parts: the solidity smart contracts and ICP smart contracts(aka canisters). The solidity smart contracts are used to submit proposals and vote on them. The ICP smart contracts are used to synchronize proposals and votes between chains.

├── components
├── interfaces
├── scripts
│── solidity
│   ├── contracts
|── src

Folder	Description
components	Chainsight components I will deploy on the Internet Computer
interfaces	Interfaces Chainight components will use to interact with the Internet Computer
scripts	Scripts for deploying Chainsight components on the Internet Computer local env
solidity	Solidity smart contracts we will deploy on Sepolia and Scroll Sepolia
src	User defined logics for Chainsight components

Following contracts are deployed on each EVM chain.

Contract	Description
contracts/proposal/ProposalFactory.sol	Contract for creating a new proposal
contracts/proposal/ProposalManager.sol	Contract for managing proposals and its votes
contracts/proposal/ProposalSynchronizer.sol	Contract for synchronizing proposals from other chains via Chainsight
contracts/voting/VotingSynchonizer.sol	Contract for synchronizing votes from other chains via Chainsight

And following canisters are deployed on the Internet Computer as Chainsight components.

Component	Description
components/proposal_factory_event_indexer_sepolia.yaml	Event indexer for ProposalFactory contract events `ProposalCreated` on Scroll Sepolia
components/proposal_factory_event_indexer_scroll_sepolia.yaml	Event indexer for ProposalFactory contract events `ProposalCreated` on Scroll Sepolia
components/proposal_lens.yaml	Lens for ProposalManager contract to convert proposal event data into another format to be used by proposal relayers
components/proposal_relayer_sepolia.yaml	Relayer for ProposalManager contract to relay proposal data from Scroll Sepolia to Sepolia
components/proposal_relayer_scroll_sepolia.yaml	Relayer for ProposalManager contract to relay proposal data from Sepolia to Scroll Sepolia
components/voting_event_indexer_sepolia.yaml	Event indexer for Voting contract events `Voted` on Sepolia
components/voting_event_indexer_scroll_sepolia.yaml	Event indexer for Voting contract events `Voted` on Scroll Sepolia
components/voting_lens.yaml	Lens for Voting contract to convert vote event data into another format to be used by voting relayers
components/voting_relayer_sepolia.yaml	Relayer for Voting contract to relay vote data from Scroll Sepolia to Sepolia
components/voting_relayer_scroll_sepolia.yaml	Relayer for Voting contract to relay vote data from Sepolia to Scroll Sepolia

Overview of Chainsight components and EVM smart contracts are as follows.

User submits a proposal on a chain.
1. The proposal is indexed by the event indexer on the chain.
The proposal is relayed to another chain by the proposal relayer by calling batchSynchronize function on the ProposalSynchonizer contract.
1. Voting on the proposal is started on each chain.
User votes on the proposal on a chain.
1. The vote is indexed by the event indexer on the chain.
2. The vote is relayed to another chain by the voting relayer by calling batchSynchronize function on the VotingSynchonizer contract.

Details of Chainsight components

Let's take a look at the details of Chainsight components with its code.

ProposalFactoryEventIndexerSepolia

This component indexes ProposalCreated events emitted by ProposalFactory contract on Scroll Sepolia. The indexer is deployed on Sepolia.

# yaml-language-server: $schema=https://raw.githubusercontent.com/horizonx-tech/chainsight-cli/main/resources/schema/event_indexer.json
version: v1
metadata:
  label: Proposal Factory Indexer Sepolia
  type: event_indexer
  description: ""
  tags:
    - TODO
datasource:
  id: 0xAEB9FBEE52B7272b5c75Bc64E4f82D24Ee2Aaa33 // ProposalFactory contract address on Sepolia
  event:
    identifier: ProposalCreated // Event name
    interface: IProposalFactory.json // Interface of ProposalFactory contract. You can find it in interfaces/ folder.
  network:
    rpc_url: https://ethereum-sepolia.blockpi.network/v1/rpc/public
    chain_id: 11155111
  from: 2739538
  contract_type: ERC-20
interval: ${INTERVAL} // Interval to check new events
cycles: null

When I need to index smart contract events, what I only have to do is to write a yaml file like this. I don't need to write any code.

ProposalFactoryEventIndexerSepolia

This is the same as ProposalFactoryEventIndexerSepolia but it indexes events emitted by ProposalFactory contract on Scroll Sepolia.


# yaml-language-server: $schema=https://raw.githubusercontent.com/horizonx-tech/chainsight-cli/main/resources/schema/event_indexer.json

version: v1
metadata:
label: Proposal Factory Indexer Scroll
type: event_indexer
description: ""
tags: - TODO
datasource:
id: 0xaA00080dd203701d94e6F262bb7101E19A0C8107
event:
identifier: ProposalCreated
interface: IProposalFactory.json
network:
rpc_url: https://sepolia-rpc.scroll.io
chain_id: 534351
from: 0
contract_type: ERC-20
interval: ${INTERVAL}
cycles: null

ProposalLens

This component converts ProposalCreated event indexed by ProposalFactoryEventIndexer into another format to be used by proposal relayers.

# yaml-language-server: $schema=https://raw.githubusercontent.com/horizonx-tech/chainsight-cli/main/resources/schema/algorithm_lens.json
version: v1
metadata:
  label: Proposal Lens
  type: algorithm_lens
  description: "TODO"
  tags:
    - TODO
datasource:
  methods:
    - id: proposal_factory_event_indexer_sepolia // This is the id of EventIndexerSepolia. But this canister can be used for Scroll Sepolia as well since the format of the event data is the same.
      identifier: "events_from_to : (nat64, nat64) -> (vec record { nat64; vec ProposalCreated })" // This identifier is defined in artifacts/proposal_factory_event_indexer_sepolia.did
      candid_file_path: null
with_args: true
cycles: null

We can write some conversion logic in src/logics/proposal_lens/lib.rs file.
Now, to use event data to synchronize proposals, we need to convert it into what ProposalSynchonizer contract expects. The format of the event data is as follows.

solidity/contracts/interfaces/IProposalSynchronizer.sol

    /**
     * @dev Batch synchronize proposals from another chain
     * @param ids The ids of the proposals
     * @param proposers proposers of the proposals
     * @param chainIds The ids of the chain where the proposals are created
     * @param startTimestamps The start timestamps of voting
     * @param endTimestamps The end timestamps of voting
     * @param proposedBlocks The block numbers of the proposals
     * @notice The length of the arrays should be the same
     **/
    function batchSynchronize(
        uint256[] calldata ids,
        address[] calldata proposers,
        uint256[] calldata chainIds,
        uint256[] calldata startTimestamps,
        uint256[] calldata endTimestamps,
        uint256[] calldata proposedBlocks
    ) external;

So, we need to collect events and convert them into the format above. The following is the code for that.

src/logics/proposal_lens/lib.rs

pub type LensValue = ( // This is the format of the event data to be used by proposal relayers.
    Vec<u128>,
    Vec<String>,
    Vec<u128>,
    Vec<u128>,
    Vec<u128>,
    Vec<u128>,
);
pub type CalculateArgs = (u64, u64); // block number from, block number to. This is provided by the caller (in this case, a proposal relayer).

pub async fn calculate(targets: Vec<String>, args: CalculateArgs) -> LensValue {
    let results = get_events_from_to_in_proposal_factory_event_indexer_sepolia(
        targets.get(0usize).unwrap().clone(), // Request argments provided by the caller (in this case, a proposal relayer).
        args,
    )
    .await
    .unwrap();
    results
        .iter()
        .map(|r| {
            let block = r.0;
            let events = &r.1;
            let e: Vec<(u128, String, u128, u128, u128, u64)> = events
                .iter()
                .map(|e| {
                    (
                        e.id.value.parse().unwrap(),
                        e.proposer.clone(),
                        e.startTimestamp.value.parse().unwrap(),
                        e.endTimestamp.value.parse().unwrap(),
                        e.chainId.value.parse().unwrap(),
                        block,
                    )
                })
                .collect();
            e
        })
        .flatten()
        .map(|e| (e.0, e.1, e.2, e.3, e.4, e.5))
        .fold(
            (vec![], vec![], vec![], vec![], vec![], vec![]),
            |mut acc, e| {
                acc.0.push(e.0);
                acc.1.push(e.1);
                acc.2.push(e.2);
                acc.3.push(e.3);
                acc.4.push(e.4);
                acc.5.push(e.5.into());
                acc
            },
        )
}

ProposalRelayerSepolia

This component relays proposals from Scroll Sepolia to Sepolia.

# yaml-language-server: $schema=https://raw.githubusercontent.com/horizonx-tech/chainsight-cli/feature/anyrelayer/resources/schema/relayer.json
version: v1
metadata:
  label: Voting Relayer Sepolia
  type: relayer
  description: "TODO"
  tags:
    - TODO
datasource:
  location:
    id: voting_lens
  method:
    identifier: "get_result :  (LensArgs) -> (record { vec nat; vec text; vec nat; vec nat; vec nat; vec nat })" // This identifier is defined in artifacts/voting_lens.did
    interface: null
    args: []
destination:
  network_id: 11155111
  type: custom
  oracle_address: 0xa9FAf4c08147f4Cbb022f3c5e666B51Fd7244c44 // ProposalSynchonizer contract address on Sepolia
  rpc_url: https://ethereum-sepolia.blockpi.network/v1/rpc/public
  interface: IVotingSynchronizer.json
  method_name: batchSynchronize
interval: ${INTERVAL}
lens_targets:
  identifiers:
    - voting_event_indexer_scroll_sepolia // Event source. This canister relayes events from Scroll Sepolia to Sepolia.
cycles: null

One of the important things for relayers is to make sure that the data is not duplicated. To do that, we need to keep track of the last block number we have relayed. The following is the code for that.

src/logics/proposal_relayer_sepolia/lib.rs

use std::str::FromStr;

use ic_web3_rs::{ethabi::Address, types::U256};

mod types;
pub type CallCanisterResponse = types::ResponseType;

pub type LensArgs = proposal_relayer_sepolia_bindings::LensArgs;

thread_local! {
    // TODO: handle edge case when tx is not relayed
    static LAST_RELAYED: std::cell::RefCell<u64> = std::cell::RefCell::new(0);
}

// This is call arguments for the lens canister. In this case, we need to provide block number from and block number to we want to get.
// `LAST_RELAYED` is the last block number we have relayed. So, we need to get events from `LAST_RELAYED + 1` to `u64::MAX` to make sure that we don't relay duplicated events.
pub fn call_args() -> (u64, u64) {
    LAST_RELAYED.with_borrow(|r| {
        let last_relayed = r.clone();
        (last_relayed + 1, u64::MAX)
    })
}

// This is a filter function for the lens canister. We need to filter out empty results. If filtered, the canister doesn't call the contract method. In this case, we don't have to call the contract method if there is no event. So we filter out empty results.
pub fn filter(res: &CallCanisterResponse) -> bool {
    if res.0.len() == 0 {
        return false;
    }
    let last_relayed = res.4.iter().max().unwrap().clone();
    LAST_RELAYED.with_borrow_mut(|r| {
        *r = (last_relayed as u64).clone();
    });
    true
}

pub struct ContractCallArgs { // This is automatically generated from interfaces/IVotingSynchronizer.json. So what I only have to do is to implement `call_args`, `filter` and `convert` functions.
    pub ids: Vec<U256>,
    pub proposers: Vec<Address>,
    pub chainIds: Vec<U256>,
    pub startTimestamps: Vec<U256>,
    pub endTimestamps: Vec<U256>,
    pub proposedBlocks: Vec<U256>,
}

// Convert the result of the lens canister into the arguments for the contract method. In this case, we need to convert the result into the format the contract method expects.
pub fn convert(res: &CallCanisterResponse) -> ContractCallArgs {
    let ids = res
        .0
        .clone()
        .iter()
        .map(|x| U256::from(x.clone()))
        .collect::<Vec<U256>>();
    let proposers = res
        .1
        .clone()
        .iter()
        .map(|x| Address::from_str(x).unwrap())
        .collect::<Vec<Address>>();
    let chain_id = res
        .2
        .clone()
        .iter()
        .map(|x| U256::from(x.clone()))
        .collect::<Vec<U256>>();
    let start_timestamps = res
        .3
        .clone()
        .iter()
        .map(|x| U256::from(x.clone()))
        .collect::<Vec<U256>>();
    let end_timestamps = res
        .4
        .clone()
        .iter()
        .map(|x| U256::from(x.clone()))
        .collect::<Vec<U256>>();
    let proposed_blocks = res
        .5
        .clone()
        .iter()
        .map(|x| U256::from(x.clone()))
        .collect::<Vec<U256>>();
    ContractCallArgs {
        ids,
        proposers,
        chainIds: chain_id,
        startTimestamps: start_timestamps,
        endTimestamps: end_timestamps,
        proposedBlocks: proposed_blocks,
    }
}

ProposalRelayerScrollSepolia

This component relays proposals from Sepolia to Scroll Sepolia. This is the same as ProposalRelayerSepolia but it relays proposals from Sepolia to Scroll Sepolia.

# yaml-language-server: $schema=https://raw.githubusercontent.com/horizonx-tech/chainsight-cli/feature/anyrelayer/resources/schema/relayer.json
version: v1
metadata:
  label: Proposal Relayer Scroll Sepolia
  type: relayer
  description: "TODO"
  tags:
    - TODO
datasource:
  location:
    id: proposal_lens
  method: We've created Chainsight components for synchronizing proposals between chains. Now, let's take a look at how to create Chainsight components for synchronizing votes between chains.
    identifier: "get_result : (LensArgs) -> (record { vec nat; vec text; vec nat; vec nat; vec nat; vec nat })"
    interface: null
    args: []
destination:
  network_id: 534351
  type: custom
  oracle_address: 0x400b306fF82EEBac84946F73826B68241421EA6F
  rpc_url: https://sepolia-rpc.scroll.io
  interface: IProposalSynchronizer.json
  method_name: batchSynchronize
interval: ${INTERVAL}
lens_targets:
  identifiers:
    - proposal_factory_event_indexer_sepolia
cycles: null

We've need to write some logics in src/logics/proposal_relayer_sepolia/lib.rs file. But its' completely the same as what we have to write in ProposalRelayerSepolia. And we don't have to write them once again. We can reuse the code by using ProposalRelayerSepolia as a template. The following is the code for that.

src/logics/proposal_relayer_scroll_sepolia/lib.rs

mod types;
pub type CallCanisterResponse = types::ResponseType;
pub type LensArgs = proposal_relayer_sepolia_bindings::LensArgs;
pub fn call_args() -> (u64, u64) {
    proposal_relayer_scroll_sepolia::call_args()
}
pub type ContractCallArgs = proposal_relayer_scroll_sepolia::ContractCallArgs;
pub fn convert(res: &CallCanisterResponse) -> ContractCallArgs {
    proposal_relayer_scroll_sepolia::convert(
        &proposal_relayer_scroll_sepolia::CallCanisterResponse {
            0: res.0.clone(),
            1: res.1.clone(),
            2: res.2.clone(),
            3: res.3.clone(),
            4: res.4.clone(),
            5: res.5.clone(),
        },
    )
}
pub fn filter(res: &CallCanisterResponse) -> bool {
    proposal_relayer_scroll_sepolia::filter(
        &proposal_relayer_scroll_sepolia::CallCanisterResponse {
            0: res.0.clone(),
            1: res.1.clone(),
            2: res.2.clone(),
            3: res.3.clone(),
            4: res.4.clone(),
            5: res.5.clone(),
        },
    )
}

That's it.

VotingEventIndexerSepolia

This component indexes Voted events emitted by Voting contract on Scroll Sepolia. The indexer is deployed on Sepolia. The difference between VotingEventIndexerSepolia and ProposalFactoryEventIndexerSepolia is kind of event they index and the contract address they use.

# yaml-language-server: $schema=https://raw.githubusercontent.com/horizonx-tech/chainsight-cli/main/resources/schema/event_indexer.json
version: v1
metadata:
  label: Voting Event Indexer Scroll
  type: event_indexer
  description: ""
  tags:
    - TODO
datasource:
  id: 0x1A0ceb79B5B2bD56c68C3E23A8a41639a7c12ac6
  event:
    identifier: Voted
    interface: IProposalManager.json
  network:
    rpc_url: https://sepolia-rpc.scroll.io
    chain_id: 534351
  from: 0
  contract_type: ERC-20
interval: ${INTERVAL}
cycles: null

No code is required to write.

VotingEventIndexerScrollSepolia

This is the same as VotingEventIndexerSepolia but it indexes events emitted by Voting contract on Scroll Sepolia.

# yaml-language-server: $schema=https://raw.githubusercontent.com/horizonx-tech/chainsight-cli/main/resources/schema/event_indexer.json
version: v1
metadata:
  label: Voting Event Indexer Scroll Sepolia
  type: event_indexer
  description: ""
  tags:
    - TODO
datasource:
  id: 0x1A0ceb79B5B2bD56c68C3E23A8a41639a7c12ac6
  event:
    identifier: Voted
    interface: IProposalManager.json
  network:
    rpc_url: https://sepolia-rpc.scroll.io
    chain_id: 534351
  from: 0
  contract_type: ERC-20
interval: ${INTERVAL}
cycles: null

VotingLens

This component converts Voted event indexed by VotingEventIndexer into another format to be used by voting relayers.

# yaml-language-server: $schema=https://raw.githubusercontent.com/horizonx-tech/chainsight-cli/main/resources/schema/algorithm_lens.json
version: v1
metadata:
  label: Voting Lens
  type: algorithm_lens
  description: "TODO"
  tags:
    - TODO
datasource:
  methods:
    - id: voting_event_indexer_sepolia
      identifier: "events_from_to : (nat64, nat64) -> (vec record { nat64; vec Voted })"
      candid_file_path: null
with_args: true
cycles: null

We can write some conversion logic in src/logics/voting_lens/lib.rs file. The concept is the same as ProposalLens. But the format of the event data is different. The following is the code for that.

use voting_lens_accessors::*;

pub type LensValue = (
    Vec<u128>,
    Vec<String>,
    Vec<bool>,
    Vec<u128>,
    Vec<u128>,
    Vec<u64>,
);
pub type CalculateArgs = (u64, u64);

pub async fn calculate(targets: Vec<String>, args: CalculateArgs) -> LensValue {
    let r = get_events_from_to_in_voting_event_indexer_sepolia(
        targets.get(0usize).unwrap().clone(),
        args,
    )
    .await;
    if r.is_err() {
        ic_cdk::println!("error: {:?}", r);
    }
    let results = r.unwrap();
    results
        .iter()
        .map(|r| {
            let block = r.0;
            let events = &r.1;
            let e: Vec<(u128, String, bool, u128, u128, u64)> = events
                .iter()
                .map(|e| {
                    (
                        e.id.value.parse().unwrap(),
                        e.voter.clone(),
                        e.support,
                        e.power.value.parse().unwrap(),
                        e.chainId.value.parse().unwrap(),
                        block,
                    )
                })
                .collect();
            e
        })
        .flatten()
        .map(|e| (e.0, e.1, e.2, e.3, e.4, e.5))
        .fold(
            (vec![], vec![], vec![], vec![], vec![], vec![]),
            |mut acc, e| {
                acc.0.push(e.0);
                acc.1.push(e.1);
                acc.2.push(e.2);
                acc.3.push(e.3);
                acc.4.push(e.4);
                acc.5.push(e.5.into());
                acc
            },
        )
}

VotingRelayerSepolia

This component relays votes from Scroll Sepolia to Sepolia.

# yaml-language-server: $schema=https://raw.githubusercontent.com/horizonx-tech/chainsight-cli/feature/anyrelayer/resources/schema/relayer.json
version: v1
metadata:
  label: Voting Relayer Sepolia
  type: relayer
  description: "TODO"
  tags:
    - TODO
datasource:
  location:
    id: voting_lens
  method:
    identifier: "get_result :  (LensArgs) -> (record { vec nat; vec text; vec nat; vec nat; vec nat; vec nat })"
    interface: null
    args: []
destination:
  network_id: 11155111
  type: custom
  oracle_address: 0xa9FAf4c08147f4Cbb022f3c5e666B51Fd7244c44
  rpc_url: https://ethereum-sepolia.blockpi.network/v1/rpc/public
  interface: IVotingSynchronizer.json
  method_name: batchSynchronize
interval: ${INTERVAL}
lens_targets:
  identifiers:
    - voting_event_indexer_scroll_sepolia
cycles: null

We've need to write some logics in src/logics/voting_relayer_sepolia/lib.rs file by the same reason as ProposalRelayerSepolia. The following is the code for that.

mod types;
use std::str::FromStr;

use ic_web3_rs::{ethabi::Address, types::U256};
pub type CallCanisterResponse = types::ResponseType;
pub type LensArgs = voting_relayer_sepolia_bindings::LensArgs;

thread_local! {
    // TODO: handle edge case when tx is not relayed
    static LAST_RELAYED: std::cell::RefCell<u64> = std::cell::RefCell::new(0);
}

pub fn call_args() -> (u64, u64) {
    LAST_RELAYED.with_borrow(|r| {
        let last_relayed = r.clone();
        (last_relayed + 1, u64::MAX)
    })
}
#[derive(Clone, Debug)]
pub struct ContractCallArgs {
    pub ids: Vec<U256>,
    pub voters: Vec<Address>,
    pub _supports: Vec<bool>,
    pub votingPowers: Vec<U256>,
    pub chainIds: Vec<U256>,
}

pub fn convert(res: &CallCanisterResponse) -> ContractCallArgs {
    let ids = res
        .0
        .clone()
        .iter()
        .map(|x| U256::from(x.clone()))
        .collect::<Vec<U256>>();
    let voters = res
        .1
        .clone()
        .iter()
        .map(|x| Address::from_str(x).unwrap())
        .collect::<Vec<Address>>();
    let _supports = res.2.clone().iter().map(|x| x > &0).collect::<Vec<bool>>();
    let voting_powers = res
        .3
        .clone()
        .iter()
        .map(|x| U256::from(x.clone()))
        .collect::<Vec<U256>>();
    let chain_ids = res
        .4
        .clone()
        .iter()
        .map(|x| U256::from(x.clone()))
        .collect::<Vec<U256>>();
    ContractCallArgs {
        ids,
        voters,
        _supports,
        votingPowers: voting_powers,
        chainIds: chain_ids,
    }
}

pub fn filter(res: &CallCanisterResponse) -> bool {
    if res.0.len() == 0 {
        return false;
    }
    let last_relayed = res.5.iter().max().unwrap().clone();
    LAST_RELAYED.with_borrow_mut(|r| {
        *r = (last_relayed as u64).clone();
    });
    true
}

VotingRelayerScrollSepolia

This component relays votes from Sepolia to Scroll Sepolia. This is the same as VotingRelayerSepolia but it relays votes from Sepolia to Scroll Sepolia.

# yaml-language-server: $schema=https://raw.githubusercontent.com/horizonx-tech/chainsight-cli/feature/anyrelayer/resources/schema/relayer.json
version: v1
metadata:
  label: Voting Relayer Scroll Sepolia
  type: relayer
  description: "TODO"
  tags:
    - TODO
datasource:
  location:
    id: voting_lens
  method:
    identifier: "get_result :  (LensArgs) -> (record { vec nat; vec text; vec nat; vec nat; vec nat; vec nat })"
    interface: null
    args: []
destination:
  network_id: 534351
  type: custom
  oracle_address: 0xE13E832e673dF3588d9a71F67C69826ECC76Cad5
  rpc_url: https://sepolia-rpc.scroll.io
  interface: IVotingSynchronizer.json
  method_name: batchSynchronize
interval: ${INTERVAL}
lens_targets:
  identifiers:
    - voting_event_indexer_scroll_sepolia
cycles: null

We've need to write some logics in src/logics/voting_relayer_scroll_sepolia/lib.rs file by the same reason as ProposalRelayerSepolia. The following is the code for that.

mod types;
pub type CallCanisterResponse = types::ResponseType;
pub type LensArgs = voting_relayer_scroll_sepolia_bindings::LensArgs;
pub fn call_args() -> (u64, u64) {
    voting_relayer_sepolia::call_args()
}

pub type ContractCallArgs = voting_relayer_sepolia::ContractCallArgs;
pub fn convert(res: &CallCanisterResponse) -> ContractCallArgs {
    voting_relayer_sepolia::convert(&voting_relayer_sepolia::CallCanisterResponse {
        0: res.0.clone(),
        1: res.1.clone(),
        2: res.2.clone(),
        3: res.3.clone(),
        4: res.4.clone(),
        5: res.5.clone(),
    })
}
pub fn filter(res: &CallCanisterResponse) -> bool {
    voting_relayer_sepolia::filter(&voting_relayer_sepolia::CallCanisterResponse {
        0: res.0.clone(),
        1: res.1.clone(),
        2: res.2.clone(),
        3: res.3.clone(),
        4: res.4.clone(),
        5: res.5.clone(),
    })
}

That's it.

The part I'd like to emphasize is that we don't have to write any code for transparency, security and scalability. We can focus on writing business logics. Usually we have to write a lot of code for that, especially specific cases like multi-chain voting. But using Chainsight and deploying canisters on the Internet Computer, we can focus on writing business logics.

In this post, I've written about how to create Chainsight components for synchronizing proposals and votes between chains. In the next post, I will deploy the canisters on the Internet Computer and show you how to use them.

Forem: hideyoshi

Chainsight Indices now available

Introduction

Index Objective

Family of Indices

Methodology

Eligibility Criteria

Composition

Step-by-step creating an EVM Price Oracle with Chainsight

What is Chainsight?

Prerequisite

Install Chainsight SDK(csx)

Project overview we will create

Create a project

Build and deploy the project for the first time

Update the project

Deploy the project again

Run the project

Supply the SepoliaETH to the relayer

Get the price from the destination contract

Conclusion

Links

Creating a multi-chain voting in 30 minutes with Chainsight

What is a multi-chain voting I am talking about?

How to create a multi-chain voting?

Prerequisites

Project Overview

Details of Chainsight components

ProposalFactoryEventIndexerSepolia

ProposalFactoryEventIndexerSepolia

ProposalLens

ProposalRelayerSepolia

ProposalRelayerScrollSepolia

VotingEventIndexerSepolia

VotingEventIndexerScrollSepolia

VotingLens

VotingRelayerSepolia

VotingRelayerScrollSepolia