The table outlines the differences between Nexus and Lumina, which are both oracle solutions supported by DIA:

DIA xMarket feeds provide smart contracts real-time price information of 3,000+ cryptocurrencies, transparently sourced from 80+ trusted, high-volume DEXs and CEXs.

The feeds facilitate the development of DeFi use cases such as money markets, lending/borrowing, synthetic asset issuance, options, derivatives and futures markets, and many more.

Browse all tokens that DIA's data library currently supports via the link below. New assets can also be supported on demand.

You can also check the list of data sources on the app.

Learn More

DIA Nexus is composed of three main stages, each critical to ensuring the accuracy, reliability, and accessibility of your data.

DIA xReal is designed for Real-World Asset (RWA) applications, bringing hundreds of data feeds for stocks, commodities, FX rates, and more on-chain.

It consists of two core components:

• xReal Price Feeds – Secure, transparent price oracles for RWA-powered dApps (options, futures, tokenized index funds & more)

• xReal Custom Solutions – On-demand oracles for tokenized assets, bond yields, FX rates, & real-world financial metrics

You can access all the available RWA data feeds & integration options below:

Learn More

Nexus is a flexible oracle solution built with dApps' cross-chain data needs in mind. It provides:

• Customizable token price feeds sourced directly from the exchanges rather than relying on third-party providers

• RWA price feeds for traditional financial assets like stocks, commodities, and more.

• Verifiable random numbers through drand's distributed randomness beacon.

• Transparent and collateral-proofed price feeds for illiquid assets such as LSTs.

Features

This guide shows you how to use the token price feeds within your smart contract and get the latest prices available to your dApp!

DIA xFair is a new oracle product that provides DeFi protocols with transparent and collateral-proofed price feeds for illiquid assets such as LSTs, computed through on-chain collateral ratio checks.

This system allows for more accurate and fair pricing, supporting various DeFi use cases like lending, borrowing, money markets, options, and helps access idle total value locked (TVL) in LSDs.

Browse all LST price feeds that DIA's data library currently supports:

Learn More

The randomness oracle enables the creation of on-chain applications including but not limited to on-chain gaming, lotteries, prediction markets, and NFT launches​.

Browse the latest randomness rounds in the DIA App:

Learn More

This page provides a comprehensive list of all the blockchain networks where DIA Nexus is accessible.

There are two ways that you can access the oracle in your dApp. You can either declare an IDIAOracleV2 interface or import the solidity library.

Using DIAOracleV2 Interface

1. Access any DIA oracle smart contract.

2. Call getValue(pair_name) with pair_name being the full pair name such as BTC/USD. You can use the "Read" section on Etherscan to execute this call.

3. The response of the call contains four values:

   1. The current asset's price in USD with a fix-comma notation of 8 decimals.

Find the detailed description of the functions and how to run tests on our GitHub page:

Using Solidity Library

DIA has a dedicated Solidity library to facilitate the integration of DIA oracles in your own contracts. The library consists of two functions, getPrice and getPriceIfNotOlderThan.

Access the library

Methods

getPrice

Returns the price of a specified asset along with the update timestamp.

Parameters:

Return Values:

getPriceIfNotOlderThan

Checks if the oracle price is older than maxTimePassed

Parameters:

Return Values:

Find a detailed integration example and how to run a test on our GitHub page:

Sample contract

Mainnet

Testnet

All DIA demo oracles include the following assets price information, delivered in USD:

• BTC/USD

• USDC/USD

• DIA/USD

Oracle details

Oracle configuration

Asset feeds

How to access data

Below is an example of a contract consuming data from our oracle on Aleph Zero mainnet. If you pass BTC/USD as the key, it will return the most recent price of BTC in USD with 8 decimal places (e.g. 9601458065403 is $96,014.58065403) along with the Unix timestamp of the last price update.

pragma solidity ^0.8.13;

interface IDIAOracleV2 {
    function getValue(string memory) external view returns (uint128, 
             uint128);
}

