Cara Menulis & Menyebarkan 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 rantai blok ke mata publik, sekarang adalah kesempatan yang sangat baik untuk memahami tren ini sendiri dengan menerbitkan kontrak NFT (Token ERC-721) Anda sendiri di rantai blok 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 (pembuat 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 penyebaran 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 semua ini — kami akan menjelaskannya!).

Di Bagian 2 dari tutorial ini, kita akan membahas bagaimana kita dapat menggunakan kontrak pintar kita untuk mencetak 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 rantai blok Ethereum, tetapi untuk mempermudah, kita akan menggunakan akun gratis di Alchemy (opens in a new tab), sebuah platform pengembang rantai blok 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 secara teknis dalam penyebaran 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 testnet Sepolia. Lihat panduan ini (opens in a new tab) jika Anda ingin mempelajari lebih lanjut tentang 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, dompet virtual di peramban yang digunakan untuk mengelola alamat akun Ethereum Anda. Jika Anda ingin lebih memahami 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 menyebarkan kontrak pintar kita ke testnet, kita akan membutuhkan 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 segera melihat ETH di akun MetaMask Anda!

Langkah 5: Periksa Saldo Anda

Untuk memastikan 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 setelah 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 membutuhkan Node.js (opens in a new tab), jadi unduh juga!).

npm init

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

    package name: (my-nft)
    version: (1.0.0)
    description: My first NFT!
    entry point: (index.js)
    test command:
    git repository:
    keywords:
    author:
    license: (ISC)
    About to write to /Users/thesuperb1/Desktop/my-nft/package.json:

    {
      "name": "my-nft",
      "version": "1.0.0",
      "description": "My first NFT!",
      "main": "index.js",
      "scripts": {
        "test": "echo \"Error: no test specified\" && exit 1"
      },
      "author": "",
      "license": "ISC"
    }

Setujui package.json, dan kita siap untuk melanjutkan!

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

Hardhat adalah lingkungan pengembangan untuk mengompilasi, menyebarkan, menguji, dan men-debug perangkat lunak Ethereum Anda. Ini membantu pengembang saat membangun kontrak pintar dan aplikasi terdesentralisasi (dapp) secara lokal sebelum menyebarkannya 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

Agar 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 menyebarkan dan berinteraksi dengan kontrak pintar kita

Langkah 10: Tulis kontrak kita

Sekarang setelah lingkungan kita disiapkan, 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.

//Kontrak berdasarkan [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";

contract MyNFT is ERC721URIStorage, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor() ERC721("MyNFT", "NFT") {}

    function mintNFT(address recipient, string memory tokenURI)
        public onlyOwner
        returns (uint256)
    {
        _tokenIds.increment();

        uint256 newItemId = _tokenIds.current();
        _mint(recipient, newItemId);
        _setTokenURI(newItemId, tokenURI);

        return newItemId;
    }
}

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.

Jadi, apa yang dilakukan kode ini sebenarnya? Mari kita uraikan, baris demi baris.

Di bagian atas kontrak pintar kita, kita mengimpor tiga kelas kontrak pintar OpenZeppelin (opens in a new tab):

@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 (opens in a new tab).
@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 dicetak dan menetapkan ID unik pada NFT baru kita. (Setiap NFT yang dicetak 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 cetak dengan kontrak pintar kita memiliki ID "1," NFT kedua kita memiliki ID "2," dll.)
@openzeppelin/contracts/access/Ownable.sol mengatur kontrol akses (opens in a new tab) pada kontrak pintar kita, sehingga hanya pemilik kontrak pintar (Anda) yang dapat mencetak NFT. (Catatan, menyertakan kontrol akses sepenuhnya merupakan preferensi. Jika Anda ingin siapa pun dapat mencetak NFT menggunakan kontrak pintar Anda, hapus kata Ownable pada baris 10 dan onlyOwner pada baris 17.)

Setelah pernyataan impor kita, kita memiliki kontrak pintar NFT kustom kita, yang secara mengejutkan sangat singkat — ini hanya berisi penghitung, konstruktor, dan satu fungsi! 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.

Dalam 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!

Terakhir, kita memiliki fungsi mintNFT(address recipient, string memory tokenURI) yang memungkinkan kita untuk mencetak NFT! Anda akan melihat fungsi ini mengambil dua variabel:

address recipient menentukan alamat yang akan menerima NFT Anda yang baru dicetak
string memory tokenURI adalah string yang harus diselesaikan ke dokumen JSON yang menjelaskan 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 menjelaskan cara mengonfigurasi metadata ini.

mintNFT memanggil beberapa metode dari Pustaka ERC-721 yang diwariskan, dan pada akhirnya mengembalikan angka yang mewakili ID dari NFT yang baru dicetak.

Langkah 11: Hubungkan MetaMask & Alchemy ke proyek Anda

