NFT Smart-kontrakter: En dybdeanalyse av ERC-721-implementering

Ikke-fungible tokener (NFT-er) har revolusjonert landskapet for digitale eiendeler, og muliggjør representasjon av unike gjenstander på blokkjeden. I hjertet av de fleste NFT-er ligger ERC-721-standarden, et sett med regler som styrer hvordan disse tokenene opprettes, administreres og overføres. Denne omfattende guiden gir en grundig utforskning av ERC-721 smart-kontrakter, og dekker deres arkitektur, implementeringsdetaljer, sikkerhetshensyn og praktiske anvendelser.

Hva er ERC-721?

ERC-721 er en standard for å representere ikke-fungible tokener på Ethereum-blokkjeden. I motsetning til ERC-20-tokener, som er fungible (som betyr at hvert token er identisk med alle andre tokener), er ERC-721-tokener unike. Hvert token har en distinkt ID, noe som gjør det egnet for å representere eierskap av unike digitale eller fysiske eiendeler.

Nøkkelegenskaper for ERC-721-tokener:

• Ikke-fungibel: Hvert token er unikt og kan skilles fra andre.
• Unik identifikasjon: Hvert token har en unik ID.
• Eierskapssporing: Standarden sporer eierskapet til hvert token.
• Overførbarhet: Tokener kan overføres fra en konto til en annen.
• Metadata: Tokener kan knyttes til metadata, som gir tilleggsinformasjon om eiendelen de representerer.

Arkitektur for ERC-721 Smart-kontrakter

En ERC-721 smart-kontrakt er et Solidity-program som implementerer ERC-721-standarden. Den inkluderer vanligvis følgende komponenter:

Kjernefunksjoner:

• balanceOf(address _owner): Returnerer antall tokener som eies av en gitt adresse.
• ownerOf(uint256 _tokenId): Returnerer adressen til eieren av et spesifikt token.
• transferFrom(address _from, address _to, uint256 _tokenId): Overfører eierskapet til et token fra en adresse til en annen. Krever godkjenning hvis det ikke initieres av eieren.
• approve(address _approved, uint256 _tokenId): Godkjenner en annen adresse til å overføre eierskapet til et spesifikt token.
• getApproved(uint256 _tokenId): Returnerer adressen som er godkjent for å overføre eierskapet til et spesifikt token.
• setApprovalForAll(address _operator, bool _approved): Aktiverer eller deaktiverer en operatør til å administrere alle tokener som eies av den som kaller funksjonen.
• isApprovedForAll(address _owner, address _operator): Sjekker om en operatør er godkjent for å administrere alle tokener som eies av en adresse.

Metadata-utvidelse (valgfri):

• name(): Returnerer navnet på token-samlingen.
• symbol(): Returnerer symbolet for token-samlingen.
• tokenURI(uint256 _tokenId): Returnerer en URI som peker til en JSON-fil som inneholder metadata om et spesifikt token. Denne URI-en peker vanligvis til en InterPlanetary File System (IPFS)-adresse.

Oppregningsutvidelse (valgfri):

• totalSupply(): Returnerer det totale antallet tokener som eksisterer.
• tokenByIndex(uint256 _index): Returnerer token-ID-en ved en gitt indeks av alle tokener lagret av kontrakten.
• tokenOfOwnerByIndex(address _owner, uint256 _index): Returnerer token-ID-en ved en gitt indeks eid av en spesifikk adresse.

Implementering av en ERC-721 Smart-kontrakt med OpenZeppelin

OpenZeppelin tilbyr et sikkert og revidert bibliotek med smart-kontrakter som forenkler utviklingen av ERC-721-tokener. Bruk av OpenZeppelins ERC721-implementering reduserer risikoen for å introdusere sårbarheter i koden din. Her er et eksempel på hvordan du implementerer en ERC-721 smart-kontrakt ved hjelp av OpenZeppelin:

Forutsetninger:

• Node.js og npm: Sørg for at du har Node.js og npm installert.
• Truffle eller Hardhat: Velg et utviklingsmiljø (f.eks. Truffle eller Hardhat) for å kompilere og rulle ut din smart-kontrakt.
• Ganache: Installer Ganache, en personlig blokkjede for Ethereum-utvikling.

Steg:

1. Initialiser et Truffle- eller Hardhat-prosjekt:

            # Truffle
mkdir my-nft-project
cd my-nft-project
truffle init

# Hardhat
mkdir my-nft-project
cd my-nft-project
npx hardhat
            

              
                Copy
              
            
          

2. Installer OpenZeppelin Contracts:

            npm install @openzeppelin/contracts
            

              
                Copy
              
            
          

3. Opprett en ERC-721 Smart-kontrakt: Opprett en ny Solidity-fil (f.eks. `MyNFT.sol`) i din `contracts`-katalog.

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract MyNFT is ERC721 {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    string private _baseURI;

    constructor(string memory name, string memory symbol, string memory baseURI) ERC721(name, symbol) {
        _baseURI = baseURI;
    }

    function mintNFT(address recipient) public returns (uint256) {
        _tokenIds.increment();

        uint256 newItemId = _tokenIds.current();
        _mint(recipient, newItemId);
        _setTokenURI(newItemId, string(abi.encodePacked(_baseURI, Strings.toString(newItemId), ".json")));

        return newItemId;
    }

    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory _tokenURI = _tokenURIs[tokenId];
        return string(abi.encodePacked(_tokenURI));
    }

    mapping (uint256 => string) private _tokenURIs;

    function setBaseURI(string memory baseURI) public {
        _baseURI = baseURI;
    }



    // Følgende funksjoner er overstyringer som kreves av Solidity.

    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721) {
        super._beforeTokenTransfer(from, to, tokenId);
    }
}

import "@openzeppelin/contracts/utils/Strings.sol";
            

              
                Copy
              
            
          

4. Kompiler smart-kontrakten: Bruk Truffle eller Hardhat for å kompilere din smart-kontrakt.

            # Truffle
truffle compile

# Hardhat
npx hardhat compile
            

              
                Copy
              
            
          

5. Opprett et utrullingsskript: Opprett en ny JavaScript-fil (f.eks. `deploy.js`) i din `migrations`- eller `scripts`-katalog.

            // Eksempel på Truffle-migrering
const MyNFT = artifacts.require("MyNFT");

module.exports = async function (deployer) {
  await deployer.deploy(MyNFT, "MyNFT", "MNFT", "ipfs://DIN_IPFS_CID/");
};

// Eksempel på Hardhat-utrullingsskript
async function main() {
  const MyNFT = await ethers.getContractFactory("MyNFT");
  const myNFT = await MyNFT.deploy("MyNFT", "MNFT", "ipfs://DIN_IPFS_CID/");

  await myNFT.deployed();

  console.log("MyNFT deployed to:", myNFT.address);
}

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

            

              
                Copy
              
            
          

6. Rull ut smart-kontrakten: Rull ut din smart-kontrakt til en lokal blokkjede (f.eks. Ganache) eller et testnettverk (f.eks. Ropsten, Rinkeby).

            # Truffle
truffle migrate

# Hardhat
npx hardhat run scripts/deploy.js --network localhost
            

              
                Copy
              
            
          

Husk å erstatte `ipfs://DIN_IPFS_CID/` med din faktiske IPFS CID (Content Identifier). Denne base-URI-en peker til stedet der NFT-metadataens JSON-filer vil bli lagret.

Lagring av NFT-metadata på IPFS

NFT-metadata lagres vanligvis "off-chain" (utenfor blokkjeden) for å redusere kostnadene ved å lagre data på blokkjeden. IPFS (InterPlanetary File System) er et desentralisert lagringsnettverk som ofte brukes til å lagre NFT-metadata. Hver NFT har en `tokenURI` som peker til en JSON-fil på IPFS som inneholder metadata om NFT-en, som navn, beskrivelse, bilde-URL og andre attributter.