contract DIAOracleV2Consumer{

    address immutable ORACLE = 0x4845890f8d7b4A0b29759271929B0FCF672aEED6;

    function getPrice(string memory key) 
    external 
    view
    returns (
        uint128 latestPrice, 
        uint128 timestampOflatestPrice
    ) {
        (latestPrice, timestampOflatestPrice) =   
                 IDIAOracleV2(ORACLE).getValue(key); 
    }
}

Support

Oracle details

Oracle configuration

Asset feeds

How to access data

Below is an example of a contract consuming data from the oracle on EduChain testnet using the IDIAOracleV2 interface. If you pass WBTC/USD as the key, it will return the most recent price of BTC in USD with 8 decimal places (e.g. 8258705325665 is $82,587.05325665) along with the Unix timestamp of the last price update.

pragma solidity ^0.8.13;

interface IDIAOracleV2 {
    function getValue(string memory) external view returns (uint128, uint128);
}

contract DIAOracleV2Consumer {

    address immutable ORACLE = 0x6626f442ebc679f7e35bc62e36e3c1e8820c81c9;

    function getPrice(string memory key) 
    external 
    view
    returns (
        uint128 latestPrice, 
        uint128 timestampOflatestPrice
    ) {
        (latestPrice, timestampOflatestPrice) =   
                 IDIAOracleV2(ORACLE).getValue(key); 
    }
}

Support

Oracle details

Oracle configuration

Asset feeds

Locate one of the deployed contracts (either testnet or mainnet) and call the getValue function. This function expects one parameter, which is the symbols of the asset you want to retrieve and a “/USD”, so for example for the Bitcoin price the parameter must be “BTC/USD”.

This will return two values:

1. The price of the asset, with 8 decimals.

2. The timestamp of the last update in Unix time format, in UTC timezone.

Contract DIAOracle(
    mut admin: Address
) extends DIAOracleBase(admin) implements IDIAOracle {
    mapping[ByteVec, DIAOracleValue] onchainValues

    event OracleUpdate(key: ByteVec, value: U256, timestamp: U256)

    const MaxBatchSize = 10

    enum ErrorCodes {
        InvalidBatchSize = 1
        InvalidKey = 2
    }

    pub fn getValue(key: ByteVec) -> DIAOracleValue {
        if (!onchainValues.contains!(key)) {
            panic!(ErrorCodes.InvalidKey)
        }

        return onchainValues[key]
    }

    @using(preapprovedAssets = true)
    pub fn setValue(key: ByteVec, value: U256, timestamp: U256) -> () {
        checkAdmin(callerAddress!())
        updateValue{admin -> ALPH: mapEntryDeposit!()}(key, value, timestamp)
    }

    @using(preapprovedAssets = true)
    pub fn setMultipleValues(
        keys: [ByteVec; 10],
        values: [U256; 10],
        timestamps: [U256; 10],
        batchSize: U256
    ) -> () {
        checkAdmin(callerAddress!())
        assert!(batchSize <= MaxBatchSize, ErrorCodes.InvalidBatchSize)

        for (let mut i = 0; i < batchSize; i = i + 1) {
            updateValue{admin -> ALPH: mapEntryDeposit!()}(
                keys[i],
                values[i],
                timestamps[i]
            )
        }
    }

    @using(preapprovedAssets = true)
    fn updateValue(key: ByteVec, value: U256, timestamp: U256) -> () {
        if (!onchainValues.contains!(key)) {
            onchainValues.insert!(admin, key, DIAOracleValue{value, timestamp})
        } else {
            onchainValues[key] = DIAOracleValue{value, timestamp}
        }

        emit OracleUpdate(key, value, timestamp)
    }
}

Support

The following is an example of how you can integrate DIA's oracle into your smart contract with Vyper:

# @version ^0.3.6

ORACLE: constant(address) = 0xCD5F78206ca1FF96Ff4c043C61a2299B2Febf3cB
latestPrice: public(uint128)
timestampOfLatestPrice: public(uint128)

