Cara Menulis & Menerapkan NFT (Bagian 1/3 dari Seri Tutorial NFT)

ERC-721

Alchemy

Solidity

kontrak pintar

Pemula

Sumi Mudgil

22 April 2021

13 menit baca

Dengan NFT yang membawa blockchain ke mata publik, sekarang adalah kesempatan yang sangat baik untuk memahami tren ini sendiri dengan menerbitkan kontrak NFT Anda sendiri (Token ERC-721) di blockchain Ethereum!

Alchemy sangat bangga dapat mendukung nama-nama terbesar di ruang NFT, termasuk Makersplace (baru-baru ini mencetak rekor penjualan karya seni digital di Christie's seharga $69 Juta), Dapper Labs (pencipta NBA Top Shot & Crypto Kitties), OpenSea (pasar NFT terbesar di dunia), Zora, Super Rare, NFTfi, Foundation, Enjin, Origin Protocol, Immutable, dan banyak lagi.

Dalam tutorial ini, kita akan memandu pembuatan dan penerapan kontrak pintar ERC-721 di jaringan testnet Sepolia menggunakan MetaMask (opens in a new tab), Solidity (opens in a new tab), Hardhat (opens in a new tab), Pinata (opens in a new tab) dan Alchemy (opens in a new tab) (jangan khawatir jika Anda belum memahami apa arti dari semua ini — kami akan menjelaskannya!).

Di Bagian 2 dari tutorial ini, kita akan membahas bagaimana kita dapat menggunakan kontrak pintar kita untuk melakukan mint NFT, dan di Bagian 3 kita akan menjelaskan cara melihat NFT Anda di MetaMask.

Dan tentu saja, jika Anda memiliki pertanyaan kapan saja, jangan ragu untuk menghubungi di Discord Alchemy (opens in a new tab) atau kunjungi dokumentasi API NFT Alchemy (opens in a new tab)!

Langkah 1: Hubungkan ke jaringan Ethereum

Ada banyak cara untuk membuat permintaan ke blockchain Ethereum, tetapi untuk mempermudah, kita akan menggunakan akun gratis di Alchemy (opens in a new tab), sebuah platform pengembang blockchain dan API yang memungkinkan kita untuk berkomunikasi dengan rantai Ethereum tanpa harus menjalankan node kita sendiri.

Dalam tutorial ini, kita juga akan memanfaatkan alat pengembang Alchemy untuk pemantauan dan analitik guna memahami apa yang terjadi di balik layar dalam penerapan kontrak pintar kita. Jika Anda belum memiliki akun Alchemy, Anda dapat mendaftar secara gratis di sini (opens in a new tab).

Langkah 2: Buat aplikasi Anda (dan kunci API)

Setelah Anda membuat akun Alchemy, Anda dapat menghasilkan kunci API dengan membuat aplikasi. Ini akan memungkinkan kita untuk membuat permintaan ke jaringan testnet Sepolia. Lihat panduan ini (opens in a new tab) jika Anda penasaran untuk mempelajari lebih lanjut tentang jaringan testnet.

Arahkan ke halaman "Create App" di Dasbor Alchemy Anda dengan mengarahkan kursor ke "Apps" di bilah navigasi dan mengklik "Create App"

Beri nama aplikasi Anda (kami memilih "My First NFT!"), berikan deskripsi singkat, pilih "Ethereum" untuk Chain, dan pilih "Sepolia" untuk jaringan Anda. Sejak the merge, testnet lainnya telah dihentikan.

Klik "Create app" dan selesai! Aplikasi Anda akan muncul di tabel di bawah ini.

Langkah 3: Buat akun (alamat) Ethereum

Kita memerlukan akun Ethereum untuk mengirim dan menerima transaksi. Untuk tutorial ini, kita akan menggunakan MetaMask, sebuah dompet virtual di peramban yang digunakan untuk mengelola alamat akun Ethereum Anda. Jika Anda ingin memahami lebih lanjut tentang cara kerja transaksi di Ethereum, lihat halaman ini dari yayasan Ethereum.

Anda dapat mengunduh dan membuat akun MetaMask secara gratis di sini (opens in a new tab). Saat Anda membuat akun, atau jika Anda sudah memiliki akun, pastikan untuk beralih ke "Sepolia Test Network" di kanan atas (sehingga kita tidak berurusan dengan uang sungguhan).

Langkah 4: Tambahkan ether dari Faucet

Untuk menerapkan kontrak pintar kita ke jaringan testnet, kita akan memerlukan beberapa ETH palsu. Untuk mendapatkan ETH, Anda dapat pergi ke Sepolia Faucet (opens in a new tab) yang di-host oleh Alchemy, masuk dan masukkan alamat akun Anda, klik "Send Me ETH". Anda akan melihat ETH di akun MetaMask Anda segera setelahnya!

Langkah 5: Periksa Saldo Anda

Untuk memeriksa kembali apakah saldo kita ada di sana, mari buat permintaan eth_getBalance (opens in a new tab) menggunakan alat komposer Alchemy (opens in a new tab). Ini akan mengembalikan jumlah ETH di dompet kita. Setelah Anda memasukkan alamat akun MetaMask Anda dan mengklik "Send Request", Anda akan melihat respons seperti ini:

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

Catatan Hasil ini dalam wei, bukan ETH. Wei digunakan sebagai denominasi terkecil dari ether. Konversi dari wei ke ETH adalah 1 eth = 10¹⁸ wei. Jadi jika kita mengonversi 0xde0b6b3a7640000 ke desimal kita mendapatkan 1*10¹⁸ wei, yang sama dengan 1 ETH.

Fiuh! Uang palsu kita semuanya ada di sana.

Langkah 6: Inisialisasi proyek kita

Pertama, kita perlu membuat folder untuk proyek kita. Arahkan ke baris perintah Anda dan ketik:

mkdir my-nft cd my-nft

Sekarang kita berada di dalam folder proyek kita, kita akan menggunakan npm init untuk menginisialisasi proyek. Jika Anda belum menginstal npm, ikuti instruksi ini (opens in a new tab) (kita juga akan memerlukan Node.js (opens in a new tab), jadi unduh juga itu!).

npm init

Tidak masalah bagaimana Anda menjawab pertanyaan instalasi; berikut adalah cara kami melakukannya sebagai referensi:

1    package name: (my-nft)
2    version: (1.0.0)
3    description: My first 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": "My first NFT!",
16      "main": "index.js",
17      "scripts": {
18        "test": "echo \"Error: no test specified\" && exit 1"
19      },
20      "author": "",
21      "license": "ISC"
22    }
Tampilkan semua