Eksempel på NFT-metadata (JSON):

            {
  "name": "Min Fantastiske NFT",
  "description": "Dette er en unik NFT.",
  "image": "ipfs://DIN_IPFS_CID/image.png",
  "attributes": [
    {
      "trait_type": "Bakgrunn",
      "value": "Blå"
    },
    {
      "trait_type": "Karakter",
      "value": "Robot"
    }
  ]
}
            

              
                Copy
              
            
          

Erstatt `ipfs://DIN_IPFS_CID/image.png` med den faktiske IPFS CID-en til bildet ditt.

Steg for å laste opp metadata til IPFS:

1. Velg en IPFS-klient: Velg en IPFS-klient som IPFS Desktop, Pinata eller NFT.Storage.
2. Last opp metadataen din: Last opp dine NFT-metadata JSON-filer og bilder til IPFS ved hjelp av din valgte klient.
3. Motta IPFS CID: Etter å ha lastet opp metadataen, vil du motta en IPFS CID. Dette er en unik identifikator for dataene dine på IPFS.
4. Oppdater smart-kontrakten: Oppdater `tokenURI`-funksjonen i smart-kontrakten din slik at den peker til din IPFS CID.

Sikkerhetshensyn for ERC-721 Smart-kontrakter

Sikkerhet er av største betydning når man utvikler ERC-721 smart-kontrakter. Her er noen kritiske sikkerhetshensyn:

• Reentrancy-angrep: Forhindre reentrancy-angrep ved å bruke Checks-Effects-Interactions-mønsteret. Dette innebærer å utføre sjekker før du gjør tilstandsendringer, deretter anvende tilstandsendringene, og til slutt samhandle med eksterne kontrakter. OpenZeppelins `ReentrancyGuard`-kontrakt kan bidra til å redusere denne sårbarheten.
• Heltallsoverflyt/-underflyt: Bruk Solidity-versjoner >= 0.8.0, som har innebygde sjekker for overflyt/underflyt. Hvis du bruker eldre versjoner, bruk OpenZeppelins `SafeMath`-bibliotek.
• Tilgangskontroll: Implementer riktige mekanismer for tilgangskontroll for å begrense hvem som kan prege, brenne eller endre tokener. Bruk OpenZeppelins `Ownable`- eller `AccessControl`-kontrakter for å administrere eierskap og tillatelser.
• Tjenestenekt (DoS): Vær klar over potensielle DoS-sårbarheter, som problemer med gassgrenser. Optimaliser koden din for å redusere gassforbruket og unngå operasjoner som potensielt kan blokkere kontrakten.
• Front Running: Implementer tiltak for å forhindre front running, som å bruke commit-reveal-skjemaer eller ordre-matching utenfor blokkjeden.
• Datavalidering: Valider alle brukerinndata for å forhindre uventet oppførsel eller sikkerhetsbrudd.
• Regelmessige revisjoner: Utfør regelmessige sikkerhetsrevisjoner av anerkjente sikkerhetsfirmaer for å identifisere og adressere potensielle sårbarheter.

Reelle anvendelser for ERC-721 NFT-er

ERC-721 NFT-er brukes i et bredt spekter av applikasjoner, inkludert:

• Digital kunst: Representerer eierskap av unike digitale kunstverk. Plattformer som SuperRare, Foundation og Nifty Gateway legger til rette for kjøp og salg av NFT-kunst.
• Samleobjekter: Skaper digitale samleobjekter, som samlekort, virtuelle kjæledyr og andre gjenstander. CryptoPunks og Bored Ape Yacht Club er eksempler på vellykkede NFT-samleprosjekter.
• Gaming: Representerer gjenstander i spill, som våpen, karakterer og land. Axie Infinity og Decentraland er eksempler på blokkjedespill som bruker NFT-er.
• Eiendom: Tokenisering av eierskap til eiendommer. Dette muliggjør fraksjonert eierskap og enklere overføring av eiendomsrettigheter.
• Forsyningskjedestyring: Sporing av opprinnelsen og ektheten til produkter i forsyningskjeden. Dette kan bidra til å forhindre forfalskning og sikre produktkvalitet.
• Billettsalg: Utstede billetter til arrangementer, konserter og andre aktiviteter. NFT-er kan bidra til å forhindre billettsvindel og gi et sikrere og mer transparent billettsystem.
• Identitetshåndtering: Representerer digitale identiteter og legitimasjon. Dette kan hjelpe enkeltpersoner med å kontrollere sine personlige data og forhindre identitetstyveri.

