What shipped

Adapters and folds for three new protocols landed end to end, and every one passed cross-engine verification against a gold schema frozen before any of them existed.

• Aquarius (including concentrated-liquidity pools), Soroswap, and FXDAO, delivered end to end.
• Two independent engines reached byte-identical output on every table of every protocol.
• Verification forced a real semantics decision: when a pool is written several times in one ledger, which write wins? Resolved to close-state, checked against chain data.

The eviction/restore adjudication for served mainnet data was rebuilt entirely from evidence pinned to the chain, correcting an earlier classifier that had mishandled restore-ledger rows.

• A strict eviction-window classifier derived from decoded ledger close-meta semantics.
• Restore-ledger rows the old classifier removed are reinstated with their complete original state.
• Genuine post-eviction ghost rows are proven absent from serving data; current state and unrelated snapshots are untouched.

No action needed: served current state was never wrong; this corrects historical rows.

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

• Unified positions endpoint: holdings, health factor, yield, and LP breakdowns in a single normalized response.
• Protocol coverage: Blend, Aquarius, and Soroswap.
• 24 endpoints across accounts, positions, activity, and protocol metadata.
• Authenticate with an API key in the x-orion-api-key header.

Testnet only for now; mainnet coverage follows once the projection pipeline runs against mainnet head.

The Orion site is live: a static Astro + Fumadocs build carrying everything you need to build against the API.

• API documentation and guides under /docs.
• An engineering log at /blog for pipeline internals and post-mortems.
• This changelog, with per-entry pages and an RSS feed at /changelog/rss.xml.

Two independent engines were reconciled over the pools’ entire lifetime, extending the earlier tip-window check to roughly fifteen months of mainnet history.

• 37,973 wallets replayed over 6,848,288 mainnet ledgers by an engine that shares no code with the production fold.
• Of 885,796 gold rows, 834,525 match exactly; the remainder are benign flush-cadence re-emits. None were unwitnessed.
• All 100 residual divergences are defects in the older engine, including an on-chain eviction the single-engine fold never saw.

Re-reading the same history straight from the public data lake produced byte-identical results.

An independent engine that shares no code with the production fold reproduced the served mainnet gold over a recent window, the first cross-engine check on mainnet data.

• A Rust batch engine replayed 119,831 mainnet ledgers from a pinned state snapshot.
• Of 17,865 shared-coordinate rows, all but one agree exactly.
• The single disagreement was settled by the live chain, in the independent engine’s favor, and fixed.

lidapters now models the Soroban entry lifecycle correctly: positions whose on-ledger state has expired are archived, and each ledger reports exactly which positions it touched.

• TTL-lapsed and evicted positions move to an archived state instead of being reported with stale values.
• A per-ledger dirty set names exactly the positions a ledger changed.
• Semantics match Soroban’s state-eviction lifecycle for archived entries.

lidapters gains a config-selected incremental state-fold strategy alongside the default full-rebuild path, a whole-strategy swap chosen once at construction.

• Two strategies, one contract: a stateless reference reducer and a persistent incremental builder, producing byte-identical output.
• Measured over 20,000 real mainnet ledgers: roughly 78× faster fold-only at real state size, with identical checksums.
• A parity gate fails loudly if the two strategies ever drift apart.

The complete mainnet Blend history, 6,848,288 ledgers since the protocol’s oracle deploys, landed gap-free on a single machine via config-sharded ingest.

• 32 config-rendered ingest shards over disjoint ledger ranges into one bronze store, in roughly 8.5 hours of wall clock.
• Two hot-loop fixes and the mainnet price decoder shipped while the fill was still running.
• The downstream fold then got 5.2× faster, with byte-identical folded state.

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

• Single-protocol (Blend) positions with health factor.
• Response schema frozen for v0.1.0, so clients built against the preview need no changes at release.

lidapters can now decode mainnet Blend prices. On mainnet the pools’ configured oracles are view-only aggregators that have never written a price to the ledger; the real prices live in Reflector feed contracts, published every 300 seconds under different key schemes and decimals.

• Reflector feed decoder (protocol versions 1 and 2) reading the real on-ledger price writes.
• Aggregator configuration resolved from each pool’s named oracle.
• Fixtures pinned to twelve real mainnet ledgers.

Without this, a mainnet fold completes healthily and produces no prices at all, a failure with no error signature.

Live-follow, historical fill, cold rebuild, and replica are the same two programs, selected entirely by a config file and a run verb.

• Two binaries, an ingest and a relay, never recompiled to change what they run.
• A verb picks the run shape; a YAML config picks the data path.
• Every scenario added this cycle needed zero new code.

Historical backfill now runs against a cloud object store hosted locally, so the standard export tooling behaves exactly as it would against a remote bucket: no account, no external dependency.

• The cloud’s own storage software runs on a local machine behind the same S3 interface the export tools expect.
• Six parallel exporters wrote the full testnet history at more than thirty times the previous speed.
• Ledgers are exported to files once and reused, replacing repeated CPU-bound replay.

The pipeline now crosses cleanly from replaying recorded history into following live network consensus, the first time it has ever caught up to the chain head.

• Two boundary faults hiding at the replay→live switch, found and fixed.
• The switch went live and stayed exactly in step with the network overnight.
• The crash that first exposed the boundary is now a permanent automated test.

Fixed a resume-path defect where a restarted indexer knew where to continue but had lost the pricing and configuration knowledge needed to value new records, silently leaving them unvalued.

• Config-class fold state (oracle asset maps, decimals, pool parameters) is rehydrated on restart, not just the ledger cursor.
• A restarted run now produces results identical to a run that never stopped.
• Covered by a permanent regression test, written to fail first.

Positions gain valuation and risk fields, computed on the write side and served without any read-time price authority.

• usd_value, health_factor, borrow_limit, and liquidation_price materialized per position.
• A parity gate holds the health factor within ±0.001 of the Blend SDK over frozen ground-truth wallets, and it is price-sensitive.
• The API reads stored values only; it never prices a position itself.

Gold entities are now stored as per-ledger immutable snapshots, with current state served as views over that history.

• Position, reserve, and summary snapshots written change-only: one row per ledger per key.
• Current state is a view over the snapshots; there are no plain current tables.
• as-of-ledger and from→to history reads on both positions and per-account summaries.

A conformance harness guards a core invariant: one indexer and N indexers folding the same ledger range must produce byte-identical gold.

• Reference-run-twice byte-identity plus N-way union equality, asserted against real database containers.
• Deterministic reducers: deltas sorted before emit; no floats, clocks, or randomness in the core.
• Schema-freeze guards on bronze and gold wired into the test suite, so an accidental schema change fails loudly instead of shipping.

The full pipeline now serves real Blend lending positions end to end: raw ledgers through ingest, relay projection, the gold read-model, and the API, USD-valued and behind TLS.

• Health-factor reconciliation over the full lending lifecycle: supply, collateral, borrow, repay, withdraw, interest accrual, and a complete liquidation cycle.
• A fixtures-and-evaluation corpus covering that lifecycle, with CSV and Markdown reconciliation rails.
• Live database reads wired for activities, reserves, the protocol registry, and TVL.

The first public release of lidapters, the open-source Stellar protocol-adapter library that turns raw on-chain data into typed position state.

• Blend adapter: decodes contract-data ledger entries into typed reserve and position state.
• Deterministic, side-effect-free reducers, reusable in any indexer.
• Consumed as a Go module by the Orion projection pipeline.