jdnichollsc/CHAINLINK.md

## README.md

      
    Raw
  

              README.md
            
          
    Blockchain

Una red altamente segura. Demo: https://andersbrownworth.com/blockchain/blockchain
Problema actual

Descentralización


Arquitectura
Política
Lógica

Beneficios


Tolerancia a fallos
Resistente a ataques
Resistente a la colusión (Participantes que traten de vulnerar el sistema)

Hashing

Método de criptografía que convierte cualquier dato en un texto único.
Merkle tree es el método usado para generar ese hash, teniendo en cuenta al anterior y el hash de cada transacción.
El nonce es un número aleatorio y de características únicas que tiene como finalidad ser usado en sistemas criptográficos.
Contract

Un acuerdo vinculante entre 2 o más partes.

Condiciones óptimas con finanzas centralizadas:

Pero cuando hay problemas:

Smart Contracts


Seguridad: No puede ser alterado, es inmutable
Garantía de ejecución: Siempre está activa, funcionando mientras haya un nodo operando.
Transparencia: Es un derecho incorporado por el código.
Mínima confianza: Reducción del riesgo sin tener que confiar en el otro.
Eficiencia: Automatizar procesos manuales.


Ethereum

Cadena de bloques, pública y Open Source, sin permisos. Se puede considerar como una máquina de estados entre las transacciones. Actualmente usa el mecanismo de consenso Proof of Work (PoW)

Nodos
Cuentas
Transacciones: Etherscan nos permite visualizar las transacciones de la red.
Transacciones pendientes (mempool): Hasta que el bloque sea confirmada se visualiza como Pending Transactions.

Ethereum Virtual Machine

Todos los nodos ejecutan el cliente de Ethereum que a su vez maneja la máquina virtual.
Ether

Criptomoneda nativa de la red de Ethereum, el símbolo es ETH.
Tokens

Representación de cualquier bien o servicio. No es más que un contrato inteligente que actualiza el estado del contrato

ER-C20: construir tokens
ERC-677: el token de Chainlink

Solidity

Lenguaje de alto nivel orientado a los contratos. Sintaxis similar a C# y JS, donde los contratos y herencia son similares a Programación Orientada a Objetos.


Tax fee

El gas es el costo de la ejecución de las transacciones. Los mineros realizan la confirmación de las transacciones y por tanto reciben un pago como recompensa. El gas es la unidad que mide el trabajo computacional requerido para correr transacciones o smart contracts en la EVM.

fee = gas usado * precio del ETH.


Un bloque se mina cada 15 segundos aproximadamente en Ethereum.

Contratos y funciones


## CHAINLINK.md

      
    Raw
  

              CHAINLINK.md
            
          
    Oraculo


Blockchain es deterministico: No se puede conectar de manera directa con información de otras fuentes

Por lo tanto hay un problema de conectividad sin un oraculo

Oraculos centralizados: mismo problema que deseamos resolver con Blockchain

Chainlink

Busca resolver este problema, de obtener información desde diferentes fuentes, de manera segura y bi-direccional con el Blockchain:

Ejemplo de Nodos Off-Chain & On-Chain con Chainlink:

Chainlink es Blockchain Agnóstico

Chainlink Data Feeds

Robinhood Fiasco:

Explore the decentralized oracle networks powered by Chainlink: https://data.chain.link/
Acceso a cualquier API de manera segura:

Todo por medio de Adaptadores con Chainlink:

Chainlink Market: https://market.link/

Random numbers son maliciosos:

Para tal motivo se tiene una solución usando Verifiable Random Function (VRF):

NFTs y juegos usando VRF:


## CODE_SMART_CONTRACTS.md

      
    Raw
  

              CODE_SMART_CONTRACTS.md
            
          
    Ejercicios de Smart Contracts

Online editor - Remix: https://remix.ethereum.org/
Instrucciones de Instalación: Brownie Track - https://docs.google.com/document/d/1o4DAjqIMes4YHpKeOPoWxxr5bFr7dBB7Racl_rGQKtE/edit?usp=sharing
Día 1 Ejercicios: https://docs.google.com/document/d/1CtROewhnKTlsoBIv6jODFt2nyJL_ZFuOGyORyIsVy8Q/edit?usp=sharing