Setujui package.json, dan kita siap untuk melanjutkan!

Langkah 7: Instal Hardhat (opens in a new tab)

Hardhat adalah lingkungan pengembangan untuk mengompilasi, menerapkan, menguji, dan men-debug perangkat lunak Ethereum Anda. Ini membantu pengembang saat membangun kontrak pintar dan dapp secara lokal sebelum menerapkannya ke rantai langsung.

Di dalam proyek my-nft kita, jalankan:

npm install --save-dev hardhat

Lihat halaman ini untuk detail lebih lanjut tentang instruksi instalasi (opens in a new tab).

Langkah 8: Buat proyek Hardhat

Di dalam folder proyek kita, jalankan:

npx hardhat

Anda kemudian akan melihat pesan selamat datang dan opsi untuk memilih apa yang ingin Anda lakukan. Pilih "create an empty hardhat.config.js":

888 888 888 888 888 888 888 888 888 888 888 888 888 888 888 8888888888 8888b. 888d888 .d88888 88888b. 8888b. 888888 888 888 "88b 888P" d88" 888 888 "88b "88b 888 888 888 .d888888 888 888 888 888 888 .d888888 888 888 888 888 888 888 Y88b 888 888 888 888 888 Y88b. 888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888 👷 Welcome to Hardhat v2.0.11 👷‍ ? What do you want to do? … Create a sample project ❯ Create an empty hardhat.config.js Quit

Ini akan menghasilkan file hardhat.config.js untuk kita yang merupakan tempat kita akan menentukan semua pengaturan untuk proyek kita (pada langkah 13).

Langkah 9: Tambahkan folder proyek

Untuk menjaga proyek kita tetap teratur, kita akan membuat dua folder baru. Arahkan ke direktori root proyek Anda di baris perintah Anda dan ketik:

mkdir contracts mkdir scripts

contracts/ adalah tempat kita akan menyimpan kode kontrak pintar NFT kita
scripts/ adalah tempat kita akan menyimpan skrip untuk menerapkan dan berinteraksi dengan kontrak pintar kita

Langkah 10: Tulis kontrak kita

Sekarang lingkungan kita sudah diatur, mari beralih ke hal yang lebih menarik: menulis kode kontrak pintar kita!

