Pengantar Ethereum untuk pengembang Python, bagian 1

Jadi, Anda telah mendengar tentang Ethereum ini dan siap untuk menjelajah lebih jauh? Postingan ini akan dengan cepat membahas beberapa dasar blockchain, lalu mengajak Anda berinteraksi dengan node Ethereum yang disimulasikan – membaca data blok, memeriksa saldo akun, dan mengirim transaksi. Sepanjang jalan, kami akan menyoroti perbedaan antara cara tradisional dalam membangun aplikasi dan paradigma terdesentralisasi yang baru ini.

Prasyarat (ringan)

Postingan ini bercita-cita untuk dapat diakses oleh berbagai macam pengembang. Alat Python akan dilibatkan, tetapi alat tersebut hanyalah sarana untuk menyampaikan ide – tidak masalah jika Anda bukan seorang pengembang Python. Namun, saya hanya akan membuat beberapa asumsi tentang apa yang sudah Anda ketahui, sehingga kita dapat dengan cepat beralih ke bagian khusus Ethereum.

Asumsi:

• Anda dapat menggunakan terminal,
• Anda telah menulis beberapa baris kode Python,
• Python versi 3.6 atau yang lebih baru telah terinstal di mesin Anda (penggunaan lingkungan virtual (opens in a new tab) sangat disarankan), dan
• Anda telah menggunakan pip, penginstal paket Python. Sekali lagi, jika salah satu dari hal ini tidak benar, atau Anda tidak berencana untuk mereproduksi kode dalam artikel ini, Anda kemungkinan besar masih dapat mengikutinya dengan baik.

Singkat tentang blockchain

Ada banyak cara untuk mendeskripsikan Ethereum, tetapi pada intinya adalah sebuah blockchain. Blockchain terdiri dari serangkaian blok, jadi mari kita mulai dari sana. Dalam istilah yang paling sederhana, setiap blok di blockchain Ethereum hanyalah beberapa metadata dan daftar transaksi. Dalam format JSON, tampilannya kira-kira seperti ini:

1{
2   "number": 1234567,
3   "hash": "0xabc123...",
4   "parentHash": "0xdef456...",
5   ...,
6   "transactions": [...]
7}
Salin

Setiap blok memiliki referensi ke blok yang mendahuluinya; parentHash hanyalah hash dari blok sebelumnya.

Blockchain pada dasarnya adalah daftar tertaut; setiap blok memiliki referensi ke blok sebelumnya.

Struktur data ini bukanlah hal yang baru, tetapi aturan (yaitu, protokol peer-to-peer) yang mengatur jaringan adalah hal yang baru. Tidak ada otoritas pusat; jaringan rekanan (peers) harus berkolaborasi untuk mempertahankan jaringan, dan bersaing untuk memutuskan transaksi mana yang akan dimasukkan ke dalam blok berikutnya. Jadi, ketika Anda ingin mengirim sejumlah uang kepada seorang teman, Anda harus menyiarkan transaksi tersebut ke jaringan, lalu menunggu hingga transaksi tersebut dimasukkan ke dalam blok yang akan datang.

Satu-satunya cara bagi blockchain untuk memverifikasi bahwa uang benar-benar dikirim dari satu pengguna ke pengguna lain adalah dengan menggunakan mata uang asli (yaitu, dibuat dan diatur oleh) blockchain tersebut. Di Ethereum, mata uang ini disebut ether, dan blockchain Ethereum berisi satu-satunya catatan resmi saldo akun.

Paradigma baru

Tumpukan teknologi terdesentralisasi yang baru ini telah melahirkan alat pengembang baru. Alat semacam itu ada dalam banyak bahasa pemrograman, tetapi kita akan melihatnya melalui lensa Python. Untuk mengulangi: meskipun Python bukan bahasa pilihan Anda, seharusnya tidak akan terlalu sulit untuk mengikutinya.

Pengembang Python yang ingin berinteraksi dengan Ethereum kemungkinan besar akan menggunakan Web3.py (opens in a new tab). Web3.py adalah pustaka yang sangat menyederhanakan cara Anda terhubung ke node Ethereum, lalu mengirim dan menerima data darinya.

Klien Ethereum dapat dikonfigurasi agar dapat dijangkau oleh IPC (opens in a new tab), HTTP, atau Websockets, sehingga Web3.py perlu mencerminkan konfigurasi ini. Web3.py menyebut opsi koneksi ini sebagai penyedia (providers). Anda harus memilih salah satu dari tiga penyedia untuk menautkan instans Web3.py dengan node Anda.

