BARU: Solana Privacy Rings kini tersedia di mainnet
Cara Bermigrasi dari Ethereum ke Solana: Panduan untuk Developer
Blog/Riset

Cara Bermigrasi dari Ethereum ke Solana: Panduan untuk Developer

Developer Experience Engineer0xIchigo di X0xIchigo di LinkedIn0xIchigo di GitHub
Bacaan 41 menit

Apa yang dibahas dalam artikel ini?

Ethereum adalah salah satu inovasi terpenting dalam beberapa tahun terakhir. Untuk pertama kalinya dalam sejarah, kita memiliki platform global terdesentralisasi yang dibangun untuk koordinasi sosial dan berpotensi merevolusi banyak industri. Terlepas dari arti pentingnya, lingkungan runtime Ethereum, Ethereum Virtual Machine (EVM), dalam kondisinya saat ini tidak dirancang untuk aplikasi kelas konsumen. Ethereum merupakan jaringan single-thread berbasis gas dengan biaya yang fluktuatif. Sebaliknya, Solana hadir sebagai jaringan ber-throughput tinggi dan berlatensi rendah. Solana menawarkan infrastruktur paralel dengan biaya rendah dan dapat diprediksi. Solana secara langsung mengatasi keterbatasan EVM dan menyempurnakan desain aslinya, menjadikannya pilihan menarik bagi developer yang ingin membangun aplikasi yang skalabel dan efisien.

Artikel ini adalah panduan migrasi lengkap bagi developer EVM yang ingin membangun di Solana. Artikel ini membahas perbedaan mendasar antara keduanya, termasuk mekanisme konsensus Ethereum dan Solana, cara keduanya memproses transaksi, serta bahasa yang digunakan untuk mengembangkan smart contract. Selanjutnya, artikel ini membahas model akun Solana, yang menawarkan pendekatan lebih seragam dan multifungsi terhadap akun. Artikel ini juga membahas Solang dan Neon EVM, dua alat yang kompatibel dengan Solidity dan meningkatkan pengalaman pengembangan di Solana.

Perbedaan Mendasar

Bagian ini membahas perbedaan penting antara Ethereum dan Solana, dua blockchain yang bertujuan menciptakan mesin status terdesentralisasi untuk koordinasi global. Namun, keduanya sangat berbeda dalam mekanisme konsensus, metode pemrosesan transaksi, dan bahasa yang digunakan untuk mengembangkan smart contract. Pemahaman yang lebih mendalam tentang perbedaan mendasar ini memperjelas keunggulan Solana dibandingkan Ethereum sebagai mesin status global berperforma tinggi.

Mekanisme Konsensus

Mekanisme konsensus menjadi fondasi setiap jaringan blockchain. Mekanisme ini menentukan cara transaksi diverifikasi dan blok ditambahkan ke blockchain secara aman, efisien, dan terdesentralisasi. Ethereum dan Solana sama-sama merupakan jaringan Proof of Stake (PoS). Meskipun memiliki fondasi PoS yang sama, pendekatan keduanya untuk mencapai konsensus berbeda karena aturan konfirmasinya.

Ethereum menggunakan Gasper, yaitu kombinasi dari Casper the Friendly Finality Gadget (Casper-FFG) dan algoritma pemilihan fork LMD-GHOST. Kombinasi ini membentuk mekanisme konsensus yang mengamankan Ethereum.

Casper adalah sistem finalitas berbasis PoS yang meningkatkan status konfirmasi blok menjadi “final.” Sebuah blok dianggap final di Ethereum ketika dua pertiga dari total stake memberikan suara untuk menyertakan blok tersebut dan blok lain dibangun di atasnya. Karena finalitas membutuhkan persetujuan dari dua pertiga total stake bahwa sebuah blok bersifat kanonis, penyerang tidak dapat membuat rantai final alternatif tanpa memiliki atau memanipulasi dua pertiga total stake serta menghilangkan setidaknya sepertiganya melalui slashing. Casper memungkinkan peserta baru melakukan sinkronisasi dengan rantai kanonis secara meyakinkan. 

LMD-GHOST adalah singkatan dari “Latest Message-Driven Greedy Heaviest Observed Sub-Tree.” Ini adalah algoritma yang menentukan fork Ethereum mana yang harus diikuti. Algoritma ini memilih fork yang menerima dukungan (yaitu, “bobot”) terbanyak dari validator jaringan, sehingga disebut “greedy heaviest sub-tree”. Setelah itu, algoritma memastikan hanya pesan terbaru dari setiap validator yang dipertimbangkan. Setiap kali blok baru diajukan ke Ethereum, validator menggunakan aturan ini untuk menentukan apakah blok tersebut harus menjadi bagian dari rantai kanonis.

Sebagai perbandingan, Solana menggunakan hash Proof of History (PoH) untuk mencapai konsensus. Meskipun namanya dapat membingungkan, PoH bukan algoritma konsensus. PoH merupakan cara untuk membuktikan waktu dalam jaringan adversarial. Lebih spesifiknya, PoH adalah fungsi stempel waktu kriptografis yang memungkinkan node menyepakati urutan peristiwa tanpa berkomunikasi satu sama lain. Leader (yaitu, validator yang menambahkan entri ke ledger) menerapkan stempel waktu pada blok untuk membuktikan bahwa sejumlah waktu telah berlalu sejak blok sebelumnya. 

Penambahan stempel waktu ini membentuk catatan historis karena membuktikan bahwa data telah ada pada waktu tertentu. Catatan historis dibuat menggunakan fungsi hash sekuensial yang tahan preimage, dengan setiap hash bergantung pada hash sebelumnya. Verifiable Delay Functions (VDFs) berperan penting dalam menghasilkan hash ini. VDF memastikan setiap hash dibangun di atas hash sebelumnya dan menyertakan waktu yang telah berlalu sejak saat itu. Integrasi VDF menambahkan dimensi waktu pada proses hashing, sehingga rangkaian peristiwa dengan stempel waktu yang dapat diverifikasi dapat dibuat di Solana.

Setelah memahami cara mekanisme Proof of History Solana menciptakan urutan peristiwa yang andal melalui stempel waktu kriptografis, penting untuk memahami integrasinya dengan mekanisme konsensus Solana, Tower BFT. Tower Byzantine Fault Tolerance (BFT) adalah varian Solana dari model konsensus Byzantine Fault Tolerance tradisional yang dioptimalkan untuk PoH. Tower BFT menggunakan catatan historis yang dibuat oleh PoH sebagai kerangka acuan. Kerangka ini memungkinkan validator memberikan suara terhadap status ledger secara efisien dan akurat. Tower BFT bekerja dengan meminta validator memberikan suara yang dikunci untuk waktu lama, dengan komitmen yang semakin kuat seiring bertambahnya suara. Berkat PoH, validator dapat mengambil keputusan yang lebih cepat dan tepat mengenai status ledger tanpa perlu berkomunikasi satu sama lain. Kombinasi PoH dan Tower BFT mempercepat konsensus serta meningkatkan keamanan dan keandalan jaringan. Hasilnya adalah lingkungan blockchain ber-throughput tinggi dan skalabel, tempat transaksi dikonfirmasi dengan cepat.

Pemrosesan Transaksi dan Lingkungan Eksekusi

Efisiensi dan skalabilitas blockchain terutama ditentukan oleh kemampuan pemrosesan transaksi dan lingkungan eksekusinya. Faktor-faktor ini menentukan kecepatan eksekusi transaksi serta efisiensi biaya operasi di jaringan. Pendekatan blockchain terhadap pemrosesan transaksi dan detail lingkungan eksekusinya sangat memengaruhi pengalaman developer.

Lingkungan runtime Ethereum beroperasi sebagai mesin stack single-thread deterministik yang dikenal sebagai Ethereum Virtual Machine (EVM). EVM berperilaku seperti fungsi matematika. Artinya, EVM menghasilkan output deterministik ketika menerima input. Ethereum dapat didefinisikan sebagai fungsi transisi status: f(S, T) = S’. Dengan status lama (S) dan sekumpulan transaksi valid baru (T), EVM menghasilkan status output valid baru (S’). EVM akan selalu mencapai status akhir yang sama jika diberikan kumpulan transaksi yang sama. Hal ini penting untuk menjaga konsistensi di seluruh node jaringan.