Buka proyek my-nft di editor favorit Anda (kami menyukai VSCode (opens in a new tab)). Kontrak pintar ditulis dalam bahasa yang disebut Solidity yang akan kita gunakan untuk menulis kontrak pintar MyNFT.sol kita.‌

Arahkan ke folder contracts dan buat file baru bernama MyNFT.sol

Di bawah ini adalah kode kontrak pintar NFT kita, yang kita dasarkan pada implementasi ERC-721 dari pustaka OpenZeppelin (opens in a new tab). Salin dan tempel konten di bawah ini ke dalam file MyNFT.sol Anda.

1//Contract based on [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721) // Kontrak berdasarkan [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
2// SPDX-License-Identifier: MIT // 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}
Tampilkan semua

1
23. Karena kita mewarisi kelas dari pustaka kontrak OpenZeppelin, di baris perintah Anda jalankan `npm install @openzeppelin/contracts^4.0.0` untuk menginstal pustaka ke dalam folder kita.
3
4Jadi, apa yang _dilakukan_ kode ini sebenarnya? Mari kita uraikan, baris demi baris.
5
6Di bagian atas kontrak pintar kita, kita mengimpor tiga kelas kontrak pintar [OpenZeppelin](https://openzeppelin.com/):
7
8- @openzeppelin/contracts/token/ERC721/ERC721.sol berisi implementasi standar ERC-721, yang akan diwarisi oleh kontrak pintar NFT kita. (Untuk menjadi NFT yang valid, kontrak pintar Anda harus mengimplementasikan semua metode standar ERC-721.) Untuk mempelajari lebih lanjut tentang fungsi ERC-721 yang diwariskan, lihat definisi antarmuka [di sini](https://eips.ethereum.org/EIPS/eip-721).
9
10- @openzeppelin/contracts/utils/Counters.sol menyediakan penghitung yang hanya dapat ditambah atau dikurangi satu. Kontrak pintar kita menggunakan penghitung untuk melacak jumlah total NFT yang di-mint dan menetapkan ID unik pada NFT baru kita. (Setiap NFT yang di-mint menggunakan kontrak pintar harus diberi ID unik—di sini ID unik kita hanya ditentukan oleh jumlah total NFT yang ada. Misalnya, NFT pertama yang kita mint dengan kontrak pintar kita memiliki ID "1," NFT kedua kita memiliki ID "2," dll.)
11
12- @openzeppelin/contracts/access/Ownable.sol mengatur [kontrol akses](https://docs.openzeppelin.com/contracts/3.x/access-control) pada kontrak pintar kita, sehingga hanya pemilik kontrak pintar (Anda) yang dapat melakukan mint NFT. (Catatan, menyertakan kontrol akses sepenuhnya merupakan preferensi. Jika Anda ingin siapa pun dapat melakukan mint NFT menggunakan kontrak pintar Anda, hapus kata Ownable pada baris 10 dan onlyOwner pada baris 17.)
13
14Setelah pernyataan impor kita, kita memiliki kontrak pintar NFT kustom kita, yang secara mengejutkan pendek — ini hanya berisi penghitung, konstruktor, dan fungsi tunggal! Ini berkat kontrak OpenZeppelin yang kita warisi, yang mengimplementasikan sebagian besar metode yang kita butuhkan untuk membuat NFT, seperti `ownerOf` yang mengembalikan pemilik NFT, dan `transferFrom`, yang mentransfer kepemilikan NFT dari satu akun ke akun lainnya.
15
16Dalam konstruktor ERC-721 kita, Anda akan melihat kita meneruskan 2 string, "MyNFT" dan "NFT." Variabel pertama adalah nama kontrak pintar, dan yang kedua adalah simbolnya. Anda dapat menamai masing-masing variabel ini sesuka Anda!
17
18Terakhir, kita memiliki fungsi `mintNFT(address recipient, string memory tokenURI)` yang memungkinkan kita untuk melakukan mint NFT! Anda akan melihat fungsi ini mengambil dua variabel:
19
20- `address recipient` menentukan alamat yang akan menerima NFT Anda yang baru di-mint
21
22- `string memory tokenURI` adalah string yang harus diselesaikan ke dokumen JSON yang mendeskripsikan metadata NFT. Metadata NFT adalah apa yang benar-benar menghidupkannya, memungkinkannya memiliki properti yang dapat dikonfigurasi, seperti nama, deskripsi, gambar, dan atribut lainnya. Di bagian 2 dari tutorial ini, kita akan mendeskripsikan cara mengonfigurasi metadata ini.
23
24`mintNFT` memanggil beberapa metode dari pustaka ERC-721 yang diwariskan, dan pada akhirnya mengembalikan angka yang mewakili ID dari NFT yang baru di-mint.
25
26## Langkah 11: Hubungkan MetaMask & Alchemy ke proyek Anda \{#connect-metamask-and-alchemy\}
27
28Sekarang kita telah membuat dompet MetaMask, akun Alchemy, dan menulis kontrak pintar kita, saatnya untuk menghubungkan ketiganya.
29
30Setiap transaksi yang dikirim dari dompet virtual Anda memerlukan tanda tangan menggunakan kunci pribadi unik Anda. Untuk memberikan izin ini kepada program kita, kita dapat dengan aman menyimpan kunci pribadi kita (dan kunci API Alchemy) dalam file lingkungan.
31
32Untuk mempelajari lebih lanjut tentang mengirim transaksi, lihat [tutorial ini](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) tentang mengirim transaksi menggunakan web3.
33
34Pertama, instal paket dotenv di direktori proyek Anda:
35
36    npm install dotenv --save
37
38Kemudian, buat file `.env` di direktori root proyek kita, dan tambahkan kunci pribadi MetaMask Anda dan URL API HTTP Alchemy ke dalamnya.
39
40- Ikuti [instruksi ini](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key) untuk mengekspor kunci pribadi Anda dari MetaMask
41
42- Lihat di bawah ini untuk mendapatkan URL API HTTP Alchemy dan salin ke papan klip Anda
43
44![Salin URL API Alchemy Anda](./copy-alchemy-api-url.gif)
45
46`.env` Anda sekarang akan terlihat seperti ini:
47
48    API_URL="https://eth-sepolia.g.alchemy.com/v2/your-api-key"
49    PRIVATE_KEY="your-metamask-private-key"
50
51Untuk benar-benar menghubungkan ini ke kode kita, kita akan merujuk variabel-variabel ini dalam file hardhat.config.js kita pada langkah 13.
52
53<EnvWarningBanner />
54
55## Langkah 12: Instal Ethers.js \{#install-ethers\}
56
57Ethers.js adalah pustaka yang memudahkan untuk berinteraksi dan membuat permintaan ke Ethereum dengan membungkus [metode JSON-RPC standar](/developers/docs/apis/json-rpc/) dengan metode yang lebih ramah pengguna.
58
59Hardhat membuatnya sangat mudah untuk mengintegrasikan [Plugin](https://hardhat.org/plugins/) untuk perkakas tambahan dan fungsionalitas yang diperluas. Kita akan memanfaatkan [plugin Ethers](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) untuk penerapan kontrak ([Ethers.js](https://github.com/ethers-io/ethers.js/) memiliki beberapa metode penerapan kontrak yang sangat bersih).
60
61Di direktori proyek Anda ketik:
62
63    npm install --save-dev @nomiclabs/hardhat-ethers ethers@^5.0.0
64
65Kita juga akan memerlukan ethers di hardhat.config.js kita pada langkah berikutnya.
66
67## Langkah 13: Perbarui hardhat.config.js \{#update-hardhat-config\}
68
69Kita telah menambahkan beberapa dependensi dan plugin sejauh ini, sekarang kita perlu memperbarui hardhat.config.js sehingga proyek kita mengetahui semuanya.
70
71Perbarui hardhat.config.js Anda agar terlihat seperti ini:
72
73```js
74    /**
75    * @type import('hardhat/config').HardhatUserConfig
76     */
77    require('dotenv').config();
78    require("@nomiclabs/hardhat-ethers");
79    const { API_URL, PRIVATE_KEY } = process.env;
80    module.exports = {
81       solidity: "0.8.1",
82       defaultNetwork: "sepolia",
83       networks: {
84          hardhat: {},
85          sepolia: {
86             url: API_URL,
87             accounts: [`0x${PRIVATE_KEY}`]
88          }
89       },
90    }
Tampilkan semua

Langkah 14: Kompilasi kontrak kita

Untuk memastikan semuanya berfungsi sejauh ini, mari kompilasi kontrak kita. Tugas kompilasi adalah salah satu tugas bawaan hardhat.

Dari baris perintah jalankan:

npx hardhat compile

Anda mungkin mendapatkan peringatan tentang pengidentifikasi lisensi SPDX yang tidak disediakan dalam file sumber, tetapi tidak perlu khawatir tentang itu — semoga semuanya terlihat baik! Jika tidak, Anda selalu dapat mengirim pesan di discord Alchemy (opens in a new tab).

Langkah 15: Tulis skrip penerapan kita

Sekarang kontrak kita telah ditulis dan file konfigurasi kita siap digunakan, saatnya untuk menulis skrip penerapan kontrak kita.

Arahkan ke folder scripts/ dan buat file baru bernama deploy.js, tambahkan konten berikut ke dalamnya:

1async function main() {
2  const MyNFT = await ethers.getContractFactory("MyNFT")
3
4  // Start deployment, returning a promise that resolves to a contract object // Mulai penerapan, mengembalikan promise yang menghasilkan objek kontrak
5  const myNFT = await MyNFT.deploy()
6  await myNFT.deployed()
7  console.log("Contract deployed to address:", myNFT.address)
8}
9
10main()
11  .then(() => process.exit(0))
12  .catch((error) => {
13    console.error(error)
14    process.exit(1)
15  })
Tampilkan semua

Hardhat melakukan pekerjaan yang luar biasa dalam menjelaskan apa yang dilakukan masing-masing baris kode ini dalam tutorial Kontrak (opens in a new tab) mereka, kami telah mengadopsi penjelasan mereka di sini.

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

ContractFactory di ethers.js adalah abstraksi yang digunakan untuk menerapkan kontrak pintar baru, jadi MyNFT di sini adalah pabrik untuk instans kontrak NFT kita. Saat menggunakan plugin hardhat-ethers, instans ContractFactory dan Contract terhubung ke penandatangan pertama secara default.

const myNFT = await MyNFT.deploy();

Memanggil deploy() pada ContractFactory akan memulai penerapan, dan mengembalikan Promise yang diselesaikan ke Contract. Ini adalah objek yang memiliki metode untuk setiap fungsi kontrak pintar kita.

Langkah 16: Terapkan kontrak kita

Kita akhirnya siap untuk menerapkan kontrak pintar kita! Arahkan kembali ke root direktori proyek Anda, dan di baris perintah jalankan:

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

Anda kemudian akan melihat sesuatu seperti:

Contract deployed to address: 0x4C5266cCc4b3F426965d2f51b6D910325a0E7650

Jika kita pergi ke Sepolia etherscan (opens in a new tab) dan mencari alamat kontrak kita, kita seharusnya dapat melihat bahwa itu telah berhasil diterapkan. Jika Anda tidak dapat melihatnya segera, harap tunggu sebentar karena ini bisa memakan waktu. Transaksi akan terlihat seperti ini:

Alamat From harus cocok dengan alamat akun MetaMask Anda dan alamat To akan mengatakan "Contract Creation". Jika kita mengklik ke dalam transaksi, kita akan melihat alamat kontrak kita di bidang To:

Yasssss! Anda baru saja menerapkan kontrak pintar NFT Anda ke rantai (testnet) Ethereum!

Untuk memahami apa yang terjadi di balik layar, mari arahkan ke tab Explorer di dasbor Alchemy (opens in a new tab) kita. Jika Anda memiliki beberapa aplikasi Alchemy, pastikan untuk memfilter berdasarkan aplikasi dan pilih "MyNFT".

Di sini Anda akan melihat beberapa panggilan JSON-RPC yang dilakukan Hardhat/Ethers di balik layar untuk kita saat kita memanggil fungsi .deploy(). Dua hal penting yang perlu disebutkan di sini adalah eth_sendRawTransaction, yang merupakan permintaan untuk benar-benar menulis kontrak pintar kita ke rantai Sepolia, dan eth_getTransactionByHash yang merupakan permintaan untuk membaca informasi tentang transaksi kita berdasarkan hash (pola khas saat mengirim transaksi). Untuk mempelajari lebih lanjut tentang mengirim transaksi, lihat tutorial ini tentang mengirim transaksi menggunakan Web3.

Sekian untuk Bagian 1 dari tutorial ini. Di Bagian 2, kita akan benar-benar berinteraksi dengan kontrak pintar kita dengan melakukan mint NFT, dan di Bagian 3 kita akan menunjukkan kepada Anda cara melihat NFT Anda di dompet Ethereum Anda!

Pembaruan terakhir halaman: 5 Desember 2025