> For the complete documentation index, see [llms.txt](https://docs.chiliz.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.chiliz.com/fr/developper/notions-avancees/flux-de-prix-on-chain/lecture-des-prix.md).

# Lecture des prix

## Étape 1 : Trouver l'adresse de l'oracle

Trois façons de trouver l'adresse d'un contrat `PriceFeed` pour une paire donnée :

* **Price Oracle Tracker** (le plus simple pendant le développement) : [price-oracle-tracker.vercel.app](https://price-oracle-tracker.vercel.app/?network=mainnet) — affiche toutes les paires déployées, les prix en direct, les décimales, le heartbeat et les adresses.
* **On-chain via OracleFactory** : appelez `pairToOracle(string pair)`. Les symboles de paire doivent être passés en majuscules (p. ex. `"PSG/USDT"`) — la factory ne normalise pas l'entrée en lecture.
* **En masse on-chain via OracleFactoryReader** : appelez `getActiveOracles()` pour récupérer toutes les paires actives et leurs adresses en un seul appel.

```solidity
interface IOracleFactory {
    function pairToOracle(string memory pair) external view returns (address);
    function getOracleCount() external view returns (uint256);
}

function resolveFeed(address factory, string memory pair)
    external view returns (address)
{
    // Pair symbol must be passed in uppercase (e.g. "PSG/USDT").
    return IOracleFactory(factory).pairToOracle(pair);
}
```

## Étape 2 : Se connecter via l'interface

Le contrat `PriceFeed` implémente la `IAggregatorV3Interface` standard de Chainlink, ainsi que des extensions spécifiques à Chiliz pour l'état de santé et le statut de pause.

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

interface IAggregatorV3Interface {
    function decimals() external view returns (uint8);
    function description() external view returns (string memory);
    function version() external view returns (uint256);

    function getRoundData(uint80 _roundId)
        external view
        returns (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        );

    function latestRoundData()
        external view
        returns (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        );
}

interface IChilizPriceFeed is IAggregatorV3Interface {
    function paused() external view returns (bool);
    function updateInterval() external view returns (uint256);
    function healthFactor() external view returns (uint80);
    function getHealthStatus()
        external view
        returns (
            uint256 lastUpdateTimestamp,
            uint256 totalRounds,
            uint256 timeSinceLastUpdate,
            bool isHealthy
        );
}
```

## Étape 3 : Lire le prix

{% hint style="warning" %}
**Le flux ne génère pas de revert en cas d'état obsolète ou en pause — c'est intentionnel.** `latestRoundData()` génère un revert avec `NoDataAvailable()` si aucun round n'existe encore, mais ne vérifie pas si le flux est en pause ou obsolète. Cela correspond à la conception de la Chainlink AggregatorV3Interface : les consommateurs sont responsables de vérifier `paused()` et `getHealthStatus()` avant de consommer un prix. Remarque : les helpers scalaires (`latestAnswer()`, `latestTimestamp()`, `getAnswer()`, `getTimestamp()`) retournent `0` plutôt que de générer un revert en l'absence de données. Consultez les [Meilleures pratiques](/fr/developper/notions-avancees/flux-de-prix-on-chain/meilleures-pratiques.md) pour le schéma de validation complet.
{% endhint %}

La fonction principale est `latestRoundData()`, qui retourne le prix actuel avec les métadonnées de round et d'horodatage.

```solidity
contract LendingOracleConsumer {
    IChilizPriceFeed public priceFeed;

    constructor(address _feed) {
        priceFeed = IChilizPriceFeed(_feed);
    }

    function getSafePrice() public view returns (uint256 price18) {
        // 1. Check feed is not paused
        require(!priceFeed.paused(), "Feed paused");

        // 2. Read latest data (reverts with NoDataAvailable() if no rounds exist)
        (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        ) = priceFeed.latestRoundData();

        // 3. Basic sanity checks
        require(answer > 0, "Invalid price");

        // 4. Optional: use explicit health check for staleness
        (, , , bool isHealthy) = priceFeed.getHealthStatus();
        require(isHealthy, "Stale price");

        // 5. Normalize to 18 decimals for internal math
        uint8 decimals_ = priceFeed.decimals();
        uint256 scale = 10 ** uint256(decimals_);
        price18 = uint256(answer) * 1e18 / scale; // This is the actual price of an asset
    }
}
```

Si votre protocole utilise les décimales natives du flux plutôt que de normaliser à 18 :

```solidity
function getRawPriceWithMeta()
    external view
    returns (int256 price, uint8 decimals_, uint256 updatedAt)
{
    require(!priceFeed.paused(), "Feed paused");

    (, int256 answer, , uint256 _updatedAt, ) =
        priceFeed.latestRoundData();
    require(answer > 0, "Invalid price");

    (, , , bool isHealthy) = priceFeed.getHealthStatus();
    require(isHealthy, "Stale price");

    decimals_ = priceFeed.decimals();
    price = answer;
    updatedAt = _updatedAt;
}
```

## Données historiques

L'oracle stocke toutes les données de rounds historiques on-chain. Chaque mise à jour de prix crée un nouveau round avec un `roundId` incrémental.

```solidity
(uint80 roundId, int256 answer, , uint256 updatedAt, ) =
    priceFeed.getRoundData(targetRoundId);
```

Vues d'aide supplémentaires exposées par le flux Chiliz :

| Fonction                           | Retourne                                    |
| ---------------------------------- | ------------------------------------------- |
| `latestAnswer()`                   | Dernier prix, ou `0` si aucun               |
| `latestTimestamp()`                | Dernier `updatedAt`, ou `0` si aucun        |
| `latestRound()`                    | ID du round actuel                          |
| `getAnswer(uint80 roundId)`        | Prix pour un round spécifique, ou `0`       |
| `getTimestamp(uint80 roundId)`     | Horodatage pour un round spécifique, ou `0` |
| `getRoundsData(uint80[] roundIds)` | Tableau `RoundData` en masse                |
| `roundExists(uint80 roundId)`      | `true` si `updatedAt > 0`                   |

## Événements

Chaque contrat `PriceFeed` émet :

* **`AnswerUpdated(int256 indexed current, uint80 indexed roundId, uint256 updatedAt)`** : émis à chaque mise à jour de prix. Filtrez par prix ou par round.
* **`NewRound(uint80 indexed roundId, address indexed startedBy, uint256 startedAt)`** : émis lors du démarrage d'un nouveau round. Filtrez par round ou par l'adresse qui l'a démarré.

## Fonctions de découverte (OracleFactoryReader)

| Fonction                                | Description                                                           |
| --------------------------------------- | --------------------------------------------------------------------- |
| `getActiveOracles()`                    | Retourne toutes les paires actives avec leurs adresses d'oracle       |
| `getAllOracles()`                       | Retourne tous les oracles, y compris les inactifs                     |
| `getOraclesByPairs(string[] pairs)`     | Résout plusieurs noms de paires en adresses d'oracle en un seul appel |
| `getOracleHealthStatus(address oracle)` | État de santé d'un oracle unique                                      |
| `getAllOracleHealthStatus()`            | État de santé de chaque oracle dans le système                        |


---

# 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.chiliz.com/fr/developper/notions-avancees/flux-de-prix-on-chain/lecture-des-prix.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.