EVM memproses transaksi secara berurutan. Pemrosesan berurutan memastikan setiap transaksi dieksekusi dalam lingkungan yang secara akurat mencerminkan status jaringan hingga saat itu. Eksekusi berurutan memungkinkan penghitungan perubahan status dan biaya gas secara presisi. Prediktabilitas ini memberikan pemahaman yang jelas kepada developer dan pengguna mengenai hasil serta biaya transaksi.

Ethereum menyederhanakan lingkungan eksekusi smart contract dengan menerapkan model eksekusi single-thread. Model ini memberi developer keuntungan berupa perubahan status yang dapat diprediksi karena setiap transaksi diproses secara berurutan. Perubahan status yang dapat diprediksi membuat lingkungan pengembangan Ethereum relatif lebih mudah dipahami oleh developer baru karena mereka dapat lebih berfokus pada logika smart contract daripada kerumitan eksekusi. Namun, kesederhanaan ini menyulitkan skalabilitas. Pemrosesan berurutan membatasi throughput jaringan. Hal ini dapat menyebabkan kemacetan, waktu tunggu transaksi yang lebih lama, dan biaya gas yang lebih tinggi saat permintaan meningkat. Karena setiap transaksi mengonsumsi gas, developer harus mengoptimalkan efisiensi gas. Pengoptimalan dilakukan untuk meningkatkan pengalaman pengguna secara keseluruhan dan mengatasi periode kemacetan, ketika kode yang tidak efisien dapat membuat aplikasi tidak dapat digunakan oleh pengguna biasa.

Developer Solana tidak perlu mengkhawatirkan pengoptimalan penggunaan gas seperti developer Ethereum. Solana dirancang sebagai mesin status ber-throughput tinggi dan berlatensi rendah yang dikenal sebagai Solana Virtual Machine (SVM). Komponen penting SVM adalah Sealevel. Sealevel adalah mesin runtime yang memproses transaksi secara paralel. Di Solana, setiap transaksi memberi tahu runtime bagian status mana yang akan dibaca atau ditulis saat dieksekusi. Runtime memproses transaksi yang tidak berkonflik dan transaksi yang membaca status yang sama secara paralel. Sealevel mengoptimalkan eksekusi smart contract dengan mendistribusikan beban kerja transaksi ke beberapa thread pada perangkat keras validator. Jadi, ketika validator memproses transaksi pada satu core, transaksi lain dapat diproses secara bersamaan pada core lainnya.

Paralelisme bawaan Solana secara signifikan mengurangi biaya transaksi. Transaksi Solana memiliki dua biaya: biaya dasar dan biaya prioritas. Biaya dasar ditetapkan sebesar 5000 lamport per tanda tangan; sebagian besar transaksi hanya memiliki satu tanda tangan. Biaya prioritas bersifat opsional dan memungkinkan suatu transaksi diprioritaskan dibandingkan transaksi lainnya. Transaksi dengan biaya prioritas lebih tinggi diprioritaskan secara nondeterministik oleh scheduler. Biaya transaksi sering kali di bawah $0.001 USD, sedangkan biaya rata-rata untuk transaksi non-voting berada dalam rentang 0.000005 hingga 0.00007 SOL. Batas atasnya lebih tinggi dari biasanya karena penggunaan biaya prioritas baru-baru ini meningkat. Dengan harga SOL saat ini sebesar ~$98.96, biaya tersebut setara dengan sekitar $0.000494 hingga $0.006968 USD. 

Biaya ini juga dapat diprediksi. Solana menggunakan pasar biaya terlokalisasi untuk mengelola permintaan. Blockspace disusun agar satu hotspot aktivitas tertentu (misalnya, mint NFT yang sedang populer) tidak mendominasi blockspace dan menaikkan biaya di seluruh jaringan. Hanya transaksi yang mencoba mengakses hotspot tertentu dengan permintaan tinggi yang akan mengalami kenaikan biaya. Pasar biaya terlokalisasi memungkinkan adanya biaya prioritas tanpa memicu perang gas besar-besaran. Lokalisasi ini berbeda dari jaringan berbasis gas seperti Ethereum, tempat transaksi diproses secara berurutan dan kemacetan global menyebabkan biaya berfluktuasi.

Ethereum adalah lingkungan runtime single-thread yang hanya memproses satu kontrak pada satu waktu. Saat ini, Ethereum tidak memanfaatkan perangkat keras multi-core modern sehingga perangkat keras validator tidak digunakan secara optimal. Keinginan untuk mempertahankan persyaratan perangkat keras node yang rendah semakin membatasi pemrosesan transaksi Ethereum. Sebagai perbandingan, kemampuan pemrosesan paralel Solana memungkinkannya memproses lebih banyak transaksi dengan memanfaatkan semua core validator yang tersedia. Ditambah dengan pasar biaya terlokalisasi, Solana menjadi mesin status global dengan performa yang jauh lebih tinggi. 

Bahasa Smart Contract

Bahasa utama untuk pengembangan smart contract di Ethereum adalah Solidity. Solidity adalah bahasa bertipe statis dengan kurung kurawal yang dirancang untuk membuat smart contract yang berjalan di EVM. Bahasa ini sangat dipengaruhi oleh JavaScript, C++, dan Python, sehingga mudah dipelajari oleh developer yang sudah terbiasa dengan bahasa-bahasa tersebut.

Yul adalah bahasa perantara tingkat rendah yang dioptimalkan untuk blockchain yang kompatibel dengan EVM. Yul memberi developer kontrol lebih besar atas eksekusi bytecode sehingga sangat efisien untuk menyempurnakan konsumsi gas dan mengelola operasi tingkat rendah lainnya. Developer dapat membuat kontrak yang lebih efisien dengan menulis kode langsung dalam Yul atau menggunakannya sebagai target kompilasi.

Vyper adalah bahasa populer bergaya Python yang mengutamakan kesederhanaan dan keamanan. Vyper sengaja memiliki lebih sedikit fitur daripada Solidity karena bertujuan mengurangi kompleksitas dan potensi kerentanan keamanan. Filosofi desain Vyper menempatkan keterbacaan dan kemudahan audit di atas segalanya. Pendekatan ini telah menginspirasi pengembangan bahasa serupa, seperti Fe, serta bahasa yang dikompilasi ke Vyper, seperti Dasy.

Rust adalah lingua franca untuk pengembangan smart contract (yang sehari-hari disebut program) di Solana. Rust adalah bahasa yang cepat dan efisien dalam penggunaan memori, dengan performa yang sebanding dengan C++. Karakteristik ini membuatnya cocok untuk mengembangkan aplikasi bagi jaringan ber-throughput tinggi dan berlatensi rendah. Sistem tipe dan model kepemilikan Rust yang kaya memastikan keamanan memori dan thread, sehingga mendorong developer membangun aplikasi yang andal dan aman. 

Meskipun Rust memiliki kurva pembelajaran yang curam bagi mereka yang baru mengenal pemrograman sistem, keuntungannya adalah kemampuan untuk membuat kode yang tangguh dan efisien. Sebagian besar pengembangan Rust dilakukan menggunakan Anchor. Anchor adalah framework dengan pendekatan yang tegas, yang menyederhanakan pengembangan program dengan mengurangi boilerplate, menjalankan berbagai pemeriksaan keamanan standar, dan menyederhanakan proses (de)serialisasi. Karena itu, pengetahuan Rust tingkat lanjut tidak terlalu penting untuk memulai. Sebagai konteks, dokumentasi Anchor menyarankan pengguna untuk memahami sembilan bab pertama Rust Book (yaitu, memahami dasar-dasar Rust). Solana Playground menyediakan beberapa tutorial Anchor untuk membantu Anda memulai.

Meskipun Rust menjadi pilihan utama, developer tidak terbatas pada bahasa tersebut. C, C++, dan bahasa apa pun yang menargetkan backend BPF LLVM (yaitu, bahasa apa pun yang dapat dikompilasi menjadi bytecode BPF) dapat digunakan. Bagi mereka yang terbiasa dengan bahasa bergaya Python seperti Vyper, Seahorse Lang memungkinkan developer menulis program dalam Python. Dengan demikian, developer mendapatkan kemudahan penggunaan Python sekaligus mempertahankan jaminan keamanan yang sama seperti jika mereka menulis kode dalam Rust. Sejumlah tutorial Seahorse yang bermanfaat, seperti Seahorse University dan Seahorse Cookbook, tersedia untuk membantu Anda mulai memprogram di Solana hari ini.