Konfigurasikan node Ethereum dan Web3.py untuk berkomunikasi melalui protokol yang sama, mis., IPC dalam diagram ini.

Setelah Web3.py dikonfigurasi dengan benar, Anda dapat mulai berinteraksi dengan blockchain. Berikut adalah beberapa contoh penggunaan Web3.py sebagai pratinjau dari apa yang akan datang:

1# read block data: # membaca data blok:
2w3.eth.get_block('latest')
3
4# send a transaction: # mengirim transaksi:
5w3.eth.send_transaction({'from': ..., 'to': ..., 'value': ...})
Salin

Instalasi

Dalam panduan ini, kita hanya akan bekerja di dalam interpreter Python. Kita tidak akan membuat direktori, file, kelas, atau fungsi apa pun.

Pertama, instal IPython (opens in a new tab) untuk lingkungan yang ramah pengguna untuk dijelajahi. IPython menawarkan penyelesaian tab, di antara fitur-fitur lainnya, sehingga jauh lebih mudah untuk melihat apa yang mungkin dilakukan di dalam Web3.py.

pip install ipython

Web3.py diterbitkan dengan nama web3. Instal seperti ini:

pip install web3

Satu hal lagi – kita akan menyimulasikan blockchain nanti, yang membutuhkan beberapa dependensi lagi. Anda dapat menginstalnya melalui:

pip install 'web3[tester]'

Anda sudah siap untuk memulai!

Catatan: Paket web3[tester] berfungsi hingga Python 3.10.xx

Menjalankan sandbox

Buka lingkungan Python baru dengan menjalankan ipython di terminal Anda. Ini sebanding dengan menjalankan python, tetapi dilengkapi dengan lebih banyak fitur tambahan.

ipython

Ini akan mencetak beberapa informasi tentang versi Python dan IPython yang Anda jalankan, lalu Anda akan melihat prompt yang menunggu input:

1In [1]:
Salin

Anda sedang melihat shell Python interaktif sekarang. Pada dasarnya, ini adalah sandbox untuk bermain. Jika Anda telah berhasil sejauh ini, saatnya untuk mengimpor Web3.py:

1In [1]: from web3 import Web3
Salin

Memperkenalkan modul Web3

Selain menjadi gerbang ke Ethereum, modul Web3 (opens in a new tab) menawarkan beberapa fungsi kenyamanan. Mari kita jelajahi beberapa di antaranya.

Dalam aplikasi Ethereum, Anda biasanya perlu mengonversi denominasi mata uang. Modul Web3 menyediakan beberapa metode pembantu khusus untuk ini: from_wei (opens in a new tab) dan to_wei (opens in a new tab).

Coba konversikan beberapa nilai ke dan dari wei. Perhatikan bahwa ada nama untuk banyak denominasi (opens in a new tab) di antara ether dan wei. Salah satu yang lebih dikenal di antaranya adalah gwei, karena sering kali begitulah biaya transaksi direpresentasikan.

1In [2]: Web3.to_wei(1, 'ether')
2Out[2]: 1000000000000000000
3
4In [3]: Web3.from_wei(500000000, 'gwei')
5Out[3]: Decimal('0.5')
Salin

Metode utilitas lain pada modul Web3 mencakup pengonversi format data (mis., toHex (opens in a new tab)), pembantu alamat (mis., isAddress (opens in a new tab)), dan fungsi hash (mis., keccak (opens in a new tab)). Banyak dari ini akan dibahas nanti dalam seri ini. Untuk melihat semua metode dan properti yang tersedia, manfaatkan pelengkapan otomatis IPython dengan mengetik Web3. dan menekan tombol tab dua kali setelah titik.

Berbicara dengan rantai

Metode kenyamanan memang menyenangkan, tetapi mari kita beralih ke blockchain. Langkah selanjutnya adalah mengonfigurasi Web3.py untuk berkomunikasi dengan node Ethereum. Di sini kita memiliki opsi untuk menggunakan penyedia IPC, HTTP, atau Websocket.

Kita tidak akan menempuh jalur ini, tetapi contoh alur kerja lengkap menggunakan Penyedia HTTP mungkin terlihat seperti ini:

• Unduh node Ethereum, mis., Geth (opens in a new tab).
• Mulai Geth di satu jendela terminal dan tunggu hingga menyinkronkan jaringan. Port HTTP default adalah 8545, tetapi dapat dikonfigurasi.
• Beri tahu Web3.py untuk terhubung ke node melalui HTTP, di localhost:8545. w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))
• Gunakan instans w3 untuk berinteraksi dengan node.

Meskipun ini adalah salah satu cara "nyata" untuk melakukannya, proses sinkronisasi memakan waktu berjam-jam dan tidak perlu jika Anda hanya menginginkan lingkungan pengembangan. Web3.py mengekspos penyedia keempat untuk tujuan ini, yaitu EthereumTesterProvider. Penyedia penguji ini menautkan ke node Ethereum yang disimulasikan dengan izin yang dilonggarkan dan mata uang palsu untuk dimainkan.

EthereumTesterProvider terhubung ke node yang disimulasikan dan berguna untuk lingkungan pengembangan yang cepat.

Node yang disimulasikan itu disebut eth-tester (opens in a new tab) dan kita menginstalnya sebagai bagian dari perintah pip install web3[tester]. Mengonfigurasi Web3.py untuk menggunakan penyedia penguji ini semudah:

1In [4]: w3 = Web3(Web3.EthereumTesterProvider())
Salin

Sekarang Anda siap untuk berselancar di rantai! Itu bukan hal yang biasa dikatakan orang. Saya hanya mengarangnya. Mari kita lakukan tur singkat.

Tur singkat

Pertama-tama, pemeriksaan kewarasan (sanity check):

1In [5]: w3.is_connected()
2Out[5]: True
Salin

Karena kita menggunakan penyedia penguji, ini bukanlah pengujian yang sangat berharga, tetapi jika gagal, kemungkinan besar Anda salah mengetik sesuatu saat membuat instans variabel w3. Periksa kembali apakah Anda menyertakan tanda kurung di dalam, yaitu, Web3.EthereumTesterProvider().

Perhentian tur #1: akun

Sebagai kemudahan, penyedia penguji membuat beberapa akun dan memuatnya dengan ether pengujian.

Pertama, mari kita lihat daftar akun tersebut:

1In [6]: w3.eth.accounts
2Out[6]: ['0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
3 '0x2B5AD5c4795c026514f8317c7a215E218DcCD6cF',
4 '0x6813Eb9362372EEF6200f3b1dbC3f819671cBA69', ...]
Salin

Jika Anda menjalankan perintah ini, Anda akan melihat daftar sepuluh string yang dimulai dengan 0x. Masing-masing adalah alamat publik dan, dalam beberapa hal, analog dengan nomor akun pada rekening giro. Anda akan memberikan alamat ini kepada seseorang yang ingin mengirimi Anda ether.

Seperti yang disebutkan, penyedia penguji telah memuat setiap akun ini dengan beberapa ether pengujian. Mari kita cari tahu berapa banyak yang ada di akun pertama:

1In [7]: w3.eth.get_balance(w3.eth.accounts[0])
2Out[7]: 1000000000000000000000000
Salin

Itu banyak sekali angka nol! Sebelum Anda tertawa terbahak-bahak ke bank palsu, ingatlah pelajaran tentang denominasi mata uang dari sebelumnya. Nilai ether direpresentasikan dalam denominasi terkecil, wei. Konversikan itu ke ether:

1In [8]: w3.from_wei(1000000000000000000000000, 'ether')
2Out[8]: Decimal('1000000')
Salin

Satu juta ether pengujian — masih lumayan.

Perhentian tur #2: data blok

Mari kita intip status dari blockchain yang disimulasikan ini:

1In [9]: w3.eth.get_block('latest')
2Out[9]: AttributeDict({
3   'number': 0,
4   'hash': HexBytes('0x9469878...'),
5   'parentHash': HexBytes('0x0000000...'),
6   ...
7   'transactions': []
8})
Salin

Banyak informasi yang dikembalikan tentang sebuah blok, tetapi hanya beberapa hal yang perlu ditunjukkan di sini:

• Nomor blok adalah nol — tidak peduli berapa lama yang lalu Anda mengonfigurasi penyedia penguji. Tidak seperti jaringan Ethereum yang sebenarnya, yang menambahkan blok baru setiap 12 detik, simulasi ini akan menunggu hingga Anda memberinya beberapa pekerjaan untuk dilakukan.
• transactions adalah daftar kosong, karena alasan yang sama: kita belum melakukan apa pun. Blok pertama ini adalah blok kosong, hanya untuk memulai rantai.
• Perhatikan bahwa parentHash hanyalah sekumpulan byte kosong. Ini menandakan bahwa ini adalah blok pertama dalam rantai, yang juga dikenal sebagai blok genesis.