interface IDIAOracleV2:
    def getValue(key: String[7]) -> (uint128, uint128): nonpayable

@external
def getPriceInfo(key: String[7]):
    self.latestPrice, self.timestampOfLatestPrice = IDIAOracleV2(ORACLE).getValue(key)

@view
@external
def checkPriceAge(maxTimePassed: uint128) -> bool:
    inTime: bool = False
    if (convert(block.timestamp, uint128) - self.timestampOfLatestPrice) < maxTimePassed:
        inTime = True
    else:
        inTime = False 

    return inTime

Find the detailed description of the functions and how to run tests on our GitHub page

Oracle details

WBTC, WETH, DOT, USDT and USDC oracle

tBTC, WETH, and vDOT oracle

Oracle configuration

Asset feeds

Mainnet

Testnet

How to access data

Accessing the oracle on-chain (Solidity)

Below is an example of a contract consuming data from the oracle on Hydration testnet using the IDIAOracleV2 interface. If you pass BTC/USD as the key, it will return the most recent price of BTC in USD with 8 decimal places (e.g. 9601458065403 is $96,014.58065403) along with the Unix timestamp of the last price update.

pragma solidity ^0.8.13;

interface IDIAOracleV2 {
    function getValue(string memory) external view returns (uint128, uint128);
}

contract DIAOracleV2Consumer{

    address immutable ORACLE = 0xc756bd338a97c1d2faab4f13b5444a08a1566917;

    function getPrice(string memory key) 
    external 
    view
    returns (
        uint128 latestPrice, 
        uint128 timestampOflatestPrice
    ) {
        (latestPrice, timestampOflatestPrice) =   
                 IDIAOracleV2(ORACLE).getValue(key); 
    }
}

Adapter contracts

Support

This guide shows you how to use the randomness oracle within your smart contract and get verifiable random numbers available to your dApp!

Oracle Details

Oracle Configuration

Asset Feeds

Mainnet

Testnet

How to Access Data

Accessing the oracle on-chain (Solidity)

Below is an example of a contract consuming data from our oracle on Sepolia testnet using the IDIAOracleV2 interface. If you pass WETH/USD as the key, it will return the most recent price of WETH in USD with 8 decimal places (e.g. 177101990135 is $1,771.01990135) along with the Unix timestamp of the last price update.

pragma solidity ^0.8.13;

interface IDIAOracleV2 {
    function getValue(string memory) external view returns (uint128, 
             uint128);
}

contract DIAOracleSample {

    address immutable ORACLE = 0x6f021bF081840F96bdd90fd756b700072C7E68A5;

    function getPrice(string memory key) 
    external 
    view
    returns (
        uint128 latestPrice, 
        uint128 timestampOflatestPrice
    ) {
        (latestPrice, timestampOflatestPrice) =   
                 IDIAOracleV2(ORACLE).getValue(key); 
    }
}

Adapter contracts

Support

Oracle details

Oracle configuration

Asset feeds

How to access data

Accessing the oracle on-chain (Solidity)

pragma solidity ^0.8.13;

interface IDIAOracleV2 {
    function getValue(string memory) external view returns (uint128, uint128);
}

contract DIAOracleV2Consumer{

    address immutable ORACLE = 0x9206296ea3aee3e6bdc07f7aaef14dfcf33d865d;

    function getPrice(string memory key) 
    external 
    view
    returns (
        uint128 latestPrice, 
        uint128 timestampOflatestPrice
    ) {
        (latestPrice, timestampOflatestPrice) =   
                 IDIAOracleV2(ORACLE).getValue(key); 
    }
}

Adapter contracts

Support

Overview

The RandomOracle contract in ink! is designed to store random values for different rounds. Each round has an associated RandomData struct containing a randomness value, a signature, and the previous signature. The contract provides methods for setting random values and retrieving random values for a given round.

Setup

1. Clone the repository:

git clone https://github.com/diadata-org/dia-wasm-oracle.git
cd dia-wasm-oracle/random-wasm-oracle

