Skip to content

Blockchain Oracle Integration for New Chains and Protocols That Read Prices

Protofire builds oracle integrations for chains and protocols that depend on oracle prices. The integration includes checks that stop a contract from acting on a stale or wrong value. Chainlink's archived 2021 post records our grant-funded integrations, and DIA merged our price scrapers in 2024 and 2025.

Luis Medeiros

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

On this page
  1. Overview
  2. Why stale feeds matter
  3. Our oracle record
  4. What we build
  5. New-chain requirements
  6. How the work runs
  7. How work starts
  8. Not the right fit
  9. Related guides and services
  10. FAQ

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

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

Oracle integration on the chain side and in the contracts

Protofire's blockchain oracle integration work covers both ends: the chain's readiness for an oracle network and the contracts that read its prices.

For example, your lending market reads a Chainlink price, and the borrow goes through. Can your team say what the contract does when that price stops updating?

A chain team has the same problem from the other side. Chainlink integrates a new chain against a published list. On a self-managed feed, the chain publishes the prices and watches them.

Who owns each layer of an oracle integration

The oracle network signs the reports. The chain meets the network's list, and your contract decides what to do with each price.

Oracle network

Oracle network

Chainlink, Pyth, RedStone or Chronicle nodes and publishers aggregate prices from their data sources and sign each report.
Protofire builds

Chain readiness

Protofire checks the chain's RPC providers, archive node, finality, audited multisig and explorer against the network's list.

Feed workflow and receiver

A workflow writes prices to a self-managed feed, and a receiver contract checks each report.

Contract checks

The contracts check freshness, bounds, decimals and the sequencer feed on rollups, keep a pause path and are tested with replayed bad answers.

Alerts and runbook

Monitors watch heartbeats, price jumps and source disagreement, and each monitor has an owner.
Your team

Feed ownership and pause rights

Your multisig owns the feed contracts, repoints adapters and pauses.

Stale oracle feeds return old prices without an error

A feed that stops updating usually does not say so, and its last price keeps coming back.Chainlink feeds update on a price move or a heartbeat, and "some heartbeats are configured to last several hours" (Chainlink). The latestRoundData() function returns the stale price with no error. Only its updatedAt time shows how old the price is. Chainlink makes developers "solely responsible" for "data quality checks, circuit breakers, and appropriate contingency logic" (Chainlink).

On a new chain, the same problem is larger. The chain or its designated operator writes a Chainlink self-managed feed. Chainlink Labs gives no SLA for that feed and does not check "Heartbeat compliance" or "Whether the correct data was written onchain" (Chainlink). So someone on the chain's side has to watch the feed.

Leaving a feed unchecked has a public record. In February 2026, a misconfigured cbETH feed priced the asset at $1.12 instead of about $2,200 on Moonwell. Fixing the feed took a governance vote and a timelock, and bad debt reached $1.78M (Moonwell).

What Protofire builds in a blockchain oracle integration

Chain readiness for Chainlink's new-chain list

Before Chainlink integrates a new EVM chain, the chain has to meet the requirements that Chainlink publishes. Protofire compares your chain with each requirement and hands the oracle network's team a readiness file. We host RPC nodes as one of the providers and deploy a Blockscout explorer. We deployed Safe on 120+ EVM networks, where it secures $2B+. A chain without an audited multisig gets a Safe deployment.

Self-managed feed workflow, receiver contract and exit terms

On a self-managed feed, your chain or its operator writes Chainlink Data Streams prices to feed contracts through a Chainlink Runtime Environment (CRE) workflow. Protofire builds the workflow and a receiver contract. The receiver contract rejects a report meant for another chain and a report no newer than the last one. Your chain's multisig owns the feed contracts from deployment, so the multisig can replace the operator, Protofire included. When Protofire stops operating the feed, the scope covers the move to your next operator or a retirement notice to readers of the feeds. A workflow deployment also needs Chainlink's approval.

Price checks in the contracts that read feeds

Your contracts check the age, sign, scale and range of a price before they act on it. Liquidations and repayments get their own stale-feed rule, because blocking them on a stale feed lets bad debt grow. Protofire writes the consumer contracts for Chainlink, Pyth or RedStone feeds. For pull feeds, we add keepers and a server-side proxy, so no API key ships in a front end.

NAV feeds, reserve feeds and checks before minting

A tokenized fund strikes its NAV once a day, so lending venues cap the feed. A stablecoin issuer can check a reserve figure onchain before each mint. A reserve check before minting fails in three known ways. First, the check compares reserves with totalSupply() on one chain while the token is deployed on several chains. Second, the check accepts a reserve figure older than the feed's heartbeat. Third, the check scales a reserve with the wrong decimals, which Chainlink says can allow "over-minting" (Chainlink). Protofire wires the feeds into minting and lending with caps and tests the reserve check against those three failures. We also build a daily match of the onchain NAV against the fund administrator's figure. Our proof of reserve page covers the data pipeline. A Protocol Roundtable episode covers pricing tokenized assets.

Alerts on heartbeats, price jumps and source disagreement