Developer yang bermigrasi dari Ethereum tidak harus terbatas pada Rust. Meskipun mempelajari dan menggunakan framework seperti Anchor dan Seahorse direkomendasikan karena popularitas serta jaminan keamanannya, hal ini tidak selalu memungkinkan. Berkat perkembangan terbaru dari Solang dan Neon Labs melalui compiler dan lingkungan developer yang kompatibel dengan EVM, developer dapat menggunakan Solidity dalam pengembangan program. Solidity memiliki tempat di Solana. Untuk mulai mengembangkan program dengan Solidity, kita perlu mempelajari lebih dalam detail model pemrograman Solana. Memahami model akun Solana sangat penting bagi developer yang melakukan transisi ini karena model tersebut menjadi fondasi pengembangan program dan interaksi di jaringan.

Memahami Model Akun

Ethereum membagi akun ke dalam dua kategori utama: externally owned accounts (EOA) dan akun kontrak. EOA adalah jenis akun standar bagi pengguna. Akun ini dikendalikan oleh private key serta dapat menyimpan saldo Ether, mengirim transaksi, dan berinteraksi dengan akun kontrak. Di sisi lain, akun kontrak berbeda karena operasinya diatur oleh kode smart contract yang tertanam di dalamnya. Akun ini tidak dapat memulai transaksi secara mandiri dan hanya dapat bertindak sebagai respons terhadap transaksi yang diterima dari EOA atau akun kontrak lain.

Solana menerapkan model akun yang lebih seragam dengan memperlakukan akun sebagai kontainer multifungsi yang menyimpan data secara persisten. Model ini memungkinkan akun apa pun menjadi program, sehingga mengaburkan batas tradisional antara akun dan smart contract. Tidak seperti Ethereum, yang menggabungkan kode dan status dalam satu akun, program Solana bersifat stateless. Artinya, program tidak menyimpan status apa pun secara internal. Sebaliknya, semua data yang perlu dioperasikan disimpan dalam akun terpisah dan diteruskan melalui referensi bersama transaksi. Penerusan akun melalui referensi memungkinkan satu deployment program generik berinteraksi dengan akun yang berbeda. Model akun Solana memisahkan kode dan data, sehingga menciptakan lingkungan pengembangan yang lebih efisien dan modular. Hal ini menguntungkan pengguna yang ingin berinteraksi dengan beberapa protokol tanpa memindahkan aset di antara program yang berbeda. Semua hal di Solana adalah akun. 

Akun Solana secara umum dapat dibagi menjadi akun executable dan non-executable. Sederhananya, akun executable adalah akun yang mampu menjalankan kode. Akun non-executable digunakan untuk menyimpan data tanpa kemampuan menjalankan kode karena akun tersebut tidak menyimpan kode apa pun.

Akun executable adalah akun yang menyimpan program. Program dapat memiliki akun tambahan, membaca atau mengkredit akun lain, mengubah data, atau mendebit akun yang dimilikinya. Akun executable dapat dibagi lebih lanjut menjadi program on-chain atau native. Program on-chain adalah kode buatan pengguna yang di-deploy ke jaringan. Program ini dapat ditingkatkan oleh upgrade authority-nya, yang biasanya merupakan akun yang melakukan deployment. Program native adalah subset khusus akun executable yang serupa dengan kontrak precompiled Ethereum, tetapi memiliki fungsi lebih luas. Program ini terintegrasi ke dalam inti Solana dan menyediakan fungsi yang diperlukan agar validator dapat beroperasi. Salah satu contoh program native adalah System Program. Program ini bertanggung jawab membuat akun baru, mengalokasikan data akun, menetapkan akun ke program, mentransfer lamport dari akun yang dimilikinya, dan membayar biaya transaksi. Daftar lengkap program native dapat ditemukan di sini.

Terlepas dari apakah akun tersebut executable atau non-executable, semua akun memiliki field yang sama: 

  • Field lamports untuk melacak saldo native akun dalam SOL
  • Field data, yang merujuk pada array byte data mentah yang disimpan oleh akun
  • Field owner yang menunjukkan program yang dapat mengubah akun ini
  • Field signer, yang digunakan dalam transaksi untuk menunjukkan apakah akun dapat menyetujui transaksi
  • Field writable untuk menentukan apakah data akun dapat diubah. Field ini memfasilitasi pemrosesan paralel dengan menandai akun yang disertakan dalam transaksi sebagai read-only atau writable
  • Field executable untuk menunjukkan apakah akun menyimpan program
  • Field rent epoch untuk menunjukkan epoch berikutnya saat akun harus membayar rent

Rent adalah biaya penyimpanan untuk menjaga akun tetap aktif di Solana dan memastikan akun tersebut disimpan dalam memori validator. Karena itu, akun harus mempertahankan saldo minimum agar tetap aktif. Rent mengurangi pembengkakan status dengan memastikan jaringan pada akhirnya mengambil kembali akun yang tidak digunakan atau kekurangan dana. Pembaruan terbaru membuat mainnet tidak lagi memiliki akun yang membayar rent. Sebaliknya, semua akun harus bebas rent saat dibuat. Akun bebas rent jika mempertahankan saldo minimum yang setara dengan pembayaran rent selama dua tahun. Alat seperti Helius API Playground dan subperintah rent pada Solana CLI dapat digunakan untuk memperkirakan jumlah SOL yang diperlukan agar sebuah akun bebas rent. Pendekatan ini berbeda dari sistem alokasi sumber daya Ethereum, tempat penyimpanan tetap ada kecuali dihapus secara eksplisit. Pendekatan Solana menawarkan struktur biaya penyimpanan status yang lebih dapat diprediksi sekaligus mengurangi pembengkakan status.

Alamat dan Program Derived Addresses (PDA)

Semua akun diidentifikasi berdasarkan alamatnya, yaitu public key unik berukuran 32 byte. Hal ini berbeda dari model data Ethereum, yang menggunakan alamat berukuran 20 byte. Solana menggunakan ed25519 (yaitu, skema tanda tangan EdDSA yang menggunakan SHA-512 dan kurva eliptik Curve22519) untuk menghasilkan alamat. Sebuah akun harus berupa titik pada kurva ed25519 agar memiliki keypair yang valid. 

Program Derived Addresses (PDA) adalah akun yang dibuat di luar kurva menggunakan bump (yaitu, nilai yang mendorong output keluar dari kurva). PDA membutuhkan tiga bagian utama: alamat program induknya, sekumpulan seed, dan bump. Seed adalah array string yang dapat memiliki nilai apa pun. Namun, sebagian besar developer membuat seed tertentu yang terkait dengan variabel status dalam program induk untuk membuat struktur data mirip hashmap. Dengan demikian, PDA dibuat dengan melakukan hashing terhadap ID program, seed, dan bump menggunakan fungsi hash SHA-512.

Tujuan PDA dibuat di luar kurva adalah agar hanya program asal PDA tersebut yang dapat menandatangani atas nama PDA. Hal ini menyederhanakan alur transaksi dengan menghasilkan tanda tangan transaksi secara terprogram, sehingga dApp trustless dapat beroperasi dengan lancar tanpa intervensi.

Berinteraksi dengan Akun

Transaksi Ethereum adalah tindakan yang mengubah status dan dimulai oleh EOA. Smart contract tidak dapat memulai transaksi secara mandiri; smart contract hanya dapat merespons transaksi. Kode kontrak menentukan respons tersebut, sedangkan biaya eksekusi transaksi diukur dalam gas. Pengguna harus menyediakan Ether yang cukup untuk membayar biaya gas ini.

Transaksi Ethereum biasanya menjalankan satu operasi, seperti memanggil fungsi smart contract tertentu. Meskipun satu transaksi dapat menyebabkan beberapa perubahan status dalam kontrak, semua perubahan terbatas pada cakupan satu pemanggilan kontrak tersebut.

Di Solana, sebuah transaksi terdiri dari array akun yang akan dibaca atau ditulis, satu atau beberapa tanda tangan, serta satu atau beberapa instruksi. Instruksi adalah perintah untuk satu pemanggilan program. Instruksi merupakan unit terkecil dari logika eksekusi dan unit operasional paling mendasar. Instruksi menentukan program yang dieksekusi, semua akun yang terlibat, dan data operasional. Program menafsirkan data dari instruksi dan beroperasi pada akun yang ditentukan. Struktur ini memungkinkan satu transaksi menjalankan serangkaian tindakan di beberapa program secara atomik. Artinya, semua instruksi berhasil atau gagal secara bersamaan. Alur transaksi Solana berbeda dari model Ethereum, tempat transaksi biasanya terkait dengan satu smart contract atau tindakan EOA.

