Crypto Data Feed

Using Pyth Core to build and deploy a crypto feed on SEDA Fast.

Contents

• Requirements

• Getting Started

• Build your Crypto Feed

Requirements

• Bun: Install Bun for package management and building.

• Rust: Install Rust for development and building.

• WASM: Install the wasm32-wasip1 target with rustup target add wasm32-wasip1 for WASM compilation.

• Alternatively, use the devcontainer for a pre-configured environment.

• A SEDA FAST developer key. Visit the Developer Page here and access a 7 day trial.

If you need more than 7 days for your trial key, please reach out to our team on Discord for an extended free trial.

Getting Started

Clone and checkout the seda-starter-kit repository:

git clone https://github.com/sedaprotocol/seda-starter-kit.git simple-price-feed; cd simple-price-feed

Bun install:

bun install

Copy and populate the .env file's MNEMONIC .

cp .env.example .env

If you need a SEDA mnemonic this can most easily be achieved by downloading Keplr wallet. You can then claim Testnet SEDA tokens at the SEDA faucet

Build your Crypto Feed

Start by navigating to the src/execution_phase.rs file. The execution phase contains the main computational component of your FAST feed. This phase dictates how data is fetched and aggregated. The src/tally_phase.rs is more important for feeds that require onchain delivery via SEDA Core or that need to be backwards compatible with a SEDA Core feed.

The first step of the program is to define which inputs will be called. In this example we will use Pyth Core as a data source for this feed. We need to know what Pyth Asset ID we want to fetch. Navigate to https://insights.pyth.network/price-feeds and select a feed. For this example I will take BTC/USD with asset ID 0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43 .

#[derive(Serialize, Deserialize)]
struct PriceFeedInput {
    base_asset_id: String, // e.g. 0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43
}

We expect a stringified price as the output:

#[derive(Serialize, Deserialize)]
pub struct PriceFeedResponse {
    price: String, // e.g. "10000"
}

Next we parse the input and set a placeholder response for the time being:

use anyhow::Result;
use seda_sdk_rs::{log, Process};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct PriceFeedInput {
    base_asset_id: String, // e.g. 0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43
}

#[derive(Serialize, Deserialize)]
pub struct PriceFeedResponse {
    price: String,
    price_timestamp: i64
}

pub fn execution_phase() -> Result<()> {
    let price_feed_input = serde_json::from_slice::<PriceFeedInput>(&Process::get_inputs())?;
    let base_asset_id = price_feed_input.base_asset_id;

    log!("Fetching price for asset with id: {}", base_asset_id);

    // Fetch and process data

    let response_placeholder = PriceFeedResponse {
        price: "1000000".to_string(),
        price_timestamp: 123312
    };

    Process::success(serde_json::to_vec(&response_placeholder)?.as_slice());
}

Now we have to fetch the price from Pyth. For this we are going to use a SEDA Data Proxy. SEDA hosts Pyth Hermes testnet proxy at: http://pyth.proxy.testnet.seda.xyz/proxy

with public key: 033ed60cfdeb7e91f718bf28e514e5c2f2990400b4643e86856e530de9b46dfb47

Lets create src/fetch_pyth.rs to hold all our data fetching logic.

// fetch_pyth.rs
use seda_sdk_rs::{HttpFetchOptions, proxy_http_fetch};
use serde::Deserialize;

const TESTNET_PROXY_PUBLIC_KEY: &str =
    "033ed60cfdeb7e91f718bf28e514e5c2f2990400b4643e86856e530de9b46dfb47";
const TESTNET_PROXY_URL: &str = "http://pyth.proxy.testnet.seda.xyz/proxy/";

/* Example Proxy Response:
{
    "parsed": [
        {
            "price": {
               "price": "3206259",
               "conf": "4107",
               "expo": -5,
               "publish_time": 1761595219
            }
        }
*/

#[derive(Debug, Deserialize)]
struct PythPriceParsedResponse {
    price: PythPriceData,
}

#[derive(Debug, Deserialize)]
pub struct PythPriceResponse {
    parsed: Vec<PythPriceParsedResponse>,
}

// They both have the same structure for price data, so we can reuse the same structs
#[derive(Clone, Debug, Deserialize,)]
pub struct PythPriceData {
    pub price: String,
    // pub conf: String, // Confidence interval
    // pub expo: i32, // Exponent - can be used to convert the price to a more readable format
    pub publish_time: i64,
}


