> 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/maturity-and-depth.md).

# Maturity and depth

An oracle with two observations is not an oracle yet, and a pool that can be moved ten percent for a few dollars is not one to lend against. Delphi reports both conditions so a contract can decide for itself rather than discover the problem in a liquidation.

## Maturity

```solidity
function maturity(address token) external view returns (uint8);
```

The value is one of three stages.

| Value | Meaning                                                              |
| ----- | -------------------------------------------------------------------- |
| 0     | Fewer than twelve observations. `consult` reverts.                   |
| 1     | Readable. At least twelve observations exist.                        |
| 2     | Mature. Readable, and the first observation is at least one day old. |

Stage 1 is the minimum for any read. Stage 2 is the level a conservative integration should require, since by then the pool has been through a full day of trading and the buffer holds enough history for long windows.

## Depth

```solidity
function depth(address token, uint24 ticks) external view returns (uint256 quoteAmount);
```

Returns how much of the quote asset a buyer would have to spend to push spot up by `ticks` ticks from where it is now. One tick is a 0.01% price change, so `depth(token, 100)` is the cost of a one percent move and `depth(token, 1000)` the cost of roughly a ten percent move.

The number comes from the pool's current liquidity, and since the launch position is the only liquidity there is, the calculation is exact inside the launch range. A reader can compare the result against the size of the positions it holds: if moving the price by the liquidation threshold costs less than the value being borrowed, the pool is too thin for that loan.

## Using both

A reasonable check before trusting a price looks like this:

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

The thresholds belong to the reader. A perp with small positions can accept a thinner pool than a lending market with large ones.


---

# 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/maturity-and-depth.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.