Cross-Program Invocations (CPI) memungkinkan sebuah program memanggil program lain dalam transaksi yang sama. Jumlah byte data akun per compute unit yang dikenakan selama CPI adalah 250. Jumlah ini kira-kira setara dengan 50MB pada 200.000 unit. CPI memungkinkan penggunaan tanda tangan yang dihasilkan secara terprogram saat melakukan pemanggilan antarprogram. Hal ini serupa dengan smart contract Ethereum yang memanggil kontrak lain secara efisien dan atomik. Namun, program pemanggil dihentikan sementara hingga program yang dipanggil selesai memproses instruksi. Reentrancy dibatasi pada rekursi mandiri langsung dengan kedalaman maksimum tetap sebesar 4. Hal ini mencegah situasi ketika sebuah program memanggil program lain dari status perantara tanpa mengetahui bahwa program tersebut mungkin dipanggil kembali nantinya.

Transaksi Solana mematuhi batas ukuran demi efisiensi, serupa dengan batas gas Ethereum. Namun, fokusnya adalah ukuran data. Transaksi Solana mengikuti standar IPv6 Maximum Transmission Unit (MTU) untuk menjamin transmisi data yang andal. Setelah ruang header yang diperlukan dialokasikan, tersedia 1232 byte untuk data paket. Solana memperkenalkan transaksi berversi untuk mendukung beberapa format transaksi dan mengatasi batasan ukuran. Selain format legacy (yaitu, format transaksi asli), Version 0 dirilis untuk mendukung Address Lookup Tables (ALT). ALT menyimpan alamat dalam struktur data berbentuk tabel secara on-chain, dengan setiap alamat diindeks menggunakan indeks u8 berukuran 1 byte. Hal ini secara signifikan mengurangi ukuran transaksi karena setiap akun hanya membutuhkan 1 byte, bukan 32 byte.

Solang

Solang adalah compiler Solidity untuk Solana dan Polkadot. Solang bertujuan mencapai kompatibilitas file sumber dengan versi 0.8 compiler Solidity EVM, meski dengan beberapa variasi agar selaras dengan arsitektur Solana dan Polkadot. Salah satu aspek penting Solang adalah penggunaan LLVM, infrastruktur compiler yang andal. Fleksibilitas LLVM memungkinkan Solang memperluas dukungan ke bahasa pemrograman lain pada masa mendatang, sehingga implementasi dan kompilasi menjadi lebih mudah. Karakteristik ini selaras dengan tujuan Solang untuk memudahkan transisi developer ke Solana atau Polkadot dan memperluas cakupan pengembangan Solidity. Solang terus dikembangkan dengan fokus pada peningkatan kompatibilitas, efisiensi, dan kemudahan penggunaan. Developer Ethereum yang ingin membawa keahlian mereka ke berbagai chain perlu memahami Solang beserta hal-hal yang perlu diperhatikan.

Instalasi

Ada beberapa cara untuk menginstal Solang. Di Mac, pengguna dapat mengunduh Solang dengan Brew menggunakan tap privat:

Kode
brew install hyperledger/solang/solang

Cara lain untuk menginstal Solang adalah menggunakan container Solang. Cara ini sangat cocok jika Anda lebih suka menggunakan Docker, karena image baru secara otomatis tersedia di container tersebut. Tersedia tag v.0.3.3 dan tag latest:

Kode
docker pull ghcr.io/hyperledger/solang:latest

Salah satu cara yang lebih mudah untuk menginstal dan menggunakan Solang adalah melalui Ancor. Untuk memulai, pastikan Rust dan Node.js telah terinstal di sistem Anda. Pengguna Windows juga perlu menyiapkan Windows Subsystem for Linux. Sekarang, kita perlu menginstal Tool Suite Solana. Di Mac dan Linux, Anda dapat melakukannya dengan perintah berikut:

Kode
 sh -c "$(curl -sSfL https://release.solana.com/v1.17.13/install)"

Jika Anda menginginkan versi perangkat lunak lain, ganti “v1.17.13” dengan tag rilis yang sesuai. Sebagai alternatif, Anda dapat menggunakan salah satu nama channel simbolis berikut: stable, beta, atau edge. Bergantung pada sistem Anda, variabel lingkungan PATH mungkin perlu diperbarui. Jika pesan ini muncul, salin dan tempel perintah yang disarankan di bawah untuk memperbarui PATH. Anda dapat mengonfirmasi versi solana yang diinginkan dengan menjalankan solana --version.

Di Windows, buka Command Prompt sebagai Administrator. Salin dan tempel perintah berikut untuk mengunduh installer Solana ke direktori sementara:

Kode
cmd /c "curl https://release.solana.com/v1.17.13/solana-install-init-x86_64-pc-windows-msvc.exe --output C:\solana-install-tmp\solana-install-init.exe --create-dirs"

Kemudian, salin dan tempel perintah berikut untuk menginstal versi terbaru Solana: C:\solana-install-tmp\solana-install-init.exe v1.17.13. Setelah instalasi selesai, tekan Enter.

Tutup jendela Command Prompt, lalu buka kembali sebagai pengguna biasa. Pastikan versi solana yang diinginkan telah terinstal dengan menjalankan solana –-version.

Selanjutnya, instal Anchor.

Sebaiknya instal Anchor menggunakan pengelola versi Anchor (avm). Anda dapat melakukannya melalui cargo dengan perintah:

Kode
cargo install -git https://github.com/coral-xyz/anchor avm --locked --force.

Kemudian, instal dan gunakan versi terbaru:

Kode
avm install latest
avm use latest

# Verify the installation
avm –version

Anchor versi 0.28 memungkinkan developer melakukan build langsung dengan Solang. Developer dapat membuat proyek Solang baru dengan perintah: anchor init project_name —solidity. Perintah ini membuat program Solang baru dan file pengujian yang menunjukkan cara berinteraksi dengan program melalui client.

Pertimbangkan untuk menginstal ekstensi Solang guna membantu penyorotan sintaks jika Anda menggunakan Visual Studio Code. Nonaktifkan semua ekstensi Solidity aktif lainnya untuk memastikan ekstensi Solang berfungsi dengan benar.

Membuat Proyek Baru

Buat proyek baru dengan perintah anchor-init project_name –solidity. Perintah ini membuat direktori baru dengan nama proyek Anda. Flag Solidity memberi tahu Anchor bahwa kita ingin menggunakan Solang. Direktori ./solidity proyek akan menyediakan program awal. Contract tersebut akan terlihat seperti berikut:

Kode
@program_id("F1ipperKF9EfD821ZbbYjS319LXYiBmjhzkkf5a26rC")
contract test {
    bool private value = true;

    @payer(payer)
    constructor() {
        print("Hello, World!");
    }

    /// A message that can be called on instantiated contracts.
    /// This one flips the value of the stored `bool` from `true`
    /// to `false` and vice versa.
    function flip() public {
            value = !value;
    }

    /// Simply returns the current value of our `bool`.
    function get() public view returns (bool) {
            return value;
    }
}

Program ini memiliki constructor untuk membuat program, menginisialisasi variabel state value ke true, dan mencatat “Hello, World!” ke log program. Fungsi flip memperbarui variabel state saat dipanggil. Fungsi get mengembalikan nilai variabel state saat ini. Bentuknya seperti smart contract Solidity biasa, tetapi ada beberapa hal yang perlu diperhatikan. Perbedaan paling signifikan adalah penggunaan anotasi.

Anotasi

Anotasi digunakan untuk pengelolaan akun. Perhatikan anotasi @program_id(“...”). Anotasi ini digunakan untuk menentukan alamat on-chain program jika sudah diketahui sebelumnya. Jika Anda ingin memanggil contract melalui panggilan eksternal, program harus memiliki notasi @program_id atau dipanggil menggunakan argumen {program_id: … }:

Kode
@program_id(“...”);

contract Foo {
	function hello() public pure {
		print(“Hello”);
	}
}

contract Foo2 {
	function bye() public pure {
		print(“Bye”);
	}
}

contract Bar {
	function new_foo() external {
		Foo.new();
	}
}

contract Bar2 {
	function new_foo(address new_foo_id) external {
		Foo2.new{program_id: new_foo_id}();
	}
}

Saat kita membuat proyek baru, contoh contract yang disediakan memiliki anotasi @payer di atas constructor. Anotasi ini menentukan akun yang akan membayar inisialisasi akun data program. Sintaks @payer(payer) mendeklarasikan akun bernama payer, yang akan diperlukan untuk setiap panggilan ke constructor.

