NAV Oracles for Tokenized Funds: Design Without an Attack Surface

A NAV oracle records net asset value on-chain; it never calculates it. Read who should sign it, how stale is too stale and what the contract does then.

Vignesh Palanivel

•

Nov 16, 2026

•

NAV Oracles for Tokenized Funds

Getting the net asset value on-chain without handing anyone a lever over every limit, price and redemption that reads it

On 12 November 2026, tokenized US Treasury products tracked by RWA.xyz held $13.97 billion across 86,336 holder addresses. In the funds among them, every subscription and redemption settles against one figure: the net asset value (NAV). In a tokenized fund, the contract that carries that figure on-chain is called a NAV oracle.

The NAV is the easy part. People already calculate it off-chain every dealing day, and tokenization doesn't change that. The hard part is that once it is on-chain, every contract trusts it. It prices subscriptions and redemptions, sizes the redemption gate and sits under every concentration and borrowing limit. That makes the NAV a single point of control. Anyone who can change it, or block a new one from being posted, can change every price, redemption and limit that depends on it.

The concern isn't the flash-loan price attacks seen in crypto markets. A fund's NAV only changes on dealing days. The real risk is a figure that is false, missing at the cut-off, never checked, or out of date.

The fund sets the NAV; the oracle only carries it. How the figure travels on-chain is a design choice, and we mark it as one.

Who this is for. Managers, administrators and engineering leads of a tokenized investment fund or money market fund, above all open-ended funds that deal daily. Closed-ended funds may calculate their NAV only occasionally, so they need less of this. Sections that apply only to some funds say so at the top.

Short on time? Here's the gist

  • The oracle records the NAV. It never calculates it. Valuation stays with the manager, the administrator or the external valuer, under the fund rules.
  • A stale NAV is not a zero and not the last value. Anything that mints, redeems or sizes a gate should stop when the figure is too old, and resume on its own when a fresh one lands.
  • A suspicious NAV should halt, not publish. Publishing a wrong figure spreads it into every limit. Halting makes the problem visible and pushes it to a person.
  • The attack surface is the keys and the configuration, not the arithmetic. Who may post, who may clear a halt, and how stale is too stale decide most of the risk.
  • Money market funds are the hardest case. They value and publish daily, and some carry two NAV figures the contract has to tell apart.

What is a NAV oracle for a tokenized fund, and what does it not do?

A NAV oracle is the contract that holds the fund's current net asset value on-chain, together with when it was accepted, who supplied it and whether it is still usable. Other contracts read it. It is a delivery and gatekeeping layer, not a valuation engine.

Stays off-chainLives in the oracle
The valuation method, its documentation and its reviewThe figure the method produced
Pricing the assets, including any model or appraisalWhen that figure was accepted, and by how many sources
Striking the NAV (calculating and fixing the official figure) and the NAV per unitWhether the figure is fresh, stale or halted
Deciding that a valuation error happenedThe record of every post, rejection and halt
Correcting investors who dealt at a wrong priceWhich configuration (sources, staleness, band) applied at the time

Two things the oracle must never do.

  1. It must not compute the NAV from on-chain balances, because a fund's assets are mostly not on-chain and the result would be wrong by construction.
  2. And it must not accept changes such as "+0.2%", rather than whole values such as "€10.42 per unit". We build the feed to accept absolute figures only. If a full figure arrives late, the next one replaces it and the record is correct again. If a change goes missing, every figure after it is built on the wrong starting point, and nothing on-chain can detect the error.
NAV oracle flow: fund setup, off-chain NAV, signed post, on-chain checks, accepted or halted, fund operations, audit trail.

What does the fund decide before the NAV reaches the chain?

Applies to every fund.

Three things are settled by the fund before any feed is built, and the feed has to follow all three.

How often the NAV is calculated

It depends on how often the fund deals. A fund that deals daily calculates its NAV daily. One that deals monthly or quarterly may calculate it only that often. The feed follows the same rhythm.

Who sets the timing

The fund's own documents set the dealing cut-off, the pricing point and the publication time. The feed has to deliver each figure in time for that schedule. The fund doesn't change its schedule to suit the feed.

Who calculates and who checks the NAV

The manager answers for the NAV, even when an administrator or valuer calculates it. In many funds, an independent party, such as a depositary or trustee, checks that the NAV is calculated in line with the fund rules.

Those two roles matter for the build. Putting the NAV on-chain is a form of publishing it, so the manager is responsible for the on-chain figure too. The independent checker's job is to verify the calculation, which makes it a natural reader of the feed, not a writer of it.

Who should sign the NAV that goes on-chain?

Applies to every fund. The answer is a governance decision, made per fund before the build.

