Skip to content

RedStone Oracle Integration for Protocols Reading Prices and Funds Publishing NAV

RedStone's network signs and delivers the prices, and RedStone's docs leave the protocol side to your team. Protofire builds that side: push reads checked against RedStone's return values, pull payloads behind your API proxy, and TSSO signing logic for NAV. DIA merged our data scrapers in 2024 and 2025.

Luis Medeiros

Reviewed by Luis Medeiros, Field CTO at ProtofireLast reviewed: November 2026

On this page
  1. Overview
  2. What you get
  3. Push feed reads
  4. Push, pull or NAV
  5. RedStone facts
  6. Why Protofire
  7. How the work goes
  8. How work starts
  9. Not the right fit
  10. Related guides and services
  11. FAQ

Work shipped for 60+ networks and 95+ protocols, including

  • Chainlink
  • Ethereum
  • Solana
  • Safe
  • Ripple
  • Aave

What RedStone runs and what your team owns

RedStone runs the data, and your team owns the protocol side. RedStone's documentation says that "The integrating team is responsible for the protocol-side integration" and that RedStone "operates the data infrastructure end-to-end" (RedStone). In a RedStone oracle integration, Protofire builds that protocol side.

A push feed answers the Chainlink-style call with RedStone's own values. For example, your lending market swaps a Chainlink feed for a RedStone push feed and keeps its consumer code. The call to latestRoundData() still answers. On RedStone feeds without rounds, the round ID is fixed at 1, and getRoundData() reverts for other round IDs (RedStone code). A check of answeredInRound against roundId then passes on each read and says nothing about the price's age.

Under TSSO, the source of a fund's NAV signs each record that RedStone publishes. RedStone and Securitize published the Trusted Single Source Oracle (TSSO) in July 2025 (RedStone). A root key signs initial NAV values and significant updates. A derivative key signs automated updates within a deviation threshold and re-signs an unchanged NAV. RedStone's post names "multi-signature wallets, cold storage, or smart account controls" as protection for the root key. The post says builders who integrate with a fund administrator "can implement signing logic" for those keys.

Who runs each part of a RedStone integration

RedStone's network signs and delivers the data. The NAV's source signs NAV, your multisig changes signers, and your contracts act on each price.

RedStone

Data providers and gateways

Provider nodes sign each price, and RedStone's gateways distribute the packages.

Relayers and adapters

Relayers write push prices onchain on a heartbeat or a deviation trigger.
Your team

NAV, reserves and TSSO keys

Your fund administrator or custodian provides the figure, and the NAV's source signs each record under TSSO.

Signers, feeds and pauses

Your multisig changes authorized signers, repoints feeds and pauses markets.
Protofire builds

Contract checks and payload wrapper

Consumer contracts check age, bounds and signers, and each call path attaches the payload.

API proxy and signing service

A proxy holds the API key, and a service your firm runs applies the TSSO signing rules.

Alerts and runbook

Monitors watch heartbeats, skipped updates and registry changes, each with an owner.

What a RedStone oracle integration includes

Push reads with age checks on the right timestamp

Your lending contracts refuse a RedStone price that is older than your limit or outside your bounds. Protofire writes the consumer adapters that compare updatedAt with each feed's heartbeat, check bounds and scale by the feed's decimals.

Pull prices on each call path, with the API key behind your proxy

Your users and keepers send transactions with signed RedStone data attached, and no RedStone API key ships in your front end. Protofire adds the payload wrapper to each call path and builds the proxy that holds the key and caches responses.

NAV records signed at the source under TSSO

Lending venues read a NAV that its source signed. For the firm that signs, Protofire builds the signing service and a daily match of onchain NAV against the fund administrator's figure. The match uses the fund's cut-off, such as 5:00 p.m. Eastern each business day for BRSRV, and flags a NAV older than the last cut-off.

Reserve figures that your mint function checks

Your token contract checks onchain reserves before minting. RedStone's proof of reserve service reads custodian, exchange, bank statement or fund administrator sources and publishes the figure onchain (RedStone). Protofire builds the reserve data endpoint that RedStone reads and the mint check.

Canton consumers that follow a changing contract ID

Your Daml workflows on Canton read RedStone prices as a viewer party, and a PricePill refuses data more than one day old. Each write archives RedStone's adapter contract and creates a new one with a new contract ID (RedStone). Protofire builds Daml consumers that find the current adapter contract and handle stale PricePills.

A runbook for signer changes, repointing and pauses

Your team knows who updates the RedStone signers your contracts accept, who repoints a feed and who pauses a market. RedStone recommends an upgrade mechanism "ideally based on multi-sig or DAO" and a watch on its data services registry (RedStone). Protofire writes the runbook and sets alerts on missed heartbeats, skipped updates and registry changes.

What a RedStone push feed returns when your contract reads it

