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:

• Icke-fungibel: Varje token är unik och skiljer sig från andra.
• Unik identifiering: Varje token har ett unikt ID.
• Ägarskapsspårning: Standarden spårar ägarskapet för varje token.
• Överförbarhet: Tokens kan överföras från ett konto till ett annat.
• Metadata: Tokens kan kopplas till metadata, vilket ger ytterligare information om tillgången de representerar.

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:

• balanceOf(address _owner): Returnerar antalet tokens som ägs av en viss adress.
• ownerOf(uint256 _tokenId): Returnerar adressen till ägaren av en specifik token.
• transferFrom(address _from, address _to, uint256 _tokenId): Överför äganderätten för en token från en adress till en annan. Kräver godkännande om den inte initieras av ägaren.
• approve(address _approved, uint256 _tokenId): Godkänner en annan adress att överföra äganderätten för en specifik token.
• getApproved(uint256 _tokenId): Returnerar den adress som är godkänd att överföra äganderätten för en specifik token.
• setApprovalForAll(address _operator, bool _approved): Aktiverar eller inaktiverar en operatör för att hantera alla tokens som ägs av anroparen.
• isApprovedForAll(address _owner, address _operator): Kontrollerar om en operatör är godkänd att hantera alla tokens som ägs av en adress.

Metadata-tillägg (valfritt):

• name(): Returnerar namnet på token-samlingen.
• symbol(): Returnerar symbolen för token-samlingen.
• tokenURI(uint256 _tokenId): Returnerar en URI som pekar på en JSON-fil med metadata om en specifik token. Denna URI pekar vanligtvis på en InterPlanetary File System (IPFS)-adress.

Uppräkningstillägg (valfritt):

• totalSupply(): Returnerar det totala antalet befintliga tokens.
• tokenByIndex(uint256 _index): Returnerar token-ID:t vid ett givet index för alla tokens som lagras av kontraktet.
• tokenOfOwnerByIndex(address _owner, uint256 _index): Returnerar token-ID:t vid ett givet index som ägs av en specifik adress.

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:

• Node.js och npm: Se till att du har Node.js och npm installerat.
• Truffle eller Hardhat: Välj en utvecklingsmiljö (t.ex. Truffle eller Hardhat) för att kompilera och driftsätta ditt smarta kontrakt.
• Ganache: Installera Ganache, en personlig blockkedja för Ethereum-utveckling.

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
            

              
                Copy
              
            
          

2. Installera OpenZeppelin Contracts:

            npm install @openzeppelin/contracts
            

              
                Copy
              
            
          

3. 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";
            

              
                Copy
              
            
          

4. Kompilera det smarta kontraktet: Använd Truffle eller Hardhat för att kompilera ditt smarta kontrakt.

            # Truffle
truffle compile

# Hardhat
npx hardhat compile
            

              
                Copy
              
            
          

5. 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);
  });

            

              
                Copy
              
            
          

6. 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
            

              
                Copy
              
            
          

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

              
                Copy
              
            
          

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:

• Återinträdesattacker (Reentrancy Attacks): Förhindra återinträdesattacker genom att använda mönstret Checks-Effects-Interactions. Detta innebär att man utför kontroller innan några tillståndsändringar görs, sedan tillämpar tillståndsändringarna och slutligen interagerar med externa kontrakt. OpenZeppelins `ReentrancyGuard`-kontrakt kan hjälpa till att minska denna sårbarhet.
• Heltalsöverflöde/underflöde (Integer Overflow/Underflow): Använd Solidity-versioner >= 0.8.0, som har inbyggda kontroller för överflöde/underflöde. Om du använder äldre versioner, använd OpenZeppelins `SafeMath`-bibliotek.
• Åtkomstkontroll: Implementera korrekta åtkomstkontrollmekanismer för att begränsa vem som kan skapa (minta), bränna eller modifiera tokens. Använd OpenZeppelins `Ownable`- eller `AccessControl`-kontrakt för att hantera ägande och behörigheter.
• Tjänstnekringsattacker (Denial of Service - DoS): Var medveten om potentiella DoS-sårbarheter, såsom problem med gasgränser. Optimera din kod för att minska gasförbrukningen och undvik operationer som potentiellt kan blockera kontraktet.
• Front running: Implementera åtgärder för att förhindra front running, som att använda commit-reveal-scheman eller order-matchning utanför kedjan.
• Datavalidering: Validera all användarinmatning för att förhindra oväntat beteende eller säkerhetsöverträdelser.
• Regelbundna granskningar: Genomför regelbundna säkerhetsgranskningar av välrenommerade säkerhetsföretag för att identifiera och åtgärda potentiella sårbarheter.

Verkliga tillämpningar av ERC-721 NFT:er

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

• Digital konst: Representerar ägande av unika digitala konstverk. Plattformar som SuperRare, Foundation och Nifty Gateway underlättar köp och försäljning av NFT-konst.
• Samlarobjekt: Skapande av digitala samlarobjekt, såsom samlarkort, virtuella husdjur och andra föremål. CryptoPunks och Bored Ape Yacht Club är exempel på framgångsrika NFT-samlarprojekt.
• Spel: Representerar föremål i spel, såsom vapen, karaktärer och land. Axie Infinity och Decentraland är exempel på blockkedjespel som använder NFT:er.
• Fastigheter: Tokenisering av äganderätt till fastigheter. Detta möjliggör fraktionerat ägande och enklare överföring av äganderätter.
• Hantering av leveranskedjor: Spårning av produkters ursprung och äkthet i leveranskedjan. Detta kan hjälpa till att förhindra förfalskning och säkerställa produktkvalitet.
• Biljettsystem: Utfärdande av biljetter till evenemang, konserter och andra aktiviteter. NFT:er kan hjälpa till att förhindra biljettbedrägerier och erbjuda ett säkrare och mer transparent biljettsystem.
• Identitetshantering: Representerar digitala identiteter och meriter. Detta kan hjälpa individer att kontrollera sina personuppgifter och förhindra identitetsstöld.

Internationella exempel:

• Digital konst: Konstnärer från hela världen använder NFT-plattformar för att sälja sina digitala konstverk, inklusive verk inspirerade av japansk anime, afrikansk stamkonst och europeiska klassiska målningar.
• Spel: Blockkedjespel som Axie Infinity har blivit populära i Sydostasien, där spelare tjänar inkomster genom att spela spelet och handla med NFT:er.
• Fastigheter: Företag i USA, Europa och Asien utforskar användningen av NFT:er för att tokenisera fastigheter och underlätta fraktionerat ägande.

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:

• Förbättrade metadatastandarder: Mer standardiserade och interoperabla metadataformat för att förbättra upptäckbarheten och användbarheten av NFT:er.
• Interoperabilitet mellan kedjor (Cross-Chain): Lösningar som gör det möjligt för NFT:er att överföras och användas över olika blockkedjenätverk.
• Förbättrade säkerhetsåtgärder: Nya säkerhetsprotokoll och verktyg för att skydda mot sårbarheter och attacker.
• Integration med verkliga tillgångar: Bredare användning av NFT:er för att representera ägande av fysiska tillgångar, såsom fastigheter, samlarobjekt och immateriella rättigheter.

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!