In most funds, three parties are involved in the NAV, and each plays a different role on-chain. The manager and an independent checker are standard. An administrator or valuer is common, but a manager can calculate the NAV itself.

PartyRole in the NAVRole in the oracle, as we build it
Administrator or valuerCalculates or values under the fund rulesThe usual posting source. Its key submits the figure
ManagerResponsible for valuation, calculation and publicationHolds governance: configures the feed, clears halts, rotates keys
Depositary or trusteeChecks the NAV is calculated in line with the fund rulesReads the feed and its history. A second posting source only if the fund wants an independent check

One source is a legitimate design. A fund with one administrator has one source. "Multi-source" comes from crypto price feeds, where using several sources is common, but a fund's NAV doesn't need it. Don't present it to a regulator as a requirement.

One source means one fewer safety check. 

With several sources, the oracle waits until a minimum number (the quorum) have sent a recent NAV, then takes the middle value (the median). If one source sends a wrong figure, the middle value ignores it. An average wouldn't, because one extreme number would pull it off. With one source, there's nothing to compare against, so the only safety check left is the deviation guard, described below. That's why our oracle refuses one combination: a single source and the deviation guard switched off. Either one on its own is acceptable. Together, whatever one key sends becomes the official NAV, unchecked.

"Signed" means a registered key, so key custody is the real control. 

In our build, a figure counts only if it arrives from an address registered as a source. The posting key is therefore authority over every limit that reads the feed. One way to protect it: keep it in the administrator's own signing infrastructure rather than on a developer's machine, separate it from the governance key, and rotate it through a two-step transfer so that a mistyped address cannot lock the feed.

How often should the feed update to meet dealing cut-offs?

Applies to open-ended funds, where investors subscribe and redeem at the NAV. A closed-ended fund that calculates its NAV only occasionally needs just a long staleness window and a clear display of the figure's date.

The feed's cadence follows the fund's dealing cycle. A fund that deals daily needs a figure per dealing day, accepted before anything prices against it. Two settings carry that.

The staleness window. This is how old a NAV can be before the oracle stops trusting it. Each fund sets its own limit. Once a figure is older than that, the oracle treats it as unknown.

There's no standard setting, because funds price at very different speeds. A fund that prices daily and one that's valued once a quarter need very different limits. So our oracle can't be used until the fund sets this window.

How to size it: take the time between two dealing days, then add the administrator's usual publishing delay. Don't add more than that.

  • Too long: a missed NAV goes unnoticed, and dealing carries on at an old price.
  • Too short: dealing stops every time the administrator publishes a little late.

The pricing point. Whether a deal prices at the last published NAV or at the next one struck after the cut-off is set by the fund rules. The contract has to match it, and this is a place where builds go wrong quietly.

Fund rules price atWhat the contract has to do
The last published NAVPrice the request when it is made, against a figure that is fresh at that moment
The next NAV after the cut-offCollect requests until the cut-off, then price every request in that window against the first figure accepted after it

Be precise about our reference build here. 

Our redemption module prices a request when it is made, against the NAV that is current at that moment, and refuses if the feed is stale. That fits a fund that deals at the last published price. A fund whose rules price at the next NAV needs the price applied when the dealing window closes instead. We scope that per fund. It is not a setting to assume.

Check that the numbers measure the same thing. 

Sometimes the contract works out the price of one token by dividing the fund's total NAV by the number of tokens. That only works if the tokens cover every unit in the fund. If some units are still held the traditional way, on a regular register and not on-chain, the price comes out wrong. For example, a fund worth €10 million has 1 million units, but only 400,000 are tokens. Dividing €10 million by 400,000 gives €25 per token, when the real price is €10.

To avoid this, we feed either the NAV for the on-chain units only or the price per unit directly. Before launch, we also check what every feed measures and how many decimal places it uses. This matters because our oracle passes on a plain number with no label, so if two feeds use different units, nothing flags it. If any unit question is still open, we don't go live.

What should the contract do when the NAV feed goes quiet?

Applies to every fund whose contracts read the NAV.

A feed can go quiet for ordinary reasons: a late strike, an outage at the administrator, a key being rotated. The design question is what each consumer does in the meantime, and the answer is not the same for all of them.

We build two reads, on purpose. The fail-closed read refuses when the figure is stale or halted. Anything that lets value move on the strength of the NAV uses it. The second read never refuses. It returns the last accepted figure flagged as not fresh, for dashboards and for passive checks that only raise a flag. No fail-closed consumer may ever use the second read.

