Leestijd: 12 min

Overzicht

Digitale verzamelobjecten die compatibel zijn met de ERC-721-standaard zijn sinds de lancering van Cryptokitties enorm populair geworden en hebben de afgelopen maanden een grote stap gezet in de richting van massale acceptatie. In deze handleiding wordt uitgelegd hoe je een NFT (ERC-721) kunt maken en implementeren met behulp van de OpenZeppelin-standaard.

Liever een videohandleiding? Volg Radek en leer hoe je in 20 minuten een ERC-721 (NFT) kunt maken en implementeren.

Abonneer je op ons YouTube-kanaal voor meer video's!Abonneren

Wat je gaat doen

• Lees meer over Non-Fungible Tokens (NFT’s) en hun toepassingsmogelijkheden
• Maak metadata aan voor het ERC-721-token dat je gaat maken
• Upload je bestanden naar een gedecentraliseerd opslagsysteem (IPFS)
• Een ERC-721-token maken en implementeren met Remix.IDE

Wat je nodig hebt

• Een Quicknode-eindpunt (je kunt er hier gratis een aanmaken)
• Een Web3-portemonnee (bijvoorbeeld MetaMask, Coinbase Wallet, Phantom of een portemonnee die compatibel is met WalletConnect) met test-ETH (je kunt deze verkrijgen via de Multi-Chain Quicknode Faucet)
• IPFS CLI is geïnstalleerd
• Een moderne webbrowser (bijvoorbeeld Chrome)

Wat is een non-fungible token?

Fungibel betekent dat iets hetzelfde is of onderling uitwisselbaar is. Zo hebben Ethereum-tokens, alle exemplaren van een bepaalde tokenklasse, bijvoorbeeld dezelfde waarde. Hetzelfde geldt voor Cardano-tokens. Fungibele tokens zijn 1:1 onderling uitwisselbaar.

Met dit in gedachten zijn NFT’s uniek; elk exemplaar is anders. Elk afzonderlijk token heeft unieke kenmerken en waarden. Voorbeelden van zaken die als NFT kunnen fungeren zijn verzamelkaarten, kunstwerken, vliegtickets, enzovoort. Ze zijn allemaal duidelijk van elkaar te onderscheiden en niet onderling uitwisselbaar. Beschouw Non-Fungible Tokens (NFT’s) als zeldzame verzamelobjecten; elk heeft unieke kenmerken, bijzondere eigenschappen en meestal ook eigen metadata.

Wat is ERC-721?

ERC staat voor Ethereum Request for Comment, en 721 is het identificatienummer van het voorstel. ERC’s zijn standaarden op applicatieniveau binnen het Ethereum-ecosysteem; ze kunnen bijvoorbeeld een smart contract-standaard zijn voor tokens zoals ERC-20. De auteur van een ERC is verantwoordelijk voor het bereiken van consensus met de Ethereum-gemeenschap, en zodra het voorstel door de gemeenschap is beoordeeld en goedgekeurd, wordt het een standaard. Je kunt de recente ERC-voorstellen hier volgen. ERC-721 is in het leven geroepen om de functionaliteit voor te stellen waarmee NFT’s binnen smart contracts kunnen worden gevolgd en overgedragen.

ERC-721 is een open standaard die beschrijft hoe niet-vervangbare tokens (NFT’s) kunnen worden gemaakt op blockchains die compatibel zijn met de EVM (Ethereum Virtual Machine); het is een standaardinterface voor niet-vervangbare tokens; de standaard bevat een reeks regels die het werken met NFT’s vergemakkelijken. NFT’s zijn niet alleen van het type ERC-721; het kunnen ook ERC-1155-tokens zijn.

Hieronder volgt een overzicht van de functies en gebeurtenissen die in de ERC-721-standaard zijn gedefinieerd:

ERC-721-functies

balanceOf: Deze functie wordt gebruikt om het aantal NFT’s (Non-Fungible Tokens) weer te geven dat in het bezit is van een bepaald adres.