A RedStone push feed records two timestamps, and a freshness check has to choose one.RedStone's adapter stores the timestamp of the signed data, usually in milliseconds, and the block timestamp of the update (RedStone code). The updatedAt value from latestRoundData() is the block time of the last write, and decimals() defaults to 8 (RedStone code). A heartbeat check compares updatedAt. A check of the data's own age reads getDataTimestampFromLatestUpdate() instead.

RedStone's published relayer configuration for Ethereum, read in November 2026, lists 95 feeds (GitHub). Its default trigger is a 0.5% deviation or 24 hours, so a quiet market can leave a day between writes. BUIDL's fundamental feed updates on a 0.01% deviation or 24 hours.

The adapter rejects a zero value and data that is no newer than the last update. A multi-feed adapter emits skip events, such as UpdateSkipDueToDataTimestamp (RedStone code). Your monitoring can alert on them.

Push feed, pull payload or NAV feed: what each asks of your code

Push, pull and TSSO NAV each give your code a different job and a different key to protect.

Who puts the price onchain

Push feed: A relayer writes to RedStone's adapter on a heartbeat or deviation trigger.

Pull payload: Your caller attaches signed data packages to its own transaction.

NAV feed (TSSO): The NAV's source signs each record, and RedStone delivers it by push or pull.

Freshness clock

Push feed: updatedAt, the block time of the last write.

Pull payload: The data timestamp, by default no more than 3 minutes old or 1 minute ahead of the block (RedStone code).

NAV feed (TSSO): The fund's valuation cut-off. BRSRV's push feeds run on a 24-hour heartbeat.

Keys and credentials

Push feed: Each relayer signs with the key of a funded wallet.

Pull payload: An API key per gateway, held in your proxy.

NAV feed (TSSO): A root key in a multisig or cold storage, and a derivative key for automated updates.

What your code adds

Push feed: Age and bound checks written for a fixed round ID of 1.

Pull payload: RedStone's consumer base contract and the payload wrapper.

NAV feed (TSSO): The signing service and a daily match against the administrator's NAV.

Failure to plan for

Push feed: A skipped update, which leaves the last value in place.

Pull payload: A call path, such as an aggregator, that drops the payload and gets a contract error.

NAV feed (TSSO): A record signed by the wrong key or out of sequence, which fails the oracle nodes' check.

When we're looking at real estate or cars or any kind of one-off goods, I don't think it should be the oracle that's being the underwriter of this collateral.
Dillon Hanson, Head of BD, DIA · The Protocol Roundtable by Protofire, Episode 2, 28:37

RedStone delivery models, pull defaults and license terms

Website operator
RedStone Distributed Data Association, Baar, Switzerland, per RedStone's privacy policy.
Delivery models
Push, Pull, Bolt (push on MegaETH and Monad as of November 2026), Live (an offchain WebSocket stream) and Proof of Reserve (RedStone).
Pull verification
By default, the contract takes the median of values from authorized signers. RedStone recommends "Approximately 3 required unique signers" (RedStone). Its production base contract requires 3 of its 5 authorized signers (RedStone code).
Non-EVM ledgers
RedStone's docs list Canton, Solana, Stellar and Sui. Push feeds also run on Starknet and Fuel.
NAV feeds
Under TSSO, each record holds the asset ID, price, timestamp and sequence number, plus the previous record's hash and signature.
Proof of reserve
Offchain attestation first, then onchain publication on a deviation threshold and a heartbeat. A TEE option can use AWS Nitro Enclaves.
Code license
The monorepo's root LICENSE is Business Source License 1.1, with Distributed Data Labs as licensor (GitHub). The Solidity files linked on this page have BUSL-1.1 headers.

Checked November 2026 against RedStone's documentation and code repositories.

Our record in oracle data work: scrapers merged by DIA

DIA merged Protofire's scrapers for five data sources into its main repository between June 2024 and January 2025.The sources are Bitflow and Velar on Stacks, Bifrost and Hydration on Polkadot, and an Alephium DEX. Scraper work is on the data side of an oracle network, where prices are sourced and checked before anyone signs them.

Four stages from read inventory to runbook

  1. Step 1

    An inventory of each RedStone read

    Protofire lists each read with its feed ID, its trigger and the address that can repoint it. For pull data, the list also names each call path, including keepers and third-party aggregators.
  2. Step 2

    Contract checks, wrapper, proxy and signing service

    Protofire writes the consumer checks and the payload wrapper. We also build the API proxy and, for a firm that signs NAV, the TSSO signing service. A smart contract audit can review the consumer contracts before launch.
  3. Step 3

    Tests with stale, zero and wrong-signer data

    Protofire's tests send stale, zero, out-of-window and wrong-signer data to each check. RedStone's Hardhat mock wrapper and Foundry mock payloads feed chosen values into the pull path.
  4. Step 4

    Runbook and handover from your keys

    Your keys deploy the contracts, and your multisig signs each change of signers or feeds. Your team gets the runbook and alert rules. Protofire's engineers can run the alerts under a written scope (managed onchain operations).

