Contracten compileren en implementeren
Leer uw Solidity-code naar bytecode te compileren en contracten op een lokaal ontwikkelnetwerk te implementeren.
Contracten compileren en implementeren is een gratis Blockchain-smart contracts met Solidity-les op CoddyKit. Dit is les 2 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.
Introductie tot compileren en implementeren
Goed gedaan met het instellen van je omgeving! Nu brengen we je Solidity-code tot leven. In deze les behandelen we twee essentiële stappen: je smart contracts compileren en implementeren.
Je kunt het vergelijken met het bouwen van een app: eerst schrijf je de code, daarna zet je die om in iets wat een computer kan uitvoeren (compileren), en ten slotte plaats je het ergens waar mensen het kunnen gebruiken (implementeren).
Wat is compileren?
Compileren is het proces waarbij je voor mensen leesbare Solidity-code wordt omgezet in voor machines leesbare bytecode. De Ethereum Virtual Machine (EVM) begrijpt deze bytecode.
- Solidity is een taal op hoog niveau.
- De EVM voert bytecode op laag niveau uit.
- De compiler fungeert als vertaler tussen beide.
Compileren met Hardhat
Hardhat maakt compileren eenvoudig. Zodra je Solidity-bestanden in de map contracts/ staan, heb je in je terminal maar één opdracht nodig.
Met deze opdracht geef je Hardhat de opdracht om alle .sol-bestanden te vinden en ze naar bytecode te compileren.
npx hardhat compileArtifacts begrijpen
Na het compileren maakt Hardhat een map artifacts/ aan. Daarin vind je JSON-bestanden voor elk contract. Deze bestanden bevatten belangrijke informatie:
- Bytecode: De door de EVM uitvoerbare code.
- ABI (Application Binary Interface): Beschrijft hoe je met je contract kunt communiceren.
- Source Map: Helpt bij het opsporen van fouten door bytecode aan broncode te koppelen.
Wat is implementeren?
Implementeren is het naar een blockchainnetwerk sturen van de bytecode van je contract. Nadat het is geïmplementeerd, bevindt je contract zich op dat netwerk en kan iedereen ermee communiceren.
Elke implementatie kost gas (een transactievergoeding) en resulteert in een uniek contractadres op de blockchain.
Lokale ontwikkelnetwerken
Voordat je naar een openbaar netwerk zoals Ethereum Mainnet implementeert, is het belangrijk om je contracten op een lokaal ontwikkelnetwerk te testen.
Hardhat wordt geleverd met een eigen ingebouwd netwerk, dat ideaal is voor snel, gratis en geïsoleerd testen. Het wordt elke keer opnieuw ingesteld wanneer je het opnieuw start.
Ons voorbeeldcontract
Voordat we kunnen implementeren, hebben we een contract nodig! We gebruiken een eenvoudig Greeter.sol-contract. Dit contract slaat een begroeting op en laat je die wijzigen.
Sla dit op in je map contracts/:
/* contracts/Greeter.sol */
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract Greeter {
string private greeting;
constructor(string memory _greeting) {
greeting = _greeting;
}
function greet() public view returns (string memory) {
return greeting;
}
function setGreeting(string memory _greeting) public {
greeting = _greeting;
}
}Het implementatiescript
Dit JavaScript-script, opgeslagen als scripts/deploy.js, vertelt Hardhat hoe ons Greeter-contract naar het netwerk moet worden geïmplementeerd.
Het gebruikt de ingebouwde ethers.js-integratie van Hardhat om de implementatie van het contract af te handelen. Probeer dit voorbeeld uit te voeren:
// scripts/deploy.js
async function main() {
const Greeter = await ethers.getContractFactory("Greeter");
const greeter = await Greeter.deploy("Hello, CoddyKit!");
await greeter.deployed();
console.log("Greeter deployed to:", greeter.address);
}
main()
.then(() => process.exit(0))
.catch((error) => {
console.error(error);
process.exit(1);
});Het implementatiescript uitvoeren
Nu je contract is gecompileerd en je implementatiescript klaarstaat, is het tijd om te implementeren! Open je terminal en voer deze opdracht uit:
Hardhat start automatisch zijn lokale netwerk, implementeert je contract en sluit daarna af (tenzij je eerst npx hardhat node uitvoert).
npx hardhat run scripts/deploy.jsTest je kennis
Laten we controleren of je het compilatie- en implementatieproces in Hardhat goed begrijpt.
Je contracten zijn live!
Je hebt geleerd hoe je je Solidity-code naar bytecode compileert en die naar een lokaal ontwikkelnetwerk implementeert!
- Compileren: Zet Solidity om in EVM-bytecode en maakt een ABI aan.
- Implementeren: Plaatst de bytecode van je contract op een blockchain.
- Hardhat Network: Ideaal voor lokaal testen.
Vervolgens leer je hoe je met deze geïmplementeerde contracten kunt communiceren!
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
Veelgestelde vragen
Is de les “Contracten compileren en implementeren” gratis?
Ja — de volledige tekst van “Contracten compileren en implementeren” 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 “Contracten compileren en implementeren”?
Leer uw Solidity-code naar bytecode te compileren en contracten op een lokaal ontwikkelnetwerk te implementeren. 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 2 van 4.
Hoe lang duurt de les “Contracten compileren en implementeren”?
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
- Hardhat of Truffle instellen
- Contracten compileren en implementeren
- Interactie met geïmplementeerde contracten
- Contracttests schrijven en uitvoeren