Example Crypto Price Feed

Example Crypto Price Feed

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

Contents

• Requirements
• Getting Started
• Building the Oracle Program
• Deploying & Querying

---

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.

rustup target add wasm32-wasip1

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

Additional Requirement for SEDA Fast

• SEDA Fast requires a FAST API key for querying.
• SEDA Core does not require a FAST API key, but instead requires submitting a Data Request onchain from a supported network or on SEDA Chain directly.

• A SEDA FAST developer key. Visit the Developer Page 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

The easiest way to start building a SEDA Oracle Program is by using the seda-starter-kit. This starter kit offers a streamlined setup process and comes with the essential tools and structure to help you create and deploy your first Oracle program on the SEDA network.

Clone and checkout the repository:

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

Install dependencies:

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

---

Building the Oracle Program

The PriceFeed Oracle Program is divided into two phases:

Execution: Fetches the price of an asset pair (e.g., BTC-USDT or a Pyth asset ID) from an external source and processes the data.

Tally: Aggregates execution reports.

🔎 Difference:

• SEDA Fast: Typically runs a single executor and forwards the result.
• SEDA Core: Multiple Overlay Nodes execute the program, and the tally phase aggregates (e.g., median) results.

---

Step 1: Entrypoint

The Oracle Program logic lives in the src folder, where main.rs serves as the entry point.

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; // Required for Pyth-based Fast example

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

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

This setup initializes the PriceFeed Oracle program and links the execution and tally phases that make up the data request.

---

Step 2: Execution Phase

The execution phase is where the Oracle Program fetches data and performs computation on the fetched data.

Pyth Core via SEDA Data Proxy

Start by defining inputs and outputs:

#[derive(Serialize, Deserialize)]
struct PriceFeedInput {
    base_asset_id: String,
}

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

Parse input:

let price_feed_input = serde_json::from_slice::<PriceFeedInput>(&Process::get_inputs())?;
let base_asset_id = price_feed_input.base_asset_id;

Create src/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/";

Define response structures and fetch logic:

pub fn fetch_hermes_pyth_price(ids: Vec<String>) -> Result<PythPriceData, serde_json::Error> {
    let ids_str = ids.join("&ids[]=");

    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),
        }),
    );

    let parsed_pyth_response = serde_json::from_slice::<PythPriceResponse>(&response.bytes)?;

    let price_data =
        parsed_pyth_response
        .parsed
        .first()
        .expect("No price data found")
        .price.clone();

    Ok(price_data)
}

Update execution phase:

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());

• This example uses proxy_http_fetch and a signed SEDA Data Proxy.
• Suitable for both Fast and Core.
• In Fast, the result is typically forwarded directly.
• In Core, results are revealed and aggregated in tally phase.

---

Calling a Public API via http_fetch

let response = http_fetch(
    format!(
        "https://api.binance.com/api/v3/ticker/price?symbol={}{}",
        symbol_a.to_uppercase(),
        symbol_b.to_uppercase()
    ),
    None,
);

Check for errors:

if !response.is_ok() {
    elog!(
        "HTTP Response was rejected: {} - {}",
        response.status,
        String::from_utf8(response.bytes)?
    );

    Process::error("Error while fetching price feed".as_bytes());
    return Ok(());
}

Parse and compute:

let data = serde_json::from_slice::<PriceFeedResponse>(&response.bytes)?;
let price: f32 = data.price.parse()?;
let result = (price * 1000000f32) as u128;

Process::success(&result.to_le_bytes());

---

Step 3: Tally Phase

---

SEDA Fast Tally Phase (Single Executor Forwarding)

let reveals = get_reveals()?;

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

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)?)

• SEDA Fast only has one executor.
• The first reveal is used and forwarded.

---

SEDA Core Tally Phase (Median Aggregation)

let reveals = get_reveals()?;
let mut prices: Vec<u128> = Vec::new();

for reveal in reveals {
    let price_bytes_slice: [u8; 16] = match reveal.body.reveal.try_into() {
        Ok(value) => value,
        Err(_err) => {
            elog!("Reveal body could not be casted to u128");
            continue;
        }
    };

    let price = u128::from_le_bytes(price_bytes_slice);
    prices.push(price);
}

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

let final_price = median(prices);

Process::success(&final_price.to_be_bytes());

SEDA Core Behavior:

• Multiple Overlay Nodes execute.
• Tally phase aggregates (median).
• Big-endian encoding for EVM compatibility.

---

Building the Oracle Program

To build:

bun run build

---

Deploying

SEDA Fast Deployment

bun run deploy

Query:

curl -L -X POST 'https://fast-api.testnet.seda.xyz/execute?encoding=json&includeDebugInfo=true' \
-H 'Authorization: Bearer {{BEARER_TOKEN}}' \
-H 'Content-Type: application/json' \
--data-raw '{
    "execProgramId": "8cf7808cdb5d16e9fb328007968b31727f8e67ac3c83b655aa61c4ccd4077125",
    "execInputs": {
        "pyth_assets": [
            "0x61c4ca5b9731a79e285a01e24432d57d89f0ecdd4cd7828196ca8992d5eafef6",
            "0xb1073854ed24cbc755dc527418f52b7d271f6cc967bbf8d8129112b18860a593"
        ]
    }
}'

---

SEDA Core Deployment

After building, you'll have the .wasm artifacts in the build directory.

These artifacts can be deployed to the SEDA network and referenced in onchain Data Requests from supported networks.

Differences between SEDA Core and Fast:

Component	SEDA Fast	SEDA Core
Execution Replication	Single executor	Multiple Overlay Nodes
Tally Behavior	Forward first reveal	Aggregated consensus (e.g. median)
Access Method	Authenticated REST API	Onchain Data Request
Encoding	JSON common	Big-endian for EVM

The Oracle Program logic remains portable between both delivery methods.