ownerOf: Deze functie geeft het adres weer van de eigenaar van een specifiek token. Elk ERC721-token is uniek en wordt aangeduid met een ID. Met deze functie kunnen gebruikers of applicaties de eigenaar van het token achterhalen aan de hand van de unieke ID.

safeTransferFrom (zonder gegevens): Deze functie draagt het eigendom van een specifiek token op veilige wijze over van het ene adres naar het andere. Deze functie controleert of de ontvanger een smart contract is. Als dat het geval is, moet het een specifieke functie (onERC721Received) implementeren om de overdracht te accepteren.

transferFrom: Deze functie wordt gebruikt om het eigendom van een token van het ene adres naar het andere over te dragen. Deze functie wordt doorgaans gebruikt wanneer de afzender toestemming heeft gekregen om het token over te dragen.

goedkeuren: Deze functie wordt gebruikt om een adres toestemming te geven om een specifiek token over te dragen. Dit maakt gedelegeerde overdrachten mogelijk, waarbij een eigenaar een andere partij toestemming kan geven om een token namens hem of haar over te dragen.

getApproved: Deze functie wordt gebruikt om het goedgekeurde adres voor een specifiek token op te vragen. Als er geen goedgekeurd adres voor het token is, retourneert deze functie een null-adres.

setApprovalForAll: Met deze functie kan een eigenaar van één of meer tokens een beheerder toestemming verlenen of intrekken om al zijn of haar tokens te beheren.

isApprovedForAll: Deze functie wordt gebruikt om te controleren of een operator bevoegd is om alle tokens van een eigenaar te beheren.

safeTransferFrom (met gegevens): Deze functie is vergelijkbaar met safeTransferFrom (zonder gegevens), maar bevat een extra gegevensparameter. Deze extra gegevens kunnen worden gebruikt om tijdens de overdracht aanvullende informatie door te geven als de ontvanger een smart contract is. Deze functie controleert ook of de ontvanger een smart contract is en of deze de functie onERC721Received implementeert.

ERC-721-evenementen

Overdracht: Deze gebeurtenis wordt gegenereerd wanneer het eigendom van een token van het ene adres naar het andere overgaat. De gebeurtenis bevat details over de afzender (van), de ontvanger (naar) en het specifieke token (op basis van ID) dat is overgedragen. Dankzij deze gebeurtenis kunnen externe luisteraars, zoals gebruikersinterfaces of andere contracten, op de overdracht reageren.

Goedkeuring: Deze gebeurtenis wordt geactiveerd wanneer een adres wordt goedgekeurd om een specifiek token over te dragen. De gebeurtenis omvat de huidige eigenaar van het token (owner), het goedgekeurde adres dat het token nu kan overdragen (approved) en het specifieke token (op basis van ID) waarvan de overdracht is goedgekeurd. Met deze gebeurtenis kunnen applicaties goedkeuringen van tokens bijhouden en daarop reageren.

ApprovalForAll: Deze gebeurtenis wordt gegenereerd wanneer een eigenaar de toestemming voor een beheerder om al zijn tokens te beheren goedkeurt of intrekt. De gebeurtenis bevat het adres van de eigenaar (owner), het adres van de beheerder (operator) en een booleaanse waarde die aangeeft of de beheerder al dan niet is goedgekeurd (approved). Met deze gebeurtenis kunnen applicaties bijhouden welke adressen de rechten hebben gekregen om alle tokens van een bepaalde eigenaar te beheren.

Toepassingen van niet-vervangbare tokens (NFT’s)

• Digitale kunst (of fysieke kunst): Kunstwerken zijn de populairste toepassingen van NFT’s. Veilingen van digitale kunst waren de eerste toepassing van NFT’s en blijven groeien.

• Gaming: Het aanbieden van in-game aankopen en verzamelobjecten voor games.

• Vastgoed: het tokeniseren van onroerend goed en slimme contracten, en het uitvoeren van aan- en verkooptransacties.

• Financiën: Financiële instrumenten zoals leningen, futures en andere verplichtingen.