Perhentian tur #3: transaksi

Kita terjebak di blok nol sampai ada transaksi yang tertunda, jadi mari kita berikan satu. Kirim beberapa ether pengujian dari satu akun ke akun lainnya:

1In [10]: tx_hash = w3.eth.send_transaction({
2   'from': w3.eth.accounts[0],
3   'to': w3.eth.accounts[1],
4   'value': w3.to_wei(3, 'ether'),
5   'gas': 21000
6})
Salin

Ini biasanya adalah titik di mana Anda akan menunggu selama beberapa detik agar transaksi Anda dimasukkan ke dalam blok baru. Proses lengkapnya kira-kira seperti ini:

1. Kirimkan transaksi dan simpan hash transaksi. Sampai blok yang berisi transaksi dibuat dan disiarkan, transaksi tersebut berstatus "tertunda". tx_hash = w3.eth.send_transaction({ … })
2. Tunggu hingga transaksi dimasukkan ke dalam blok: w3.eth.wait_for_transaction_receipt(tx_hash)
3. Lanjutkan logika aplikasi. Untuk melihat transaksi yang berhasil: w3.eth.get_transaction(tx_hash)

Lingkungan simulasi kita akan menambahkan transaksi dalam blok baru secara instan, sehingga kita dapat segera melihat transaksi tersebut:

1In [11]: w3.eth.get_transaction(tx_hash)
2Out[11]: AttributeDict({
3   'hash': HexBytes('0x15e9fb95dc39...'),
4   'blockNumber': 1,
5   'transactionIndex': 0,
6   'from': '0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
7   'to': '0x2B5AD5c4795c026514f8317c7a215E218DcCD6cF',
8   'value': 3000000000000000000,
9   ...
10})
Tampilkan semua
Salin

Anda akan melihat beberapa detail yang familier di sini: bidang from, to, dan value harus cocok dengan input dari panggilan send_transaction kita. Hal lain yang meyakinkan adalah bahwa transaksi ini dimasukkan sebagai transaksi pertama ('transactionIndex': 0) di dalam blok nomor 1.

Kita juga dapat dengan mudah memverifikasi keberhasilan transaksi ini dengan memeriksa saldo dari kedua akun yang terlibat. Tiga ether seharusnya telah berpindah dari satu akun ke akun lainnya.

1In [12]: w3.eth.get_balance(w3.eth.accounts[0])
2Out[12]: 999996999979000000000000
3
4In [13]: w3.eth.get_balance(w3.eth.accounts[1])
5Out[13]: 1000003000000000000000000
Salin

Yang terakhir terlihat bagus! Saldonya berubah dari 1.000.000 menjadi 1.000.003 ether. Tetapi apa yang terjadi pada akun pertama? Tampaknya telah kehilangan sedikit lebih dari tiga ether. Sayangnya, tidak ada yang gratis dalam hidup ini, dan menggunakan jaringan publik Ethereum mengharuskan Anda memberikan kompensasi kepada rekan-rekan Anda atas peran pendukung mereka. Biaya transaksi kecil dipotong dari akun yang mengirimkan transaksi - biaya ini adalah jumlah gas yang dibakar (21000 unit gas untuk transfer ETH) dikalikan dengan biaya dasar yang bervariasi sesuai dengan aktivitas jaringan ditambah tip yang diberikan kepada validator yang memasukkan transaksi ke dalam blok.

Selengkapnya tentang gas

Dan bernapaslah

Kita telah melakukan ini untuk sementara waktu, jadi ini sepertinya tempat yang baik untuk beristirahat. Penjelajahan ini terus berlanjut, dan kita akan terus menjelajah di bagian kedua dari seri ini. Beberapa konsep yang akan datang: menghubungkan ke node nyata, kontrak pintar, dan token. Punya pertanyaan lanjutan? Beri tahu saya! Umpan balik Anda akan memengaruhi ke mana kita akan pergi dari sini. Permintaan diterima melalui Twitter (opens in a new tab).

Pembaruan terakhir halaman: 3 Maret 2026

m (opens in a new tab)

b (opens in a new tab)

n (opens in a new tab)

+15

Lihat kontributor