Jak wybić NFT (Część 2/3 serii samouczków NFT)

ERC-721

alchemy

solidity

smart kontrakty

Początkujący

Sumi Mudgil

22 kwietnia 2021

8 minuta czytania

Beeple (opens in a new tab): 69 milionów USD 3LAU (opens in a new tab): 11 milionów USD Grimes (opens in a new tab): 6 milionów USD

Wszyscy oni wybili swoje NFT za pomocą potężnego API Alchemy. W tym samouczku nauczymy Cię, jak zrobić to samo w <10 minut.

„Wybicie NFT” to akt publikacji unikalnej instancji Twojego tokena ERC-721 na blockchainie. Używając naszego inteligentnego kontraktu z części 1 tej serii samouczków NFT, zaprezentujmy nasze umiejętności Web3 i wybijmy NFT. Na koniec tego samouczka będziesz w stanie wybić tyle NFT, ile tylko dusza (i portfel) zapragnie!

Zaczynajmy!

Krok 1: Zainstaluj Web3

Jeśli śledziłeś pierwszy samouczek dotyczący tworzenia inteligentnego kontraktu NFT, masz już doświadczenie w korzystaniu z Ethers.js. Web3 jest podobne do Ethers, ponieważ jest to biblioteka używana do ułatwienia tworzenia zapytań do blockchaina Ethereum. W tym samouczku będziemy używać Alchemy Web3 (opens in a new tab), która jest ulepszoną biblioteką Web3, która oferuje automatyczne ponawianie prób i solidne wsparcie dla WebSocket.

W głównym katalogu projektu uruchom:

1npm install @alch/alchemy-web3

Krok 2: Stwórz plik `mint-nft.js`

Wewnątrz katalogu scripts utwórz plik mint-nft.js i dodaj następujące linie kodu:

1require("dotenv").config()
2const API_URL = process.env.API_URL
3const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
4const web3 = createAlchemyWeb3(API_URL)

Krok 3: Pobierz ABI swojego kontraktu

ABI naszego kontraktu (Application Binary Interface) to interfejs do interakcji z naszym inteligentnym kontraktem. Możesz dowiedzieć się więcej o ABI kontraktów tutaj (opens in a new tab). Hardhat automatycznie generuje dla nas ABI i zapisuje je w pliku MyNFT.json. Aby z tego skorzystać, musimy przeanalizować zawartość, dodając następujące linie kodu do naszego pliku mint-nft.js:

1const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")

Jeśli chcesz zobaczyć ABI, możesz je wydrukować w swojej konsoli:

1console.log(JSON.stringify(contract.abi))

Aby uruchomić mint-nft.js i zobaczyć swoje ABI wydrukowane w konsoli, przejdź do terminala i uruchom:

1node scripts/mint-nft.js

Krok 4: Skonfiguruj metadane dla swojego NFT za pomocą IPFS

Jeśli pamiętasz z naszego samouczka w części 1, nasza funkcja inteligentnego kontraktu mintNFT przyjmuje parametr tokenURI, który powinien prowadzić do dokumentu JSON opisującego metadane NFT — co tak naprawdę ożywia NFT, pozwalając mu mieć konfigurowalne właściwości, takie jak nazwa, opis, obraz i inne atrybuty.

Interplanetary File System (IPFS) to zdecentralizowany protokół i sieć peer-to-peer do przechowywania i udostępniania danych w rozproszonym systemie plików.

Użyjemy Pinaty, wygodnego API i zestawu narzędzi IPFS, do przechowywania naszych aktywów NFT i metadanych, aby upewnić się, że nasze NFT jest naprawdę zdecentralizowane. Jeśli nie masz konta Pinata, zarejestruj darmowe konto tutaj (opens in a new tab) i wykonaj kroki w celu zweryfikowania swojego adresu e-mail.

Po utworzeniu konta:

Przejdź na stronę "Files" i kliknij niebieski przycisk "Upload" w lewym górnym rogu strony.
Prześlij obraz do Pinaty — będzie to zasób obrazu dla Twojego NFT. Możesz nazwać zasób, jak tylko chcesz
Po przesłaniu zobaczysz informacje o pliku w tabeli na stronie "Files". Zobaczysz także kolumnę CID. Możesz skopiować CID, klikając przycisk kopiowania obok niego. Możesz zobaczyć swój plik pod adresem: https://gateway.pinata.cloud/ipfs/<CID>. Przykładowo, obraz, którego użyliśmy na IPFS, można znaleźć tutaj (opens in a new tab).

Dla wzrokowców, powyższe kroki zostały podsumowane tutaj:

Teraz będziemy chcieli przesłać jeszcze jeden dokument do Pinaty. Ale zanim to zrobimy, musimy go stworzyć!

W katalogu głównym utwórz nowy plik o nazwie nft-metadata.json i dodaj następujący kod json:

1{
2  "attributes": [
3    {
4      "trait_type": "Rasa",
5      "value": "Maltipoo"
6    },
7    {
8      "trait_type": "Kolor oczu",
9      "value": "Mokka"
10    }
11  ],
12  "description": "Najbardziej uroczy i wrażliwy szczeniak na świecie.",
13  "image": "ipfs://QmWmvTJmJU3pozR9ZHFmQC2DNDwi2XJtf3QGyYiiagFSWb",
14  "name": "Ramses"
15}
Pokaż wszystko

Możesz dowolnie zmieniać dane w pliku json. Możesz usuwać lub dodawać atrybuty w sekcji atrybutów. Co najważniejsze, upewnij się, że pole obrazu wskazuje na lokalizację Twojego obrazu IPFS — w przeciwnym razie Twoje NFT będzie zawierać zdjęcie (bardzo uroczego!) psa.

Gdy skończysz edytować plik JSON, zapisz go i prześlij do Pinaty, postępując według tych samych kroków, co przy przesyłaniu obrazu.

Krok 5: Stwórz instancję swojego kontraktu

Teraz, aby wejść w interakcję z naszym kontraktem, musimy stworzyć jego instancję w naszym kodzie. Aby to zrobić, będziemy potrzebować adresu naszego kontraktu, który możemy uzyskać z wdrożenia lub z Blockscout (opens in a new tab), wyszukując adres, którego użyliśmy do wdrożenia kontraktu.

W powyższym przykładzie adres naszego kontraktu to 0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778.

Następnie użyjemy metody kontraktowej Web3 contract method (opens in a new tab), aby utworzyć nasz kontrakt przy użyciu ABI i adresu. W pliku mint-nft.js dodaj następujące elementy:

1const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
2
3const nftContract = new web3.eth.Contract(contract.abi, contractAddress)

Krok 6: Zaktualizuj plik `.env`

Teraz, aby tworzyć i wysyłać transakcje do łańcucha Ethereum, użyjemy Twojego publicznego adresu konta Ethereum, aby uzyskać nonce konta (wyjaśnimy poniżej).

Dodaj swój klucz publiczny do pliku .env — jeśli ukończyłeś część 1 samouczka, nasz plik .env powinien teraz wyglądać tak:

1API_URL = "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
2PRIVATE_KEY = "your-private-account-address"
3PUBLIC_KEY = "your-public-account-address"

Krok 7: Stwórz swoją transakcję

Najpierw zdefiniujmy funkcję o nazwie mintNFT(tokenData) i utwórzmy naszą transakcję, wykonując następujące czynności:

Pobierz swoje PRIVATE_KEY i PUBLIC_KEY z pliku .env.
Następnie będziemy musieli ustalić nonce konta. Specyfikacja nonce służy do śledzenia liczby transakcji wysłanych z Twojego adresu – czego potrzebujemy do celów bezpieczeństwa i zapobiegania atakom typu replay (opens in a new tab). Aby uzyskać liczbę transakcji wysłanych z Twojego adresu, używamy getTransactionCount (opens in a new tab).
Na koniec skonfigurujemy naszą transakcję z następującymi informacjami:

'from': PUBLIC_KEY — Źródłem naszej transakcji jest nasz adres publiczny
'to': contractAddress — Kontrakt, z którym chcemy wejść w interakcję i do którego wysyłamy transakcję
'nonce': nonce — Nonce konta z liczbą transakcji wysłanych z naszego adresu
'gas': estimatedGas — Szacowany gaz potrzebny do sfinalizowania transakcji
'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI() — Obliczenia, które chcemy wykonać w tej transakcji — co w tym przypadku oznacza wybicie NFT

Twój plik mint-nft.js powinien teraz wyglądać tak:

1   require('dotenv').config();
2   const API_URL = process.env.API_URL;
3   const PUBLIC_KEY = process.env.PUBLIC_KEY;
4   const PRIVATE_KEY = process.env.PRIVATE_KEY;
5
6   const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
7   const web3 = createAlchemyWeb3(API_URL);
8
9   const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json");
10   const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778";
11   const nftContract = new web3.eth.Contract(contract.abi, contractAddress);
12
13   async function mintNFT(tokenURI) {
14     const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); //pobierz najnowszy nonce
15
16   //transakcja
17     const tx = {
18       'from': PUBLIC_KEY,
19       'to': contractAddress,
20       'nonce': nonce,
21       'gas': 500000,
22       'data': nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI()
23     };
24   }
Pokaż wszystko

Krok 8: Podpisz transakcję

Teraz, gdy stworzyliśmy naszą transakcję, musimy ją podpisać, aby ją wysłać. Tutaj użyjemy naszego klucza prywatnego.

web3.eth.sendSignedTransaction da nam hasz transakcji, którego możemy użyć, aby upewnić się, że nasza transakcja została wydobyta i nie została odrzucona przez sieć. Zauważysz, że w sekcji podpisywania transakcji dodaliśmy sprawdzanie błędów, aby wiedzieć, czy nasza transakcja zakończyła się pomyślnie.