ConsumerOn a stale or halted NAVWhy
Subscription pricing and mintingStopsIssuing units against an unverifiable price dilutes existing holders or the new one
Redemption pricing and payoutStopsPaying out at the wrong price moves value between investors
Redemption gate sizingStopsA gate sized off an old NAV pays early redeemers out of value that belongs to those behind them
A trade that increases a limited exposureStopsYou may not add exposure to a limit you cannot measure
A trade that reduces exposureContinuesIt can only move every ratio down, and blocking it would trap a fund in a breach
A passive limit re-checkRuns and flagsA flag computed on last week's NAV beats no flag
A transfer between eligible holdersUnaffectedIt moves neither the NAV nor the fund's capital

Two rules make this behave.

  • First, recovery is automatic. When a fresh figure is accepted, the fail-closed consumers resume without anyone flipping a switch, so a late strike costs a delay and not an incident.
  • Second, consumers must pull the new figure before they act on it. In our build, every pricing path syncs the latest accepted NAV inline before it computes, and a refresh call is open to anyone. A refresh that only a privileged role could call would let that role keep an oversized redemption window open simply by not calling.

How do you stop a wrong NAV reaching the register?

Applies to every fund. This is the control that matters most when the feed has a single source.

A wrong figure is worse than a missing one, because a missing figure stops things and a wrong one prices them. Our oracle carries four checks, each an engineering choice rather than a requirement.

1. A deviation guard that halts.

Each feed has a maximum move against the last accepted value. A post outside it is not published, and the feed's timestamp stops advancing. The old figure remains readable for dashboards, but it ages, and every fail-closed consumer stops on schedule. Publishing the suspicious figure would spread it into every limit. Keeping the old figure and treating it as current is just as risky, because deals would then go through at an out-of-date price. Halting is the only option that avoids both problems.

2. A move, not a rate.

The band measures the jump, not the jump per day. It is tempting to widen it when the feed has been down for a week, on the logic that NAV naturally moved. That inverts the control. The longer the contract has been blind, the less a large jump should be adopted without a person looking at it, so a feed that returns out of band is meant to halt.

3. Two exits from a halt, both on the record.

If the old figure was right and the post was wrong, governance re-confirms the old figure with a reference to the off-chain decision, and dealing resumes. If the move was real, governance widens the band and the sources post again. That path leaves a configuration event showing the band was widened to admit the move. Neither path lets anyone write a price directly. And a re-confirmed figure is flagged as such until the sources post again, so a consumer sizing a payout can tell a re-attested figure from one the sources agreed.

4. Refusals at the edges.

The oracle won't accept a NAV of zero. Every calculation that uses the NAV divides by it or sizes amounts from it, so a zero would break them. Besides, a fund that's truly worth nothing gets closed down, not priced. The oracle also won't let anyone remove a source if that would leave a feed with too few sources to reach its quorum. That feed wouldn't raise an error. It would quietly go out of date and freeze every fund that relies on it.

The guard can also trip a pause on the wider platform, so an anomaly stops activity rather than only emitting an event. We isolate that call. A pause target that fails must never be able to undo the halt or block the posting source.

Does a money market fund need anything different?

Applies to money market funds.

Money market funds are the hardest case for a NAV feed, for two reasons.

A daily NAV. Money market funds value their assets and publish their NAV every dealing day, so the staleness window has to be sized to a single dealing day.

Two figures, and a switch between them. Some money market funds keep a stable price per unit, such as 1.00, alongside the actual NAV per unit, and the contract has to know which one it's reading. Some may deal at the stable price only while it stays within a narrow band of the actual NAV. Once the gap is bigger, deals must use the actual NAV. On-chain, that means two feeds and a comparison before every price, not one feed.

Fund typeFigures the feed carriesWhat the pricing path does
Variable NAVNAV per unitPrices at it
Stable NAVStable price and NAV per unitMay price at the stable price
Stable NAV with a bandStable price and NAV per unitPrices at the stable price only inside the band, otherwise at the NAV per unit

What should the audit trail show?

Applies to every fund. The independent checker, the auditor and the supervisor all read it.

For any past dealing point, the oracle's record alone should answer four questions, with no one piecing it together from emails:

  • What figure was used?
  • Who supplied it?
  • Was it fresh?
  • Did anyone override a check?
EventWhat it proves
Each source's post, with its value and timeWho said what, and when. Removing a source stops its posts counting but never deletes them
Each accepted figure, with the number of agreeing sourcesWhich figure priced which deals, and how strong the evidence was
Each configuration changeThe staleness window, quorum and band in force at any moment
Each deviation trip, rejected re-post and halt exitWhen a check fired, and which way the manager decided it
Each re-attestation, with its decision referenceWhere freshness came from governance rather than from sources

