Leestijd: 6 min

Overzicht

Ethereum-ontwikkelomgevingen zoals Hardhat maken het eenvoudiger om met smart contracts en Ethereum-knooppunten te werken. Ze bieden een reeks hulpmiddelen om smart contracts naadloos te schrijven, te testen en te implementeren. In deze handleiding gaan we een ‘Hello World’-smart contract maken en dit via Hardhat en Quicknode op het Sepolia-testnet implementeren.

Vereisten

• Een Quicknode-account (maak hier gratis een account aan)
• Een EVM-compatibele wallet (bijvoorbeeld MetaMask)
• Node.js is geïnstalleerd
• Veiligheidshelm opgezet (we zullen hier ook op ingaan in de handleiding)
• CLI/Terminalvenster
• Code- of teksteditor (bijv. VSCode)
• ETH op het Sepolia-testnet (je kunt de Quicknode Multi-chain Faucet gebruiken om er gratis wat te krijgen)

Wat is Hardhat?

Hardhat is een ontwikkelomgeving die ontwikkelaars helpt bij het compileren, implementeren, testen en debuggen van hun Ethereum-applicaties. Het beschikt over een van de overzichtelijkste en meest gedetailleerde documentaties. Hardhat biedt bovendien console.log()-functionaliteit, vergelijkbaar met JavaScript, voor debugdoeleinden. Daarnaast beschikt Hardhat over talrijke plug-ins, waardoor de functionaliteit nog verder wordt uitgebreid.

Hardhat en andere afhankelijkheden installeren

We gaan Hardhat installeren met behulp van npm, dat bij Node.js wordt meegeleverd. 

Maak eerst een nieuwe projectmap aan en ga daarheen. Je mag hier gerust je eigen namen gebruiken:

mkdir HardhatTutorial
cd HardhatTutorial

Open Terminal/cmd in je projectmap en voer de volgende opdrachten in.

npm init --y
npm install --save-dev hardhat

Nu Hardhat is geïnstalleerd, gaan we een nieuw Hardhat-project starten. Daarvoor gebruiken we npx. Npx helpt bij het uitvoeren van Node.js-programma’s. 

npx hardhat init

Je krijgt de CLI-interface van Hardhat te zien. Selecteer „Create an empty hardhat.config.js“ en druk op Enter.

Laten we nu de andere afhankelijkheden installeren die nodig zijn om met Hardhat te kunnen werken.

npm install --save-dev @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai

We hebben deze afhankelijkheden nodig om geautomatiseerde tests voor contracten te schrijven.

Het meest voorkomende probleem bij het installeren van pakketten met npm is vaak een interne fout in `node-gyp`. Je kunt hier de installatie-instructies voor node-gyp volgen.

Opmerking: Als je het node-gyp-probleem tegenkomt, moet je ervoor zorgen dat je Python-versie overeenkomt met een van de compatibele versies die in de bovenstaande instructies worden vermeld. 

Een ander veelvoorkomend probleem is een verouderde cache. Wis je npm-cache door simpelweg het onderstaande in je terminal in te voeren:

npm cache clean

Laten we nu een privésleutel voor onze wallet aanmaken, wat test-ETH voor gas regelen en een Ethereum-node opzetten; dit alles hebben we nodig om ons smart contract te implementeren.

De privésleutel aanmaken/opvragen

We hebben een Ethereum-wallet nodig om de implementatie van ons smart contract te betalen.

Zodra je wallet is aangemaakt en je de privésleutel ervan hebt opgehaald, voegen we deze in het volgende deel toe aan het Hardhat-configuratiebestand (bijvoorbeeld hardhat.config.js).

Je kunt de handleidingen van Quicknode volgen om een privésleutel en een Ethereum-adres te genereren in JavaScript, Ruby, Python, Go en PHP.

Volg deze instructies om de privésleutel uit je MetaMask -portemonnee op te halen:

• Klik op het MetaMask-pictogram, een gestileerde vossenkop, in je browser. Als je het niet ziet, kijk dan op de pagina ‘Extensies’ van je browser.
• Klik op het ⋮ -symbool en vervolgens op ‘Accountgegevens’.
• Klik vervolgens op ‘Privésleutel weergeven ’ en volg de instructies.

