Blockchain-smart contracts met Solidity · Les

Off-chain gegevens ophalen

Implementeer patronen voor het opvragen en ontvangen van gegevens van externe API's via Chainlink, met behoud van de gegevensintegriteit.

Les 3 van 411 stappen

Off-chain gegevens ophalen is een gratis Blockchain-smart contracts met Solidity-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Blockchain-smart contracts met Solidity. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Blockchain-smart contracts met Solidity bevat in totaal 4 lessen.

On-chain en off-chain verbinden

Smart contracts bevinden zich op de blockchain en zijn afgescheiden van de buitenwereld. Maar wat als je contract realtimegegevens nodig heeft, zoals een cryptovalutaprijs of een weerbericht?

Daar komen orakels om de hoek kijken. In deze les leer je patronen implementeren voor het aanvragen en ontvangen van externe gegevens uit API's met behulp van Chainlink, zodat de gegevens veilig en betrouwbaar zijn.

Het aanvraag-antwoordmodel van orakels

Chainlink fungeert als brug, zodat je smart contract veilig kan communiceren met gegevensbronnen buiten de blockchain. Dit werkt via een cyclus van aanvragen en antwoorden:

Je smart contract stuurt een aanvraag naar een Chainlink-orakelnetwerk.
Een Chainlink-knooppunt haalt de gegevens op uit de opgegeven API.
Het Chainlink-knooppunt stuurt vervolgens een antwoord terug naar je contract door een specifieke callback-functie aan te roepen.

Je contract: een Chainlink-client

Om met Chainlink te communiceren, moet je Solidity-contract overerven van het door Chainlink geleverde contract ChainlinkClient.

Dit basiscontract geeft je toegang tot essentiële functies voor het opbouwen en versturen van gegevensaanvragen, evenals beveiligingsfuncties voor het ontvangen van antwoorden.

Een gegevensaanvraag starten

Om gegevens op te vragen, gebruikt je functies zoals buildChainlinkRequest en sendChainlinkRequestTo.

buildChainlinkRequest: Bereidt de aanvraag voor en specificeert gegevens zoals de Chainlink-taak-ID, het adres van je contract en de callbackfunctie die de oracle moet aanroepen.
sendChainlinkRequestTo: Stuurt de voorbereide aanvraag samen met de LINK-tokenvergoeding naar de Chainlink-oracle.

Code: actuele prijsgegevens opvragen

Hier zie je een vereenvoudigd contract dat laat zien hoe je een Chainlink-aanvraag voor externe gegevens, zoals een cryptoprijs, start. Je zou dit contract op een testnetwerk implementeren.

De functie requestEthPrice bouwt de aanvraag op, specificeert welke API moet worden aangeroepen en stuurt de aanvraag naar de oracle.