Sekarang setelah kita membuat dompet MetaMask, akun Alchemy, dan menulis kontrak pintar kita, saatnya untuk menghubungkan ketiganya.

Setiap transaksi yang dikirim dari dompet virtual Anda memerlukan tanda tangan menggunakan kunci privat unik Anda. Untuk memberikan izin ini kepada program kita, kita dapat dengan aman menyimpan kunci privat kita (dan kunci API Alchemy) dalam file lingkungan.

Untuk mempelajari lebih lanjut tentang mengirim transaksi, lihat tutorial ini tentang mengirim transaksi menggunakan Web3.

Pertama, instal paket dotenv di direktori proyek Anda:

npm install dotenv --save

Kemudian, buat file .env di direktori root proyek kita, dan tambahkan kunci privat MetaMask Anda dan URL API Alchemy HTTP ke dalamnya.

Ikuti instruksi ini (opens in a new tab) untuk mengekspor kunci privat Anda dari MetaMask
Lihat di bawah ini untuk mendapatkan URL API Alchemy HTTP dan salin ke papan klip Anda

.env Anda sekarang akan terlihat seperti ini:

API_URL="https://eth-sepolia.g.alchemy.com/v2/your-api-key (opens in a new tab)" PRIVATE_KEY="your-metamask-private-key"

Untuk benar-benar menghubungkan ini ke kode kita, kita akan merujuk variabel-variabel ini di file hardhat.config.js kita pada langkah 13.

Jangan commit .env! Pastikan untuk tidak pernah membagikan atau mengekspos file .env Anda kepada siapa pun, karena Anda akan membahayakan rahasia Anda jika melakukannya. Jika Anda menggunakan version control, tambahkan .env Anda ke file gitignore.

Langkah 12: Instal Ethers.js

Ethers.js adalah Pustaka yang memudahkan untuk berinteraksi dan membuat permintaan ke Ethereum dengan membungkus metode JSON-RPC standar dengan metode yang lebih ramah pengguna.

Hardhat membuatnya sangat mudah untuk mengintegrasikan Plugin (opens in a new tab) untuk perkakas tambahan dan fungsionalitas yang diperluas. Kita akan memanfaatkan plugin Ethers (opens in a new tab) untuk penyebaran kontrak (Ethers.js (opens in a new tab) memiliki beberapa metode penyebaran kontrak yang sangat rapi).

Di direktori proyek Anda ketik:

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

Kita juga akan mewajibkan ethers di hardhat.config.js kita pada langkah berikutnya.

Langkah 13: Perbarui hardhat.config.js

Kita telah menambahkan beberapa dependensi dan plugin sejauh ini, sekarang kita perlu memperbarui hardhat.config.js sehingga proyek kita mengetahui semuanya.

Perbarui hardhat.config.js Anda agar terlihat seperti ini:

    /**
    * @type import('hardhat/config').HardhatUserConfig
    */
    require('dotenv').config();
    require("@nomiclabs/hardhat-ethers");
    const { API_URL, PRIVATE_KEY } = process.env;
    module.exports = {
       solidity: "0.8.1",
       defaultNetwork: "sepolia",
       networks: {
          hardhat: {},
          sepolia: {
             url: API_URL,
             accounts: [`0x${PRIVATE_KEY}`]
          }
       },
    }

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 penyebaran kita

Sekarang setelah kontrak kita ditulis dan file konfigurasi kita siap digunakan, saatnya untuk menulis skrip penyebaran kontrak kita.

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

async function main() {
  const MyNFT = await ethers.getContractFactory("MyNFT")

  // Mulai penyebaran, mengembalikan promise yang menghasilkan objek kontrak
  const myNFT = await MyNFT.deploy()
  await myNFT.deployed()
  console.log("Contract deployed to address:", myNFT.address)
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error)
    process.exit(1)
  })

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 menyebarkan 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 penyebaran, dan mengembalikan Promise yang diselesaikan ke Contract. Ini adalah objek yang memiliki metode untuk setiap fungsi kontrak pintar kita.

Langkah 16: Sebarkan kontrak kita

Kita akhirnya siap untuk menyebarkan 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 Etherscan Sepolia (opens in a new tab) dan mencari alamat kontrak kita, kita seharusnya dapat melihat bahwa itu telah berhasil disebarkan. 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 bertuliskan "Contract Creation". Jika kita mengklik transaksi, kita akan melihat alamat kontrak kita di bidang To:

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

Untuk memahami apa yang terjadi secara teknis, 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 dibuat oleh Hardhat/Ethers secara teknis untuk kita saat kita memanggil fungsi .deploy(). Dua hal penting yang perlu diperhatikan 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 umum 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 mencetak NFT, dan di Bagian 3 kita akan menunjukkan kepada Anda cara melihat NFT Anda di dompet Ethereum Anda!