Rédaction du contrat : les bases de l'intégration Oracle

1. Commencer par les bases :
   Commençons par définir notre contrat, spécifier la version de Solidity, et importer la bibliothèque Chainlink que nous utiliserons :
   ```
   Solidity
   // SPDX-License-Identifier : MIT

pragma solidity ^0.8.21 ;

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol" ;

contrat OracleIntegratedContract {
AggregatorV3Interface interne priceFeed ;

// Visibilité du constructeur supprimée
constructor(address _priceFeed) {
    priceFeed = AggregatorV3Interface(_priceFeed);
}

1. 
Dans ce segment, nous avons spécifié que notre contrat utiliserait un flux de prix en chaîne. Le constructeur prend une adresse pour le contrat de flux de prix sur le réseau Ethereum.

1. 
Récupération de données à partir d'Oracle

1. 
Étendons notre contrat pour récupérer le dernier prix de l'Ethereum :

Solidité
function getLatestEthPrice() public view returns (int) {
(,int price,,,) = priceFeed.latestRoundData();
return price;
}

1. 
La fonction `latestRoundData()` de l'interface Chainlink Aggregator nous fournit diverses données, y compris le prix le plus récent.

## Manipuler les réponses de l'Oracle : Gérer les données une fois qu'elles sont reçues

Les données extraites des oracles sont souvent présentées dans des formats bruts qui peuvent ne pas convenir immédiatement à nos besoins. Il est essentiel de traiter ces données correctement dans nos contrats intelligents :



1. 
Formatage des données

1. 
Supposons que l'oracle renvoie le prix d'Ethereum en USD, mais multiplié par 10^8 pour s'assurer qu'il n'y a pas de décimales (ce qui est courant dans les configurations d'oracle). Pour obtenir le prix réel, vous devez formater les données :

Solidité
function getFormattedEthPrice() public view returns (int) {
int rawPrice = getLatestEthPrice();
return rawPrice / 10**8;
}

1. 
Cette fonction récupère le prix brut, puis le divise par 10^8 pour obtenir la valeur réelle.

1. 
Gestion des erreurs

1. 
Tenez toujours compte de la possibilité que l'oracle ne parvienne pas à récupérer les données :

Solidité
function safeGetLatestEthPrice() public view returns (int) {
(,int price,,uint256 timestamp,) = priceFeed.latestRoundData();
require(timestamp > 0, “Failed to fetch data from the oracle”);
return price;
}

1. 
Ici, la fonction `latestRoundData()` fournit également un horodatage. Si le timestamp est 0, cela signifie probablement que l'oracle n'a pas réussi à récupérer les données, et nous gérons cela avec une instruction `require`.
Votre code complet devrait ressembler à ceci :

Solidité
// SPDX-License-Identifier : MIT

pragma solidity ^0.8.21 ;

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol" ;

contrat OracleIntegratedContract {
AggregatorV3Interface interne priceFeed ;

// Visibilité du constructeur supprimée
constructor(address _priceFeed) {
    priceFeed = AggregatorV3Interface(_priceFeed);
}

function getLatestEthPrice() public view returns (int) {
    (,int price,,,) = priceFeed.latestRoundData();
    return price;
}

function getFormattedEthPrice() public view returns (int) {
    int rawPrice = getLatestEthPrice();
    return rawPrice / 10**8;
}

function safeGetLatestEthPrice() public view returns (int) {
    (,int price,,uint256 timestamp,) = priceFeed.latestRoundData();
    require(timestamp > 0, "Failed to fetch data from the oracle");
    return price;
}

}
```

À la fin de cette leçon, vous devriez avoir un contrat intelligent intégré à l'oracle de base rédigé dans Remix. Ce contrat récupère le dernier prix de l'Ethereum et traite les données renvoyées. Dans nos prochaines leçons, nous déploierons ce contrat et approfondirons les meilleures pratiques et les nuances.