How the Best Price Actually Gets Found: A Technical Breakdown of Omniston's Quote-Sourcing Engine

How the Best Price Actually Gets Found: A Technical Breakdown of Omniston's Quote-Sourcing Engine

Ask "what's the best price for this swap?" and most DEXs answer by reading one number off one pool. Omniston, STON.fi's routing layer, answers that question by running an entire sourcing architecture underneath a single request — querying multiple, structurally different kinds of liquidity at once and comparing what comes back. This piece breaks down that architecture: not the marketing pitch, but the actual layers and data flow behind "best price."

🗨️ "Omniston is STON.fi's aggregation layer that finds best rates by combining on-chain liquidity sources and RFQ resolvers." — STON.fi developer documentation

▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔

🧱 The Two Fundamentally Different Kinds of Liquidity Being Queried

The architecture isn't querying one type of source multiple times — it's querying two genuinely different kinds of liquidity, each with its own logic, and comparing across them:

• 🧿 On-chain AMM pools. STON.fi's own pools, plus external TON AMMs like DeDust and TonCo, priced by their own constant-product or stableswap curves, readable directly from on-chain reserves.
• 🔱 RFQ resolvers. Independent market makers who don't have a fixed public pool at all — they respond to a specific request with a price they're personally willing to honor, decided fresh each time.

These aren't competing implementations of the same idea. An AMM pool's price is a deterministic function of its current reserves — anyone can calculate it. A resolver's quote is a decision, informed by inventory and risk appetite, that doesn't exist until it's actually asked for. Sourcing "the best quote" means comparing a calculation against a decision, in real time, and that's a meaningfully harder problem than just checking which of several static numbers is bigger.

▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔

Why a Single Integration Point Matters More Than It Sounds

It would be easy to assume "aggregation" just means "check several places and pick the best." The harder engineering problem is that these sources don't share a common interface on their own — a DEX pool and an independent resolver don't naturally speak the same protocol.

🗨️ "Omniston connects to multiple DEXs and RFQ resolvers, allowing users to access a wide range of liquidity sources through a single integration point." — independent Omniston protocol breakdown, 2025

That single integration point is doing real translation work: normalizing an on-chain pool read and an off-chain-adjacent resolver's signed quote into one comparable format, so a developer building on top of STON.fi never has to write separate logic for "if it's a pool" versus "if it's a resolver." That abstraction is a meaningful part of what "RFQ architecture" actually refers to — not just the request-for-quote handshake itself, but the whole normalization layer sitting behind it.

▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔

🔭 The Architecture, Layer by Layer

🧰 The client-facing layer A trader or an integrated app sends one swap request through the SDK or API — one call, regardless of how many sources ultimately get queried underneath it. This layer's whole job is hiding the complexity of everything below it.

🛎️ The RFQ core This is the coordination layer: it receives the request, assigns it a unique rfq_id, and fans it out to every connected source simultaneously — both triggering fresh reads from AMM pools and broadcasting the request to resolvers over their open gRPC streams.

🪝 The resolver network A distributed set of independent market makers, each running their own service, each deciding independently what to offer for that specific request. Nothing here is centrally controlled — the RFQ core is a coordinator, not a price-setter.

⚜️ On-chain pool readers In parallel with the resolver broadcast, the same request triggers a read against connected AMM pools' current reserves — STON.fi's own v1 and v2 pools, plus external pools like DeDust and TonCo — calculating what each would offer for that exact trade size right now.

🎗️ The comparison and selection engine Once responses come back from both categories of source, this layer evaluates them together — price, but also depth and reliability — and either selects a single winning source or constructs a split route across several, depending on what actually produces the best outcome for that specific trade.

▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔

🧑‍💻 What the Sourcing Layer Actually Looks Like in Code

Since this is genuinely an engineering architecture underneath the trading language, it's worth seeing the real shape of it. The snippets below are illustrative — written in the style of STON.fi's documented SDK patterns, simplified for clarity rather than copied verbatim from the official docs.

One request, fanned out to two source types in parallel:

import { Omniston, blockchain, settlementMethod } from '@ston-fi/omniston-sdk'; const omniston = new Omniston({ apiUrl: 'wss://omni-ws.ston.fi' }); // A single call — the fan-out to pools and resolvers happens underneath this const { rfqId } = await omniston.requestQuote({ quoteRequest: { offerAsset: { blockchain: blockchain.Ton, address: 'EQC...offer_jetton' }, askAsset: { blockchain: blockchain.Ton, address: 'EQC...ask_jetton' }, amount: { offerAmount: '1000000000' }, settlementMethods: [settlementMethod.Swap], }, });

Inside the RFQ core, roughly what's happening on receipt of that request:

async function handleQuoteRequest(request: QuoteRequest): Promise<RfqId> { const rfqId = generateRfqId(); // Two structurally different source types, queried in parallel const [poolQuotes, resolverQuotes] = await Promise.all([ readAmmPoolReserves(request), // deterministic — calculated from on-chain state broadcastToResolvers(request, rfqId), // decision-based — awaits live responses ]); const candidates = normalizeQuotes([...poolQuotes, ...resolverQuotes]); const route = selectBestRoute(candidates); // single winner, or a split across several return rfqId; }

Normalizing two genuinely different quote shapes into one comparable format:

function normalizeQuotes(raw: (PoolReserveRead | ResolverResponse)[]): Quote[] { return raw.map((source) => 'reserves' in source ? { type: 'pool', askAmount: calcConstantProductOutput(source), depth: source.reserves } : { type: 'resolver', askAmount: source.quotedAmount, depth: source.maxFillSize } ); }

That normalization step is the actual engineering core of "RFQ architecture" — a pool read and a resolver's signed response start out as two incompatible shapes, and everything downstream (comparison, routing, splitting) depends on collapsing them into one interface first.

▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔

🧰 Cross-Chain Adds a Third Dimension Entirely

Same-chain sourcing is already a two-source comparison problem. Cross-chain sourcing adds settlement architecture into the same decision.

🗨️ "Omniston uses the same RFQ flow for both TON and cross-chain swaps... cross-chain settlement is handled through HTLC-based atomic swaps." — STON.fi, Omniston Protocol documentation

For a cross-chain request, the sourcing engine isn't just asking "who has the best price" — it's asking that question and factoring in which resolvers can actually settle safely across two separate blockchains. A resolver quoting a cross-chain leg has to be able to lock destination-side assets in an HTLC, paired against the trader's source-side lock, sharing the same cryptographic condition. The "best quote" for a cross-chain trade is filtered, from the start, to resolvers capable of that settlement guarantee — not just whoever happens to quote the tightest number.

▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔

🔭 Comparing on the Dimensions That Actually Matter

💧 Deterministic sources vs. decision-based sources. An AMM pool's price can be calculated by anyone with reserve data; a resolver's quote is a live decision that only exists once requested. The architecture has to treat these as genuinely different categories of input, not variations on the same thing.

🧭 Single-source lookup vs. normalized multi-source comparison. Without a shared integration layer, comparing a pool's calculated price against a resolver's signed quote would require bespoke logic for every source added. The RFQ core exists specifically to remove that burden from anyone building on top of it.

⏱️ Same-chain sourcing vs. cross-chain sourcing. Same-chain sourcing is purely a pricing comparison. Cross-chain sourcing is a pricing comparison filtered by settlement capability — a resolver can't win a cross-chain quote it can't actually settle safely.

⚖️ Single winner vs. split route. The sourcing engine doesn't default to picking one winner — if splitting a trade across several sources genuinely produces a better blended outcome, that becomes the selected route instead.

▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔

✅ What Genuinely Makes This Sourcing Architecture Work

1. Two structurally different source types, compared on equal footing. Deterministic pool math and live resolver decisions get normalized into one comparable format rather than handled as separate systems.
2. A single coordination layer removes integration burden. Anyone building on top of STON.fi queries one interface, not a growing list of bespoke connections to individual pools and market makers.
3. Cross-chain quotes are pre-filtered by settlement capability. A resolver can't win a cross-chain trade it can't actually settle atomically, which protects the trader before price even enters the comparison.

⚠️ What's Worth Understanding Correctly

• "Best quote" isn't always a single winner. The architecture is equally capable of returning a split route when that genuinely beats any single source.
• Resolver quotes are decisions, not standing offers. A quote reflects that resolver's willingness at that specific moment — it isn't a permanent price sitting on a shelf.
• Cross-chain sourcing carries a narrower pool of eligible resolvers by design. That's a safety filter, not a limitation — capability to settle safely comes before price in that specific comparison.

🏁 Bottom Line

Sourcing the best quote isn't a single lookup — it's an architecture running two structurally different comparison problems in parallel: deterministic pool math on one side, live resolver decisions on the other, normalized through a shared coordination layer and, for cross-chain trades, filtered by settlement capability before price ever enters the picture. Understanding that architecture is the difference between assuming "best price" means "checked a few extra pools" and seeing it for what it actually is — a real-time comparison engine built specifically because those source types were never going to be comparable on their own.

This article reflects independent research based on STON.fi's public developer documentation as of mid-2026. Architecture details and supported protocols evolve as the system ships updates — always verify current functionality directly on docs.ston.fi before making decisions involving real funds.