Internasjonale eksempler:

• Digital kunst: Kunstnere fra hele verden bruker NFT-plattformer for å selge sine digitale kunstverk, inkludert verk inspirert av japansk anime, afrikansk stammekunst og europeiske klassiske malerier.
• Gaming: Blokkjedespill som Axie Infinity har blitt populære i Sørøst-Asia, der spillere tjener penger ved å spille spillet og handle med NFT-er.
• Eiendom: Selskaper i USA, Europa og Asia utforsker bruken av NFT-er for å tokenisere eiendommer og legge til rette for fraksjonert eierskap.

Avanserte ERC-721-konsepter

ERC-721A

ERC-721A er en mer gass-effektiv implementering av ERC-721-standarden som optimaliserer preging av flere NFT-er i en enkelt transaksjon. Den reduserer gasskostnadene ved å amortisere lagringskostnadene over flere tokener. Dette kan være fordelaktig for prosjekter som involverer preging av store antall NFT-er.

Lazy Minting (Lat preging)

Lazy minting er en teknikk der NFT-er bare preges når de blir kjøpt. Dette kan spare gasskostnader for prosjekter som har et stort antall NFT-er, men ikke forventer at alle blir solgt. NFT-metadataen lagres utenfor blokkjeden til NFT-en blir kjøpt, da blir tokenet preget og metadataen lagt til på blokkjeden.

Soulbound Tokens (Sjelbundne tokener)

Soulbound-tokener er NFT-er som er permanent knyttet til en spesifikk adresse og ikke kan overføres. Disse tokenene kan brukes til å representere ikke-overførbar legitimasjon, som utdanningsgrader, faglige sertifiseringer eller medlemskap i et fellesskap. Dette oppnås ved å fjerne eller begrense `transferFrom`-funksjonen.

Fremtiden for ERC-721 og NFT-er

ERC-721-standarden fortsetter å utvikle seg, med pågående forskning og utvikling fokusert på å forbedre effektiviteten, sikkerheten og funksjonaliteten. Fremtidige utviklinger kan omfatte:

• Forbedrede metadatastandarder: Mer standardiserte og interoperable metadataformater for å forbedre oppdagbarheten og brukervennligheten til NFT-er.
• Krysskjede-interoperabilitet: Løsninger som gjør at NFT-er kan overføres og brukes på tvers av forskjellige blokkjedenettverk.
• Forbedrede sikkerhetstiltak: Nye sikkerhetsprotokoller og verktøy for å beskytte mot sårbarheter og angrep.
• Integrasjon med reelle eiendeler: Bredere adopsjon av NFT-er for å representere eierskap av fysiske eiendeler, som eiendom, samleobjekter og immaterielle rettigheter.

Konklusjon

ERC-721 smart-kontrakter er et kraftig verktøy for å representere eierskap av unike digitale og fysiske eiendeler på blokkjeden. Ved å forstå arkitekturen, implementeringsdetaljene, sikkerhetshensynene og de praktiske anvendelsene av ERC-721, kan utviklere bygge innovative og virkningsfulle NFT-prosjekter. Etter hvert som NFT-økosystemet fortsetter å vokse og utvikle seg, vil ERC-721-standarden spille en avgjørende rolle i å forme fremtiden for digitalt eierskap.

Denne guiden gir et solid grunnlag for å forstå og implementere ERC-721 smart-kontrakter. Husk å alltid prioritere sikkerhet og følge beste praksis når du utvikler og ruller ut dine egne NFT-prosjekter. Lykke til!