1. Install required tools and dependencies:

cargo install --force --git https://github.com/paritytech/cargo-contract.git
rustup component add rust-src --toolchain nightly
rustup target add wasm32-unknown-unknown --toolchain nightly

Usage

1. Build the contract:

cargo +nightly contract build

1. Deploy contract using this UI

https://contracts-ui.substrate.io/

Example

To use the RandomOracle contract in your own project, follow these steps:

1. In your own project, add the random-wasm-oracle as a dependency. Open your project's Cargo.toml and add the following:

[dependencies]
random-wasm-oracle = { path = "path/to/dia-wasm-oracle/random-wasm-oracle" }

1. In your project's smart contract, import the necessary modules and types from the random-wasm-oracle crate:

use randomoracle::RandomOracleRef;

1. In your contract's storage, add a RandomOracleRef field:

#[ink(storage)]
pub struct YourContract {
    // Your other fields...
    random_oracle: RandomOracleRef,
}

1. In your contract's constructor, add a parameter for the RandomOracle contract's address and initialize the RandomOracleRef:

#[ink(constructor)]
pub fn new(random_oracle: AccountId) -> Self {
    Self {
        // Initialize your other fields...
        random_oracle: RandomOracleRef::from_account_id(random_oracle),
    }
}

1. Implement methods to interact with the RandomOracle contract, e.g., getting random values for a specific round:

#[ink(message)]
pub fn get_random_value_for_round(&self, round: Vec<u8>) -> Vec<u8> {
    self.random_oracle.get_random_value_for_round(round)
}

1. Build and deploy your contract, providing the RandomOracle contract's address https://shibuya.subscan.io/account/Y9YVxsyH8bza5zyK1AVW4iw1r7twVdoXMoDzWwdwraapvSM when instantiating your contract.

2. Interact with your contract to call the methods that use the RandomOracle contract.

DIA uses the drand.love public randomness beacon, and updates its oracle with round number, randomness and signature. Anyone can access published random values via round ID.

{
	"round": 1597683,
	"randomness": "24138936fcbf7fc3951c928158be6998cee3af622142d0790333608d17a5c5f6",
	"signature": "8c04905c0adf34f1fb007915d9ccc7d07b97305fc63952726f9367c87f36ab687c5e190c151f6ac4d760a9e009fc54230adb8513885449d649a229bc727be9ff347bdbce1c609cebf993b6ae57133fbcf23f96b15dbd3510cb5f2ade6b30b647",
	"previous_signature": "ada42197a2db89866da4c44348f77f7868e41e961ec32e636b912d43c625386afae9e54944ac573047dbd227ee495b52059586c8d8cd0edfe18cc15ca0666a66651da1d62b12af2d0fac19735bed9298690a593571965c3ad7c7b11947e76ec0"
}

The DIA randomness smart contract is structured as follows

pragma solidity ^0.8.0;

contract DIARandomOracle {

  struct Random { 
    string randomness;
    string signature;
    string previousSignature;
  }

  mapping (uint256 => Random) public values;
  uint256 public lastRound = 0;

  address public oracleUpdater;

  event OracleUpdate(string key, uint128 value, uint128 timestamp);
  event UpdaterAddressChange(address newUpdater);

  constructor() {
    oracleUpdater = msg.sender;
  }

  function setRandomValue(uint256 _round, string memory _randomness, string memory _signature, string memory _previousSignature) public {
    require(msg.sender == oracleUpdater,"not a updater");
    require(lastRound<_round, "old round");
    lastRound = _round;
    values[_round] = Random(_randomness, _signature, _previousSignature);
  }

  function getValue(uint256 _round) external view returns (Random memory) {
    return values[_round];
  }

  function updateOracleUpdaterAddress(address newOracleUpdaterAddress) public {
    require(msg.sender == oracleUpdater,"not a updater");
    oracleUpdater = newOracleUpdaterAddress;
    emit UpdaterAddressChange(newOracleUpdaterAddress);
  }

  function getRandomValueFromRound(uint256 _round) external view returns (string memory) {
    return values[_round].randomness;
  }

  function getRandomValueFromRoundWithSignature(uint256 _round) external view returns (Random memory) {
    return values[_round];
  }

  function getLastRound() public view returns(uint256) {
    return lastRound;
  }
}