Saat contract dibuat instance-nya, contract tersebut memerlukan akun program untuk menyimpan kode yang dapat dieksekusi dan akun data untuk menyimpan variabel state. Akun data dapat dibuat menggunakan kode sisi client, lalu diteruskan ke transaksi yang memanggil constructor. Sebagai alternatif, akun data dapat dibuat oleh constructor. Setidaknya, anotasi @payer harus disediakan. Seed dan bump harus disediakan jika akun data akan menjadi PDA. Anotasi @seed menentukan seed untuk memperoleh PDA dan dapat berupa string literal atau string heksadesimal dengan format hex”1234”. Jika berada sebelum suatu argumen, anotasi seed harus merujuk ke argumen bertipe bytes, address, atau array byte dengan panjang tetap. Anotasi @bump menentukan nilai yang digunakan untuk menghasilkan alamat off-curve. Nilainya harus berupa satu byte bertipe bytes1. Anotasi opsional @space dapat digunakan untuk menentukan ukuran akun data. Anotasi ini merupakan ekspresi uint64 yang dapat berupa konstanta atau menggunakan salah satu argumen constructor. Menurut dokumentasi Solang, setidaknya @space harus sama dengan ukuran yang diberikan saat menjalankan perintah solang -v:

Kode
$ solang compile --target solana -v examples/solana/flipper.sol
...
info: contract flipper uses at least 17 bytes account data
…

Jika program tidak memiliki constructor, anotasi ini dapat dipasangkan dengan constructor kosong. Dokumentasi Solang menyediakan contoh berikut:

Kode
@program_id("Foo5mMfYo5RhRcWa4NZ2bwFn4Kdhe8rNK5jchxsKrivA")
contract Foo {

    @space(500 + 12)
    @seed("Foo")
    @payer(payer)
    constructor(@seed bytes seed_val, @bump bytes1 bump_val) {
        // ...
    }
}

Anotasi fungsi digunakan untuk mendeklarasikan akun yang diperlukan bagi fungsi eksternal:

  • @account(foo) mendeklarasikan akun foo sebagai akun hanya-baca
  • @mutableAccount(bar) mendeklarasikan akun bar sebagai akun yang dapat diubah
  • @signer(fizz) mendeklarasikan akun fizz sebagai penanda tangan hanya-baca
  • @mutableSigner(buzz) mendeklarasikan akun buzz sebagai penanda tangan yang dapat diubah

Akun yang dideklarasikan dengan anotasi @payer pada constructor dapat diakses di dalamnya. Akun yang dideklarasikan dengan anotasi fungsi tersedia dalam vektor tx.accounts. Misalnya, Anda akan menggunakan tx.accounts.ichigo untuk mengakses akun yang dideklarasikan sebagai @account(ichigo). Ini akan mengembalikan struct bawaan AccountInfo. Struct ini mengikuti struktur yang sama seperti yang kita uraikan di bagian “Memahami Model Akun”. Penamaannya sedikit berbeda:

  • key: alamat atau public key akun. Bertipe address
  • lamports: saldo lamport akun. Bertipe uint64
  • data: data akun. Bertipe bytes
  • owner: pemilik akun. Bertipe address
  • rent_epoch: epoch berikutnya saat biaya sewa akun jatuh tempo. Bertipe uint64
  • is_signer: menentukan apakah akun menandatangani transaksi. Bertipe bool
  • is_writable: menentukan apakah akun dapat ditulis dalam transaksi ini. Bertipe bool
  • executable: menentukan apakah akun merupakan program. Bertipe bool

Keterbatasan

Ketidakcocokan utama antara Solang dan pengembangan Ethereum tradisional adalah:

  • msg.sender tidak tersedia di Solana. Dengan model akun, contract Rust dapat mengakses berbagai akun data, lalu akun mana yang akan kita anggap sebagai pemanggil? Dalam banyak kasus, kita tidak dapat mengidentifikasi satu akun sebagai pemanggil. Selain itu, runtime tidak memiliki mekanisme untuk mengambil akun pemanggil
  • Tidak ada fungsi ecrecover(), tetapi tersedia fungsi signatureVerify() untuk memeriksa tanda tangan ed25519.
  • Pernyataan try-catch tidak berfungsi. Runtime akan menghentikan eksekusi dan membatalkan seluruh transaksi jika panggilan eksternal atau pembuatan contract gagal.
  • Definisi error dan revert dengan pesan error belum berfungsi
  • Mentransfer nilai native melalui panggilan fungsi tidak berfungsi.
  • Banyak fungsi bawaan Yul tidak tersedia. Solang mendukung sebagian besar fungsi bawaan, tetapi operasi memori dan chain belum diimplementasikan.
  • Format ERC-20 saat ini belum didukung. SPL Token didefinisikan berdasarkan Token Program. Token Program adalah cara native Solana untuk membuat, mencetak, mentransfer, dan membakar token. File spl_token.sol harus disalin ke source tree Anda dan diimpor saat diperlukan untuk menggunakan library SplToken

Selain itu, register SVM memiliki lebar 64 bit, yang berarti integer 64 bit (yaitu, uint64 dan int64) lebih disarankan daripada integer 256 bit. Operasi dengan tipe yang lebih lebar dari 64 bit, seperti uint256 atau int256, dibagi menjadi beberapa operasi. Hal ini membuatnya lebih lambat dan mengonsumsi lebih banyak unit komputasi.

Untuk alamat, literal alamat harus ditentukan menggunakan sintaks address"36VtvSbE6jVGGQytYWSaDPG7uZphaxEjpJHUUpuUbq4D". Sintaks heksadesimal Ethereum (misalnya, 0xE0f5206BBD039e7b0592d8918820024e2a7437b9) tidak didukung. Semua saldo dan nilai di Solana memiliki lebar 64 bit. Artinya, fungsi bawaan untuk alamat (yaitu, .balance(), .transfer(), dan .send()) menggunakan integer 64 bit.

Meskipun Solang menawarkan jalur menarik bagi developer EVM untuk memasuki ekosistem Solana, ada beberapa keterbatasan yang perlu dipertimbangkan dengan cermat. Peralihan ke model berbasis akun Solana bukan sekadar perubahan sintaksis—ini merupakan perubahan mendasar pada logika smart contract. Fungsi, pola pemrograman, dan fitur khusus EVM tertentu tidak tersedia di Solang. Developer tidak dapat memindahkan smart contract Ethereum ke Solang dan mengharapkannya berfungsi tanpa penyesuaian signifikan. Fitur yang belum tersedia, seperti definisi error yang tepat dan revert dengan pesan error, dapat menjadi masalah serius. Namun, penting untuk menyadari bahwa Solang adalah alat yang terus berkembang, dan setiap pembaruan ditujukan untuk meningkatkan pengalaman developer Solidity di Solana. Solang menawarkan beberapa keunggulan tersendiri untuk membuat pengalaman ini lebih baik.

Keunggulan

Terlepas dari keterbatasan tersebut, tersedia sejumlah fungsi bawaan dan pilihan desain untuk meningkatkan pengalaman developer. Misalnya, contract yang dikembangkan di Solang dapat berinteraksi dengan program Anchor. Hal ini dapat dilakukan dengan menghasilkan interface Solidity dari IDL program Anchor. IDL adalah singkatan dari “Interface Description Language”. Pada dasarnya, IDL adalah file JSON yang berisi semua spesifikasi program. File ini mencakup semua informasi yang diperlukan untuk berinteraksi dengan program Anchor. Anchor secara otomatis menghasilkan IDL saat mengembangkan program menggunakan framework-nya. Ini sangat mirip dengan ABI di Ethereum. Untuk menghasilkan interface Solidity dari IDL, gunakan perintah berikut: solang idl [-output directory] [IDL file]. Setelah itu, file dapat diimpor menggunakan sintaks import “...”;.

Solang menyediakan library Solana, yaitu serangkaian library yang memungkinkan contract Solidity berinteraksi dengan instruksi khusus Solana. Solang menyediakan library SPL Token untuk mencetak, membakar, dan mentransfer token. Library ini dapat dianggap setara dengan ERC-20 dan ERC-721. Solang juga menyediakan library System Instructions agar developer dapat berinteraksi dengan System Program Solana.