Error correction needs this record. If a NAV later turns out to be wrong, the fund rules decide how affected investors are compensated. The trail is what identifies them: every subscription and redemption that priced against the wrong figure, at what amount. Build the correction path before the first material error. Settled on-chain transactions do not reverse themselves, and the only remedy available afterwards would otherwise be a forced transfer.

Where is the attack surface, then?

Applies to every fund. This is the review list we work from.

SurfaceWhat goes wrongOne way to close it
Posting keyA compromised key posts a wrong figureDeviation guard, quorum where the fund has more than one source, key held in the administrator's signing infrastructure
Governance keyA compromised key clears a halt or widens a bandMulti-signature governance and a time delay on configuration changes; neither exit can write a price
Staleness windowSet too long, a missed strike passes silentlySize it to the dealing interval; tightening it applies to the figure already on the books
Consumers on the wrong readA pricing path reads the never-refusing viewOne read for value-moving paths, enforced in code review and the audit
Refresh left to one roleThe role delays a refresh and keeps an oversized gate openRefresh open to anyone; pricing paths sync inline
Units and decimalsTotal NAV divided by an incomplete token supply, or two feeds in different unitsUnits fixed in configuration, checked at integration, blocker if open
Change feedsA missed delta leaves the book permanently wrongAbsolute values only
Oracle addressHard-wired into consuming contracts, so a provider change means redeploying themConsumers hold the oracle behind a setter controlled by the manager's governance; swapping it never re-reads a figure inside the swap

What does a NAV oracle not fix?

It does not make the valuation right. If the method is undocumented or the inputs are poor, the oracle delivers a well-guarded wrong number. Valuation stays with the manager and the valuer.

It does not make a fund liquid. A fresh NAV lets redemptions price. So,it does not create cash to pay them, and a gate sized correctly is still a gate.

It does not remove the people. Clearing a halt, deciding a move was real and correcting investors after an error are judgments. The contract makes each one visible and recorded. It does not make them.

Where to go from here

Every contract in a tokenized fund trusts the NAV, so the feed that carries it matters far more than its size in code suggests. Before scoping one, a fund can usually answer five questions: who calculates the NAV and in which system, how often the fund deals, whether deals price at the last NAV or the next one, whether every unit is on-chain, and who in the manager's governance can clear a halt. Those answers, more than the contract, decide what the build involves.

If you are scoping a tokenized fund. Our tokenization development for authorized firms covers the token, the register, the NAV feed, the compliance modules and the independent audit. To map your fund's dealing cycle onto a feed design, book an architecture review.

If you are earlier in the decision. Our fund tokenization guide for licensed asset managers covers what changes, and what does not, when fund units go on-chain.

This is engineering commentary, not legal advice. How fund rules apply to a specific fund needs sign-off from counsel.

Frequently asked questions

What is a NAV oracle for a tokenized fund?

It is the contract that holds a fund's net asset value on-chain, with when it was accepted, who supplied it and whether it is still usable. Pricing, redemption and limit contracts read it. It records the NAV calculated off-chain. It never calculates it.

Does a NAV oracle need several data sources?

No. One administrator feeding one figure is a legitimate design. Several sources add a cross-check, but they are a design choice. With a single source, the deviation guard becomes the main safety check.

What happens to subscriptions and redemptions if the NAV feed goes stale?

In our build, they stop until a fresh figure is accepted, then resume automatically. Trades that only reduce exposure continue, and transfers between eligible holders are unaffected, because they do not move the NAV.

Who should post the NAV on-chain: the manager, the administrator or the depositary?

Usually the administrator or valuer posts, the manager holds governance, and the depositary or other independent checker reads the record. The manager stays responsible for the NAV, and the checker's role is to verify the calculation, so it is a better reader than writer.

How is a money market fund different?

Its NAV is calculated and published every dealing day. Some money market funds also keep a stable price per unit alongside the actual NAV, and may deal at it only while the gap stays within a set band. The contract needs both figures.

What is the biggest risk in a NAV oracle?

The keys and settings, not the arithmetic. Whoever can post a figure, clear a halt or loosen the staleness window controls every limit and price that reads the feed. Guard those first.

Vignesh Palanivel

Vignesh Palanivel

I'm the Founder & CEO of InnBlockchain, a blockchain engineering and smart contract security partner to EU-regulated FinTechs and asset-backed founders. Over 7+ years building tokenization, exchange, and wallet infrastructure, I've worked across MiFID II/III, Prospectus Regulation, DLT Pilot Regime, and MiCA compliance requirements for RWA and digital-asset platforms.

On This Page

Talk to InnBlockchain

Get a clear plan for your blockchain project, from architecture & compliance to launch.