Mi primer Smart Contract:

// SPDX-License-Identifier: MIT
pragma solidity 0.6.7;

contract MyFirstContract {
    uint256 number;
    
    function setNumber(uint256 _number) public {
        number = _number;
    }
    
    function getNumber() public view returns(uint256) {
        return number;
    }
}
Verificar deploy del contrato: https://kovan.etherscan.io/address/0xe76b8a218eed9b9f1eed05d06ccb9d7c3f91e1ee

Usando Mappings

// SPDX-License-Identifier: MIT
pragma solidity 0.6.7;

contract MappingsContract {
    
    string[] names;
    mapping (string => uint) public phoneNumbers;
    
    function addPhoneNumber(string memory _name, uint _phoneNumber) public {
        phoneNumbers[_name] = _phoneNumber;
    }
    
    function getPhoneNumber(string memory _name) public view returns(uint)  {
        return phoneNumbers[_name];
    }
    
    function addName(string memory _name) public {
        names.push(_name);
    }
    
    function getName(uint256 _num) public view returns(string memory) {
        return names[_num];
    }
}
Deploy del contrato: 0xD6BEccF3e8532D61D216Ce00bd889CdBB48318Dd

Manejar string cuesta más que integers, para que se le indique al compilador que solo se va a manejar en memoria se usa la palabra reservada memory. storage y memory son dos lugares que la EVM usa para almacenar informacion, siendo storage persistente mientras el memory se elimina al final de la transaccion.


Cuando especificas memory en el return value estas diciendo que vas a devolver por valor y no por referencia


Price Feeds

Ethereum Data Feeds: https://docs.chain.link/docs/ethereum-addresses/
// SPDX-License-Identifier: MIT
pragma solidity 0.6.7;

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

contract PriceConsumerContract {
    
    AggregatorV3Interface internal priceFeed;
    
    constructor() public {
        // Kovan Testnet
        // Aggregator: ETH/USD
        // Address: 0x9326BFA02ADD2366b30bacB125260Af641031331
        priceFeed = AggregatorV3Interface(0x9326BFA02ADD2366b30bacB125260Af641031331);
    }
    
    /**
     * Get the latest price
     */
    function getLatestPrice() public view returns(int) {
        (
            uint80 roundID,
            int price,
            uint startedAt,
            uint timeStamp,
            uint80 answeredInRound
        ) = priceFeed.latestRoundData();
        return price;
    }
}

Llamar una API con Chainlink

Documentación: https://docs.chain.link/docs/request-and-receive-data/
// SPDX-License-Identifier: MIT
pragma solidity 0.6.7;

import "@chainlink/contracts/src/v0.6/ChainlinkClient.sol";
 