• Softwaretitels: Softwarelicenties ter bestrijding van piraterij en ter waarborging van de privacy.

• Concertkaartjes/kaartjes voor sportwedstrijden: Om ervoor te zorgen dat er geen fraude plaatsvindt bij de kaartverkoop en dat fans op één plek hun eerdere ervaringen kunnen terugkijken.

• Naleving van KYC-voorschriften: een token aanmaken voor de KYC-procedure van een specifieke gebruiker.

ETH testen

Nu we weten wat ERC-721-tokens zijn en hoe ze werken, gaan we eens kijken hoe we onze eigen tokens kunnen maken en in gebruik nemen.

We gaan ons contract uitrollen op het Ethereum Sepolia-testnet. Om te beginnen heb je de MetaMask -browserextensie nodig (of een andere compatibele web3-wallet; Phantom, WalletConnect-compatibel) en wat test-ETH, die je kunt verkrijgen via de Quicknode Multi-Chain Faucet. Sluit gewoon je wallet aan of plak het adres in en klik op ‘Doorgaan’. Je wordt gevraagd om een tweet te delen voor een bonus (we raden dit aan!); anders klik je gewoon op ‘Nee, bedankt, stuur me gewoon 0,05 ETH’. Houd er rekening mee dat er een saldo-eis van 0,001 ETH op het Ethereum-mainnet geldt om de EVM-faucets te kunnen gebruiken.

Bestanden toevoegen aan IPFS

Voordat we ons NFT-contract opstellen, moeten we onze kunstwerken voor de NFT hosten en een metadatabestand aanmaken; hiervoor gebruiken we IPFS – een gedistribueerd peer-to-peer-systeem voor het opslaan en delen van bestanden. Er zijn verschillende manieren om met het IPFS-protocol te werken. Je kunt IPFS op je eigen systeem installeren en beheren, of kiezen voor Quicknode als eenvoudigere oplossing. Quicknode vereenvoudigt je toegang tot IPFS door de onderliggende infrastructuur te beheren. Dankzij deze aanpak kun je je concentreren op je content, zonder dat je je zorgen hoeft te maken over het onderhouden van een lokale IPFS-node voor het vastpinnen van gegevens. Met Quicknode worden de technische complexiteiten voor je afgehandeld.

We behandelen beide manieren om je bestanden naar IPFS te uploaden: via de standaard IPFS-CLI of via de gestroomlijnde Quicknode IPFS-service.

Standaardmethode: met behulp van de IPFS-CLI

Download en installeer de IPFS CLI die bij uw besturingssysteem past door de installatiehandleiding in de IPFS-documentatie te volgen .

Hieronder volgen de stappen voor het hosten van de afbeelding en het metadatabestand.

Stap 1: Een IPFS-repository aanmaken

Start de IPFS-repository door het volgende in een terminal- of cmd-venster in te voeren.

ipfs init

Stap 2: De IPFS-daemon starten

Start de IPFS-daemon, open een apart terminal-/cmd-venster en typ het volgende.

IPFS-daemon

Stap 3: Een afbeelding toevoegen aan IPFS

Ga naar het eerste terminalvenster en voeg de afbeelding toe aan IPFS (in dit geval art.png).

ipfs add art.png

Kopieer de hash die begint met Qm en voeg daar het voorvoegsel„https://ipfs.io/ipfs/“ aan toe; het moet er ongeveer zo uitzien: https://ipfs.io/ipfs/QmQEVVLJUR1WLN15S49rzDJsSP7za9DxeqpUzWuG4aondg

Stap 4: Een JSON-bestand toevoegen aan IPFS

Maak een JSON-bestand aan met de naam nft.json en sla het op in dezelfde map als de afbeelding.

JSON-bestandsformaat:

{
	"name": "NFT Art",
	"description": "This image shows the true nature of NFT.",
	"image": "https://ipfs.io/ipfs/QmZzBdKF7sQX1Q49CQGmreuZHxt9sVB3hTc3TTXYcVZ7jC"
}