Alerts fire on a missed heartbeat, a price jump or disagreement with a second source. Each alert has an owner and a runbook. Protofire's engineers run the monitoring under a written scope (managed onchain operations). Otherwise, your team runs the monitoring once your team has the runbooks.

Four steps of an oracle integration with Protofire

  1. Step 1

    A list of gaps in the chain or the feeds

    For a chain, Protofire tests your RPC, finality, execution and explorer against Chainlink's list. For a protocol, we list each feed with its heartbeat, its decimals and the address that can repoint it.
  2. Step 2

    Fixes, a feed workflow or consumer contracts

    Protofire writes the fixes, the feed workflow or the consumer contracts. For Pyth or RedStone pull feeds, we add the keepers and the server-side proxy for the API key.
  3. Step 3

    Tests that replay bad answers before launch

    Before launch, tests send stale, zero, out-of-range and out-of-order answers to each check in the contracts.
  4. Step 4

    A runbook and an exit plan for each feed

    The runbook names who can pause, who can repoint an adapter and how long a governance change takes. Each feed gets an exit plan for the day its oracle network changes terms or drops your chain.

How work with Protofire starts

A chain team sends its RPC, multisig and explorer setup.A protocol team sends the contracts that read prices, or a repository. A Protofire engineer goes through the material before the first call. The full process is on how we work.

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.

When you do not need an outside oracle team

An outside oracle team adds little to your project in four cases.

  • The feed you need is already live on your chain, and your Solidity engineers can own the checks. Reading a Chainlink feed follows a documented pattern on EVM chains, so your team writes the read checks and your auditor reviews them.
  • You need a contracted data provider or a reserve attestation. The data contract is with the data company or the oracle operator, and Protofire builds around that contract. An attestation is an accountant's report, and a proof-of-reserve feed does not replace it. Protofire wires the reserve figure into minting.
  • You want a guarantee that a price is fresh and right. Chainlink's documentation leaves the integrating developer responsible for the checks, and Protofire's tests do not guarantee a price.
  • You want Protofire to be the oracle. Protofire runs no decentralized oracle network and sells no market data. We attest no reserves and hold no license for oracle, market-data or attestation work.

FAQ

What is blockchain oracle integration?
Blockchain oracle integration connects a chain or a smart contract to an oracle network's price and reserve feeds. The integration includes checks that stop a contract from acting on a bad value. Protofire prepares new chains for Chainlink's requirements and builds chain-side feed workflows. Protofire also writes the freshness, bounds and decimals checks inside the contracts that read prices.
Who can integrate Chainlink, Pyth or RedStone feeds for our chain or protocol?
Protofire integrates oracle feeds for chains and for protocols. For a chain, Protofire closes the gaps on Chainlink's list and builds the chain's self-managed feed workflow. For a protocol, Protofire writes the price reads and their tests. Protofire is a Chainlink core contributor and helps maintain Chainlink CCIP. But Chainlink itself decides whether to integrate a new chain. We integrate Pyth and RedStone feeds for teams that chose them.
What does Chainlink require before it integrates a new chain, and who pays?
Chainlink's list for a new chain covers independent RPC providers, an archive node and documented finality. The list also covers Ethereum-equivalent execution, an audited multisig and an explorer with verification APIs. Under Chainlink Scale, ecosystems "contribute economic resources that offset the integration, maintenance, and operating costs of Chainlink services on their networks" (Chainlink).
Who runs a chain's own price feeds after launch?
On a Chainlink self-managed feed, the chain or its designated operator runs the feed after launch. Chainlink Labs does not monitor a self-managed feed. The operator has three jobs: "running the workflow, maintaining contracts, and supporting integrators". A Chainlink-compatible OCR (Off-Chain Reporting) stack with several nodes survives the failure of one node. But those nodes add no independent party, because the operator also picks the data sources.
Which checks should a contract run when it reads an oracle price?
A contract that reads an oracle price should compare updatedAt with the feed's heartbeat plus a small margin. The contract should also reject zero or negative answers and scale each price by the feed's decimals. Your own contract should enforce bounds, because Chainlink says minAnswer and maxAnswer are "no longer used" on most feeds (Chainlink). On a rollup, the contract should read the sequencer feed and refuse prices for a grace period after a restart. Liquidations and repayments need their own stale-feed rule. The contract also needs a pause path that skips the governance timelock.
Does a lending market need a push or a pull oracle?
Either type can serve a lending market, if the contract enforces a maximum price age and refuses an update older than the one it holds. A push feed writes a price on a deviation or a heartbeat. With a pull feed, the caller picks which signed price to post. So the age limit is also the window for choosing a favorable price (Pyth). Chainlink offers both types, as Data Feeds and Data Streams.
Is an oracle an ICT third-party provider under DORA?
On Protofire's reading, an oracle feed delivered under contract is an ICT service. Its register type is S05 "Provision of data" (Implementing Regulation (EU) 2024/2956, Annex III). A decentralized feed read onchain with no contract has no provider to register, but it remains an ICT dependency. Protofire found no supervisory guidance on oracles under DORA as of November 2026. Your counsel decides the entry in your register. Our DORA guide explains the register.

Discussed on The Protocol Roundtable

All episodes

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.