M

MLOG

Dansk

Udforsk detaljerne i ERC-721 smart contracts for NFT'er. Lær om deres arkitektur, implementering, sikkerhedsovervejelser og anvendelser i den virkelige verden.

NFT Smart Contracts: Et Dybdegående Kig på ERC-721 Implementering

Non-Fungible Tokens (NFT'er) har revolutioneret landskabet for digitale aktiver ved at muliggøre repræsentation af unikke genstande på blockchainen. Kernen i de fleste NFT'er er ERC-721-standarden, et sæt regler, der styrer, hvordan disse tokens oprettes, administreres og overføres. Denne omfattende guide giver en dybdegående udforskning af ERC-721 smart contracts, der dækker deres arkitektur, implementeringsdetaljer, sikkerhedsovervejelser og praktiske anvendelser.

Hvad er ERC-721?

ERC-721 er en standard til at repræsentere non-fungible tokens på Ethereum-blockchainen. I modsætning til ERC-20-tokens, som er fungible (hvilket betyder, at hver token er identisk med alle andre tokens), er ERC-721-tokens unikke. Hver token har et distinkt ID, hvilket gør den egnet til at repræsentere ejerskab af unikke digitale eller fysiske aktiver.

Nøglekarakteristika for ERC-721 Tokens:

ERC-721 Smart Contract Arkitektur

En ERC-721 smart contract er et Solidity-program, der implementerer ERC-721-standarden. Den inkluderer typisk følgende komponenter:

Kernefunktioner:

Metadata-udvidelse (Valgfri):

Opnummereringsudvidelse (Valgfri):

Implementering af en ERC-721 Smart Contract med OpenZeppelin

OpenZeppelin leverer et sikkert og revideret bibliotek af smart contracts, der forenkler udviklingen af ERC-721-tokens. At bruge OpenZeppelins ERC721-implementering reducerer risikoen for at introducere sårbarheder i din kode. Her er et eksempel på, hvordan man implementerer en ERC-721 smart contract ved hjælp af OpenZeppelin:

Forudsætninger:

Trin:

  1. Initialiser et Truffle- eller Hardhat-projekt:
# 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. Opret en ERC-721 Smart Contract: Opret en ny Solidity-fil (f.eks. `MyNFT.sol`) i din `contracts`-mappe.
// 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 funktioner er overskrivninger, der kræves af Solidity.

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

import "@openzeppelin/contracts/utils/Strings.sol";
  1. Kompilér Smart Contracten: Brug Truffle eller Hardhat til at kompilere din smart contract.
# Truffle
truffle compile

# Hardhat
npx hardhat compile
  1. Opret et Deployment Script: Opret en ny JavaScript-fil (f.eks. `deploy.js`) i din `migrations`- eller `scripts`-mappe.
// Eksempel på Truffle Migration
const MyNFT = artifacts.require("MyNFT");

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

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

  await myNFT.deployed();

  console.log("MyNFT deployet til:", myNFT.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
  1. Deploy Smart Contracten: Deploy din smart contract til en lokal blockchain (f.eks. Ganache) eller et testnetværk (f.eks. Ropsten, Rinkeby).
# Truffle
truffle migrate

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

Husk at erstatte `ipfs://YOUR_IPFS_CID/` med dit faktiske IPFS CID (Content Identifier). Denne basis-URI peger på den placering, hvor dine NFT-metadata JSON-filer vil blive gemt.

Opbevaring af NFT Metadata på IPFS

NFT-metadata opbevares typisk off-chain for at reducere omkostningerne ved at lagre data på blockchainen. IPFS (InterPlanetary File System) er et decentraliseret lagringsnetværk, der almindeligvis bruges til at opbevare NFT-metadata. Hver NFT har en `tokenURI`, som peger på en JSON-fil på IPFS, der indeholder metadata om NFT'en, såsom dens navn, beskrivelse, billed-URL og andre attributter.

Eksempel på NFT Metadata (JSON):

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

Erstat `ipfs://YOUR_IPFS_CID/image.png` med det faktiske IPFS CID for dit billede.

Trin til at Uploade Metadata til IPFS:

  1. Vælg en IPFS-klient: Vælg en IPFS-klient såsom IPFS Desktop, Pinata eller NFT.Storage.
  2. Upload dine Metadata: Upload dine NFT-metadata JSON-filer og billeder til IPFS ved hjælp af din valgte klient.
  3. Få IPFS CID: Efter upload af dine metadata vil du modtage et IPFS CID. Dette er en unik identifikator for dine data på IPFS.
  4. Opdater Smart Contracten: Opdater `tokenURI`-funktionen i din smart contract, så den peger på dit IPFS CID.

Sikkerhedsovervejelser for ERC-721 Smart Contracts

Sikkerhed er altafgørende, når man udvikler ERC-721 smart contracts. Her er nogle kritiske sikkerhedsovervejelser:

Anvendelser af ERC-721 NFT'er i den Virkelige Verden

ERC-721 NFT'er bruges i en lang række applikationer, herunder:

Internationale Eksempler:

Avancerede ERC-721 Koncepter

ERC-721A

ERC-721A er en mere gas-effektiv implementering af ERC-721-standarden, der optimerer minting af flere NFT'er i en enkelt transaktion. Den reducerer gasomkostningerne ved at afskrive lageromkostningerne over flere tokens. Dette kan være fordelagtigt for projekter, der involverer minting af store antal NFT'er.

Lazy Minting

Lazy minting er en teknik, hvor NFT'er først mintes, når de bliver købt. Dette kan spare gasomkostninger for projekter, der har et stort antal NFT'er, men ikke forventer, at alle bliver solgt. NFT-metadata gemmes off-chain, indtil NFT'en købes, hvorefter tokenet mintes, og metadataene tilføjes til blockchainen.

Soulbound Tokens

Soulbound tokens er NFT'er, der er permanent bundet til en specifik adresse og ikke kan overføres. Disse tokens kan bruges til at repræsentere ikke-overførbare legitimationsoplysninger, såsom uddannelsesgrader, faglige certificeringer eller medlemskab i et fællesskab. Dette muliggøres ved at fjerne eller begrænse `transferFrom`-funktionen.

Fremtiden for ERC-721 og NFT'er

ERC-721-standarden fortsætter med at udvikle sig, med løbende forskning og udvikling fokuseret på at forbedre dens effektivitet, sikkerhed og funktionalitet. Fremtidige udviklinger kan omfatte:

Konklusion

ERC-721 smart contracts er et kraftfuldt værktøj til at repræsentere ejerskab af unikke digitale og fysiske aktiver på blockchainen. Ved at forstå arkitekturen, implementeringsdetaljerne, sikkerhedsovervejelserne og de praktiske anvendelser af ERC-721 kan udviklere bygge innovative og virkningsfulde NFT-projekter. Mens NFT-økosystemet fortsætter med at vokse og udvikle sig, vil ERC-721-standarden spille en afgørende rolle i at forme fremtiden for digitalt ejerskab.

Denne guide giver et solidt grundlag for at forstå og implementere ERC-721 smart contracts. Husk altid at prioritere sikkerhed og følge bedste praksis, når du udvikler og deployer dine egne NFT-projekter. Held og lykke!