M

MLOG

Norsk

Utforsk kompleksiteten i ERC-721 smart-kontrakter for NFT-er. Lær om deres arkitektur, implementering, sikkerhetshensyn og anvendelser i den virkelige verden.

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:

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:

Metadata-utvidelse (valgfri):

Oppregningsutvidelse (valgfri):

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:

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
  1. Installer OpenZeppelin Contracts:
npm install @openzeppelin/contracts
  1. 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";
  1. Kompiler smart-kontrakten: Bruk Truffle eller Hardhat for å kompilere din smart-kontrakt.
# Truffle
truffle compile

# Hardhat
npx hardhat compile
  1. 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);
  });
  1. 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

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"
    }
  ]
}

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:

Reelle anvendelser for ERC-721 NFT-er

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

Internasjonale eksempler:

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:

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!