Solang juga menyertakan beberapa fungsi bawaan yang dapat diimpor dengan solana. Ini mencakup struct AccountMeta dan AccountInfo. Struct AccountMeta digunakan untuk menentukan akun mana yang harus diteruskan kepada pihak yang dipanggil dalam panggilan eksternal (yaitu, CPI). Struct AccountMeta memiliki struktur berikut:

  • pubkey: alamat atau public key akun. Bertipe address
  • is_writable: menentukan apakah pihak yang dipanggil dapat menulis ke akun ini. Bertipe bool
  • is_signer: menentukan apakah pihak yang dipanggil dapat menganggap akun ini menandatangani transaksi. Bertipe bool

Jika argumen accounts tidak disertakan dalam panggilan eksternal, compiler Solang secara otomatis menghasilkan array AccountMeta. Ini hanya berfungsi jika fungsi dideklarasikan sebagai external. Jika tidak, array AccountMeta harus dibuat secara manual sesuai urutan akun yang ditentukan dalam IDL. Jika panggilan tertentu tidak memerlukan akun, teruskan vektor kosong: {accounts: []}. Dokumentasi Solang menyediakan contoh yang jelas tentang cara membuat array AccountMetas:

Kode
function build_this() external {
	// When calling a constructor from an external function, the data account for the contract
	// 'BeingBuilt' should be passed as the 'BeingBuilt_dataAccount' in the client code.
	BeingBuilt.new("my_seed");
}

function build_that(address data_account, address payer_account) public {
	AccountMeta[3] metas = [
		AccountMeta({
			pubkey: data_account,
      is_signer: true,
      is_writable: true
		}),
    AccountMeta({
    	pubkey: payer_account,
      is_signer: true,
      is_writable: true
    }),
    AccountMeta({
      pubkey: address"11111111111111111111111111111111",
      is_writable: false,
      is_signer: false
    })
  ];
  BeingBuilt.new{accounts: metas}("my_seed");

	// No accounts are needed in this call, so we pass an empty vector.
	BeingBuilt.say_this{accounts: []}("It's summertime!");
}

Solang juga memiliki fungsi bawaan untuk:

Solang menjembatani kesenjangan antara Solana dan Ethereum dengan menyediakan compiler beserta rangkaian alat lengkap yang memudahkan transisi developer EVM. Meski memiliki keterbatasan, Solang menawarkan beberapa fitur untuk meningkatkan pengalaman developer, termasuk kemampuan berinteraksi dengan program Anchor, mengakses library khusus Solana, dan menggunakan fungsi bawaan. Integrasi konsep yang sudah dikenal, seperti IDL dan standar token, makin memudahkan proses pembelajaran. Tidak perlu memikirkan atau mengoptimalkan gas juga menjadi nilai tambah. Solang merupakan langkah penting menuju interoperabilitas antara Solana dan Ethereum. Bagi developer EVM yang ingin berekspansi ke dunia Solana berperforma tinggi, Solang dapat menjadi salah satu alat yang digunakan.

Neon EVM

Solang bukan satu-satunya pilihan bagi developer Solidity yang ingin membangun di Solana. Neon EVM menyebut dirinya sebagai EVM pertama di dunia yang dapat diparalelkan. Neon EVM merupakan lingkungan Ethereum yang sepenuhnya kompatibel di Solana. Ini adalah solusi sinergis bagi siapa pun yang ingin menskalakan dApp Ethereum di Solana dengan cara yang ramah developer. Developer dapat men-deploy dApp tanpa mengonfigurasi ulang smart contract, tetap menggunakan bahasa dan alat yang mereka sukai.

Arsitektur

Neon EVM terdiri dari tiga komponen utama: program Neon EVM, Neon Proxy, dan Neon DAO.

Neon EVM adalah program Solana yang menerima transaksi menyerupai Ethereum dan memprosesnya di Solana sesuai aturan EVM. Transaksi menyerupai Ethereum yang diarahkan ke Neon EVM ini disebut Neon Transactions. Transaksi tersebut merupakan subset metode JSON RPC sesuai Ethereum JSON-RPC API.

Neon Proxy memungkinkan developer Ethereum memindahkan dApp mereka ke Neon dengan perubahan minimal. Neon Proxy mengemas transaksi EVM ke dalam transaksi Solana dan berfungsi sebagai solusi terkontainerisasi bagi Neon Operators. Operator ini menjalankan server Neon Proxy, menerima pembayaran dalam NEON, dan melakukan pembayaran dalam ekosistem Solana menggunakan SOL. NEON merupakan token utilitas sekaligus tata kelola: Neon Operators mengumpulkannya untuk membayar biaya gas yang diperlukan dalam eksekusi transaksi, sedangkan pemiliknya dapat berpartisipasi dalam Neon DAO.

Neon DAO adalah model tata kelola berbasis komunitas yang dirancang untuk memberdayakan pemegang token NEON dalam proses pengambilan keputusan untuk Neon EVM. Neon DAO terdiri dari pengguna, operator, kontributor, serta developer inti dan aplikasi yang bersama-sama membahas aturan tata kelola dan evolusi protokol. DAO beroperasi melalui berbagai majelis terdesentralisasi yang berfokus pada ekosistem, pengembangan, dan keamanan. Setiap majelis memfasilitasi pengambilan keputusan kolaboratif dan peninjauan proposal untuk bidangnya masing-masing. Majelis yang berfokus pada ekosistem mengawasi pertumbuhan ekosistem yang berkelanjutan serta mengelola dana untuk hibah dan inisiatif. Majelis yang berfokus pada pengembangan menangani peningkatan teknis pada program Neon dan intervensi darurat. Majelis yang berfokus pada keamanan melindungi treasury Neon dan program Neon dari potensi ancaman.

Kompatibilitas EVM

Neon EVM memfasilitasi interaksi EVM di Solana dengan:

  • Mengimplementasikan sebagian besar metode JSON-RPC API Ethereum
  • Menggunakan proxy khusus untuk menangani panggilan Ethereum
  • Beradaptasi dengan perbedaan dan keterbatasan yang ditimbulkan oleh arsitektur Solana

Berinteraksi dengan Neon EVM serupa dengan berinteraksi dengan EVM lainnya. Developer dapat menggunakan metode RPC API yang sudah dikenal dan mengarahkannya ke Neon Proxy, sehingga pengalaman developer tetap mulus. Fitur utamanya meliputi:

  • Kompatibilitas dengan smart contract Solidity dan Vyper, serta alat pengembangan Ethereum standar seperti Metamask, Foundry, dan Remix
  • Dukungan apa adanya untuk sebagian besar Opcode Ethereum
  • Penerimaan permintaan transaksi Ethereum tipe 0 / legacy. Transaksi EIP-1559 saat ini belum didukung

Tentu saja, adaptasi tertentu diperlukan agar Neon EVM dapat berfungsi dengan benar di Solana. Perbedaan pentingnya meliputi:

  • Neon EVM mendukung semua contract prakompilasi yang ditentukan di evm.code. Namun, contract Solidity yang berisi panggilan berikut tidak akan dieksekusi: bigModExp, bn256Add, bn256ScalarMult, dan bn256Pairing. Neon EVM memerlukan implementasi panggilan sistem Solana agar dapat mendukung contract tersebut pada masa mendatang
  • Meskipun sebagian besar opcode didukung apa adanya, opcode COINBASE, PREVRANDAO (FKA DIFFICULTY), GASLIMIT, BASEFEE, dan GAS tidak didukung. Ini dikenal sebagai opcode varian dan diadaptasi untuk digunakan di Neon EVM.
  • Konsumsi gas dan penghitungan biaya berbeda dari Ethereum. Secara umum, biayanya lebih rendah karena Solana berperan sebagai settlement layer
  • Metode transfer() dan send() milik Solidity tidak aman dari reentrancy di Neon EVM karena penghitungan gas yang berbeda
  • Model akun Solana memengaruhi penyimpanan smart contract, dengan fungsi penyimpanan dan izin akses yang berbeda untuk akun yang dapat dan tidak dapat dieksekusi
  • Neon EVM menggunakan transaksi berversi, sehingga jumlah maksimum akun yang dapat digunakan dalam satu transaksi dibatasi hingga 64
  • Neon EVM menggunakan Berkley Packet Filter (BPF) Solana dengan batas memori heap sebesar 256 KB. Hal ini membatasi ukuran panggilan contract dan memerlukan strategi pengoptimalan untuk mengelola penggunaan memori secara efektif
  • Fungsi berbasis waktu seperti block.number dan block.timestamp berperilaku berbeda. Developer sangat disarankan untuk tidak menggunakannya saat mengembangkan di Neon EVM