Voeg nu het JSON-bestand toe.

ipfs add nft.json

Neem de hash die begint met Qm en voeg daar‘https://ipfs.io/ipfs/’ aan toe; het moet er ongeveer zo uitzien: https://ipfs.io/ipfs/QmUFbUjAifv9GwJo7ufTB5sccnrNqELhDMafoEmZdPPng7

Sla deze URL op. We hebben deze nodig om onze NFT te slaan.

Quicknode IPFS-oplossing: een eenvoudiger alternatief

info

Als je meer wilt weten over de prijzen van Quicknode IPFS, kun je hier onze tariefplannen bekijken.

Als je op zoek bent naar een eenvoudigere aanpak, biedt de IPFS-dienst van Quicknode een gebruiksvriendelijke, efficiënte oplossing voor het uploaden van je NFT-bestanden. Met Quicknode hoef je je geen zorgen te maken over het beheer van de infrastructuur, waardoor je je kunt concentreren op je content in plaats van op het onderhouden van een lokale IPFS-node.

Volg deze stappen om Quicknode voor IPFS te gaan gebruiken:

Stap 1: Inloggen bij Quicknode

Log in op Quicknode en selecteer de optie ‘IPFS’ in de zijbalk aan de linkerkant:

Stap 2: Een afbeelding toevoegen aan IPFS met Quicknode

Upload uw afbeeldingsbestand snel door het te slepen en neer te zetten of door te klikken om bestanden te selecteren in uw Finder-/Verkenner-venster. In deze handleiding gebruiken we de onderstaande afbeelding.

Klik na het uploaden op de bestandsnaam op het tabblad ‘Bestanden ’ en klik vervolgens op de knop ‘IPFS-URL kopiëren’. Zoals te zien is op de onderstaande schermafbeelding.

https://qn-shared.quicknode-ipfs.com/ipfs/QmQEVVLJUR1WLN15S49rzDJsSP7za9DxeqpUzWuG4aondg

Stap 3: Een JSON-bestand toevoegen aan IPFS met Quicknode

Maak een JSON-bestand aan met de naam nft.json, vervang je IPFS-URL in de afbeelding veld in en sla het op. Upload na het opslaan je JSON-bestand naar IPFS, net zoals in de vorige stap.

{
    "name": "NFT Art",
    "description": "This image shows the true nature of NFT.",
    "image": "https://qn-shared.quicknode-ipfs.com/ipfs/QmQEVVLJUR1WLN15S49rzDJsSP7za9DxeqpUzWuG4aondg"
}

Klik na het uploaden op de bestandsnaam op het tabblad ‘Bestanden’ en kopieer de IPFS-URL. Deze moet er ongeveer zo uitzien als hieronder.

https://qn-shared.quicknode-ipfs.com/ipfs/QmeVHZzKGEDbEbG5MVz4hUucNf4qZTRfW18AgdJNTrv22m

Sla deze URL op. We hebben deze nodig om onze NFT te slaan.

Ons eigen token maken

Voor het gemak en de veiligheid gebruiken we het OpenZeppelin ERC-721-contract om onze NFT aan te maken. Met OpenZeppelin hoeven we niet de volledige ERC-721-interface te schrijven. In plaats daarvan kunnen we het bibliotheekcontract importeren en de functies daarvan gebruiken.

Ga naar de Ethereum Remix IDE en maak een nieuw Solidity-bestand aan, bijvoorbeeld - MyToken.sol

Plak de volgende code in je nieuwe Solidity-script:

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

import "@openzeppelin/contracts@5.0.0/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts@5.0.0/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts@5.0.0/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts@5.0.0/access/Ownable.sol";

contract MyToken is ERC721, ERC721URIStorage, ERC721Burnable, Ownable {
    constructor(address initialOwner)
        ERC721("MyToken", "MTK")
        Ownable(initialOwner)
    {}

    function safeMint(address to, uint256 tokenId, string memory uri)
        public
        onlyOwner
    {
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, uri);
    }

    // The following functions are overrides required by Solidity.

    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