pub fn fetch_hermes_pyth_price(ids: Vec<String>) -> Result<PythPriceData, serde_json::Error> {
    // This proxy expects the ids to be in the format "ids[]=id1&ids[]=id2&ids[]=id3"
    let ids_str = ids.join("&ids[]=");

    // Fetch the price data from the Pyth proxy - verify the response is valid and signed by the proxy key
    let response = proxy_http_fetch(
        [TESTNET_PROXY_URL, "price/latest?ids[]=", ids_str.as_str()].concat(),
        Some(TESTNET_PROXY_PUBLIC_KEY.to_string()),
        Some(HttpFetchOptions {
            method: seda_sdk_rs::HttpFetchMethod::Get,
            headers: Default::default(),
            body: None,
            timeout_ms: Some(2_000),
        }),
    );

    // Parse the response into a PythPriceResponse struct
    let parsed_pyth_response = serde_json::from_slice::<PythPriceResponse>(&response.bytes)?;

    // Get the first (and only) price data from the response
    let price_data = 
        parsed_pyth_response
        .parsed
        .first()
        .expect("No price data found")
        .price.clone();

    // Return the price data
    Ok(price_data)
}

We then add fetch_pyth to src/main.rs so it can be accessed from our execution phase

// src/main.rs
use execution_phase::execution_phase;
use seda_sdk_rs::oracle_program;
use tally_phase::tally_phase;

mod execution_phase;
mod tally_phase;
mod fetch_pyth; // new addition

#[oracle_program]
impl PriceFeed {
    fn execute() {
        execution_phase().unwrap();
    }

    fn tally() {
        tally_phase().unwrap();
    }
}

Now update execution_phase.rs to fetch the data using fetch_pyth and return the result:

use anyhow::Result;
use seda_sdk_rs::{log, Process};
use serde::{Deserialize, Serialize};

use crate::fetch_pyth::fetch_hermes_pyth_price;

#[derive(Serialize, Deserialize)]
struct PriceFeedInput {
    base_asset_id: String, // e.g. 0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43
}

#[derive(Serialize, Deserialize)]
pub struct PriceFeedResponse {
    price: String,
    price_timestamp: i64,
}

pub fn execution_phase() -> Result<()> {
    let price_feed_input = serde_json::from_slice::<PriceFeedInput>(&Process::get_inputs())?;
    let base_asset_id = price_feed_input.base_asset_id;

    log!("Fetching price for asset with id: {}", base_asset_id);

    let price_response = fetch_hermes_pyth_price(vec![base_asset_id])?;
    
    let response_placeholder = PriceFeedResponse {
        price: price_response.price.to_string(),
        price_timestamp: price_response.publish_time,
    };

    Process::success(serde_json::to_vec(&response_placeholder)?.as_slice());
}

Now we just alter tally_phase.rs to simply verify that our response is formatted correctly, and then forward it as is:

use anyhow::Result;
use crate::execution_phase::PriceFeedResponse;
use seda_sdk_rs::{log, Process, get_reveals};

pub fn tally_phase() -> Result<()> {
    // Retrieve consensus reveals from the tally phase.
    let reveals = get_reveals()?;

    if reveals.is_empty() {
        Process::error("No consensus among revealed results".as_bytes());
    }

    // Parse the first reveal as the response
    // SEDA Fast only has one executor, so we use the first (and only) reveal
    let latest_response: PriceFeedResponse = reveals
        .into_iter()
        .map(|reveal| serde_json::from_slice(&reveal.body.reveal))
        .next()
        .ok_or_else(|| anyhow::anyhow!("No reveals to process"))??;

    Process::success(&serde_json::to_vec(&latest_response)?)
}

We can now deploy the feed and start querying it:

bun run deploy

Which should result in something like:

tx	06C4205396F6480F807A9A7B51D9C159C96E59A32C7D6DEA12F9F56C7051CC2A
oracleProgramId	e87808ce3f0809314e92a604164df5312cec84b4f0256c9af0a92000141f53c9

You can then query the fast oracle by calling:

curl -L -X POST 'https://fast-api.testnet.seda.xyz/execute?encoding=json&includeDebugInfo=true'
-H 'Authorization: {{MY_BEARER_TOKEN}}'
-H 'Content-Type: application/json'
--data-raw '{ "execProgramId": "c0dca277052bf42c3a4af363cc73815c7c79119e2b1771c3b50648c902dc792d", "execInputs": { "base_asset_id": "0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43" } } '

What's Next

Add additional computation to your feed:

• Unit conversion on the Pyth price (take the expo + price and convert it)

• Handle confidence intervals

• Add a separate quote asset to the Input

• Query the quote asset additionally to the base asset

• Add a cross-rate for the base asset from e.g. USD -> USDC