Kopieer de privésleutel en sla deze op; we hebben deze nodig in de volgende stappen.

Het wordt aanbevolen om gevoelige informatie, zoals privésleutels, op te slaan in een .env-bestand en deze via omgevingsvariabelen in het configuratiebestand op te nemen, of om een nieuwe, secundaire MetaMask-portemonnee aan te maken die uitsluitend voor ontwikkelingsdoeleinden is bedoeld.

Testnet-ETH verkrijgen

We gaan ons contract op het Sepolia-testnet implementeren. Om te kunnen beginnen, hebben we wat test-ETH nodig in onze MetaMask -portemonnee, zoals we in de vorige stap hebben gezien.

Ga naar de Quicknode Multi-Chain Faucet en koppel je wallet of plak je walletadres in. Je moet de Ethereum-keten en het Sepolia-netwerk selecteren en vervolgens geld aanvragen.

Let op: je moet een saldo van ten minste 0,001 ETH op het Ethereum-mainnet hebben om gebruik te kunnen maken van de faucet.

Een Quicknode Ethereum-eindpunt instellen

Om ons contract op de Sepolia-blockchain van Ethereum te implementeren, hebben we toegang nodig tot een Ethereum Sepolia-node. Daarvoor kunnen we vrijwel elke Ethereum-client gebruiken, zoals Geth of OpenEthereum (voorheen Parity). Aangezien dat iets te omslachtig is voor het implementeren van één enkel contract, maken we hier gewoon een gratis Quicknode-account aan en genereren we eenvoudig een Ethereum-eindpunt. Nadat je je gratis Ethereum Sepolia-eindpunt hebt aangemaakt, houd je de URL van je HTTP-provider bij de hand, want die heb je nodig in het volgende gedeelte.

Het configuratiebestand instellen

Open het bestand hardhat.config.js en plak daar het volgende in:

require("@nomiclabs/hardhat-waffle");

const endpointUrl = "ADD_YOUR_QUICKNODE_URL_HERE";
const privateKey = "ADD_YOUR_PRIVATE_KEY_HERE";

module.exports = {
  solidity: "0.8.21",
  networks: {
    sepolia: {
      url: endpointUrl,
      accounts: [privateKey],
    },
  },
};

Vervang ADD_YOUR_PRIVATE_KEY_HERE door de privésleutel die we in de vorige stap hebben verkregen en vervang ADD_YOUR_QUICKNODE_URL_HERE door de HTTP-knooppunt-URL die we in de vorige stap hebben verkregen, en sla het bestand op.

Uitleg bij de bovenstaande code:

• Regel 1: Het pakket hardhat-waffle wordt geïmporteerd.

• Regel 3-4: De URL van het eindpunt en de privésleutel definiëren.

• Regel 6-14: De Solidity-versie vermelden en het netwerk „sepolia“ definiëren.

Een contract opstellen

Maak nu, voor ons contract, een nieuwe map ‘contracts’ aan en plaats daarin een nieuw bestand met de naam HelloWorld.sol.

mkdir contracts && echo > contracts/HelloWorld.sol

Kopieer en plak de volgende code in je Solidity-bestand HelloWorld.sol:

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

contract HelloWorld {

    string saySomething;

    constructor() {
        saySomething = "Hello World!";
    }

    function speak() public view returns(string memory) {
        return saySomething;
    }
}

Uitleg bij de bovenstaande code:

• Regel 1: Het SPDX-licentietype specificeren; dit is een toevoeging sinds Solidity ^0.6.8. 

Wanneer de broncode van een smart contract openbaar wordt gemaakt, kunnen deze licenties helpen bij het oplossen of voorkomen van auteursrechtelijke kwesties. Als je geen specifiek licentietype wilt aangeven, kun je de speciale licentie UNLICENSED gebruiken of de hele opmerking gewoon overslaan (dit leidt niet tot een foutmelding, maar alleen tot een waarschuwing).