Meskipun Neon EVM menyediakan lingkungan yang familier dan kompatibel, developer EVM harus memahami serta beradaptasi dengan perbedaan utama agar berhasil melakukan migrasi dan membangun di Solana.

Menghubungkan ke RPC Neon

Developer dapat dengan mudah terhubung ke RPC Neon menggunakan Chainlist. Di sini, developer dapat terhubung ke Neon EVM Mainnet atau Devnet. Klik Hubungkan Wallet pada modal Mainnet atau Devnet, lalu klik Setujui saat wallet Anda muncul.

Pengguna sebaiknya memilih operator yang optimal sebelum mengirim transaksi ke Neon EVM. Perluas detail kartu untuk melihat endpoint RPC yang tersedia bagi setiap jaringan:

Jika Anda memilih Operator yang berbeda dari operator default yang disediakan saat menghubungkan wallet, Anda harus melakukan koneksi manual. Dokumentasi Neon EVM menyediakan panduan lengkap untuk terhubung ke Proxy menggunakan Foundry, Hardhat, Remix, dan Truffle. Kita akan membahas cara terhubung menggunakan Foundry di bagian deployment.

Setelah terhubung, developer dapat menggunakan Neon Faucet untuk memperoleh NEON atau token pengujian ERC-20 lainnya. Developer juga dapat menggunakan endpoint request_neon untuk meminta token secara terprogram:

Kode
curl -i -X POST \
	-d '{"wallet": "Your wallet", "amount": 1}' \
	'http://localhost:3333/request_neon'

Perintah ini mengirim permintaan POST untuk menerima token ke alamat wallet yang ditentukan.

Siklus Hidup Transaksi dan Biaya Gas

Ada tiga langkah utama untuk mengeksekusi transaksi dari dApp Ethereum di Solana melalui Neon EVM:

  • Pengguna memulai transaksi menyerupai Ethereum yang telah ditandatangani dan diarahkan ke endpoint RPC Neon
  • Transaksi diteruskan ke Neon Proxy melalui Ethereum API. Proxy memperkirakan gas yang diperlukan untuk mengeksekusi transaksi, memulai penyiaran dengan membungkus transaksi menyerupai Ethereum ke dalam transaksi Solana, lalu mengirim transaksi yang telah dibungkus ke Neon EVM. Proses ini menghasilkan tanda terima Solana dan tanda terima transaksi Neon EVM yang sesuai. Smart contract Neon membuka pembungkus transaksi, memverifikasi tanda tangan pengguna, dan memuat state EVM dari penyimpanan Solana. Transaksi dieksekusi di dalam BPF Solana
  • Solana dan Neon EVM memperbarui state masing-masing untuk menyelesaikan permintaan transaksi

Inilah seluruh siklus hidup transaksi di Neon EVM, mulai dari inisiasi hingga eksekusi. Developer dapat mengunjungi NeonScan untuk melihat transaksi dan blok terbaru, serta mencari akun, token, blok, atau hash transaksi.

Developer juga dapat mengirim transaksi tanpa gas. Fitur ini diimplementasikan untuk mendukung pengguna yang tidak memiliki cukup token NEON guna membayar biaya transaksi awal. Developer dapat memperoleh paket awal transaksi tanpa gas dengan menghubungi info@neonevm.org. Proxy Operator yang dipilih developer tetap akan menangani transaksi tersebut, tetapi Neon menanggung biaya transaksinya. Biasanya, setiap akun Neon baru mendapatkan minimal tiga transaksi tanpa gas.

Proses transaksi tanpa gas adalah sebagai berikut:

  • Pengguna akhir memulai transaksi melalui dApp
  • dApp meminta harga gas saat ini dari Proxy Operator yang dipilih. Jika memenuhi syarat, Proxy Operator menandai akun Neon untuk sejumlah transaksi tanpa gas tertentu
  • Untuk transaksi tersebut, dApp akan menampilkan biaya gas sebesar nol
  • Pengguna akhir menandatangani transaksi tanpa biaya gas
  • Proxy Operator mengeksekusi transaksi, dengan biaya gas SOL dibayar oleh Neon Foundation

Dokumentasi Neon EVM menyediakan cuplikan berikut untuk menunjukkan cara meminta transaksi tanpa gas:

Kode
try {
	// Get gasless transaction if user account is eligible
  const rawGasPrice = await axios.post(rpcApiUrl, {
  	method: 'neon_gasPrice',
    params: [{ from: address }],
    jsonrpc: "2.0",
    id: new Date().getTime()
   })

   tx.gasPrice = rawGasPrice.data?.result;
	} catch (e) {
  	//Else, get standard GAS price
   	setError('Can\'t retrieve gas price for transaction')

    const rawGasPrice = await web3.eth.getGasPrice();

    tx.gasPrice = web3.utils.toHex(rawGasPrice);
} finally {
    setTx(tx)
}

NeonPass

NeonPass adalah alat untuk mentransfer token antara Solana dan Neon EVM. Alat ini memungkinkan transfer aset tanpa hambatan antara Associated Token Accounts Solana dan akun token ERC-20 Neon EVM. NeonPass menggunakan contract interface Neon EVM dan penyimpanan akun khusus. Token Solana Program Library (SPL) dikemas ke dalam interface ERC-20 di dalam factory contract Neon EVM. Hal ini memungkinkan SPL disimpan dalam akun token ERC-20 yang kompatibel dengan dApp Solidity. NeonPass memungkinkan transfer token dua arah antara akun Solana dan Neon EVM. Tidak seperti bridge tradisional yang mengunci dan mencetak aset baru, NeonPass memindahkan token secara langsung di antara kedua jenis akun. Hal ini memungkinkan transisi token Solana dan Neon EVM tanpa hambatan.

Deployment

Developer dapat melakukan deployment ke Neon EVM menggunakan Hardhat, Foundry, Truffle, dan Remix. Karena cara termudah menggunakan Solang adalah melalui Anchor, semua pengujian dilakukan dalam TypeScript. Namun, kini para penggemar berat Solidity akhirnya dapat menguji dan men-deploy dApp Solidity ke Solana melalui Foundry.

Pertama, pastikan Anda memiliki wallet yang kompatibel dengan EVM dan terhubung ke Neon EVM Devnet. Kemudian, clone proyek contoh Foundry milik Neon dan buka direktori tersebut:

Kode
git clone https://github.com/neonlabsorg/neon-tutorials
cd neon-tutorials/foundry

Kemudian, instal Foundryup, installer toolchain Foundry, lalu jalankan foundryup untuk menginstal binary prakompilasi terbaru (nightly) (yaitu, force, cast, anvil, dan chisel):

Kode
curl -L https://foundry.paradigm.xyz | bash
foundryup

Instal library yang diperlukan:

Kode
forge install foundry-rs/forge-std --no-commit
forge install openzeppelin/openzeppelin-contracts --no-commit

Sekarang, dapatkan private key untuk akun wallet Anda. Di Metamask, misalnya, Anda dapat melihat private key dengan mengklik menu hamburger dan membuka Account Details > Show Private Key. Anda akan diminta memasukkan kata sandi. Klik Konfirmasi untuk mengakses private key akun Anda. Ingat, jangan bagikan key ini kepada siapa pun dan lakukan langkah-langkah yang diperlukan untuk melindunginya.

Kemudian, buat file .env dengan variabel berikut:

Kode
RPC_URL_DEVNET=https://devnet.neonevm.org
CHAIN_ID_DEVNET=245022926
RPC_URL_MAINNET=https://neon-proxy-mainnet.solana.p2p.org
CHAIN_ID_MAINNET=245022934
PRIVATE_KEY=
VERIFIER_URL_BLOCKSCOUT=https://neon-devnet.blockscout.com/api

Ganti <YOUR_PRIVATE_KEY> dengan private key Anda, lalu jalankan source .env.

Untuk mengompilasi contract proyek, buka direktori src dan jalankan forge build. Konsol seharusnya menampilkan bahwa proses compiler berhasil. Contract juga dapat diuji menggunakan perintah forge test. Untuk men-deploy contract proyek, jalankan perintah berikut:

Kode
forge create --rpc-url $RPC_URL_DEVNET --private-key $PRIVATE_KEY src/TestERC20/TestERC20.sol:TestERC20 --constructor-args "Test ERC20 Token" "TERC20" --legacy

Anda akan melihat output yang serupa dengan berikut:

