Contract types

Claros publishes data through two small Odra contracts on Casper testnet (casper-test). Both are keyed by the same feed_id string, and both follow the Pyth model: on-chain values are integers, and the human value is amount / 10^decimals.

• AttestationRegistry stores the feed VALUES. Its read methods return an Attestation.
• FeedRegistry stores self-describing METADATA. Its read methods return a Feed.

This page is the type reference: the exact struct fields with their Rust types, the read entry points, the Option returns, and the feed-enumeration methods. For the full integration walkthrough (declaring external_contract traits and wiring a ContractRef), see cross-contract reads. For off-chain access, see the TypeScript SDK and the REST API.

The two registries

These are the live package addresses on casper-test. Cross-contract callers pass them as Address arguments (Casper contract package addresses); the SDK and REST service have them baked in.

Attestation

A single recorded value plus its provenance. Returned by get_latest and get_at on AttestationRegistry.

use odra::casper_types::U512;
use odra::prelude::*;
 
#[odra::odra_type]
pub struct Attestation {
    pub period: u64,
    pub amount: U512,
    pub source_hash: String,
    pub attester: Address,
    pub timestamp: u64,
}

Feed

Self-describing metadata for a feed, so a consumer reading a value can interpret it (decimals, unit, source) entirely on-chain. Returned by get_feed on FeedRegistry.

#[odra::odra_type]
pub struct Feed {
    pub decimals: u8,
    pub unit: String,
    pub title: String,
    pub source: String,
    pub route: String,
    pub frequency: String,
    pub description: String,
}

Read entry points

These are the methods a consumer calls. All are &self views: free to call off-chain (SDK, REST) and gas-only on-chain. The write methods (attest, register_feed) are restricted, see write entry points.

The Option returns

get_latest, get_at, get_feed, and get_feed_at all return Option<...>. None is a normal, expected outcome, not an error condition:

On-chain, unwrap deliberately with a meaningful revert (unwrap_or_revert or a match) rather than assuming a value exists. Off-chain, the SDK mirrors this: getReading, getValue, getFeed, and feedIdAt each return T | null.

// Cross-contract: handle the None case explicitly.
let att = match AttestationRegistryContractRef::new(self.env(), areg).get_latest(feed_id) {
    Some(a) => a,
    None => self.env().revert(Error::NoData), // feed unknown or not yet attested
};

Feed enumeration

FeedRegistry keeps an index so you can list every feed without an off-chain catalog. Read feed_count() for the total, then walk get_feed_at(i) from 0 to count - 1 to get each feed_id, and get_feed(id) for its metadata.

let freg = FeedRegistryContractRef::new(self.env(), feed_registry);
 
let n = freg.feed_count(); // u64, e.g. 39
for i in 0..n {
    if let Some(id) = freg.get_feed_at(i) {
        let feed = freg.get_feed(id).unwrap_or_revert(&self.env());
        // feed.decimals, feed.unit, feed.frequency, ...
    }
}

import { ClarosOracle } from 'claros-oracle'
 
const oracle = new ClarosOracle() // testnet addresses baked in
 
const n = await oracle.feedCount()        // 37
const first = await oracle.feedIdAt(0)    // get_feed_at(0)
const ids = await oracle.listFeedIds()    // string[], loops feedIdAt for you
 
for (const id of ids) {
  const feed = await oracle.getFeed(id)   // get_feed(id) -> Feed | null
}

Scaling: amount / 10^decimals

Every value is an integer. To get the human number, read decimals from the Feed and divide. decimals is per-feed, so never assume a fixed scale. On-chain, keep the math in integers (wasm contracts are no_std, so there are no floats):

// EIA.PET.PRICE.WTI.DAILY: decimals = 6, amount = 78_940_000  ($78.94/bbl)
let scale = U512::from(10u64).pow(U512::from(feed.decimals as u32)); // 1_000_000
let whole = att.amount / scale;                                      // 78

The worked example, including how to recover the fractional part without floats, is on cross-contract reads. Off-chain, the SDK and REST compute value for you.

Method names across surfaces

The same on-chain entry point has a different name in each reading surface. This table maps them:

Events

If you index attestations instead of polling get_latest, both contracts emit a typed event on write:

RevenueAttested.index is the 0-based position the new value took in that feed’s history, so you can fetch it later with get_at(asset_id, index).

Write entry points

These exist for completeness. They are restricted to the Claros agent and owner, so a third-party contract cannot call them (both revert Unauthorized = 1 for any other caller).

New feeds are claimed by whichever ZK-eligible account registers them; feeds that predate the network upgrade remain with the first-party Claros agent, account-hash 43d7dd06d5538e504e54a3f235f1596f7d2e803e9065bf3c0d040f5cd31a21d4.

Related