> For the complete documentation index, see [llms.txt](https://docs.delphirhc.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.delphirhc.com/the-oracle/compared.md).

# Compared with a plain pool

Every Uniswap v3 pool carries the same averaging machinery Delphi uses, so it is fair to ask what Delphi adds. The short answer is that a plain pool can produce an average, while Delphi produces one that is safe to build on and that exists without anyone having to set it up. This page shows the two differences that matter most, then walks through what they mean for the things people actually build.

## One pump, two oracles

The chart below runs the same trade through both designs: a swap pushes the spot price up five hundred percent, holds it there for three seconds, and sells back. The pool depth and the averaging window are identical. The only difference is what the oracle is allowed to record.

![One pump, two oracles](https://delphirhc.com/docs-assets/compare-spike.svg)

In the plain pool the average takes the spike at face value, because the pool wrote the spiked price into its history for as long as it lasted, and a two-minute average moves by almost five percent. On Delphi the recorded price may move only about three percent per second, so those three seconds were written as three small steps instead of a cliff, and the same average moves by a third of a percent. To move Delphi's average by the same amount the attacker has to hold the pool at the false price for many times longer, against everyone who can sell into it, and the cost of the attack scales with that time.

The gap widens with the window. Over a thirty-minute average the plain pool still registers the spike; Delphi's line does not visibly move.

## The life of a token's oracle

The second difference is whether the oracle exists at all. A v3 pool records a single observation until someone pays to expand its buffer, and in practice nobody does, so tokens launched on other launchpads have no usable average even though the code is there. On Delphi the oracle is registered in the launch transaction and grows its own history from the first swap.

![The life of a token's oracle](https://delphirhc.com/docs-assets/compare-lifecycle.svg)

## Side by side

|                       | Plain Uniswap pool                  | Delphi                               |
| --------------------- | ----------------------------------- | ------------------------------------ |
| Averaging             | Uniswap v3 tick accumulator         | The same                             |
| Recorded price        | The pool's actual tick              | Rate-limited to 300 ticks per second |
| History at launch     | One slot                            | Grows on its own, up to 8,192        |
| Readable price        | Tick sums, maths left to the reader | `consult` in the quote asset         |
| Position value        | Not provided                        | `quote`                              |
| Readiness signal      | None                                | `maturity`                           |
| Liquidity check       | None                                | `depth`                              |
| Chainlink-shaped feed | None                                | One per token and window             |
| Liquidity             | Can be withdrawn                    | Locked in the pool                   |

## What it changes for builders

The examples below take the same product and describe it twice: once with a token from a launchpad that gives it a pool and nothing else, and once with a Delphi token.

### A lending market

With a plain launchpad token there is no price to lend against. The market's options are to list nothing, or to read the pool's spot price and accept that a borrower can pump it for one block, borrow against the inflated value, and walk away with the loan. Most markets choose to list nothing, which is why launchpad tokens are not collateral anywhere.

With a Delphi token the market calls `quote` for the collateral's value at the thirty-minute average, checks `maturity` to make sure the oracle has enough history, and checks `depth` to make sure moving the price by its liquidation threshold would cost more than the loan. That is three view calls and a listing that can go live the day the token launches.

```solidity
require(ORACLE.maturity(token) >= 2, "oracle not mature");
require(ORACLE.depth(token, 500) >= minDepth, "pool too thin");
uint256 collateralValue = ORACLE.quote(token, amount, 1800);
```

### A perpetual or a prediction market

Settlement needs a price nobody can set for themselves at the moment of settlement. Settling on a plain pool's spot price means whoever has the largest position also has the cheapest way to move the settlement price in the final block. Settling on Delphi's average means the settlement price is the last thirty minutes of trading, rate-limited, and the same for everyone.

### An index or a basket token

A basket that holds several launchpad tokens has to rebalance on some price. Using each pool's last trade means the basket's weights can be pushed around by anyone willing to trade once in a thin pool just before the rebalance. Using each token's `consult` means the weights follow the average, and a trade timed to the rebalance has no more effect than any other trade in the window.

### A stablecoin or a mirror asset

Anything that mints and redeems against a token's value needs the value to be hard to fake in both directions: minting cheap by pushing the price up and redeeming dear by pushing it down. The mirror token on testnet does exactly this against a Delphi token, minting and redeeming at the thirty-minute average, and it is the simplest demonstration that the number can carry real value.

### The token's creator

A creator on a plain launchpad ships a token that trades and nothing else, and any integration has to wait for someone to build and maintain a price feed for it. A creator on Delphi ships a token that a lending market, a perp or a basket can integrate on launch day with the calls above, which is a reason for those integrations to happen and a reason for people to hold the token beyond the first week.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.delphirhc.com/the-oracle/compared.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.