Users can call getLastRound()to obtain the ID of the latest published round. To obtain the randomness of a certain round, users can call getRandomValueFromRound(uint256 _round)using the obtaines round ID.

The signature can also be requested by calling getRandomValueFromRoundWithSignature(uint256 _round).

Please be aware that you should always let all inputs commit before any randomness is used in a later round. For example, if you build a lottery, only call randomness after the last participant has committed their stake. To show this in an example, we will build a simple dice game.

Example: Dice Game

Imagine a simple game where two players play against each other. Both throw a dice and the user with the higher rolled number wins. In case of a draw, nobody wins. Both players need to "seed" the game with an initial number between 1 and 6, that will be added to the randomness (modulo 6). It is a fair game where everyone has a 50% chance of winning.

pragma solidity ^0.8.0;
  

import "../DIARandomOracle.sol";

contract DiceGame {
  address public randomOracle;
  uint256 seed1 = 0;
  uint256 seed2 = 0;
  uint256 latestRoundId = 0;
  
  constructor(address oracle) {
    randomOracle = oracle;
  }

  function getRandomValue(uint256 _round) public view returns (string memory) {
    return DIARandomOracle(randomOracle).getRandomValueFromRound(_round);
  }
  
  function commitPlayer1(uint256 seed) external {
    require(seed > 0, "Seed must be between 1 and 6");
    require(seed < 7, "Seed must be between 1 and 6");
    
    seed1 = seed;
    latestRoundId = DIARandomOracle(randomOracle).getLastRound();
  }
  
  function commitPlayer2(uint256 seed) external {
    require(seed > 0, "Seed must be between 1 and 6");
    require(seed < 7, "Seed must be between 1 and 6");
    
    seed2 = seed;
    latestRoundId = DIARandomOracle(randomOracle).getLastRound();
  }
  
  function rollDice() public view returns (uint) {
    require(seed1 > 0, "Player 1 needs to commit their seed!");
    require(seed2 > 0, "Player 2 needs to commit their seed!");
    
    uint _round = latestRoundId + 10;
    
    require(DIARandomOracle(randomOracle).getLastRound() >= _round, "Wait for the randmoness round to roll your dice.");
    
    string memory rand = getRandomValue(_round);
    uint256 player1result = (uint256(keccak256(abi.encodePacked(rand))) + seed1) % 6;
    uint256 player2result = (uint256(keccak256(abi.encodePacked(rand))) + seed2) % 6;
    
    seed1 = 0;
    seed2 = 0;
    
    if (player1result > player2result) {
      return 1;
    } else if (player2result > player1result) {
      return 2;
    } else {
      return 0;
    }
  }
}

Both players need to commit their seeds. The latest published roundID is stored for the duration of the game. When both committed their values and the wait time of 10 rounds has passed, the dice can be rolled and the player ID of the winner is returned (or 0 in case of a draw).

You can follow the guide for how to access the price feeds deployed on each chain in your dApp:

You can follow the guide for how to access the price feeds deployed on each chain in your dApp:

Introduction to DIA

Usage of DIA Oracles on LUKSO

Overview

The DIA oracle on LUKSO is free of use. dApps built on LUKSO can leverage the oracle to access up-to-date asset price information. This oracle is designed for production environments and comes with a predefined list of feeds and settings.

How to Access DIA Oracles

Developers can access specific asset prices via dedicated smart contract adapters listed in the next section. Each adapter contract provides price data by calling functions without additional parameters.

1. latestAnswer - provides the latest available price data for BTC/USD with 8 decimals accuracy

2. latestRoundData - provides the latest available price data for BTC/USD (8 decimals) with the Unix timestamp (UTC timezone) of the last update

Included Price Feeds