• Regel 2: De Solidity-versie aangeven.

• Regel 4: We beginnen ons contract met de naam HalloWereld.

• Regel 6: Een variabele aanmaken saySomething van het type string.

• Regel 8-10: De constructor wordt aangeroepen en de tekenreeks „Hello World!“ wordt opgeslagen in de saySomething variabele.

• Regel 12-14: Een functie aanmaken met de naam spreken van het type public, die de tekenreeks retourneert die is opgeslagen in de saySomething variabele.

Sla het bestand op en compileer het contract met behulp van de volgende Hardhat-opdracht.

npx hardhat compile

Als je contract succesvol wordt gecompileerd, krijg je een uitvoer die er ongeveer zo uitziet:

Het Hello World-smartcontract implementeren

Om ons contract nu te implementeren, maken we een bestand ` deploy.js` aan in een nieuwe map met de naam ` scripts`.

mkdir scripts && echo > scripts/deploy.js

Kopieer en plak het volgende in je deploy.js-bestand:

async function main() {

	const [deployer] = await ethers.getSigners();

	console.log(
	"Deploying contracts with the account:",
	deployer.address
	);

	const HelloWorld = await ethers.getContractFactory("HelloWorld");
	const contract = await HelloWorld.deploy();

	console.log("Contract deployed at:", contract.address);

	const saySomething = await contract.speak();
  	
	console.log("saySomething value:", saySomething);
}

main()
  .then(() => process.exit(0))
  .catch(error => {
	console.error(error);
	process.exit(1);
  });

Uitleg bij de bovenstaande code.

• Regel 1: Een asynchrone functie starten met de naam hoofdpagina.

• Regel 3: Het Ethereum-adres ophalen om de transactie te ondertekenen en dit opslaan in het adres van de deployer. 

• Regel 5-8: Het Ethereum-adres samen met een tekenreeks naar de console afdrukken.

• Regel 10: De methode ethers.js aanroepen ContractFactory. Hiermee wordt gezocht naar de HelloWorld.sol bestand, en een instantie retourneren die we kunnen gebruiken ContractFactory methoden ingeschakeld.

• Regel 11: De functie `deploy` wordt aangeroepen op ContractFactory om het contract in werking te stellen. 

• Regel 13: Het adres van het geïmplementeerde contract wordt naar de console afgedrukt.

• Regel 15: De functie aanroepen spreken van het ingevoerde contract.

• Regel 17: De retourwaarde van de functie weergeven spreken naar de console.

• Regel 20: De functie aanroepen hoofdpagina.

• Regels 21-24: Controleren op fouten, eventuele fouten weergeven en het proces beëindigen.

Sla het bestand op en voer het volgende uit om het contract te implementeren.

npx hardhat run scripts/deploy.js --network sepolia

Zodra het contract met succes is geïmplementeerd, krijg je een uitvoer te zien met het adres van het geïmplementeerde contract en de retourwaarde van de `speak`-functie, namelijk de waarde van `saySomething`.

We kunnen de implementatie controleren door het adres van het geïmplementeerde contract te kopiëren en in de zoekbalk van Sepolia Etherscan te plakken. Hierdoor wordt informatie over het geïmplementeerde contract weergegeven.

Conclusie

Dat was het dan! Je hebt nu de basis onder de knie van het maken, compileren en implementeren van smart contracts met Hardhat. Maar dat is nog niet alles – Hardhat biedt ook tools voor het testen en debuggen van je code. Bekijk de officiële documentatie van Hardhat voor meer informatie.

Schrijf je in voor onze nieuwsbrief voor meer artikelen en handleidingen over Ethereum. Als je vragen hebt, kun je gerust gebruikmaken van ons speciale kanaal op Discord of feedback geven via het onderstaande formulier. Blijf op de hoogte van het laatste nieuws door ons te volgen op Twitter en via ons Telegram-kanaal voor aankondigingen.

We ❤️ feedback!

Laat het ons weten als je feedback hebt of suggesties voor nieuwe onderwerpen. We horen graag van je.