contract APIConsumer is ChainlinkClient {
  
    uint256 public volume;
    
    // Internal properties for this contract
    address private oracle;
    bytes32 private jobId;
    uint256 private fee;
    
    /**
     * Network: Kovan
     * Chainlink - 0x2f90A6D021db21e1B2A077c5a37B3C7E75D15b7e
     * Chainlink - 29fa9aa13bf1468788b7cc4a500a45b8
     * Fee: 0.1 LINK
     */
    constructor() public {
        setPublicChainlinkToken();
        oracle = 0x2f90A6D021db21e1B2A077c5a37B3C7E75D15b7e;
        jobId = "29fa9aa13bf1468788b7cc4a500a45b8";
        fee = 0.1 * 10 ** 18; // 0.1 LINK
    }
    
    /**
     * Create a Chainlink request to retrieve API response, find the target
     * data, then multiply by 1000000000000000000 (to remove decimal places from data).
     ************************************************************************************
     *                                    STOP!                                         * 
     *         THIS FUNCTION WILL FAIL IF THIS CONTRACT DOES NOT OWN LINK               *
     *         ----------------------------------------------------------               *
     *         Learn how to obtain testnet LINK and fund this contract:                 *
     *         ------- https://docs.chain.link/docs/acquire-link --------               *
     *         ---- https://docs.chain.link/docs/fund-your-contract -----               *
     *                                                                                  *
     ************************************************************************************/
    function requestVolumeData() public returns (bytes32 requestId) 
    {
        Chainlink.Request memory request = buildChainlinkRequest(jobId, address(this), this.fulfill.selector);
        
        // Set the URL to perform the GET request on
        request.add("get", "https://min-api.cryptocompare.com/data/pricemultifull?fsyms=ETH&tsyms=USD");
        
        // Set the path to find the desired data in the API response, where the response format is:
        // {"RAW":
        //      {"ETH":
        //          {"USD":
        //              {
        //                  ...,
        //                  "VOLUME24HOUR": xxx.xxx,
        //                  ...
        //              }
        //          }
        //      }
        //  }
        request.add("path", "RAW.ETH.USD.VOLUME24HOUR");
        
        // Multiply the result by 1000000000000000000 to remove decimals
        // Solidity don't support float numbers
        int timesAmount = 10**18;
        request.addInt("times", timesAmount);
        
        // Sends the request
        return sendChainlinkRequestTo(oracle, request, fee);
    }
    
    /**
     * Receive the response in the form of uint256
     */ 
    function fulfill(bytes32 _requestId, uint256 _volume) public recordChainlinkFulfillment(_requestId)
    {
        volume = _volume;
    }
    
    /**
     * Withdraw LINK from this contract
     * 
     * NOTE: DO NOT USE THIS IN PRODUCTION AS IT CAN BE CALLED BY ANY ADDRESS.
     * THIS IS PURELY FOR EXAMPLE PURPOSES ONLY.
     */
    function withdrawLink() external {
        LinkTokenInterface linkToken = LinkTokenInterface(chainlinkTokenAddress());
        require(linkToken.transfer(msg.sender, linkToken.balanceOf(address(this))), "Unable to transfer");
    }
}

Chainlink VRF provides Verifiable Randomness:

Chainlink VRF Contract Addresses: https://docs.chain.link/docs/vrf-contracts/

LINK: Basicamente es el Token que vamos a usar para pagar
VRF Coordinator: Intermediario que realiza consultas del oraculo, que facilita la comunicación entre las diferentes partes
Key Hash: Usado para verificar el proceso de generación del valor random, parecido a una llave secreta
Fee

// SPDX-License-Identifier: MIT
pragma solidity 0.6.7;

import "@chainlink/contracts/src/v0.6/VRFConsumerBase.sol";
 
/**
 * THIS IS AN EXAMPLE CONTRACT WHICH USES HARDCODED VALUES FOR CLARITY.
 * PLEASE DO NOT USE THIS CODE IN PRODUCTION.
 */
contract RandomNumberConsumer is VRFConsumerBase {
    
    bytes32 internal keyHash;
    uint256 internal fee;
    
    uint256 public randomResult;
    
    /**
     * Constructor inherits VRFConsumerBase
     * 
     * Network: Kovan
     * Chainlink VRF Coordinator address: 0xdD3782915140c8f3b190B5D67eAc6dc5760C46E9
     * LINK token address:                0xa36085F69e2889c224210F603D836748e7dC0088
     * Key Hash: 0x6c3699283bda56ad74f6b855546325b68d482e983852a7a82979cc4807b641f4
     */
    constructor() 
        VRFConsumerBase(
            0xdD3782915140c8f3b190B5D67eAc6dc5760C46E9, // VRF Coordinator
            0xa36085F69e2889c224210F603D836748e7dC0088  // LINK Token
        ) public
    {
        keyHash = 0x6c3699283bda56ad74f6b855546325b68d482e983852a7a82979cc4807b641f4;
        fee = 0.1 * 10 ** 18; // 0.1 LINK (Varies by network)
    }
    
    /** 
     * Requests randomness 
     */
    function getRandomNumber() public returns (bytes32 requestId) {
        require(LINK.balanceOf(address(this)) >= fee, "Not enough LINK - fill contract with faucet");
        return requestRandomness(keyHash, fee);
    }
 
    /**
     * Callback function used by VRF Coordinator
     */
    function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
        randomResult = randomness;
    }
 
    // function withdrawLink() external {} - Implement a withdraw function to avoid locking your LINK in the contract
}

  
## HARDHAT.md

      
    Raw
  

              HARDHAT.md
            
          
    HardHat


