> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mecone.trade/llms.txt
> Use this file to discover all available pages before exploring further.

# Consuming the Feeds

> Signed official rounds over REST, on-chain, or an adapter

Every five minutes Mecone signs each of its eight public indices into a
**signed official round** — the one source of truth, an immutable record you
can verify offline against one pinned public key. The [signed
round](/oracle/signed-rounds) is transport-neutral: every rail below carries
that same round, and none of them can create or alter one.

## Choosing your integration path

| You are…                                                           | Read this                                                                               | What you get                                                                                                                                                                                                                         |
| ------------------------------------------------------------------ | --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| A venue settling perps, or anyone who must not trust the transport | **[Signed official rounds](/oracle/signed-rounds)** — HTTPS pull + offline verification | The signed round itself: exact value, official timestamps, verifiable end-to-end. Fresh rounds need a partner token; 24h-delayed rounds and all verification material are open.                                                      |
| An EVM venue that already reads oracles on-chain                   | **A. On-chain (below)**                                                                 | All eight published feeds live on Arbitrum Sepolia for testnet wiring. At mainnet onboarding the publisher carries verified signed rounds on-chain at their official effective time, so your contract reads the signed round itself. |
| A dashboard, terminal, or anything displaying a live price         | **B. REST (below)**                                                                     | The continuous live index (the v1 snapshot `value`; legacy `index_now`) — more granular than official rounds, for display. Settle against official rounds, not this.                                                                 |

All paths serve the same eight production indices. Fresh signed rounds are a
licensed pull (partner token, metered per read); rounds older than 24 hours
and everything verification needs — anchor, keysets, registry, verifier kit —
stay open, because the signed round is a portable artifact and verification
uses public material only.

## A. On-chain (EVM venues)

Reading a Mecone index on-chain is a single call against the oracle contract:

* **Feed id** = `keccak256("MECON_<symbol>")`: the encoded asset id is the
  keccak hash of the plaintext symbol.
* Call `getTemporalNumericValueV1(bytes32 id)` on the oracle contract; it
  returns `{ uint64 timestampNs, int192 quantizedValue }`.
* Values are quantized **×10¹⁸** (divide by 1e18 to de-quantize).
* **Dollar valuations are published in billions of USD** so they quantize in
  line with the macro percentages: `MOAI` reading `~921` means `$921B`. Macro
  percentage feeds read directly (`2.13` = 2.13%).
* **The `$` unit differs by transport.** The Mecone API returns valuations in
  raw dollars while the on-chain rail carries them in billions — API
  `921000000000` and on-chain `921e18` are the same $921B. `%` and `$/hr\`
  feeds are not rescaled between transports.

```solidity theme={null}
struct TemporalNumericValue { uint64 timestampNs; int192 quantizedValue; }
interface IOracleFeed {
    function getTemporalNumericValueV1(bytes32 id) external view returns (TemporalNumericValue memory);
}

// Read US GDP:
bytes32 id = keccak256("MECON_MGDP");
TemporalNumericValue memory v = IOracleFeed(ORACLE).getTemporalNumericValueV1(id);
int256 gdp = int256(v.quantizedValue); // 1e18-scaled -> 2.13% = 2.13e18
```

We ship a reference consumer (`MeconeStorkConsumer`) that maps a short market
key to its feed id and adds a tight staleness window on top of the oracle's,
plus a minimal reference perp that settles against it, both live on testnet
([quickstart](/oracle/testnet)).

<Note>
  **Testnet today, signed rounds on-chain at mainnet.** The eight published
  feeds are live on **Arbitrum Sepolia** for wiring and integration testing.
  At mainnet onboarding we provision a dedicated publisher key and deploy the
  publisher that carries **signed official rounds** on-chain — pulling each
  feed's latest round, verifying it against the pinned root anchor with the
  same kit partners use, and publishing it on-chain at the round's official
  effective time — so the value your contract reads is the signed round
  itself. For settlement-grade values today, pull them from the
  [signed-rounds service](/oracle/signed-rounds).
</Note>

<Note>
  **The on-chain rail is a pull oracle.** The on-chain value for a feed
  updates when someone submits the signed payload
  (`updateTemporalNumericValuesV1`, fee via `getUpdateFeeV1`). Venues either
  run the open-source chain pusher, or submit the signed update atomically in
  the transaction that consumes it. For pilots we run the pusher for you.
</Note>

### Feed ids (same on mainnet and testnet)

| Symbol | Asset id       | Feed id (`bytes32`)                                                  |
| ------ | -------------- | -------------------------------------------------------------------- |
| MGDP   | `MECON_MGDP`   | `0xc1b9ff58ed9bcf48022dd2c866207d7d4300802f6b4582b3b096817be2f233f0` |
| MCPI   | `MECON_MCPI`   | `0x09e722e06a32236b1653a32d00d58f38d9d52156cce4e510edcf6c0be3dc2e22` |
| MUNEMP | `MECON_MUNEMP` | `0xc960b63f8aa14945c9c86e08309fe2686b415058c1dd3677bf8538c19f593cda` |
| MOAI   | `MECON_MOAI`   | `0xc0be26c2318039c5bd6715deae6f49f873ba7e5226529659119338c137f2a192` |
| MANTH  | `MECON_MANTH`  | `0x9b9da9435546ad30be4a18c1afd6fdfd202c1d57088bfb21bd1dc2d9f9ca7e80` |
| MH100  | `MECON_MH100`  | `0xf9c19de6bf85ab849b0c6474707ddbf45c392ce1905e5ead5d33f6cd02ca480d` |
| MH200  | `MECON_MH200`  | `0xc6de3d7f8dd73811950a285630988490e97335189e63fff663406305eeaf68a3` |
| MB200  | `MECON_MB200`  | `0x0b7e68829242d67d1973f738f82851c7f65827d774d20d3922e4960dfee55745` |

Oracle contract addresses per chain:
[docs.stork.network/resources/contract-addresses/evm](https://docs.stork.network/resources/contract-addresses/evm).

## B. Off-chain feed

If you post your own oracle price (an internal oracle, or a HIP-3 style
deployer feeding an L1), pull the value from the versioned Mecone API and post
it:

```bash theme={null}
curl https://api.mecone.trade/api/v1/indices/us-gdp/snapshots/latest
# -> { "data": { "scope": "live_indicative", "value": { "decimal": "2.12…", "unit": "%", … }, … } }
```

`value` is the index level in its natural unit, with a wire-stable `decimal`
string beside the JSON number; a snapshot is explicitly `live_indicative`, so
settle against [`rounds/latest`](/api-reference#latest-committed-round) or the
[signed rounds](/oracle/signed-rounds), not against it. The legacy
`curl https://api.mecone.trade/api/markets/us-gdp` (`index_now`) contract
remains unchanged for existing pilots. Full field reference: [API](/api-reference).

## C. Signed official rounds (verifiable)

For settlement, audit, or any integration where you must not trust the
transport: every five minutes each index becomes a **cryptographically signed
official round** — the round id is the EIP-712 digest of the signed body, the
signer is authorized by a keyset attested by Mecone's pinned root key, and a
self-contained \~250-line verifier is served by the endpoint itself. One public
value to pin, three commands to verify a live production round:
[Signed Official Rounds](/oracle/signed-rounds).