Below is the list of included price feeds. Use the corresponding adapter address to query the latest price information.

Oracle Configuration Settings

Methodology: VWAPIR

Update frequency: 0.5% deviation + 24-hour heartbeat

Each asset is updated every two minutes, if the new price deviates from the old one by more than 0.5%. Additionally, a heartbeat of 24 hours is applied, which means that each price is updated at least once per day even if it moves by less than 0.5%.

Oracle Support

Introduction to DIA

Information on Usage of DIA Oracles on Kadena

Deployed contracts

As Kadena allows for several chains in parallel, it is important to retrieve the price from the correct chain. Currently, DIA oracles are deployed on these chains:

How to access DIA oracles?

Locate one of the deployed contracts (either testnet or mainnet) and call the get-value function. This function expects one parameter, which is the symbols of the asset you want to retrieve and a “/USD”, so for example for the Bitcoin price the parameter must be “BTC/USD”.

This will return two values:

1. The price of the asset, with 8 decimals.

2. The timestamp of the last update in Unix time format, in UTC timezone.

Included price feeds

The Kadena oracle includes the following price feeds. Use the Query Symbol as a parameter in the get-value function to receive the latest price information for any of these assets.

Oracle configuration settings

Methodology: VWAPIR

Update frequency: 0.5% deviation + 24-hour heartbeat

Each asset is updated every two minutes, if the new price deviates from the old one by more than 0.5%. Additionally, a heartbeat of 24 hours is applied, which means that each price is updated at least once per day even if it moves by less than 0.5%.

Support

Oracles require a constant stream of updates, thus gas costs reimbursement for updates is needed. To achieve this, all oracles deployed by DIA have a dedicated wallet which calls oracle contracts for updates. This is referred to as the "gas wallet".

How it works

For the gas wallet to perform new oracle contract updates, it must have a sufficient balance of the blockchain's native token to cover the transaction's gas costs.

The gas wallet can be funded with a one-time lump sum, allowing it to keep updating for a while. However, monitoring the gas wallet's balance is necessary to ensure continuity in the oracle's operations.

DIA has set up internal gas wallet balance trackers. We recommend protocols to actively monitor them to ensure that the wallet balance remains sufficient for pushing new oracle updates.

Estimate Updates Count for Oracles

DIA has a dedicated endpoint for asset historical updates count to help you estimate the number of oracle updates. This allows to foresee potential gas costs that would be required for running the oracle.

Get historical Oracle updates count

GET https://api.diadata.org/v1/assetUpdates/:blockchain/:address/:deviation/:updateFreq

The endpoint returns information on the asset deviation and updates count if it was used in the oracle. It takes price change (deviation) and oracle's ticker frequency as the main parameters to determine estimated updates count based on historical data.

Path Parameters

Introduction to DIA Oracles

Usage of DIA Oracles on Stacks

Deployed Contracts

Access the oracles in the smart contracts below:

How to Access DIA Oracles?

You can query for assets like "STX/USD" or "stSTX/USD" in the get-value() read function. It returns two values:

1. The price of STX/USD with 8 decimals

2. The timestamp of the last update (UTC timezone)

Included Price Feeds & Data Sources

The Stacks oracle includes the following price feeds:

Oracle Configuration Settings

Methodology: MAIR

Update frequency: 15-minute heartbeat

A consistent heartbeat refreshes all asset prices every 15 minutes.

Support

The DiaAssetSpecificCallingConvention contract is compatible with AggregatorV3Interface, allowing developers to read price data from a DIA oracle contract deployed for each asset by calling latestRoundData() and returning the latest available price of that specific asset.

Data

• Influx

• PostgreSQL

• Redis

• Kafka

Services

• Filterblock

• Tradesblock

Scrapers

• Foreign

• Liquidity

• Collector

Development Specific

• Ping jobs

• Prepare job (when install does not depend on external image)

Additional

• Grafana

  • Loki

  • Influx

Helms being tested

• DIA Helm chart: DIA platform