/*
  This is a simplified example for explanation.
  For a real deployment, replace placeholders like
  oracle address, LINK address, jobId, and fee
  with values for your chosen Chainlink network.
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

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

contract PriceConsumer is ChainlinkClient {
    bytes32 public lastRequestId; // Stores the ID of our last request
    uint256 public currentPrice; // Where we'll store the fetched price

    address private immutable i_oracle; // Chainlink oracle address
    bytes32 private immutable i_jobId;  // Specific job ID for the data source
    uint256 private immutable i_fee;    // Amount of LINK to pay for the request

    constructor(address _oracle, address _link, bytes32 _jobId, uint256 _fee) {
        setChainlinkToken(_link); // Set the LINK token address
        i_oracle = _oracle;
        i_jobId = _jobId;
        i_fee = _fee;
    }

    // Function to request a price from a Chainlink oracle
    function requestEthPrice() public returns (bytes32) {
        // 1. Build the Chainlink request
        Chainlink.Request memory request = buildChainlinkRequest(
            i_jobId,                      // The job ID for the oracle
            address(this),                // Our contract's address
            this.fulfillEthPrice.selector // The function the oracle will call back
        );

        // 2. Add parameters for the Chainlink node (e.g., API URL, path to data)
        request.add("get", "https://min-api.cryptocompare.com/data/price?fsym=ETH&tsyms=USD");
        request.add("path", "USD"); // Extract the USD value from the JSON response
        request.addInt("times", 100000000); // Multiply by 10^8 for fixed-point math

        // 3. Send the request to the oracle
        lastRequestId = sendChainlinkRequestTo(i_oracle, request, i_fee);
        return lastRequestId;
    }

    // The fulfillEthPrice function will be defined later!
}

Aanvragen volgen met ID's

Wanneer je sendChainlinkRequestTo aanroept, retourneert deze een unieke identificatie: een bytes32-waarde met de naam requestId.

Deze ID werkt als een volgnummer voor je gegevensaanvraag.
Dit is essentieel, omdat er meerdere aanvragen in behandeling kunnen zijn. De requestId zorgt ervoor dat je contract bij terugkomst van de gegevens weet bij welke aanvraag deze horen.

Sla deze requestId altijd op in een statusvariabele!

De gegevensaanvraag voltooien

Zodra de Chainlink-node de gegevens heeft opgehaald, roept deze de callbackfunctie aan die je hebt opgegeven (bijvoorbeeld fulfillEthPrice) in je contract.

Deze functie heeft als doel om:

de requestId te ontvangen, zodat deze aan de oorspronkelijke aanvraag kan worden gekoppeld;
de daadwerkelijke gegevens te ontvangen die door de oracle zijn opgehaald (bijvoorbeeld uint256 _price);
de gegevens in de status van je contract te verwerken en op te slaan.

Code: de callback implementeren

We maken ons PriceConsumer-contract compleet door de functie fulfillEthPrice toe te voegen. Dit is de functie die de Chainlink-oracle aanroept met de opgehaalde prijs.

De modifier recordChainlinkFulfillment en de controle van requestId zijn cruciaal voor de beveiliging en integriteit van de gegevens.

/*
  This is a simplified example for explanation.
  For a real deployment, replace placeholders like
  oracle address, LINK address, jobId, and fee
  with values for your chosen Chainlink network.
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

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

contract PriceConsumer is ChainlinkClient {
    bytes32 public lastRequestId; // Stores the ID of our last request
    uint256 public currentPrice; // Where we'll store the fetched price

    address private immutable i_oracle; // Chainlink oracle address
    bytes32 private immutable i_jobId;  // Specific job ID for the data source
    uint256 private immutable i_fee;    // Amount of LINK to pay for the request

    constructor(address _oracle, address _link, bytes32 _jobId, uint256 _fee) {
        setChainlinkToken(_link); // Set the LINK token address
        i_oracle = _oracle;
        i_jobId = _jobId;
        i_fee = _fee;
    }

    // Function to request a price from a Chainlink oracle
    function requestEthPrice() public returns (bytes32) {
        Chainlink.Request memory request = buildChainlinkRequest(
            i_jobId,
            address(this),
            this.fulfillEthPrice.selector // Callback function
        );
        request.add("get", "https://min-api.cryptocompare.com/data/price?fsym=ETH&tsyms=USD");
        request.add("path", "USD");
        request.addInt("times", 100000000); // Multiply by 10^8
        lastRequestId = sendChainlinkRequestTo(i_oracle, request, i_fee);
        return lastRequestId;
    }

    // This is the callback function called by the Chainlink oracle
    function fulfillEthPrice(bytes32 _requestId, uint256 _price)
        public
        recordChainlinkFulfillment(_requestId) // Security modifier
    {
        // Crucial: Check if the requestId matches our last sent request
        require(lastRequestId == _requestId, "Request ID mismatch!");
        currentPrice = _price; // Store the fetched price
    }
}

De gegevensintegriteit verbeteren

De integriteit van gegevens buiten de blockchain waarborgen is van het grootste belang. Chainlink gebruikt hiervoor verschillende mechanismen, en je hoort deze te gebruiken:

recordChainlinkFulfillment(_requestId): Deze modifier (uit ChainlinkClient) controleert of de aanroeper de geautoriseerde Chainlink-oracle voor die specifieke requestId is.
requestId koppelen: Neem altijd een controle op zoals require(lastRequestId == _requestId, ...) in je callback. Zo voorkom je dat een oude of niet-gerelateerde aanvraag per ongeluk of kwaadwillig wordt voltooid.
Foutafhandeling: Bedenk wat er gebeurt als de oracle mislukt of ongeldige gegevens retourneert. Implementeer controles en maak de transactie indien nodig ongedaan.

Korte controle: de oracle-stroom

Je hebt geleerd hoe je gegevens bij Chainlink-oracles opvraagt en ontvangt.

Bekijk de volgende stappen in een aanvraag-antwoordcyclus van Chainlink:

Beantwoord dit in de interactieve les

Samenvatting: gegevens buiten de blockchain ophalen

In deze les hebben we onderzocht hoe je smart contracts met externe gegevens kunt laten werken met behulp van Chainlink-oracles.

We hebben het aanvraag-antwoordmodel behandeld, waarbij je contract gegevens opvraagt en een oracle-node deze levert.
Je hebt gezien hoe je het basiscontract ChainlinkClient gebruikt om aanvragen op te bouwen en te versturen.
We hebben een callbackfunctie geïmplementeerd (bijvoorbeeld fulfillEthPrice) om de gegevens te ontvangen.
Tot slot hebben we het belang besproken van het koppelen van requestId en van de modifier recordChainlinkFulfillment voor gegevensintegriteit en beveiliging.

Je kunt nu contracten bouwen die reageren op gebeurtenissen uit de echte wereld!

Gratis beginnen

Leer Blockchain-smart contracts met Solidity met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Off-chain gegevens ophalen” gratis?

Ja — de volledige tekst van “Off-chain gegevens ophalen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Blockchain-smart contracts met Solidity wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Blockchain-smart contracts met Solidity bevat in totaal 4 lessen.

Wat leer ik in “Off-chain gegevens ophalen”?

Implementeer patronen voor het opvragen en ontvangen van gegevens van externe API's via Chainlink, met behoud van de gegevensintegriteit. Je oefent met Blockchain-smart contracts met Solidity door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Blockchain-smart contracts met Solidity te beginnen?

Ervaring vooraf is niet nodig. Blockchain-smart contracts met Solidity op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Off-chain gegevens ophalen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Blockchain-smart contracts met Solidity?

Ja. Elke les over Blockchain-smart contracts met Solidity bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Blockchain-smart contracts met Solidity