How work with RedStone feeds starts

RedStone issues the pull API key to your firm, and your proxy reads the key from your own vault.If your firm signs NAV under TSSO, it holds the root key and the derivative key that the signing service uses. The alert service that Protofire can operate reads data and makes no write call.

Proposal
In writing, one business day after the discovery call: findings, a plan in phases and the first step we recommend.
Price
Fixed per phase when you commission it, against written acceptance criteria. Overruns inside them are ours to absorb, invoices follow delivered milestones, and you can stop at any phase boundary. Anything we operate after launch is priced in the proposal as its own recurring line, with the notice to end it.
Ownership
Code we write for you, contracts, the keys and credentials this work creates and the accounts your infrastructure runs in are yours by contract, within the license of any third-party software involved. Keys that a custody platform or a staking provider holds under its own key model stay with it under your contract; every other custody key stays with you or the custodian you appoint. Where the scope places something on servers we rent, it says what moves to you and when. An NDA is available from your first message, and we sign a data processing agreement (DPA) together with it.
After launch
Delivery closes with a hypercare window and a defect warranty, with their terms written into the proposal. A service we operate continues under its written scope until that scope ends.
Access
Read-only by default. A role that can start requests only if your written scope names one; never a signer, approver, administrator, key holder or recovery role on your contracts, wallets or custody platform. Services we build call each platform on credentials your staff issue and keep in your vault. Anything that approves or moves funds runs in your environment, and a scope under which we operate a service lists every write call it makes. Where the scope has us operate nodes, validators, monitors, explorers or indexers, it names the role and any key we hold on those servers, and in your own cloud account you can remove it.
Licenses
Protofire is an engineering firm and holds no financial or crypto-asset license; licensed activity stays with you and your providers.

How we work shows a worked proposal.

Requests outside a RedStone integration with Protofire

Four kinds of request need RedStone, your own team or another page.

  • You need a new feed, a feed methodology or a proof of reserve attestation layer. RedStone manages that setup, and its docs say "PoR feed setup is handled directly with the RedStone team". Protofire builds the protocol and issuer side around them.
  • A push feed is already live on your chain, and your engineers and auditor own the Solidity checks. Your team can read the feed through latestRoundData() without an outside firm. A RedStone feed and Protofire's tests do not guarantee that a price is right.
  • You want Protofire as relayer, signer or NAV key holder. After launch, Protofire holds no relayer, signing or TSSO key and is not a RedStone data provider. A service that your firm owns posts the prices.
  • You are choosing between oracle networks or readying a new chain for Chainlink. Our blockchain oracle integration page covers that choice.

FAQ

What is RedStone oracle integration?
RedStone oracle integration connects a protocol, a tokenized fund or a Canton workflow to RedStone's push, pull or NAV feeds. It includes the contract checks, payload wrappers and API proxy that RedStone leaves to the integrating team, plus TSSO signing logic for NAV. Protofire builds those parts for firms that chose RedStone.
Who can integrate RedStone feeds into our lending market or vault?
Protofire builds the protocol side of a RedStone integration for lending markets and vaults. That includes the consumer checks, the pull wrapper and the runbook for your curator or governance. RedStone chooses the product configuration with your team, and its docs say that determination "is made collaboratively".
How does a tokenized fund publish NAV through RedStone, and who signs it?
Under TSSO, the NAV's source signs each record with a root key or a derivative key. RedStone's post describes that source as a single fund administrator. Oracle nodes check the signature and the link to the previous record. Oracles that use TSSO can publish attestations openly or to a permissioned set, such as whitelisted lending vaults or regulators. Our fund tokenization providers guide compares the platforms that issue fund tokens.
How do we keep RedStone's API key out of our front end?
RedStone's docs say "Don't call RedStone's gateway directly from a dApp's frontend" (RedStone). Your front end calls a small proxy that you control, and the proxy caches responses for a few seconds. The gateway allows one request per second per API key. RedStone gives two gateway and key pairs, and the second pair serves as the fallback.
Can we run our own RedStone relayer?
RedStone's docs call relayers permissionless and recommend "multiple (ideally independent) instances" (RedStone). RedStone's adapter base lets any address send an update by default, and a deployed adapter can restrict its updaters. Protofire can set up an instance. Your firm runs it, and a wallet that your firm holds and funds signs each update.

Get a proposal

Tell us what you are building. An engineer reads it, we have a short call, and the written proposal follows within one business day.

Luis MedeirosField CTO, reads every request · LinkedIn

A demo or repository link also works.