• Influx: Timeseries db

• Grafana: Dashboard for monitoring

• Loki: Logging the services

• kube-prometheus: Monitoring Minikube cluster

Prepare

Scrapers

CEX (Kraken as example)

Prepare

Run the scraper

DEX (CurveFi as example)

Prepare

Run the scraper

Clean

Advanced usage

Access services between Docker Composes

On prepare step if you want to connect services between other Compose files, create a deployments/local/exchange-scraper/docker-compose.override.yml file:

And instead of run the services using this command:

Now in other Compose file just use like this:

Now in Docker context, service-x can resolve the http://influxdb:8086 hostname

Preparing the local files

1. Clone repo and change directory:

Preparing a local cluster

2. Next, start the development environment by running the following command to start a Minikube node:

1. Build the necessary service containers by executing the following commands:

1. Run the installation script to set up the necessary services (Redis cache, Kafka streams, PostgreSQL, and InfluxDB databases) by executing the following commands:

Now that you have the local cluster running, you are ready to start.

1. import the test data from the diadata snapshot service: This requires the default structure to be empty and created inside the postgres server. The script will automatically download the snapshot, install it and remove the downloaded snapshot again.

Other useful commands

To stop the cluster:

To delete the cluster node:

DIA has a dedicated infrastructure for testing various integrations into the system. In the following pages you can learn how it works.

Start here:

Or proceed directly to the scraper integration tutorials:

Add a new liquidity scraper

Implement LiquidityScraper interface at pkg/dia/scraper/liquidity-scrapers/ScraperInterface.go file

type LiquidityScraper interface {
	Pool() chan dia.Pool
	Done() chan bool
}

1. Add a scraper implementation, MyLiquidityScraper.go file to pkg/dia/scraper/liquidity-scrapers/ folder implement the functions:

func (scraper *MyLiquidityScraper) Pool() chan dia.Pool {}
func (scraper *MyLiquidityScraper) Done() chan bool {}

1. Add a constructor for the scraper:

func NewMyLiquidityScraper(exchange dia.Exchange) *MyLiquidityScraper {}

Liquidity Command

go mod tidy -go=1.16 && go mod tidy -go=1.17 && go install && liquidityScraper -exchange=ExchangeName

Liquidity Test

go mod tidy -go=1.16 && go mod tidy -go=1.17 && go install && liquidityScraper -exchange=EXCHANGE_NAME

• PlatypusFinance: go mod tidy -go=1.16 && go mod tidy -go=1.17 && go install && liquidityScraper -exchange=PlatypusFinance

• Orca: go mod tidy -go=1.16 && go mod tidy -go=1.17 && go install && SOLANA_URI_REST=https://try-rpc.mainnet.solana.blockdaemon.tech/ liquidityScraper -exchange=Orca

Add a new foreign scraper

Implement ForeignScrapperer interface at pkg/dia/scraper/foreign-scrapers/Scrapper.go file

type ForeignScrapperer interface {
	UpdateQuotation() error
	GetQuoteChannel() chan *models.ForeignQuotation
}

Add the scraper implementation a MyForeignScraper.go Golang file to pkg/dia/scraper/foreign-scrapers/ folder and add the next implementations:

func (scraper *MyForeignScraper) Pool() chan dia.Pool {}
func (scraper *MyForeignScraper) Done() chan bool {}

1. Add a constructor for the scraper:

func NewMyForeignScraper(exchange dia.Exchange) *MyForeignScraper {}

1. Add MyForeignScraper case at scraper file cmd/foreignscraper/foreign.go:

switch *scraperType {
	case "MyForeignScraper":
		log.Println("Start scraping data")
		sc = scrapers.NewMyForeignScraper(ds)
}

Foreign Command

go mod tidy -go=1.16 && go mod tidy -go=1.17 && go install && foreignscraper -foreignType=ForeignType

Foreign Test

go mod tidy -go=1.16 && go mod tidy -go=1.17 && go install && foreignscraper -foreignType=FOREIGN_TYPE