M

MLOG

Svenska

Utforska komplexiteten i ERC-721 smarta kontrakt för NFT:er. Lär dig om deras arkitektur, implementering, säkerhetsaspekter och verkliga tillämpningar.

NFT smarta kontrakt: En djupdykning i ERC-721-implementering

Icke-fungibla tokens (NFT:er) har revolutionerat landskapet för digitala tillgångar och möjliggjort representationen av unika föremål på blockkedjan. Kärnan i de flesta NFT:er är ERC-721-standarden, en uppsättning regler som styr hur dessa tokens skapas, hanteras och överförs. Denna omfattande guide ger en djupgående utforskning av ERC-721 smarta kontrakt, och täcker deras arkitektur, implementeringsdetaljer, säkerhetsaspekter och praktiska tillämpningar.

Vad är ERC-721?

ERC-721 är en standard för att representera icke-fungibla tokens på Ethereum-blockkedjan. Till skillnad från ERC-20-tokens, som är fungibla (vilket innebär att varje token är identisk med alla andra), är ERC-721-tokens unika. Varje token har ett distinkt ID, vilket gör den lämplig för att representera ägande av unika digitala eller fysiska tillgångar.

Nyckelegenskaper för ERC-721-tokens:

Arkitektur för ERC-721 smarta kontrakt

Ett ERC-721 smart kontrakt är ett Solidity-program som implementerar ERC-721-standarden. Det innehåller vanligtvis följande komponenter:

Kärnfunktioner:

Metadata-tillägg (valfritt):

Uppräkningstillägg (valfritt):

Implementera ett ERC-721 smart kontrakt med OpenZeppelin

OpenZeppelin tillhandahåller ett säkert och granskat bibliotek av smarta kontrakt som förenklar utvecklingen av ERC-721-tokens. Att använda OpenZeppelins ERC721-implementering minskar risken för att introducera sårbarheter i din kod. Här är ett exempel på hur man implementerar ett ERC-721 smart kontrakt med OpenZeppelin:

Förutsättningar:

Steg:

  1. Initiera ett 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. Installera OpenZeppelin Contracts:
npm install @openzeppelin/contracts
  1. Skapa ett ERC-721 smart kontrakt: Skapa en ny Solidity-fil (t.ex. `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öljande funktioner är åsidosättningar som krävs 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. Kompilera det smarta kontraktet: Använd Truffle eller Hardhat för att kompilera ditt smarta kontrakt.
# Truffle
truffle compile

# Hardhat
npx hardhat compile
  1. Skapa ett driftsättningsskript: Skapa en ny JavaScript-fil (t.ex. `deploy.js`) i din `migrations`- eller `scripts`-katalog.
// Exempel på Truffle-migrering
const MyNFT = artifacts.require("MyNFT");

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

// Exempel på Hardhat-driftsättningsskript
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 deployed to:", myNFT.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
  1. Driftsätt det smarta kontraktet: Driftsätt ditt smarta kontrakt på en lokal blockkedja (t.ex. Ganache) eller ett testnätverk (t.ex. Ropsten, Rinkeby).
# Truffle
truffle migrate

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

Kom ihåg att ersätta `ipfs://YOUR_IPFS_CID/` med ditt faktiska IPFS CID (Content Identifier). Denna bas-URI pekar på platsen där dina NFT-metadata JSON-filer kommer att lagras.

Lagra NFT-metadata på IPFS

NFT-metadata lagras vanligtvis utanför kedjan (off-chain) för att minska kostnaden för att lagra data på blockkedjan. IPFS (InterPlanetary File System) är ett decentraliserat lagringsnätverk som ofta används för att lagra NFT-metadata. Varje NFT har en `tokenURI` som pekar på en JSON-fil på IPFS som innehåller metadata om NFT:n, såsom dess namn, beskrivning, bild-URL och andra attribut.

Exempel på NFT-metadata (JSON):

{
  "name": "Min Fantastiska NFT",
  "description": "Detta är en unik NFT.",
  "image": "ipfs://YOUR_IPFS_CID/image.png",
  "attributes": [
    {
      "trait_type": "Bakgrund",
      "value": "Blå"
    },
    {
      "trait_type": "Karaktär",
      "value": "Robot"
    }
  ]
}

Ersätt `ipfs://YOUR_IPFS_CID/image.png` med det faktiska IPFS CID för din bild.

Steg för att ladda upp metadata till IPFS:

  1. Välj en IPFS-klient: Välj en IPFS-klient som IPFS Desktop, Pinata eller NFT.Storage.
  2. Ladda upp din metadata: Ladda upp dina NFT-metadata JSON-filer och bilder till IPFS med din valda klient.
  3. Få IPFS CID: Efter att du har laddat upp din metadata kommer du att få ett IPFS CID. Detta är en unik identifierare för din data på IPFS.
  4. Uppdatera det smarta kontraktet: Uppdatera `tokenURI`-funktionen i ditt smarta kontrakt så att den pekar på ditt IPFS CID.

Säkerhetsaspekter för ERC-721 smarta kontrakt

Säkerhet är av yttersta vikt vid utveckling av ERC-721 smarta kontrakt. Här är några kritiska säkerhetsaspekter:

Verkliga tillämpningar av ERC-721 NFT:er

ERC-721 NFT:er används i ett brett spektrum av tillämpningar, inklusive:

Internationella exempel:

Avancerade ERC-721-koncept

ERC-721A

ERC-721A är en mer gaseffektiv implementering av ERC-721-standarden som optimerar skapandet (minting) av flera NFT:er i en enda transaktion. Den minskar gaskostnaderna genom att amortera lagringskostnaderna över flera tokens. Detta kan vara fördelaktigt för projekt som involverar skapandet av ett stort antal NFT:er.

Lazy Minting (Lat skapande)

Lazy minting (lat skapande) är en teknik där NFT:er endast skapas (mintas) när de köps. Detta kan spara gaskostnader för projekt som har ett stort antal NFT:er men inte förväntar sig att alla kommer att säljas. NFT-metadatan lagras utanför kedjan tills NFT:n köps, då token skapas och metadatan läggs till på blockkedjan.

Soulbound Tokens (Själsbundna tokens)

Soulbound tokens är NFT:er som är permanent knutna till en specifik adress och inte kan överföras. Dessa tokens kan användas för att representera icke-överförbara meriter, såsom examensbevis, yrkescertifieringar eller medlemskap i en gemenskap. Detta möjliggörs genom att ta bort eller begränsa `transferFrom`-funktionen.

Framtiden för ERC-721 och NFT:er

ERC-721-standarden fortsätter att utvecklas, med pågående forskning och utveckling fokuserad på att förbättra dess effektivitet, säkerhet och funktionalitet. Framtida utvecklingar kan inkludera:

Slutsats

ERC-721 smarta kontrakt är ett kraftfullt verktyg för att representera ägande av unika digitala och fysiska tillgångar på blockkedjan. Genom att förstå arkitekturen, implementeringsdetaljerna, säkerhetsaspekterna och de praktiska tillämpningarna av ERC-721 kan utvecklare bygga innovativa och slagkraftiga NFT-projekt. I takt med att NFT-ekosystemet fortsätter att växa och utvecklas kommer ERC-721-standarden att spela en avgörande roll i att forma framtiden för digitalt ägande.

Denna guide ger en solid grund för att förstå och implementera ERC-721 smarta kontrakt. Kom ihåg att alltid prioritera säkerhet och följa bästa praxis när du utvecklar och driftsätter dina egna NFT-projekt. Lycka till!