Punto del curso de Solidity: 12.2 Uso de Chainlink y otros oráculos

Los oráculos son servicios que permiten a los contratos inteligentes controlar y reaccionar a datos externos al entorno blockchain.
Uno de los oráculos más conocidos y utilizados es Chainlink. En esta sección, exploraremos cómo integrar Chainlink en contratos
inteligentes Solidity para acceder a datos fuera de la blockchain, como precios de activos, eventos deportivos, resultados de
sorteos, y más.

¿Qué es un oráculo

Un oráculo es un puente entre el mundo exterior y la blockchain, permitiendo que los contratos inteligentes accedan a datos externos
de manera confiable. Los oráculos son esenciales para muchos casos de uso en contratos inteligentes, ya que los datos disponibles
en la blockchain son limitados.

Usando Chainlink en un contrato inteligente

Chainlink es una infraestructura descentralizada de oráculos que permite a los contratos inteligentes conectarse de forma seguras
a fuentes de datos externas. Aquí mostramos cómo utilizar Chainlink para obtener datos de precios de activos.

Configuración del entorno

Antes de comenzar, asegúrate de tener configurado un entorno de desarrollo de Solidity, que incluye una versión reciente de
Truffle o Hardhat, Node.js, y un proveedor de blockchain como Ganache para pruebas locales.

Instalación de Chainlink

Para instalar la librería de Chainlink en tu proyecto, puedes ejecutar el siguiente comando:

npm install @chainlink/contracts
    

Escribiendo el contrato inteligente

Ahora que tenemos la librería instalada, podemos escribir nuestro contrato inteligente. Aquí un ejemplo de cómo obtener el precio
de ETH/USD utilizando Chainlink:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0

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

contract PriceConsumerV3 {
    
    AggregatorV3Interface internal priceFeed
    
    /
      Network: Kovan
      Aggregator: ETH/USD
      Address: 0x9326BFA02ADD2366b30bacB125260Af641031331
     /
    constructor() {
        // Inicializamos el contrato con la dirección del precio ETH/USD en Kovan
        priceFeed = AggregatorV3Interface(0x9326BFA02ADD2366b30bacB125260Af641031331)
    }

    /
      Devuelve el precio actual de ETH/USD
     /
    function getLatestPrice() public view returns (int) {
        (
            uint80 roundID, 
            int price,
            uint startedAt,
            uint timeStamp,
            uint80 answeredInRound
        ) = priceFeed.latestRoundData()
        // El precio ya viene con 8 decimales
        return price
    }
}
    

En este contrato, utilizamos la interfaz AggregatorV3Interface que proporciona Chainlink para comunicarnos con el oráculo del precio ETH/USD.
Inicializamos el contrato con la dirección del agregador correspondiente.

Despliegue del contrato

Para desplegar este contrato en una red de prueba como Kovan, necesitamos una configuración que incluye un script de despliegue y un archivo de
configuración de Truffle o Hardhat. Aquí un ejemplo usando Truffle:

Configuración de Truffle (truffle-config.js)

module.exports = {
    networks: {
        kovan: {
            provider: () => new HDWalletProvider(mnemonic, https://kovan.infura.io/v3/YOUR_INFURA_PROJECT_ID),
            network_id: 42,
            gas: 5500000,        // Gas limit
            confirmations: 2,    // Confirmaciones de bloque antes de considerar la transacción
            timeoutBlocks: 200,  // Número de bloques de tiempo de espera
            skipDryRun: true     // Saltar el dry run antes de las migraciones
        },
    },
    compilers: {
        solc: {
            version: 0.8.0,
        },
    },
}
    

Script de despliegue (migrations/2_deploy_contracts.js)

const PriceConsumerV3 = artifacts.require(PriceConsumerV3)

module.exports = function(deployer) {
    deployer.deploy(PriceConsumerV3)
}
    

Con esta configuración de Truffle, puedes desplegar tu contrato en la red Kovan. Recuerda cambiar YOUR_INFURA_PROJECT_ID y asegurarte de
que tu archivo .env tenga las credenciales adecuadas.

Verificación del precio obtenido

Una vez el contrato esté desplegado, puedes interactuar con él utilizando Truffle o cualquier otra herramienta compatible con Ethereum.
A continuación, un script simple en JavaScript usando web3 para llamar a la función getLatestPrice:

const Web3 = require(web3)
const contractABI = require(./build/contracts/PriceConsumerV3.json).abi
const contractAddress = ADDRESS_OF_DEPLOYED_CONTRACT

const web3 = new Web3(new Web3.providers.HttpProvider(https://kovan.infura.io/v3/YOUR_INFURA_PROJECT_ID))
const priceConsumer = new web3.eth.Contract(contractABI, contractAddress)

async function fetchPrice() {
    const latestPrice = await priceConsumer.methods.getLatestPrice().call()
    console.log(Latest ETH/USD price:, latestPrice)
}

fetchPrice()
    

Este script obtiene el precio más reciente de ETH/USD desde el contrato desplegado y lo imprime en la consola.

Otros proveedores de oráculos

Aunque Chainlink es uno de los oráculos más populares, existen otros proveedores de oráculos en el ecosistema de blockchain.
Algunos de los más notables incluyen:

• Band Protocol: Un protocolo de oráculos descentralizados que ofrece alta velocidad y escalabilidad.
• Oraclize/Provable: Proporciona datos de fuentes HTTP(S) y ejecuta scripts off-chain para consultas complejas.
• API3: Un proyecto que permite a las API nativas proporcionar datos directamente a las aplicaciones descentralizadas sin intermediarios.

Conclusión

Los oráculos son componentes esenciales en el desarrollo de contratos inteligentes avanzados que requieren datos externos.
Chainlink proporciona una solución robusta y descentralizada que facilita el acceso a estos datos. Comprender cómo integrar
y utilizar oráculos es una habilidad valiosa para cualquier desarrollador de blockchain.