Kode
[⠰] Compiling...
No files changed, compilation skipped
Deployer: 0x4455E84Eaa56a01676365D4f86348B311969a4f4
Deployed to: 0x5537599aa2F97Dd60a66342522a465A7f2e40Ff9
Transaction hash: 0x6de9dab8a526cbac33008056d185b93dff725605efb791bf116b6bece4f0c486

Untuk memverifikasi contract Anda, jalankan perintah berikut:

Kode
forge verify-contract --chain-id $CHAIN_ID_DEVNET  src/TestERC20/TestERC20.sol:TestERC20 --verifier-url $VERIFIER_URL_BLOCKSCOUT --verifier blockscout

Ganti <contract_address> dengan alamat smart contract Anda. Anda akan menerima respons OK beserta URL yang mengarah ke alamat contract di BlockScout, explorer Devnet milik Neon. Anda juga dapat mengonfigurasi file .env agar menggunakan NeonScan sebagai pengganti BlockScout, yang juga mendukung devnet.

Keunggulan dan Keterbatasan

Developer yang menginginkan pengalaman pengembangan serupa Ethereum sebaiknya memilih Neon EVM. Neon EVM adalah lingkungan yang kompatibel dengan EVM, mengirim transaksi menyerupai Ethereum, dan menggunakan alat yang sudah dikenal. Fitur seperti NeonPass, dukungan untuk sebagian besar opcode EVM, serta penyediaan transaksi tanpa gas membuat transisi ke Solana jauh lebih mudah. Namun, Neon EVM tidak sempurna. Ada beberapa keterbatasan, seperti perubahan pada logika smart contract agar sesuai dengan infrastruktur Solana, pengoperasian dalam batasan Berkeley Packet Filter (BFP) dan model akun Solana, serta pembatasan tertentu pada opcode dan contract prakompilasi. Memahami dan menangani berbagai detail ini sangat penting agar deployment ke Solana dari lingkungan yang kompatibel dengan EVM dapat berhasil.

Migrasi Sebelumnya

Sejumlah tugas kompleks harus diselesaikan agar protokol Ethereum berskala besar dapat diterapkan pada blockchain non-EVM. Tugas tersebut mencakup merekrut engineer non-Solidity untuk membangun ulang basis kode dari awal, menemukan mitra audit tepercaya, mengaudit ulang basis kode baru, dan menyesuaikan kontrak tata kelola untuk menegakkan keputusan DAO. Semua ini berpotensi menelan biaya jutaan dolar dan membutuhkan kerja khusus selama berbulan-bulan. Bagi sebagian besar proyek, hal ini tidak memungkinkan. Namun, migrasi semacam ini pernah dilakukan.

Helium adalah jaringan LoRaWAN yang bertujuan menciptakan infrastruktur nirkabel terdesentralisasi untuk mendukung perangkat Internet untuk Segala (IoT). Hal ini dilakukan menggunakan hotspot, yaitu perangkat kecil berdaya rendah yang menyerupai menara seluler mini dan terhubung ke hotspot lain dalam jarak jauh. Helium awalnya berjalan pada blockchain Layer 1 (L1) miliknya sendiri, tetapi tim developernya mengusulkan perpindahan ke Solana melalui HIP 70. Perpindahan ini memungkinkan Helium memperoleh waktu aktif lebih tinggi, komposabilitas lebih baik, dan pengalaman pengguna lebih cepat, sekaligus mempertahankan tingkat keamanan yang tinggi dan biaya penggunaan yang rendah. Komunitas memberikan dukungan yang sangat besar terhadap proposal tersebut, dan Helium bermigrasi ke Solana pada April 2023. COO Helium Scott Sigel menggambarkan migrasi tersebut sebagai peristiwa yang membosankan —tidak ada masalah pada jaringan maupun infrastruktur Helium. Itu adalah impian seorang engineer. Tim tersebut juga menjabarkan seluruh proses migrasi dalam serangkaian panduan di dokumentasi mereka. Migrasi Helium meraih kesuksesan besar dan memberikan manfaat signifikan bagi komunitas.

Migrasi ini bukan peristiwa yang berdiri sendiri. The Render Network, platform rendering GPU terdesentralisasi pertama di dunia, berhasil meningkatkan infrastruktur intinya dari Ethereum ke Solana pada November 2023. Komunitas memberikan suara dukungan untuk RNP-002 agar bermigrasi ke Solana. Pendiri Render, Jules Urbach, menggambarkan migrasi tersebut sebagai momen bersejarah. Ia menyatakan: “Kecepatan transaksi Solana yang luar biasa, biaya rendah, dan komitmennya terhadap arsitektur berskala web menjadikannya pilihan sempurna bagi Render Network seiring kami terus membangun infrastruktur metaverse yang dapat diskalakan dan terdesentralisasi.”

Migrasi Render tidak menimbulkan dampak yang terlalu negatif bagi penggunanya. Pengguna dapat melakukan bridge dana dari Ethereum ke Solana menggunakan Render Upgrade Assistant. Pengguna menghubungkan dompet Ethereum mereka, menentukan jumlah RNDR yang ingin dimigrasikan, lalu menunggu token dikirimkan ke dompet Solana yang ditentukan. 

Maker adalah salah satu proyek Ethereum yang paling representatif. Mereka bertujuan membuka potensi keuangan terdesentralisasi melalui Maker Platform, sebuah platform inklusif yang dirancang untuk meningkatkan pemberdayaan ekonomi dan kesetaraan akses ke pasar keuangan global. Platform ini terdiri dari MakerDAO untuk mengelola proyek Maker dan protokol Maker untuk DAI, “mata uang pertama di dunia yang tidak berpihak dan stablecoin terdesentralisasi terkemuka.” Rune Christensen, pendiri Maker, mengunggah tweet tentang penggunaan fork basis kode Solana untuk mengembangkan appchain Maker: 

Migrasi pada dasarnya memang kompleks. Terlepas dari biaya finansial, reputasi, dan waktu untuk memigrasikan seluruh infrastruktur proyek dari Ethereum ke Solana, berbagai proyek memilih Solana. Dengan alat seperti Solang dan Neon EVM, migrasi tidak harus selalu kompleks. Seperti migrasi Helium, prosesnya bisa saja membosankan dan hampir tidak memberikan dampak buruk pada dana pengguna, sebagaimana yang terjadi pada Render Network. Solana adalah blockchain dengan performa tertinggi di pasar yang dibangun untuk skala web. Inilah tempat untuk membangun, dan semakin banyak proyek yang menyadarinya.

Kesimpulan

Solidity adalah lingua franca dalam pengembangan smart contract. EVM telah menjadi lingkungan smart contract yang dominan sejak kemunculannya. Namun, EVM memiliki kelemahan. Aplikasi berskala web untuk konsumen memerlukan jaringan dengan throughput tinggi dan latensi rendah guna mendukung operasinya. Lingkungan Ethereum yang single-threaded dan berbasis gas volatil tidak mampu mendukung proyek Jaringan Infrastruktur Fisik Terdesentralisasi (DePIN) dengan throughput tinggi seperti Helium. 

Untuk menjawab tantangan tersebut, Solana hadir sebagai alternatif yang kuat. Cara terbaik untuk memanfaatkan keunggulan Solana sepenuhnya adalah dengan benar-benar membangun di Solana. Berkat perkembangan terbaru, alat seperti Solang dan Neon EVM memungkinkan developer EVM yang berminat untuk bermigrasi menggunakan alat dan bahasa yang sudah mereka kenal. Artikel ini menyajikan panduan komprehensif tentang arsitektur Solana, perbandingannya dengan Ethereum, serta cara developer EVM dapat mulai mengembangkan aplikasi di Solana. Solana adalah blockchain dengan performa tertinggi di pasar. Momentum, perhatian, dan jumlah aplikasi bereputasi untuk konsumen yang dimilikinya terus meningkat. Mengapa menunggu Ethereum dapat diskalakan jika Anda bisa menikmati manfaat blockchain yang cepat dan dapat diskalakan sekarang juga?

Jika Anda sudah membaca sejauh ini, terima kasih, anon! Pastikan Anda memasukkan alamat email di bawah agar tidak pernah melewatkan informasi terbaru tentang Solana. Siap mempelajari lebih lanjut? Bergabunglah dengan Discord kami untuk mulai membangun masa depan di blockchain dengan performa tertinggi sekarang juga.

Referensi Lebih Lanjut

Berlangganan Helius

Ikuti perkembangan terbaru dalam pengembangan Solana dan dapatkan pembaruan saat kami memublikasikan postingan

Gambar diperbesar