Consume Data

cargo new miden-price-reader
cd miden-price-reader

[dependencies]
pm-accounts     = { git = "https://github.com/astraly-labs/pragma-miden" }
pm-utils-cli    = { git = "https://github.com/astraly-labs/pragma-miden" }
miden-client    = { version = "0.17", features = ["tonic", "testing"] }
miden-protocol  = "0.17"
miden-standards = "0.17"
tokio           = { version = "1", features = ["rt-multi-thread", "macros"] }
anyhow          = "1"

use anyhow::{Context, Result};
use miden_client::{
    account::AccountId, keystore::FilesystemKeyStore,
    rpc::domain::account::AccountStorageRequirements, transaction::ForeignAccount, Client, Felt,
    Word, ZERO,
};
use miden_protocol::account::{StorageMapKey, StorageSlotName};
use miden_protocol::vm::AdviceInputs;
use miden_standards::code_builder::CodeBuilder;
use pm_accounts::oracle::get_oracle_component_library;
use pm_utils_cli::setup_testnet_client;
use std::collections::BTreeMap;

// Pragma oracle on the Miden 0.17 testnet — check github.com/astraly-labs/pragma-miden#deployments
const ORACLE_ID: &str = "0x0d39e78df12351510ec5047670b40e";

// Storage slot names (defined in oracle.masm / publisher.masm)
const SLOT_NEXT_INDEX: &str = "pragma::oracle::next_publisher_index";
const SLOT_PUBLISHERS: &str = "pragma::oracle::publishers";
const SLOT_ENTRIES: &str = "pragma::publisher::entries";

/// Fetches the oracle account, reads all registered publisher IDs from its
/// storage map, imports each one, and returns the full list of ForeignAccounts
/// needed to call `get_median` via FPI.
async fn get_oracle_foreign_accounts(
    client: &mut Client<FilesystemKeyStore>,
    oracle_id: AccountId,
    faucet_word: Word,
) -> Result<Vec<ForeignAccount>> {
    client.import_account_by_id(oracle_id).await?;
    client.sync_state().await?;

    let oracle_account = client
        .get_account(oracle_id)
        .await?
        .context("oracle account not found on testnet")?;
    let storage = oracle_account.storage();

    // next_publisher_index tells us how many publishers are registered (indices start at 2)
    let count_slot = StorageSlotName::new(SLOT_NEXT_INDEX)?;
    let publisher_count = storage
        .get_item(&count_slot)
        .context("unable to read next_publisher_index")?[0]
        .as_canonical_u64();

    // publishers map: keys are [index, 0, 0, 0], values hold the publisher account id
    let publishers_slot = StorageSlotName::new(SLOT_PUBLISHERS)?;
    let publisher_ids: Vec<AccountId> = (2..publisher_count)
        .map(|i| -> Result<AccountId> {
            let key: Word = [Felt::new(i)?, ZERO, ZERO, ZERO].into();
            let w = storage
                .get_map_item(&publishers_slot, StorageMapKey::new(key))
                .with_context(|| format!("publisher at index {i} not found"))?;
            // Same layout as pm-oracle-cli: [prefix, suffix, 0, 0]
            Ok(AccountId::new_unchecked([w[0], w[1]]))
        })
        .collect::<Result<_>>()?;

    // Each publisher (with the entry for our pair) + the oracle itself
    let entries_slot = StorageSlotName::new(SLOT_ENTRIES)?;
    let mut foreign_accounts: Vec<ForeignAccount> = vec![];
    for pid in &publisher_ids {
        client.import_account_by_id(*pid).await?;
        foreign_accounts.push(ForeignAccount::public(
            *pid,
            AccountStorageRequirements::new([(
                entries_slot.clone(),
                &[StorageMapKey::new(faucet_word)],
            )]),
        )?);
    }
    foreign_accounts.push(ForeignAccount::public(
        oracle_id,
        AccountStorageRequirements::default(),
    )?);
    Ok(foreign_accounts)
}

#[tokio::main]
async fn main() -> Result<()> {
    // Store: ./miden_storage/store.sqlite3, keystore: ./keystore (relative to CWD)
    let mut client = setup_testnet_client(None, None).await?;
    println!("Latest block: {}", client.sync_state().await?.block_num);

    let oracle_id = AccountId::from_hex(ORACLE_ID)?;

    // BTC/USD — faucet_id "1:0" → word [0, 0, suffix, prefix]
    let (prefix, suffix) = (1u64, 0u64);
    let faucet_word: Word = [ZERO, ZERO, Felt::new(suffix)?, Felt::new(prefix)?].into();

    let foreign_accounts =
        get_oracle_foreign_accounts(&mut client, oracle_id, faucet_word).await?;
    client.sync_state().await?;

    // The script calls get_median via FPI using the oracle component library.
    // Stack input : [prefix, suffix, 0, 0]  (prefix on top)
    // Stack output: [is_tracked, median, amount]
    let script_code = format!(
        "
        use oracle_component::oracle_module
        use miden::core::sys

        @transaction_script
        pub proc main
            push.0.0.{suffix}.{prefix}
            call.oracle_module::get_median
            exec.sys::truncate_stack
        end
        ",
        prefix = prefix,
        suffix = suffix,
    );
    let oracle_lib = get_oracle_component_library();
    let script = CodeBuilder::default()
        .with_dynamically_linked_package(&*oracle_lib)
        .map_err(|e| anyhow::anyhow!("library error: {e:?}"))?
        .compile_tx_script(script_code)
        .map_err(|e| anyhow::anyhow!("compile error: {e:?}"))?;

    // Read-only: execute_program, not submit_new_transaction
    let output_stack = client
        .execute_program(
            oracle_id,
            script,
            AdviceInputs::default(),
            foreign_accounts
                .into_iter()
                .map(|fa| (fa.account_id(), fa))
                .collect::<BTreeMap<_, _>>(),
        )
        .await
        .map_err(|e| anyhow::anyhow!("execute_program failed: {e:?}"))?;

    let is_tracked = output_stack[0].as_canonical_u64();
    let median = output_stack[1].as_canonical_u64();

    if is_tracked == 0 {
        println!("BTC/USD: not tracked by the oracle.");
    } else {
        // BTC/USD is an 8-decimal pair (see "Available assets" below)
        println!("BTC/USD median: {} (raw: {})", median as f64 / 100_000_000.0, median);
    }
    Ok(())
}

cargo run --release
# Latest block: 92610
# BTC/USD median: 77365.11 (raw: 7736511888374)

# Single asset
pm-oracle-cli median 1:0 --network testnet
# Median value: 8450000000000 (amount: 0)

# Multiple assets — 47% faster (single sync)
pm-oracle-cli median-batch 1:0 2:0 6:0 7:0 --network testnet --json