M

MLOG

Magyar

Fedezze fel az NFT-khez használt ERC-721 okosszerződések bonyolultságát. Ismerje meg architektúrájukat, implementációjukat, biztonsági szempontjaikat és valós alkalmazásaikat.

NFT Okosszerződések: Az ERC-721 Implementáció Részletes Áttekintése

A Nem Helyettesíthető Tokenek (NFT-k) forradalmasították a digitális eszközök világát, lehetővé téve egyedi tárgyak reprezentálását a blokkláncon. A legtöbb NFT középpontjában az ERC-721 szabvány áll, egy szabályrendszer, amely meghatározza, hogyan hozzák létre, kezelik és ruházzák át ezeket a tokeneket. Ez az átfogó útmutató mélyrehatóan vizsgálja az ERC-721 okosszerződéseket, kitérve azok architektúrájára, implementációs részleteire, biztonsági megfontolásaira és gyakorlati alkalmazásaira.

Mi az ERC-721?

Az ERC-721 egy szabvány a nem helyettesíthető tokenek reprezentálására az Ethereum blokkláncon. Ellentétben az ERC-20 tokenekkel, amelyek helyettesíthetők (vagyis minden token azonos minden más tokennel), az ERC-721 tokenek egyediek. Minden tokennek külön azonosítója van, ami alkalmassá teszi őket egyedi digitális vagy fizikai eszközök tulajdonjogának képviseletére.

Az ERC-721 tokenek főbb jellemzői:

Az ERC-721 Okosszerződés Architektúrája

Egy ERC-721 okosszerződés egy Solidity program, amely megvalósítja az ERC-721 szabványt. Általában a következő komponenseket tartalmazza:

Alapvető Funkciók:

Metaadat Bővítmény (Opcionális):

Felsorolás Bővítmény (Opcionális):

ERC-721 Okosszerződés Implementálása az OpenZeppelin Segítségével

Az OpenZeppelin biztonságos és auditált okosszerződés-könyvtárat biztosít, amely leegyszerűsíti az ERC-721 tokenek fejlesztését. Az OpenZeppelin ERC721 implementációjának használata csökkenti a sebezhetőségek bevezetésének kockázatát a kódba. Íme egy példa, hogyan implementáljunk egy ERC-721 okosszerződést az OpenZeppelin segítségével:

Előfeltételek:

Lépések:

  1. Truffle vagy Hardhat projekt inicializálása:
# Truffle
mkdir my-nft-project
cd my-nft-project
truffle init

# Hardhat
mkdir my-nft-project
cd my-nft-project
npx hardhat
  1. OpenZeppelin Contracts telepítése:
npm install @openzeppelin/contracts
  1. ERC-721 Okosszerződés létrehozása: Hozzon létre egy új Solidity fájlt (pl. `MyNFT.sol`) a `contracts` könyvtárban.
// 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;
    }



    // The following functions are overrides required by Solidity.

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

import "@openzeppelin/contracts/utils/Strings.sol";
  1. Az okosszerződés fordítása: Használja a Truffle-t vagy a Hardhat-et az okosszerződés lefordításához.
# Truffle
truffle compile

# Hardhat
npx hardhat compile
  1. Telepítési szkript létrehozása: Hozzon létre egy új JavaScript fájlt (pl. `deploy.js`) a `migrations` vagy a `scripts` könyvtárban.
// Truffle Migration Example
const MyNFT = artifacts.require("MyNFT");

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

// Hardhat Deployment Script Example
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. Az okosszerződés telepítése: Telepítse az okosszerződést egy helyi blokkláncra (pl. Ganache) vagy egy teszthálózatra (pl. Ropsten, Rinkeby).
# Truffle
truffle migrate

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

Ne felejtse el kicserélni az `ipfs://YOUR_IPFS_CID/` részt a tényleges IPFS CID-jére (Content Identifier). Ez az alap URI arra a helyre mutat, ahol az NFT metaadat JSON fájljai tárolva lesznek.

NFT Metaadatok Tárolása az IPFS-en

Az NFT metaadatokat általában láncon kívül (off-chain) tárolják, hogy csökkentsék az adatok blokkláncon való tárolásának költségeit. Az IPFS (InterPlanetary File System) egy decentralizált tárolóhálózat, amelyet általában NFT metaadatok tárolására használnak. Minden NFT-nek van egy `tokenURI`-ja, amely egy IPFS-en lévő JSON fájlra mutat, amely tartalmazza az NFT metaadatait, például a nevét, leírását, képének URL-jét és egyéb tulajdonságait.

