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.

Reviewed by Luis Medeiros, Field CTO at ProtofireLast reviewed: November 2026
On this page
Work shipped for 60+ networks and 95+ protocols, including
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.
Data providers and gateways
Relayers and adapters
NAV, reserves and TSSO keys
Signers, feeds and pauses
Contract checks and payload wrapper
API proxy and signing service
Alerts and runbook
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.
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
- 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. - 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. - 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. - 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?
Who can integrate RedStone feeds into our lending market or vault?
How does a tokenized fund publish NAV through RedStone, and who signs it?
How do we keep RedStone's API key out of our front end?
Can we run our own RedStone relayer?
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.