Uitleg bij de bovenstaande code:

Regel 1: Het SPDX-licentietype wordt gespecificeerd als MIT. Dit geeft aan dat de code valt onder de MIT-licentie, een soepele open-source-licentie die het mogelijk maakt de code te gebruiken, aan te passen en te verspreiden met zeer weinig beperkingen.

Regel 2: De Solidity-versie wordt opgegeven als ^0.8.20. Dit geeft aan dat de code is geschreven met Solidity-versie 0.8.20 of een compatibele versie.

Regels 4-7: De benodigde contracten uit de OpenZeppelin-bibliotheek importeren.

• ERC721.sol: Dit contract is geïmporteerd uit de OpenZeppelin-bibliotheek en vormt de basisimplementatie van de ERC721-standaard. ERC721 is de standaard voor niet-vervangbare tokens (NFT’s).

• ERC721URIStorage.sol: Dit contract breidt ERC721 uit en voegt functionaliteit toe voor het opslaan en beheren van metadata-URI’s die aan NFT’s zijn gekoppeld. Metadata-URI’s verwijzen doorgaans naar aanvullende informatie over de NFT.

• ERC721Burnable.sol: Dit contract breidt ERC721 eveneens uit en voegt de mogelijkheid toe om NFT’s te ‘burnen’ (te vernietigen). Het biedt een functie om NFT’s definitief uit de omloop te halen, en alleen de eigenaar kan deze functie activeren.

• Ownable.sol: Dit contract wordt gebruikt voor toegangscontrole. Hiermee kun je een eigenaar aanwijzen die binnen het contract speciale rechten heeft. De eigenaar kan bepaalde acties uitvoeren die andere gebruikers niet kunnen uitvoeren.

Regel 9: Het contract met de naam MyToken en waarbij wordt vermeld dat het een uitbreiding vormt op de contracten ERC721, ERC721URIStorage en Ownable. Dit betekent dat de MyToken Het contract neemt de functionaliteit en eigenschappen over die in deze contracten zijn gedefinieerd.

Regel 10: Hier begint de constructorfunctie. Constructors zijn speciale functies in Solidity die slechts één keer worden uitgevoerd tijdens de implementatie van het contract. Deze constructor neemt één argument, eerste eigenaar, wat een Ethereum-adres is.

Regel 11: Deze regel roept de constructor van het ERC721-contract aan met de argumenten "MyToken" en "MTK". Hiermee wordt het NFT-contract geïnitialiseerd met de naam "MyToken" en het symbool "MTK".

Regel 12: Deze regel roept de constructor van het Ownable-contract aan, waarbij de eerste eigenaar van het MyToken-contract wordt ingesteld op het adres dat is opgegeven als initialOwner.

Regel 15: De functie declareren safeMint met drie argumenten: to (het adres van de ontvanger van het NFT-token), tokenId (de unieke identificatiecode van het token) en uri (de URI van het JSON-bestand dat aan het token is gekoppeld). Deze functie kan alleen worden aangeroepen door de eigenaar van het contract (aangegeven door de enige eigenaar modificator).

Regel 19: Een nieuw token aanmaken door de functie _safeMint functie die is overgenomen uit het ERC721-contract. Deze functie maakt een nieuw token aan en wijst dit toe aan het opgegeven adres van de ontvanger.

Regel 20: De token-URI (metadata-URI) instellen die aan het token is gekoppeld met behulp van de _setTokenURI functie overgenomen van de ERC721URIStorage contract. De URI wordt ingesteld op basis van de opgegeven tokenId en uri.

Regels 25-32: De door Solidity vereiste override-implementaties voor de ERC721 en ERC721URIStorage contracten. tokenURI is een functie die de metadata-URI ophaalt die aan een bepaald tokenId is gekoppeld. De functie is gemarkeerd als ‘public’ en ‘view’, wat aangeeft dat het een functie is die alleen-lezen is en door iedereen kan worden aangeroepen.