1require("dotenv").config()
2const API_URL = process.env.API_URL
3const PUBLIC_KEY = process.env.PUBLIC_KEY
4const PRIVATE_KEY = process.env.PRIVATE_KEY
5
6const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
7const web3 = createAlchemyWeb3(API_URL)
8
9const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
10const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
11const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
12
13async function mintNFT(tokenURI) {
14  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //pobierz najnowszy nonce
15
16  //transakcja
17  const tx = {
18    from: PUBLIC_KEY,
19    to: contractAddress,
20    nonce: nonce,
21    gas: 500000,
22    data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),
23  }
24
25  const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)
26  signPromise
27    .then((signedTx) => {
28      web3.eth.sendSignedTransaction(
29        signedTx.rawTransaction,
30        function (err, hash) {
31          if (!err) {
32            console.log(
33              "Hasz Twojej transakcji to: ",
34              hash,
35              "\nSprawdź Mempool Alchemy, aby zobaczyć status swojej transakcji!"
36            )
37          } else {
38            console.log(
39              "Coś poszło nie tak podczas przesyłania transakcji:",
40              err
41            )
42          }
43        }
44      )
45    })
46    .catch((err) => {
47      console.log(" Błąd Promise:", err)
48    })
49}
Pokaż wszystko

Krok 9: Wywołaj `mintNFT` i uruchom node `mint-nft.js`

Pamiętasz plik metadata.json, który przesłałeś do Pinaty? Pobierz jego hashcode z Pinaty i przekaż następujący parametr do funkcji mintNFT: https://gateway.pinata.cloud/ipfs/<metadata-hash-code>

Oto jak uzyskać hashcode:

Jak uzyskać hashcode metadanych NFT na Pinacie

Sprawdź dwukrotnie, czy skopiowany hashcode prowadzi do Twojego metadata.json, ładując https://gateway.pinata.cloud/ipfs/<metadata-hash-code> w osobnym oknie. Strona powinna wyglądać podobnie do poniższego zrzutu ekranu:

Twoja strona powinna wyświetlać metadane json

W całości Twój kod powinien wyglądać mniej więcej tak:

1require("dotenv").config()
2const API_URL = process.env.API_URL
3const PUBLIC_KEY = process.env.PUBLIC_KEY
4const PRIVATE_KEY = process.env.PRIVATE_KEY
5
6const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
7const web3 = createAlchemyWeb3(API_URL)
8
9const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
10const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
11const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
12
13async function mintNFT(tokenURI) {
14  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //pobierz najnowszy nonce
15
16  //transakcja
17  const tx = {
18    from: PUBLIC_KEY,
19    to: contractAddress,
20    nonce: nonce,
21    gas: 500000,
22    data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),
23  }
24
25  const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)
26  signPromise
27    .then((signedTx) => {
28      web3.eth.sendSignedTransaction(
29        signedTx.rawTransaction,
30        function (err, hash) {
31          if (!err) {
32            console.log(
33              "Hasz Twojej transakcji to: ",
34              hash,
35              "\nSprawdź Mempool Alchemy, aby zobaczyć status swojej transakcji!"
36            )
37          } else {
38            console.log(
39              "Coś poszło nie tak podczas przesyłania transakcji:",
40              err
41            )
42          }
43        }
44      )
45    })
46    .catch((err) => {
47      console.log("Błąd Promise:", err)
48    })
49}
50
51mintNFT("ipfs://QmYueiuRNmL4MiA2GwtVMm6ZagknXnSpQnB3z2gWbz36hP")
Pokaż wszystko

Teraz uruchom node scripts/mint-nft.js, aby wdrożyć swoje NFT. Po kilku sekundach w terminalu powinna pojawić się odpowiedź podobna do tej:

1Hasz Twojej transakcji to: 0x301791fdf492001fcd9d5e5b12f3aa1bbbea9a88ed24993a8ab2cdae2d06e1e8
2
3Sprawdź Mempool Alchemy, aby zobaczyć status swojej transakcji!

Następnie odwiedź swój mempool Alchemy (opens in a new tab), aby zobaczyć status swojej transakcji (czy jest w toku, wydobyta, czy została odrzucona przez sieć). Jeśli Twoja transakcja została odrzucona, warto również sprawdzić Blockscout (opens in a new tab) i wyszukać hasz swojej transakcji.

Wyświetl hasz transakcji NFT na Etherscan

I to wszystko! Właśnie wdrożyłeś ORAZ wybiłeś NFT na blockchainie Ethereum

Używając mint-nft.js możesz wybić tyle NFT, ile tylko dusza (i portfel) zapragnie! Pamiętaj tylko, aby przekazać nowy tokenURI opisujący metadane NFT (w przeciwnym razie skończysz, tworząc kilka identycznych z różnymi ID).

Prawdopodobnie chciałbyś móc pochwalić się swoim NFT w swoim portfelu – więc koniecznie sprawdź Część 3: Jak wyświetlić swoje NFT w portfelu!

Strona ostatnio zaktualizowana: 23 lutego 2026

+20