What shipped

FxDAO rejoins Blend, Aquarius and Soroswap in the Positions API, reshaped around what a vault actually is rather than the pool-share form the other three share.

• A vault comes back with its collateral and its outstanding debt kept apart, in the denomination it was opened in — US dollars, euros or pounds.
• Pin a request to a ledger and the API answers with the vaults as they stood at that point, which is what a reconciliation or a report needs. No vault on the network is open today, so the history is where the value sits.
• A vault is open when it still holds collateral. A closed one is never returned as an open position, and a wallet holding none comes back empty rather than as an error.
• USD values are attached where a price resolves and are null with the reason named where none does, never a fabricated zero.

The Positions API is public, served from mainnet.g.orionhq.run, and the developer console at console.orionhq.run lets you provision your own access instead of asking us for a key.

• /v1/health is unauthenticated, so you can check the service before you have credentials. Every other route requires an x-orion-token header and returns 401 without one.
• Sign in to the developer console with GitHub or an emailed passcode, create an organisation, then issue and revoke keys. A key’s value is shown once at issuance and never returned again.
• Every response carries a meta block: how stale the data is, the last indexed ledger, whether the result is partial, and the sources behind it. Responses also carry x-request-id and x-ratelimit-* headers.

Blend positions on mainnet come back priced, and Soroswap joins Blend and Aquarius in the Positions API.

• A Blend position returns per pool: supply, collateral and borrowings leg by leg, each with its USD value and yield, plus a net value and a health factor for the pool.
• Soroswap positions are served per pair: LP shares and the wallet’s share of the pool, with closed positions excluded. Where no price is available for one leg of a pair, the USD value is null with the reason attached rather than a fabricated zero.
• Blend activity records carry the asset and the amount for every event.

Two more protocols join Blend in the Positions API, and a third is indexed ahead of being served.

• Aquarius, including concentrated-liquidity pools, with per-pair positions and history.
• Soroswap, with LP shares and the wallet’s share of each pool.
• FxDAO data is indexed, ahead of being served.

Soroban entries can expire and later be restored. A point-in-time read over one of those windows now answers the way the ledger says it happened.

• A position that was restored on-chain reads back with its full state for the ledgers it held it.
• A position that genuinely stopped existing is absent from historical reads.

No action needed: current state was unaffected; this corrects historical reads.

The first public release of the Positions API is live on Stellar testnet. Ask for an account, get back everything it holds, across protocols, in one shape.

• A unified positions route: holdings, health factor, yield, and LP breakdowns in a single normalised response.
• Protocol coverage: Blend, Aquarius, and Soroswap.
• 24 routes across accounts, positions, activity, and protocol metadata.
• Authenticate with an API key in the x-orion-token header.

Testnet only for now; mainnet coverage follows.

The Orion API Reference is published, carrying everything you need to build against the Positions API.

• Route-by-route reference documentation and guides under /docs.
• An engineering log at /blog.
• This changelog, with per-entry pages and an RSS feed at /changelog/rss.xml.

The check that covered recent mainnet positions now covers the whole range the Positions API answers for, and every wallet in it — not a sample, and not just wallets that are still active.

• A wallet that opened and closed a position long ago reads back the way the chain says it happened.
• Where the check disagreed with what we served, the chain decided and the served history was corrected.

Served mainnet positions were reconciled against the chain itself rather than against our own record of it — the first such check on mainnet data.

• Every position agreed but one, and the chain settled that one.
• The served answer was corrected to match what the ledger says.

Soroban entries expire, and positions built on them now follow that lifecycle instead of outliving it.

• A position whose on-ledger state has expired is reported as archived rather than returned with its last known values.
• Archival matches Soroban’s own state-eviction semantics, including entries that are later restored.

The gap between a ledger closing and that ledger being answerable no longer grows with the length of the chain. A position read today is as fresh as one read when the pools were new.

• Each response reports its own staleness, so you never have to guess how current an answer is.

The Positions API answers for the whole of Blend on the public network, from the first Blend position ever opened, at ledger 56,627,601, through to the ledger the API currently serves. Ask for a wallet at any ledger in that range and you get what it held at that moment — not a reconstruction from today’s state.

• Every wallet that has ever held a Blend position is readable at any ledger in the range, whether or not it holds one now.
• Oracle prices are carried across the same range, so a position is valued at the price that applied at the ledger you are asking about, rather than the price today.
• The same treatment extends to a new protocol without waiting for it to accumulate history first.

A private preview of the Positions API for Blend lending pools, run to validate the response shape before the public release.

• Blend positions with a health factor.
• The response schema is frozen for v0.1.0, so clients built against the preview need no changes at release.

Positions in mainnet Blend pools return USD values, drawn from the Reflector feeds that carry the real on-ledger price writes rather than from the view-only aggregators the pools name as their oracle.

• Every mainnet Blend pool is priced, across both Reflector feed protocol versions.
• Each valuation carries its vintage, so you can see which price it used and how old that price was.

Adding a protocol, extending how far back Orion answers, or rebuilding a protocol’s history no longer waits on a software release, so coverage reaches the Positions API as soon as the data does.

• Every coverage change made this cycle reached the API without one.

When Orion adds a protocol, its history comes with it. You can read a wallet’s positions in that protocol from well before the day support shipped, rather than starting a fresh record from the announcement.

• A newly covered protocol is queryable across its past as soon as it is queryable at all.

Orion answers from the network as it stands now rather than from where recorded history left off. A position read reflects the chain within seconds of a ledger closing.

• Every response reports its own staleness and the last indexed ledger, so how current an answer is, is something you can read rather than assume.

A position is priced the same way at every ledger it existed, with no stretch of its history coming back unvalued.

• Read a wallet at any point in its history and the USD values, health factor and yield are there.

Positions gain valuation and risk fields, so a client no longer has to price anything itself.

• usd_value, health_factor, borrow limit and liquidation price are returned per position.
• Valuation is attached to a position when it is recorded, so repeating a request returns the same numbers.
• Each valuation carries its vintage: which price it used and how old that price was.

Every position is recorded per ledger and kept, so the Positions API can answer questions about the past as well as the present.

• Pass as_of_ledger to any positions route to read a wallet exactly as it stood at that ledger.
• Walk a range with from-to history reads on a Blend pool, on an account’s Blend summary, and on an Aquarius pair.
• Current state is derived from the same history, so a point-in-time read and a live read never disagree.

A point-in-time read is stable: the same wallet at the same ledger returns the same position today, tomorrow, and after any change we ship.

• Historical answers do not drift as new ledgers arrive.
• A change that would alter a past answer is caught before it reaches the API.

The Positions API serves real Blend lending positions from mainnet data, USD valued and behind TLS.

• The full lending lifecycle is covered: supply, collateral, borrow, repay, withdraw, interest accrual, and liquidation.
• Health factors were reconciled against Blend’s own numbers across that lifecycle before release.
• Account activity, the protocol registry, and per-protocol TVL read from live data.

Blend lending state on Stellar reads as typed reserves and per-wallet positions rather than as raw contract data — the shape everything the Positions API serves is built on.

• A wallet’s supply, collateral and borrowings in a Blend pool are addressable as fields, not as encoded ledger entries.