Regels 34-41: De functie `supportsInterface` implementeren, die vereist is door de ERC721 en ERC721URIStorage contracten. Deze functie controleert of een bepaalde interfaceId door het contract wordt ondersteund en retourneert op basis daarvan een booleaanse waarde.

Door deze functionaliteiten en contracten te combineren, creëert de code een op maat gemaakt ERC721-tokencontract met de naam MyToken. Met dit contract kan de contracthouder op veilige wijze nieuwe tokens slaan, er metadata-URI’s aan koppelen en de benodigde interfaces ondersteunen die zijn gedefinieerd in de ERC721-standaard.

Neem nu even de tijd om het slimme contract aan te passen met je eigen gegevens, als je dat wilt. Je kunt de naam en het symbool van het token aanpassen door de volgende regel te wijzigen - ERC721("MyToken", "MTK").

Als je klaar bent, compileer je het smart contract en implementeer je het met behulp van Geïnjecteerde provider (zorg ervoor dat je in Metamask het Sepolia-testnet selecteert voordat je het contract compileert). Plak vervolgens je walletadres in het veld vlak naast de Implementeren knop om de eerste eigenaar parameter van de constructorfunctie. Klik ten slotte op Implementeren op Remix.IDE.

Als u vóór de implementatie de foutmelding „Dit contract is mogelijk abstract“ krijgt, zorg er dan voor dat u onder het tabblad „Contract“ het juiste contract selecteert.

Bevestig de transactie in Metamask:

Ga nu naar het gedeelte ‘Deployed Contracts’ in Remix en vouw het geïmplementeerde contract uit. Je ziet dan een heleboel functies en methoden. Vouw de safeMint functie en voeg de volgende gegevens toe:

1. Voer het adres van je wallet in het veld _to in.
2. Voer een willekeurige waarde uit de reeks Big Number in het veld _tokenId in. We raden aan om '1' te gebruiken, aangezien dit het eerste token is dat wordt geslagen.
3. Voor de _uri Vul in het veld de URI in van het JSON-bestand dat overeenkomt met de methode die je in de vorige stappen hebt gebruikt:
   • Als je de standaard IPFS CLI-methode hebt gebruikt: gebruik de URI die je hebt verkregen nadat je je bestand naar IPFS hebt geüpload, zoals beschreven in het gedeelte ‘Standaardmethode: IPFS CLI gebruiken ’. Dit is de IPFS-link met het voorvoegsel https://ipfs.io/ipfs/, gevolgd door de hash van je bestand.
   • Als je voor de IPFS-dienst van Quicknode hebt gekozen: gebruik de URI die Quicknode je heeft verstrekt nadat je je bestand hebt geüpload in het gedeelte ‘Quicknode IPFS-oplossing: een eenvoudiger alternatief ’. Quicknode genereert een unieke URI voor je bestand, die je hier moet invoeren.

Klik op ‘Transact’ en bevestig de transactie via MetaMask. Dit kan een paar minuten duren, maar je kunt altijd via een block explorer zoals Etherscan controleren of de transactie is uitgevoerd. Nu heb je de NFT op de Sepolia-keten.

Je kunt ook andere details bekijken, zoals naam, symbool, eigenaar van, of tokenURI door de eerder genoemde token-ID in te voeren.

Conclusie

Gefeliciteerd met het maken van je allereerste NFT! Help je kunstenaarsvrienden om hun kunstwerken op de Ethereum-blockchain te zetten, of word zelf kunstenaar. Bekijk de Wizard van OpenZeppelin voor meer voorbeelden.

Schrijf je in voor onze nieuwsbrief voor meer artikelen en handleidingen over Ethereum. Als je feedback hebt, neem dan gerust contact met ons op via Twitter. Je kunt ook altijd met ons chatten op onze Discord-communityserver, waar je enkele van de coolste ontwikkelaars tegenkomt die je ooit zult ontmoeten :)

We ❤️ feedback!

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