Instrucciones de Instalación: Hardhat Track: https://docs.google.com/document/d/12ySG-i3qeOdOMdzQ9N6b8epQz72-nHK9z7hl5hNk9e0/edit?usp=sharing
Ejercicios del día 2 y 3 Hardhat: https://docs.google.com/document/d/1eDZ9esSmozBif5ehRncQd8dqJTHwG9ZKjvVUMN1dFOA/edit?usp=sharing

Entorno de Desarrollo

Remix IDE


Basado en Web (Online)
Módulos para probar, depurar y desplegar contratos inteligentes
No puede integrar otras partes de un proyecto
No puede guardar archivos localmente sin plugins
Cualquier funcionalidad personalizada requiere crear/usar un plugin

Brownie


Basado en Python

Hardhat IDE


Basado en JavaScript
Red local para simular Ethereum
Funciones de plugin extensibles
Alto nivel de características de depuración


Mi primer proyecto Hardhat

Repo: https://github.com/jdnichollsc/my-first-hardhat
Crear un proyecto usando el Hardhat Starter Kit


Hardhat Started Kit: https://github.com/smartcontractkit/hardhat-starter-kithttps://github.com/jdnichollsc/chainlink-hardhat-box
Repo: https://github.com/jdnichollsc/chainlink-hardhat-box

  
## NETWORK.md

      
    Raw
  

              NETWORK.md
            
          
    Hardhat Local Network


Hardhat Network se puede considerar como otra red para pruebas:

Beneficios:

Bifurcar Mainnet para comunicarnos con protocolos
Estado inicial:

Bloque Genesis
20 cuentas con 10000 ETH cada una


Mocks


Deploy al Local Network


Dashboard: https://dashboard.alchemyapi.io/
Ethereum usando un Forking Mainnet: https://docs.chain.link/docs/ethereum-addresses/#Ethereum%20Mainnet
Iniciar la red local de hardhat: npx hardhat node


Ganache es una red local de prueba desarrollada por trufflesuite con una interfaz visual, donde puedes ver bloques, contratos, transacciones, y demas de una manera sencilla, y tambien acepta forks de otras redes.


Local Network using Hardhat:

npx hardhat node - Start a Node using Hardhat with a forking Mainnet
Verify: Started HTTP and WebSocket JSON-RPC server at http://127.0.0.1:8545/
npx hardhat deploy - Deploy smart contracts to a local network with Ethereum
npx hardhat block-number --network localhost - Verify the fork, the block number is 0 in a local network
npx hardhat read-price-feed --contract 0x4C4a2f8c81640e47606d3fd77B353E87Ba015584 --network localhost - Debug
Verify value: https://data.chain.link/ethereum/mainnet/crypto-usd/eth-usd


Seguridad


Toca cambiar el paradigma en cuanto a la seguridad al ser inmutable:

Testing para Smart Contracts

Bug vs Vulnerabilidad (Las pruebas no evitan vulnerabilidades)

Tipos de Tests

Escribir buenos Tests

Tests de Integración

Herramientas de Testing

Testing Coverage

Testing Security

Pruebas de integración:

npx hardhat deploy
yarn test-integration - Las pruebas tienen retrasos para probar las transacciones con los nodos Chainlink

Pruebas de cobertura:


defaultNetwork: "hardhat"


npx hardhat node


npx hardhat coverage --testfiles "test/unit/*.js"


Ethereum Smart Contract Best Practices: https://consensys.github.io/smart-contract-best-practices/known_attacks/