Példa NFT Metaadatra (JSON):

{
  "name": "My Awesome NFT",
  "description": "This is a unique NFT.",
  "image": "ipfs://YOUR_IPFS_CID/image.png",
  "attributes": [
    {
      "trait_type": "Background",
      "value": "Blue"
    },
    {
      "trait_type": "Character",
      "value": "Robot"
    }
  ]
}

Cserélje ki az `ipfs://YOUR_IPFS_CID/image.png` részt a kép tényleges IPFS CID-jére.

Lépések a Metaadatok IPFS-re Történő Feltöltéséhez:

  1. Válasszon egy IPFS klienst: Válasszon egy IPFS klienst, mint például az IPFS Desktop, Pinata vagy NFT.Storage.
  2. Töltse fel a metaadatokat: Töltse fel az NFT metaadat JSON fájljait és képeit az IPFS-re a kiválasztott kliens segítségével.
  3. Szerezze meg az IPFS CID-t: A metaadatok feltöltése után kap egy IPFS CID-t. Ez egy egyedi azonosító az adataihoz az IPFS-en.
  4. Frissítse az okosszerződést: Frissítse a `tokenURI` funkciót az okosszerződésben, hogy az IPFS CID-jére mutasson.

Biztonsági Megfontolások az ERC-721 Okosszerződéseknél

A biztonság rendkívül fontos az ERC-721 okosszerződések fejlesztésekor. Íme néhány kritikus biztonsági megfontolás:

Az ERC-721 NFT-k Valós Világbeli Alkalmazásai

Az ERC-721 NFT-ket számos alkalmazásban használják, többek között:

Nemzetközi Példák:

Haladó ERC-721 Koncepciók

ERC-721A

Az ERC-721A az ERC-721 szabvány egy gázhatékonyabb implementációja, amely optimalizálja több NFT egyetlen tranzakcióban történő létrehozását. Csökkenti a gázköltségeket azáltal, hogy a tárolási költségeket több token között amortizálja. Ez előnyös lehet olyan projektek számára, amelyek nagyszámú NFT létrehozásával járnak.

Lazy Minting (Lusta létrehozás)

A lusta létrehozás egy olyan technika, ahol az NFT-ket csak akkor hozzák létre, amikor megvásárolják őket. Ez gázköltségeket takaríthat meg olyan projektek számára, amelyek nagyszámú NFT-vel rendelkeznek, de nem számítanak arra, hogy mindegyiket eladják. Az NFT metaadatait láncon kívül tárolják, amíg az NFT-t meg nem vásárolják, ekkor a tokent létrehozzák, és a metaadatokat hozzáadják a blokklánchoz.

Soulbound Tokenek (Lélekhez kötött tokenek)

A lélekhez kötött tokenek olyan NFT-k, amelyek véglegesen egy adott címhez vannak kötve és nem ruházhatók át. Ezeket a tokeneket nem átruházható hitelesítő adatok, például oktatási végzettségek, szakmai tanúsítványok vagy egy közösségben való tagság képviseletére lehet használni. Ezt a `transferFrom` funkció eltávolításával vagy korlátozásával teszik lehetővé.

Az ERC-721 és az NFT-k Jövője

Az ERC-721 szabvány folyamatosan fejlődik, a folyamatban lévő kutatások és fejlesztések a hatékonyság, a biztonság és a funkcionalitás javítására összpontosítanak. A jövőbeli fejlesztések magukban foglalhatják:

Következtetés

Az ERC-721 okosszerződések hatékony eszközt jelentenek az egyedi digitális és fizikai eszközök tulajdonjogának képviseletére a blokkláncon. Az ERC-721 architektúrájának, implementációs részleteinek, biztonsági megfontolásainak és gyakorlati alkalmazásainak megértésével a fejlesztők innovatív és hatásos NFT projekteket hozhatnak létre. Ahogy az NFT ökoszisztéma tovább növekszik és fejlődik, az ERC-721 szabvány kritikus szerepet fog játszani a digitális tulajdonjog jövőjének alakításában.

Ez az útmutató szilárd alapot nyújt az ERC-721 okosszerződések megértéséhez és implementálásához. Ne feledje, hogy mindig a biztonságot helyezze előtérbe, és kövesse a legjobb gyakorlatokat saját NFT projektjeinek fejlesztése és telepítése során. Sok sikert!