Jak napisać i wdrożyć NFT (Część 1/3 serii samouczków NFT)

ERC-721

Alchemy

Solidity

smart kontrakty

Początkujący

Sumi Mudgil

22 kwietnia 2021

12 minuta czytania

Ponieważ NFT przyciągają uwagę opinii publicznej do blockchaina, jest to doskonała okazja, aby samemu zrozumieć ten szum, publikując własny kontrakt NFT (token ERC-721) na blockchainie Ethereum!

Alchemy jest niezwykle dumne z zasilania największych nazwisk w przestrzeni NFT, w tym Makersplace (które niedawno ustanowiło rekordową sprzedaż cyfrowego dzieła sztuki w Christie's za 69 milionów dolarów), Dapper Labs (twórców NBA Top Shot i Crypto Kitties), OpenSea (największy na świecie rynek NFT), Zora, Super Rare, NFTfi, Foundation, Enjin, Origin Protocol, Immutable i wiele innych.

W tym samouczku przeprowadzimy Cię przez proces tworzenia i wdrażania inteligentnego kontraktu ERC-721 w sieci testowej Sepolia przy użyciu MetaMask (opens in a new tab), Solidity (opens in a new tab), Hardhat (opens in a new tab), Pinata (opens in a new tab) i Alchemy (opens in a new tab) (nie martw się, jeśli jeszcze nie rozumiesz, co to wszystko oznacza — wyjaśnimy to!).

W części 2 tego samouczka omówimy, jak możemy użyć naszego inteligentnego kontraktu do wybicia NFT, a w części 3 wyjaśnimy, jak wyświetlić swoje NFT w MetaMask.

I oczywiście, jeśli masz w dowolnym momencie pytania, nie wahaj się skontaktować z nami na Discordzie Alchemy (opens in a new tab) lub odwiedzić dokumentację API NFT firmy Alchemy (opens in a new tab)!

Krok 1: Połącz się z siecią Ethereum

Istnieje wiele sposobów na wysyłanie żądań do blockchaina Ethereum, ale dla ułatwienia użyjemy darmowego konta w Alchemy (opens in a new tab), platformie deweloperskiej blockchain i API, które pozwalają nam komunikować się z łańcuchem Ethereum bez konieczności uruchamiania własnych węzłów.

W tym samouczku skorzystamy również z narzędzi deweloperskich Alchemy do monitorowania i analityki, aby zrozumieć, co dzieje się „pod maską” podczas wdrażania naszego inteligentnego kontraktu. Jeśli nie masz jeszcze konta Alchemy, możesz zarejestrować się za darmo tutaj (opens in a new tab).

Krok 2: Stwórz swoją aplikację (i klucz API)

Po utworzeniu konta Alchemy możesz wygenerować klucz API, tworząc aplikację. Pozwoli nam to na wysyłanie żądań do sieci testowej Sepolia. Sprawdź ten przewodnik (opens in a new tab), jeśli chcesz dowiedzieć się więcej o sieciach testowych.

Przejdź do strony „Utwórz aplikację” w panelu Alchemy, najeżdżając kursorem na „Aplikacje” na pasku nawigacyjnym i klikając „Utwórz aplikację”.

Nazwij swoją aplikację (my wybraliśmy „Mój pierwszy NFT!”), dodaj krótki opis, wybierz „Ethereum” jako łańcuch i „Sepolia” jako sieć. Od czasu The Merge pozostałe sieci testowe zostały wycofane.

Kliknij „Utwórz aplikację” i to wszystko! Twoja aplikacja powinna pojawić się w poniższej tabeli.

Krok 3: Utwórz konto Ethereum (adres)

Potrzebujemy konta Ethereum do wysyłania i odbierania transakcji. W tym samouczku użyjemy MetaMask, wirtualnego portfela w przeglądarce, który służy do zarządzania adresem konta Ethereum. Jeśli chcesz dowiedzieć się więcej o tym, jak działają transakcje w Ethereum, sprawdź tę stronę od Ethereum Foundation.

Możesz pobrać i utworzyć konto MetaMask za darmo tutaj (opens in a new tab). Podczas tworzenia konta lub jeśli już je masz, pamiętaj o przełączeniu się na „Sieć testową Sepolia” w prawym górnym rogu (abyśmy nie operowali prawdziwymi pieniędzmi).

Krok 4: Dodaj ether z Faucet

Aby wdrożyć nasz inteligentny kontrakt w sieci testowej, będziemy potrzebować trochę fałszywego ETH. Aby zdobyć ETH, możesz przejść do Sepolia Faucet (opens in a new tab) hostowanego przez Alchemy, zalogować się i wpisać adres swojego konta, a następnie kliknąć „Wyślij mi ETH”. Wkrótce powinieneś zobaczyć ETH na swoim koncie MetaMask!

Krok 5: Sprawdź swoje saldo

Aby upewnić się, że nasze saldo jest prawidłowe, wykonajmy żądanie eth_getBalance (opens in a new tab) za pomocą narzędzia kompozytora Alchemy (opens in a new tab). Zwróci to ilość ETH w naszym portfelu. Po wprowadzeniu adresu konta MetaMask i kliknięciu „Wyślij żądanie” powinieneś zobaczyć następującą odpowiedź:

1`{"jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000"}`

Uwaga Ten wynik jest w wei, a nie w ETH. Wei jest używany jako najmniejsza jednostka etheru. Przelicznik z wei na ETH to 1 eth = 10¹⁸ wei. Więc jeśli przekonwertujemy 0xde0b6b3a7640000 na liczbę dziesiętną, otrzymamy 1*10¹⁸ wei, co równa się 1 ETH.

Uff! Wszystkie nasze fałszywe pieniądze są na miejscu.

Krok 6: Zainicjuj nasz projekt

Najpierw musimy utworzyć folder dla naszego projektu. Przejdź do wiersza poleceń i wpisz:

1mkdir my-nft
2cd my-nft

Teraz, gdy jesteśmy w folderze projektu, użyjemy npm init, aby zainicjować projekt. Jeśli nie masz jeszcze zainstalowanego npm, postępuj zgodnie z tymi instrukcjami (opens in a new tab) (będziemy również potrzebować Node.js (opens in a new tab), więc pobierz go również!).

1npm init

Nie ma większego znaczenia, jak odpowiesz na pytania instalacyjne; dla odniesienia, oto jak my to zrobiliśmy:

1    package name: (my-nft)
2    version: (1.0.0)
3    description: Mój pierwszy NFT!
4    entry point: (index.js)
5    test command:
6    git repository:
7    keywords:
8    author:
9    license: (ISC)
10    About to write to /Users/thesuperb1/Desktop/my-nft/package.json:
11
12    {
13      "name": "my-nft",
14      "version": "1.0.0",
15      "description": "Mój pierwszy NFT!",
16      "main": "index.js",
17      "scripts": {
18        "test": "echo \"Error: no test specified\" && exit 1"
19      },
20      "author": "",
21      "license": "ISC"
22    }
Pokaż wszystko

Zatwierdź plik package.json i możemy zaczynać!

Krok 7: Zainstaluj Hardhat (opens in a new tab)

Hardhat to środowisko programistyczne do kompilacji, wdrażania, testowania i debugowania oprogramowania Ethereum. Pomaga deweloperom w tworzeniu inteligentnych kontraktów i dapek lokalnie przed wdrożeniem ich na żywym łańcuchu.

Wewnątrz naszego projektu my-nft uruchom:

1npm install --save-dev hardhat

Sprawdź tę stronę, aby uzyskać więcej szczegółów na temat instrukcji instalacji (opens in a new tab).

Krok 8: Utwórz projekt Hardhat

W folderze naszego projektu uruchom:

1npx hardhat

Powinieneś wtedy zobaczyć wiadomość powitalną i opcję wyboru tego, co chcesz zrobić. Wybierz „utwórz pusty hardhat.config.js”:

1888    888                      888 888               888
2888    888                      888 888               888
3888    888                      888 888               888
48888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
5888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
6888    888 .d888888 888    888  888 888  888 .d888888 888
7888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
8888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888
9👷 Welcome to Hardhat v2.0.11 👷‍
10? What do you want to do? …
11Create a sample project
12❯ Create an empty hardhat.config.js
13Quit
Pokaż wszystko

Spowoduje to wygenerowanie dla nas pliku hardhat.config.js, w którym określimy całą konfigurację naszego projektu (w kroku 13).

Krok 9: Dodaj foldery projektu

Aby utrzymać porządek w naszym projekcie, utworzymy dwa nowe foldery. Przejdź do katalogu głównego projektu w wierszu poleceń i wpisz:

1mkdir contracts
2mkdir scripts

contracts/ to miejsce, w którym będziemy przechowywać kod naszego inteligentnego kontraktu NFT
scripts/ to miejsce, w którym będziemy przechowywać skrypty do wdrażania i interakcji z naszym inteligentnym kontraktem

Krok 10: Napisz nasz kontrakt

Teraz, gdy nasze środowisko jest skonfigurowane, przejdźmy do bardziej ekscytujących rzeczy: pisania kodu naszego inteligentnego kontraktu!

Otwórz projekt my-nft w swoim ulubionym edytorze (my lubimy VSCode (opens in a new tab)). Inteligentne kontrakty są pisane w języku zwanym Solidity, którego użyjemy do napisania naszego inteligentnego kontraktu MyNFT.sol.‌

Przejdź do folderu contracts i utwórz nowy plik o nazwie MyNFT.sol

Poniżej znajduje się kod naszego inteligentnego kontraktu NFT, który oparliśmy na implementacji ERC-721 z biblioteki OpenZeppelin (opens in a new tab). Skopiuj i wklej poniższą zawartość do pliku MyNFT.sol.

1//Kontrakt oparty na [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
2// SPDX-License-Identifier: MIT
3pragma solidity ^0.8.0;
4
5import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
6import "@openzeppelin/contracts/utils/Counters.sol";
7import "@openzeppelin/contracts/access/Ownable.sol";
8import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
9
10contract MyNFT is ERC721URIStorage, Ownable {
11    using Counters for Counters.Counter;
12    Counters.Counter private _tokenIds;
13
14    constructor() ERC721("MyNFT", "NFT") {}
15
16    function mintNFT(address recipient, string memory tokenURI)
17        public onlyOwner
18        returns (uint256)
19    {
20        _tokenIds.increment();
21
22        uint256 newItemId = _tokenIds.current();
23        _mint(recipient, newItemId);
24        _setTokenURI(newItemId, tokenURI);
25
26        return newItemId;
27    }
28}
Pokaż wszystko

Ponieważ dziedziczymy klasy z biblioteki kontraktów OpenZeppelin, w wierszu poleceń uruchom npm install @openzeppelin/contracts^4.0.0, aby zainstalować bibliotekę w naszym folderze.

Więc co dokładnie robi ten kod? Przeanalizujmy go linijka po linijce.

Na początku naszego inteligentnego kontraktu importujemy trzy klasy inteligentnych kontraktów OpenZeppelin (opens in a new tab):

@openzeppelin/contracts/token/ERC721/ERC721.sol zawiera implementację standardu ERC-721, który odziedziczy nasz inteligentny kontrakt NFT. (Aby być prawidłowym NFT, twój inteligentny kontrakt musi implementować wszystkie metody standardu ERC-721). Aby dowiedzieć się więcej o odziedziczonych funkcjach ERC-721, sprawdź definicję interfejsu tutaj (opens in a new tab).
@openzeppelin/contracts/utils/Counters.sol dostarcza liczniki, które mogą być zwiększane lub zmniejszane tylko o jeden. Nasz inteligentny kontrakt używa licznika do śledzenia całkowitej liczby wybitych NFT i ustawiania unikalnego ID dla naszego nowego NFT. (Każdy NFT wybity przy użyciu inteligentnego kontraktu musi mieć przypisane unikalne ID — tutaj nasze unikalne ID jest po prostu określane przez całkowitą liczbę istniejących NFT. Na przykład, pierwszy NFT, który wybijemy za pomocą naszego inteligentnego kontraktu, ma ID „1”, nasz drugi NFT ma ID „2” itd.).
@openzeppelin/contracts/access/Ownable.sol konfiguruje kontrolę dostępu (opens in a new tab) w naszym inteligentnym kontrakcie, więc tylko właściciel inteligentnego kontraktu (Ty) może wybijać NFT. (Uwaga, włączenie kontroli dostępu jest całkowicie kwestią preferencji. Jeśli chcesz, aby każdy mógł wybić NFT za pomocą Twojego inteligentnego kontraktu, usuń słowo Ownable w linii 10 i onlyOwner w linii 17).

Po naszych instrukcjach importu mamy nasz niestandardowy inteligentny kontrakt NFT, który jest zaskakująco krótki — zawiera tylko licznik, konstruktor i jedną funkcję! Jest to zasługa odziedziczonych kontraktów OpenZeppelin, które implementują większość metod potrzebnych do stworzenia NFT, takich jak ownerOf, która zwraca właściciela NFT, oraz transferFrom, która przenosi własność NFT z jednego konta na drugie.

W naszym konstruktorze ERC-721 zauważysz, że przekazujemy 2 ciągi znaków, „MyNFT” i „NFT”. Pierwsza zmienna to nazwa inteligentnego kontraktu, a druga to jego symbol. Możesz nazwać każdą z tych zmiennych, jak tylko chcesz!

Wreszcie, mamy naszą funkcję mintNFT(address recipient, string memory tokenURI), która pozwala nam wybić NFT! Zauważysz, że ta funkcja przyjmuje dwie zmienne:

address recipient określa adres, który otrzyma Twój świeżo wybity NFT
string memory tokenURI to ciąg znaków, który powinien wskazywać na dokument JSON opisujący metadane NFT. Metadane NFT to to, co naprawdę ożywia go, pozwalając na konfigurowalne właściwości, takie jak nazwa, opis, obraz i inne atrybuty. W części 2 tego samouczka opiszemy, jak skonfigurować te metadane.

mintNFT wywołuje niektóre metody z odziedziczonej biblioteki ERC-721 i ostatecznie zwraca liczbę reprezentującą ID świeżo wybitego NFT.

Krok 11: Połącz MetaMask i Alchemy z Twoim projektem

Teraz, gdy utworzyliśmy portfel MetaMask, konto Alchemy i napisaliśmy nasz inteligentny kontrakt, nadszedł czas, aby połączyć te trzy elementy.

Każda transakcja wysłana z Twojego wirtualnego portfela wymaga podpisu przy użyciu Twojego unikalnego klucza prywatnego. Aby udzielić naszemu programowi tego uprawnienia, możemy bezpiecznie przechowywać nasz klucz prywatny (i klucz API Alchemy) w pliku środowiskowym.

Aby dowiedzieć się więcej o wysyłaniu transakcji, sprawdź ten samouczek o wysyłaniu transakcji przy użyciu web3.

Najpierw zainstaluj pakiet dotenv w katalogu swojego projektu:

1npm install dotenv --save

Następnie utwórz plik .env w katalogu głównym naszego projektu i dodaj do niego swój klucz prywatny MetaMask oraz adres URL HTTP API Alchemy.

Postępuj zgodnie z tymi instrukcjami (opens in a new tab), aby wyeksportować swój klucz prywatny z MetaMask
Zobacz poniżej, jak uzyskać adres URL HTTP API Alchemy i skopiować go do schowka

Twój plik .env powinien teraz wyglądać tak:

1API_URL="https://eth-sepolia.g.alchemy.com/v2/twój-klucz-api"
2PRIVATE_KEY="twój-prywatny-klucz-metamask"

Aby faktycznie połączyć je z naszym kodem, odwołamy się do tych zmiennych w naszym pliku hardhat.config.js w kroku 13.

Nie udostępniaj pliku .env! Upewnij się, że nigdy nie udostępniasz ani nie ujawniasz nikomu swojego pliku .env, ponieważ narażasz w ten sposób swoje sekrety. Jeśli korzystasz z kontroli wersji, dodaj swój plik .env do pliku gitignore.

Krok 12: Zainstaluj Ethers.js

Ethers.js to biblioteka, która ułatwia interakcję i wysyłanie żądań do Ethereum, opakowując standardowe metody JSON-RPC w bardziej przyjazne dla użytkownika metody.

Hardhat bardzo ułatwia integrację wtyczek (opens in a new tab) w celu uzyskania dodatkowych narzędzi i rozszerzonej funkcjonalności. Skorzystamy z wtyczki Ethers (opens in a new tab) do wdrażania kontraktów (Ethers.js (opens in a new tab) ma kilka bardzo przejrzystych metod wdrażania kontraktów).

W katalogu projektu wpisz:

1npm install --save-dev @nomiclabs/hardhat-ethers ethers@^5.0.0

Będziemy również wymagać ethers w naszym pliku hardhat.config.js w następnym kroku.

Krok 13: Zaktualizuj hardhat.config.js

Do tej pory dodaliśmy kilka zależności i wtyczek, teraz musimy zaktualizować hardhat.config.js, aby nasz projekt o nich wszystkich wiedział.

Zaktualizuj swój plik hardhat.config.js, aby wyglądał następująco:

1    /**
2    * @type import('hardhat/config').HardhatUserConfig
3    */
4    require('dotenv').config();
5    require("@nomiclabs/hardhat-ethers");
6    const { API_URL, PRIVATE_KEY } = process.env;
7    module.exports = {
8       solidity: "0.8.1",
9       defaultNetwork: "sepolia",
10       networks: {
11          hardhat: {},
12          sepolia: {
13             url: API_URL,
14             accounts: [`0x${PRIVATE_KEY}`]
15          }
16       },
17    }
Pokaż wszystko

Krok 14: Skompiluj nasz kontrakt

Aby upewnić się, że wszystko do tej pory działa, skompilujmy nasz kontrakt. Zadanie kompilacji jest jednym z wbudowanych zadań Hardhat.

Z wiersza poleceń uruchom:

1npx hardhat compile

Możesz otrzymać ostrzeżenie o SPDX license identifier not provided in source file, ale nie musisz się tym martwić — miejmy nadzieję, że wszystko inne wygląda dobrze! Jeśli nie, zawsze możesz napisać wiadomość na discordzie Alchemy (opens in a new tab).

Krok 15: Napisz nasz skrypt wdrożeniowy

Teraz, gdy nasz kontrakt jest napisany, a nasz plik konfiguracyjny jest gotowy, nadszedł czas, aby napisać nasz skrypt wdrażający kontrakt.

Przejdź do folderu scripts/ i utwórz nowy plik o nazwie deploy.js, dodając do niego następującą zawartość:

1async function main() {
2  const MyNFT = await ethers.getContractFactory("MyNFT")
3
4  // Rozpocznij wdrożenie, zwracając obietnicę, która rozwiązuje się do obiektu kontraktu
5  const myNFT = await MyNFT.deploy()
6  await myNFT.deployed()
7  console.log("Kontrakt wdrożony pod adresem:", myNFT.address)
8}
9
10main()
11  .then(() => process.exit(0))
12  .catch((error) => {
13    console.error(error)
14    process.exit(1)
15  })
Pokaż wszystko

Hardhat wykonuje niesamowitą robotę, wyjaśniając, co robi każda z tych linii kodu w swoim samouczku dotyczącym kontraktów (opens in a new tab), a my przyjęliśmy ich wyjaśnienia tutaj.

1const MyNFT = await ethers.getContractFactory("MyNFT");

ContractFactory w ethers.js to abstrakcja używana do wdrażania nowych inteligentnych kontraktów, więc MyNFT jest tutaj fabryką dla instancji naszego kontraktu NFT. Podczas korzystania z wtyczki hardhat-ethers, instancje ContractFactory i Contract są domyślnie połączone z pierwszym sygnatariuszem.

1const myNFT = await MyNFT.deploy();

Wywołanie deploy() na ContractFactory rozpocznie wdrożenie i zwróci Promise, który rozwiązuje się do obiektu Contract. Jest to obiekt, który ma metodę dla każdej z naszych funkcji inteligentnego kontraktu.

Krok 16: Wdróż nasz kontrakt

Jesteśmy wreszcie gotowi do wdrożenia naszego inteligentnego kontraktu! Wróć do katalogu głównego swojego projektu i w wierszu poleceń uruchom:

1npx hardhat --network sepolia run scripts/deploy.js

Powinieneś wtedy zobaczyć coś takiego:

1Kontrakt wdrożony pod adresem: 0x4C5266cCc4b3F426965d2f51b6D910325a0E7650

Jeśli przejdziemy na Etherscan Sepolia (opens in a new tab) i wyszukamy adres naszego kontraktu, powinniśmy zobaczyć, że został on pomyślnie wdrożony. Jeśli nie widzisz go od razu, poczekaj chwilę, ponieważ może to zająć trochę czasu. Transakcja będzie wyglądać mniej więcej tak:

Adres From powinien pasować do adresu Twojego konta MetaMask, a adres To będzie oznaczony jako „Tworzenie Kontraktu”. Jeśli klikniemy w transakcję, zobaczymy adres naszego kontraktu w polu To:

Taaak! Właśnie wdrożyłeś swój inteligentny kontrakt NFT do łańcucha Ethereum (sieci testowej)!

Aby zrozumieć, co dzieje się pod maską, przejdźmy do karty Explorer w naszym panelu Alchemy (opens in a new tab). Jeśli masz wiele aplikacji Alchemy, pamiętaj, aby filtrować według aplikacji i wybrać „MyNFT”.

Tutaj zobaczysz kilka wywołań JSON-RPC, które Hardhat/Ethers wykonały dla nas „pod maską”, gdy wywołaliśmy funkcję .deploy(). Dwa ważne, o których należy tu wspomnieć, to eth_sendRawTransaction, czyli żądanie faktycznego zapisu naszego inteligentnego kontraktu na łańcuchu Sepolia, oraz eth_getTransactionByHash, czyli żądanie odczytania informacji o naszej transakcji na podstawie jej hasza (typowy wzorzec podczas wysyłania transakcji). Aby dowiedzieć się więcej o wysyłaniu transakcji, zapoznaj się z tym samouczkiem na temat wysyłania transakcji przy użyciu Web3.

To wszystko, jeśli chodzi o część 1 tego samouczka. W części 2 będziemy faktycznie wchodzić w interakcję z naszym inteligentnym kontraktem, wybijając NFT, a w części 3 pokażemy, jak wyświetlić swoje NFT w portfelu Ethereum!

Strona ostatnio zaktualizowana: 5 grudnia 2025