5 Cara Pengembangan Aplikasi Ergo Berubah Selamanya Berkat Appkit
3 Desember 2019
Dengan terima kasih kepada Robert Kornacki dan Denys Zadorozhnyi.
Ergo Appkit adalah sebuah pustaka untuk
pengembangan poliglot Aplikasi Ergo berdasarkan
GraalVM. GraalVM memiliki banyak kasus penggunaan
yang hebat. Mengembangkan hal itu, dalam artikel ini kita akan membahas beberapa fitur Appkit
yang diwarisi dari GraalVM dan membawa Anda langkah demi langkah dalam belajar bagaimana memanfaatkan fitur-fitur tersebut.
- 0. Contoh Skenario
- 1. Pengembangan Aplikasi Java Ergo
- 2. Aplikasi Ergo dengan Jejak Kecil dan Startup Cepat
- 3. Kembangkan Aplikasi Ergo dalam JavaScript, Python, Ruby
- 4. Pustaka Bersama Native Ergo
- 5. Debug Aplikasi Ergo Poliglot Anda
Contoh Skenario
Kita akan membuat aplikasi konsol sederhana (disebut
FreezeCoin)
dalam Java yang menggunakan pustaka Appkit. Dengan menggunakan Appkit, kita akan dapat dengan mudah mengirim transaksi baru ke node Ergo secara programatis. Transaksi
ini akan mentransfer sejumlah Erg ke dalam kotak baru yang dilindungi oleh
kontrak Ergo berikut yang ditulis dalam ErgoScript (lihat
introduksi ini dan lebih banyak contoh
lanjutan untuk mempelajari lebih lanjut tentang ErgoScript).
// Kontrak Freezer
{
// Parameter
// freezeDeadline: Int - beberapa nomor blok di masa depan setelah kotak dapat dibelanjakan
// ownerPk: SigmaProp - kunci publik pemilik kotak baru
sigmaProp(HEIGHT > freezeDeadline) && ownerPk
}
Singkatnya, sebuah kotak (dan oleh karena itu dana di dalam kotak) terkunci di bawah kontrak (atau skrip) di blockchain Ergo. Agar kotak dapat dibelanjakan, kontrak harus dievaluasi menjadi benar. Oleh karena itu, individu yang ingin membelanjakan kotak harus memastikan bahwa kontrak dievaluasi menjadi benar berdasarkan logika yang dikodekan di dalamnya.
Kontrak Freezer kita di atas memeriksa kondisi berikut sebelum mengizinkan kotak untuk dibelanjakan:
-
Nomor blok saat ini dari blockchain Ergo (alias HEIGHT blockchain) lebih besar dari batas waktu yang ditentukan.
-
Transaksi pengeluaran harus ditandatangani oleh pemilik kunci rahasia yang sesuai dengan kunci publik ownerPk.
Kondisi pertama melarang siapa pun untuk membelanjakan kotak sebelum blockchain Ergo tumbuh ke tinggi yang diberikan. Karena blok baru di blockchain ditambang sekitar setiap 2 menit rata-rata, menggunakan tinggi blockchain saat ini, mudah untuk mendefinisikan durasi penundaan yang kita inginkan seperti 1 hari, 1 minggu, atau 1 bulan. (yaitu (60 / 2) * 24 * 7 = 5040, yang merupakan jumlah blok per minggu).
Sekarang kita akan membahas secara mendalam bagaimana kita dapat mengambil Kontrak Freezer ini dan mengintegrasikannya dengan pustaka Appkit untuk membuat aplikasi konsol FreezeCoin sehingga siapa pun dapat memilih untuk membekukan koin mereka jika mereka mau. (Diberikan, kontrak/dApp ini sebenarnya tidak berguna, namun ini adalah contoh sederhana yang efektif untuk menunjukkan bagaimana tumpukan teknologi ini bekerja sehingga Anda sendiri dapat membangun dApps yang berguna di masa depan.)
1. Pengembangan Aplikasi Java Ergo
Appkit bertujuan untuk menyediakan seperangkat antarmuka yang dapat digunakan secara idiomatis
dalam Java. Anda akan merasa seperti di rumah menggunakan Appkit jika Anda adalah seorang veteran Java.
Silakan ikuti instruksi pengaturan untuk GraalVM dan
Appkit jika Anda ingin mereproduksi contoh di bawah ini.
Untuk menggunakan Appkit dalam implementasi Java FreezeCoin kita harus menambahkan
ketergantungan berikut dalam file gradle
dependencies {
implementation("org.ergoplatform", "ergo-appkit_2.12", "3.1.0", "compile")
...
}
Selanjutnya, pada saat runtime, Appkit/aplikasi kita perlu terhubung dengan Node Ergo melalui REST API. Seringkali,
node akan berjalan secara lokal dan tersedia di http://localhost:9052/. Ini adalah skenario standar bagi siapa pun yang telah mengatur full-node dengan mengikuti instruksi ini dan menggunakan konfigurasi default.
Oleh karena itu, kita akan mengasumsikan bahwa Anda telah mengatur dan memulai Node Ergo Anda sehingga tersedia untuk pengujian aplikasi.
Selanjutnya, aplikasi kita perlu tahu bagaimana cara terhubung ke node lokal yang sedang berjalan, selain berbagai pengaturan lain agar berfungsi dengan baik. Kita akan menggunakan file json dengan parameter konfigurasi berikut yang akan dimuat oleh aplikasi FreezeCoin kita saat startup.
{
"node": {
"nodeApi": {
"apiUrl": "http://localhost:9052/",
"apiKey": "masukkan apiKey rahasia Anda yang dihasilkan selama pengaturan node di sini"
},
"wallet": {
"mnemonic": "kunci mnemonik yang digunakan untuk menginisialisasi atau memulihkan dompet node",
"password": "kata sandi yang Anda pilih untuk melindungi dompet",
"mnemonicPassword": "kata sandi yang Anda pilih untuk melindungi mnemonik"
},
"networkType": "TESTNET"
},
"parameters": {
"newBoxSpendingDelay": "30",
"ownerAddress": "3WzR39tWQ5cxxWWX6ys7wNdJKLijPeyaKgx72uqg9FJRBCdZPovL"
}
}
Di sini apiKey adalah kunci rahasia yang diperlukan untuk otentikasi API yang dapat diperoleh seperti yang dijelaskan
di sini.
Mnemonik Anda adalah frasa rahasia yang diperoleh selama pengaturan dompet baru.
Cara kerja aplikasi kita adalah pengguna akan meluncurkannya dari baris perintah dan memberikan satu argumen. Argumen ini adalah jumlah nilai (dalam NanoErgs) yang ingin mereka bekukan/kunci di bawah kontrak Freezer yang kita tulis di atas.
Langkah pertama untuk aplikasi FreezeCoin kita adalah membaca file json konfigurasi yang baru saja kita buat dan menerima argumen baris perintah dari pengguna:
public static void main(String[] args) {
long amountToSend = Long.parseLong(args[0]); // nilai positif dalam NanoErg
ErgoToolConfig conf = ErgoToolConfig.load("freeze_coin_config.json");
// sisa kode yang dibahas di bawah
...
}
Dengan ini, kita sekarang dapat memperoleh penundaan pengeluaran dan alamat pemilik yang telah didefinisikan dalam file konfigurasi json.
int newBoxSpendingDelay = Integer.parseInt(conf.getParameters().get("newBoxSpendingDelay"));
Address ownerAddress = Address.create(conf.getParameters().get("ownerAddress"));
Selanjutnya kita perlu terhubung ke node Ergo yang sedang berjalan dari aplikasi Java kita sehingga kita dapat menggunakan data yang baru saja kita analisis dan memposting sesuatu di rantai. Ini dilakukan dengan membuat
instance ErgoClient yang menggunakan nilai-nilai yang telah kita tentukan sebelumnya untuk node kita dari file konfigurasi json juga.
ErgoNodeConfig nodeConf = conf.getNode();
ErgoClient ergoClient = RestApiErgoClient.create(nodeConf);
Sekarang kita memiliki instance dari ErgoClient,
kita dapat mengeksekusi blok kode apa pun dan memiliki akses ke konteks blockchain saat ini.
String txJson = ergoClient.execute((BlockchainContext ctx) -> {
// gunakan ctx di sini untuk membuat dan menandatangani transaksi baru
// kemudian kirim ke node
});
Lambda yang diteruskan ke execute dipanggil ketika konteks blockchain saat ini dimuat dari node Ergo. Dalam lambda ini kita
akan menempatkan logika aplikasi kita.
Pertama kita mulai dengan beberapa langkah tambahan.
// akses dompet yang tertanam di node Ergo
// (menggunakan dompet yang ditentukan melalui mnemonik yang kita masukkan di freeze_coin_config.json)
ErgoWallet wallet = ctx.getWallet();
// hitung total jumlah NanoErgs yang perlu kita kirim ke kotak baru
// termasuk membayar biaya transaksi
long totalToSpend = amountToSend + Parameters.MinFee;
// minta kotak yang tidak terpakai yang menutupi jumlah NanoErgs yang diperlukan dari dompet
Optional<List<InputBox>> boxes = wallet.getUnspentBoxes(totalToSpend);
if (!boxes.isPresent())
throw new ErgoClientException(
"Tidak cukup koin di dompet yang Anda tentukan untuk membayar " + totalToSpend, null);
// buat "prover", yang merupakan objek khusus yang akan digunakan untuk menandatangani transaksi
// prover harus dikonfigurasi dengan rahasia dompet Anda, yang diperlukan untuk menghasilkan tanda tangan (alias bukti)
ErgoProver prover = ctx.newProverBuilder()
.withMnemonic(
nodeConf.getWallet().getMnemonic(),
nodeConf.getWallet().getPassword())
.build();
Pada titik ini kita telah memilih kotak input untuk transaksi pengeluaran kita, tetapi kita sekarang perlu membuat kotak output dengan amountToSend yang ditentukan dan terkunci di bawah kontrak Freezer.
// satu-satunya cara untuk membuat transaksi adalah menggunakan pembangun tx yang diperoleh dari konteks
// pembangun menggunakan konteks untuk mengakses data blockchain yang diperlukan.
UnsignedTransactionBuilder txB = ctx.newTxBuilder();
// buat kotak baru menggunakan pembangun baru yang diperoleh dari pembangun transaksi
// dalam hal ini kita menyusun kontrak Ergo baru dari kode ErgoScript Freezer
OutBox newBox = txB.outBoxBuilder()
.value(amountToPay)
.contract(ctx.compileContract(
ConstantsBuilder.create()
.item("freezeDeadline", ctx.getHeight() + newBoxSpendingDelay)
.item("ownerPk", ownerAddress.getPublicKey())
.build(),
"{ sigmaProp(HEIGHT > freezeDeadline) && ownerPk }"))
.build();
Perhatikan, untuk mengkompilasi ErgoContract dari kode sumber skrip Freezer, metode compileContract
memerlukan bahwa kita memberikan nilai untuk konstanta bernama yang digunakan dalam skrip.
Jika tidak ada konstanta semacam itu yang digunakan, maka ConstantsBuilder.empty() dapat diteruskan ke dalamnya.
Dalam hal ini kita meneruskan kunci publik pemilik kotak baru ke dalam placeholder ownerPk
dalam skrip. Untuk mengulangi dari sebelumnya, ini berarti bahwa kotak hanya dapat dibelanjakan oleh pemilik kunci rahasia yang sesuai.
Selanjutnya, kita membuat transaksi yang belum ditandatangani menggunakan semua data yang telah kita kumpulkan sejauh ini.
// berikan pembangun transaksi dengan kotak mana yang akan kita belanjakan, output mana
// yang harus dibuat, total biaya transaksi, dan alamat untuk perubahan yang akan dikirim
UnsignedTransaction tx = txB.boxesToSpend(boxes.get())
.outputs(newBox)
.fee(Parameters.MinFee)
.sendChangeTo(prover.getP2PKAddress())
.build();
Dan akhirnya kita:
- Menggunakan prover untuk menandatangani transaksi yang dibangun
- Dengan demikian memperoleh instance
SignedTransaction - Menggunakan konteks blockchain untuk mengirim transaksi yang ditandatangani ke
node Ergo.
txId yang dihasilkan dapat digunakan untuk merujuk ke transaksi ini
nanti, namun kita tidak menggunakannya di sini.
SignedTransaction signed = prover.sign(tx);
String txId = ctx.sendTransaction(signed);
return signed.toJson(true);
Seperti yang mungkin Anda perhatikan, untuk langkah terakhir kita menunjukkan bahwa mungkin untuk menyusun transaksi yang ditandatangani
ke dalam string Json dengan pencetakan yang rapi diaktifkan. Lihat kode sumber lengkap
dari contoh untuk detail lebih lanjut dan untuk menggunakannya sebagai template dalam aplikasi Anda sendiri.
Sekarang dengan semua kode yang sudah ditetapkan, kita dapat menjalankan aplikasi FreezeCoin kita menggunakan langkah-langkah berikut
(mengasumsikan Anda berada di direktori tempat Anda mengkloning
ergo-appkit-examples).
$ pwd
direktori/tempat/Anda/mengkloning/ergo-appkit-examples
$ ./gradlew clean shadowJar
Ini akan menyusun file build/libs/appkit-examples-3.1.0-all.jar yang berisi
aplikasi Java FreezeCoin kita dan semua ketergantungannya dalam satu fat jar.
Perhatikan, langkah ini harus diulang setelah ada perubahan yang dilakukan pada kode sumber Java aplikasi kita.
Setelah membuat aplikasi kita, kita sekarang dapat menggunakan aplikasi FreezeCoin kita:
$ java -cp build/libs/appkit-examples-3.1.0-all.jar \
org.ergoplatform.appkit.examples.FreezeCoin 1000000000
Anda akan mendapatkan sesuatu seperti output di konsol ini.
Dan dengan itu transaksi Anda diterima oleh node Ergo dan disiarkan ke jaringan di mana ia akan menunggu di kolam transaksi untuk ditambahkan ke blok. Setelah seorang penambang memilih dan menambahkannya ke dalam blok, koin Anda akan secara resmi "dibekukan" dalam kotak baru yang dibuat berdasarkan nilai yang Anda berikan kepada aplikasi FreezeCoin.
Contoh ini mengasumsikan bahwa node Ergo (dan dompet yang tertanam) dimiliki oleh pengguna FreezeCoin. Namun ini tidak secara ketat diperlukan dan antarmuka Appkit
dapat digunakan untuk membuat dan mengirim transaksi baru menggunakan node Ergo publik sembarangan.
2. Aplikasi Ergo dengan Jejak Kecil dan Startup Cepat
Seperti yang Anda ketahui, menggunakan Java untuk proses yang berjalan singkat memiliki banyak kekurangan.
Aplikasi cenderung menderita dari waktu startup yang lama dan penggunaan memori yang relatif tinggi.
Mari kita jalankan FreezeCoin menggunakan perintah waktu untuk
mendapatkan waktu nyata (waktu yang berlalu di dinding) yang dibutuhkan seluruh program untuk berjalan dari
awal hingga akhir. Kita menggunakan flag -l untuk mencetak penggunaan memori juga.
$ /usr/bin/time -l java -cp build/libs/appkit-examples-3.1.0-all.jar \
org.ergoplatform.appkit.examples.FreezeCoin 1000000000
...
4.97 real 8.41 user 0.69 sys
513703936 ukuran set residens maksimum
0 ukuran memori bersama rata-rata
0 ukuran data tidak bersama rata-rata
0 ukuran tumpukan tidak bersama rata-rata
125010 pemulihan halaman
1216 kesalahan halaman
0 swap
0 operasi input blok
0 operasi output blok
13 pesan yang dikirim
86 pesan yang diterima
1 sinyal yang diterima
2384 pengalihan konteks sukarela
17409 pengalihan konteks yang tidak sukarela
Seperti yang terlihat di atas, aplikasi kecil ini membutuhkan 2 utas paralel hampir 4
detik untuk berjalan. Sebagian besar waktu itu dapat dikaitkan dengan startup JVM dan
kompiler JIT latar belakang yang berjalan. Ini adalah kinerja yang cukup buruk, dan kita tahu kita bisa melakukan jauh lebih baik.
Untungnya, GraalVM memberikan kita solusi yang sempurna.
Kita dapat menyelesaikan masalah bawaan dengan JVM ini dengan mengkompilasi kode Java
sebelumnya menjadi gambar eksekusi native melalui GraalVM. Ini menghindari kebutuhan untuk menggunakan kompiler just-in-time Java
pada saat runtime.
Pengalaman bagi kita (pengembang yang menggunakan GraalVM) cukup mirip dengan kompiler konvensional seperti gcc. Perhatikan,
kita mungkin perlu menjalankan ./gradlew clean shadowJar terlebih dahulu.
$ ./gradlew clean shadowJar
$ native-image --no-server \
-cp build/libs/appkit-examples-3.1.0-all.jar\
--report-unsupported-elements-at-runtime\
--no-fallback -H:+TraceClassInitialization -H:+ReportExceptionStackTraces\
-H:+AddAllCharsets -H:+AllowVMInspection -H:-RuntimeAssertions\
--allow-incomplete-classpath \
--enable-url-protocols=http,https org.ergoplatform.appkit.examples.FreezeCoin freezecoin
[freezecoin:3133] classlist: 35,217.78 ms
[freezecoin:3133] (cap): 6,063.07 ms
[freezecoin:3133] setup: 8,268.99 ms
[freezecoin:3133] (typeflow): 60,238.25 ms
[freezecoin:3133] (objects): 33,009.06 ms
[freezecoin:3133] (features): 4,796.86 ms
[freezecoin:3133] analysis: 102,876.01 ms
[freezecoin:3133] (clinit): 11,642.43 ms
[freezecoin:3133] universe: 13,718.96 ms
[freezecoin:3133] (parse): 5,053.18 ms
[freezecoin:3133] (inline): 18,317.24 ms
[freezecoin:3133] (compile): 44,806.82 ms
[freezecoin:3133] compile: 72,288.24 ms
[freezecoin:3133] image: 7,955.29 ms
[freezecoin:3133] write: 2,872.25 ms
[freezecoin:3133] [total]: 243,813.30 ms
Perintah sederhana di atas menghasilkan eksekusi native lengkap yang disebut freezecoin.
Untuk menekankan, eksekusi ini bukan sekadar peluncur untuk JVM. Faktanya, ia tidak menghubungkan ke JVM atau mengemas
JVM dengan cara apa pun. native-image mengkompilasi kode FreezeCoin, serta semua
pustaka Java yang bergantung padanya, semuanya hingga kode mesin sederhana.
Jika kita melihat pustaka yang digunakan freezecoin, Anda dapat melihat bahwa ia hanya menggunakan pustaka sistem standar. Dengan demikian, kita dapat memindahkan hanya eksekusi ini ke sistem lain
yang tidak memiliki JVM terpasang dan ia akan berjalan di sana tanpa masalah.
$ otool -L freezecoin # ldd freezecoin di Linux
freezecoin:
/usr/lib/libSystem.B.dylib (versi kompatibilitas 1.0.0, versi saat ini 1252.50.4)
/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation (versi kompatibilitas 150.0.0, versi saat ini 1455.12.0)
/usr/lib/libz.1.dylib (versi kompatibilitas 1.0.0, versi saat ini 1.2.11)
Jika kita mengukur waktu eksekusi baru freezecoin ini, kita dapat melihat bahwa ia mulai sekitar 8x lebih cepat, dan menggunakan
sekitar 6x lebih sedikit memori. Apa yang berarti adalah Anda tidak merasakan jeda yang nyata yang selalu Anda dapatkan saat menjalankan
program yang berjalan singkat dengan JVM.
$ DYLD_LIBRARY_PATH=$GRAAL_HOME/jre/lib /usr/bin/time -l ./freezecoin 1800000000
0.43 real 0.15 user 0.03 sys
81289216 ukuran set residens maksimum
0 ukuran memori bersama rata-rata
0 ukuran data tidak bersama rata-rata
0 ukuran tumpukan tidak bersama rata-rata
20079 pemulihan halaman
0 kesalahan halaman
0 swap
0 operasi input blok
0 operasi output blok
13 pesan yang dikirim
86 pesan yang diterima
0 sinyal yang diterima
11 pengalihan konteks sukarela
138 pengalihan konteks yang tidak sukarela
Ini hanyalah salah satu dari banyak manfaat hebat GraalVM yang dapat kita manfaatkan dengan Appkit.
3. Kembangkan Aplikasi Ergo dalam JavaScript, Python, Ruby
GraalVM mendukung yang disebut pemrograman poliglot di mana komponen yang berbeda dari
sebuah aplikasi dapat dikembangkan menggunakan bahasa yang paling sesuai dan kemudian
bergabung secara mulus pada saat runtime. Dengan cara ini, pustaka unik yang ditulis dalam
Java dapat digunakan dalam aplikasi node.js yang ditulis dalam JavaScript, misalnya.
Untuk mendukung pemrograman poliglot, platform GraalVM memiliki implementasi berkinerja tinggi
sendiri dari bahasa-bahasa populer. Kita akan memanfaatkan ini untuk
proyek contoh FreezeCoin kita untuk menunjukkan betapa mudahnya menggunakan bahasa pilihan Anda.
Sebelum menjalankan contoh di bawah ini (dalam JavaScript, Python, dan Ruby), silakan pastikan bahwa Anda telah
menjalankan versi Java dari FreezeCoin secara lokal untuk memastikan semuanya diatur dengan benar.
JavaScript
GraalVM dapat menjalankan JavaScript dan
Node.js
aplikasi secara langsung. Ini kompatibel dengan spesifikasi ECMAScript 2019
.
Selain itu, peluncur js dan node menerima opsi baris perintah khusus --jvm dan --polyglot
yang memungkinkan skrip JS mengakses objek dan kelas Java.
Mengingat hal itu, implementasi JS dari FreezeCoin dapat dengan mudah ditulis menggunakan antarmuka API Appkit.
Silakan lihat kode sumber lengkap dari implementasi FreezeCoin JS
untuk detailnya.
Perintah berikut menggunakan peluncur node untuk mengeksekusi skrip FreezeCoin.js.
$ node --jvm --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
js-examples/FreezeCoin.js 1000000000
Perhatikan, jalur dalam perintah adalah relatif terhadap root dari
direktori proyek ergo-appkit-examples.
Python
GraalVM dapat menjalankan skrip Python
, meskipun
implementasi Python masih eksperimental (lihat juga
bagian kompatibilitas
untuk detail).
Contoh Python dari
FreezeCoin
dapat dieksekusi menggunakan perintah berikut
$ graalpython --jvm --polyglot --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
python-examples/FreezeCoin.py 1900000000
Ruby
GraalVM dapat menjalankan skrip Ruby
menggunakan
implementasi TruffleRuby, yang masih eksperimental (lihat juga
bagian kompatibilitas
untuk detail).
TruffleRuby bertujuan untuk sepenuhnya kompatibel dengan implementasi standar Ruby, MRI, versi 2.6.2
Contoh Ruby dari
FreezeCoin
dapat dieksekusi menggunakan perintah berikut
$ truffleruby --polyglot --jvm --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
ruby-examples/FreezeCoin.rb 1900000000
4. Pustaka Bersama Native Ergo
Manfaat hebat lainnya dari GraalVM adalah kita dapat mengkompilasi kelas Java menjadi pustaka bersama native alih-alih eksekusi.
Untuk melakukan ini kita mendeklarasikan satu atau lebih metode statis sebagai @CEntryPoint.
public class FreezeCoin {
...
/**
* Titik masuk yang dapat dipanggil dari C yang membungkus {@link FreezeCoin#sendTx}
*/
@CEntryPoint(name = "sendTx")
public static void sendTxEntryPoint(
IsolateThread thread,
SignedWord amountToSendW,
CCharPointer configFileNameC,
CCharPointer resBuffer, UnsignedWord bufferSize) throws FileNotFoundException {
long amountToSend = amountToSendW.rawValue();
// Konversi string C ke string Java target.
String configFileName = CTypeConversion.toJavaString(configFileNameC);
String txJson = sendTx(amountToSend, configFileName);
// masukkan string hasil ke dalam buffer yang disediakan
CTypeConversion.toCString(txJson, resBuffer, bufferSize);
}
...
}
Kita kemudian dapat mengkompilasi menjadi pustaka bersama dan file header yang dihasilkan secara otomatis. Perhatikan penggunaan opsi --shared.
$ native-image --no-server \
-cp build/libs/appkit-examples-3.1.0-all.jar\
--report-unsupported-elements-at-runtime\
--no-fallback -H:+TraceClassInitialization -H:+ReportExceptionStackTraces\
-H:+AddAllCharsets -H:+AllowVMInspection -H:-RuntimeAssertions\
--allow-incomplete-classpath \
--enable-url-protocols=http,https
--shared -H:Name=libfreezecoin -H:Path=c-examples
$ otool -L c-examples/libfreezecoin.dylib
c-examples/libfreezecoin.dylib:
.../c-examples/libfreezecoin.dylib (versi kompatibilitas 0.0.0, versi saat ini 0.0.0)
/usr/lib/libSystem.B.dylib (versi kompatibilitas 1.0.0, versi saat ini 1252.50.4)
/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation (versi kompatibilitas 150.0.0, versi saat ini 1455.12.0)
/usr/lib/libz.1.dylib (versi kompatibilitas 1.0.0, versi saat ini 1.2.11)
Sekarang kita memiliki kemampuan untuk menulis program C
yang menggunakan pustaka tersebut.
Antarmuka ke pustaka native kita memang memiliki sedikit
boilerplate (karena VM perlu mengelola heap, utas, pengumpul sampah
dan lainnya), dan oleh karena itu kita perlu membuat instance dan memberikannya
utasan utama kita.
#include <stdlib.h>
#include <stdio.h>
#include <libfreezecoin.h>
int main(int argc, char **argv) {
graal_isolate_t *isolate = NULL;
graal_isolatethread_t *thread = NULL;
if (graal_create_isolate(NULL, &isolate, &thread) != 0) {
fprintf(stderr, "graal_create_isolate error\n");
return 1;
}
char * configFileName = "freeze_coin_config.json";
// ambil amountToSend dari argumen cmd dan panggil pembuatan transaksi
long amountToSend = atol(argv[1]);
char result[1024 * 16];
sendTx(thread, amountToSend, configFileName, result, sizeof(result));
// cetak hasil yang diserialisasi
printf("%s\n", result);
if (graal_detach_thread(thread) != 0) {
fprintf(stderr, "graal_detach_thread error\n");
return 1;
}
return 0;
}
Kita dapat mengkompilasi ini dengan alat sistem standar kita dan dengan mudah menjalankan eksekusi kita (set LD_LIBRARY_PATH=. di Linux).
$ clang -Ic-examples -Lc-examples -lfreezecoin c-examples/freezecoin.c -o call_freezecoin
$ otool -L call_freezecoin
$ DYLD_LIBRARY_PATH=$GRAAL_HOME/jre/lib ./call_freezecoin 1000000000
5. Debugging Aplikasi Ergo Poliglot Anda
Anda dapat melakukan debugging JS, Python, dan Ruby di IntelliJ, tetapi jika karena alasan tertentu ini
tidak berfungsi untuk Anda atau tidak sesuai dengan editor pilihan Anda, GraalVM menawarkan opsi lain.
Semua bahasa GraalVM (kecuali Java) diimplementasikan menggunakan kerangka umum
Truffle.
Truffle memungkinkan alat seperti debugger diimplementasikan sekali dan tersedia
untuk semua bahasa yang didukung.
Dengan demikian kita dapat menjalankan program kita dengan flag --inspect yang akan memberi kita tautan untuk
membuka di Chrome dan akan menghentikan program di debugger.
$ ruby --polyglot --jvm --inspect --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
ruby-examples/FreezeCoin.rb 1900000000
Debugger mendengarkan di port 9229.
Untuk memulai debugging, buka URL berikut di Chrome:
chrome-devtools://devtools/bundled/js_app.html?ws=127.0.0.1:9229/30c7da1e-7558a47d09b
...
Dari sini kita dapat menetapkan breakpoint dan melanjutkan eksekusi. Ketika ia berhenti kita akan melihat
nilai variabel, dapat melanjutkan lagi hingga breakpoint berikutnya, dan melakukan semua yang kita harapkan dari debugger.
Kesimpulan
Dan dengan semua yang telah dikatakan dan dilakukan, kita melihat betapa mudahnya menggunakan Appkit untuk
develop Aplikasi Ergo. Appkit bergantung pada pustaka inti yang sama persis yang
digunakan dalam mengimplementasikan protokol konsensus Ergo. Pustaka ini mencakup
kompiler ErgoScript, kriptografi, interpreter byte code, serialisasi data
dan komponen inti lainnya. Menggunakan GraalVM kita dapat menggunakan kembali komponen yang telah teruji ini
dalam konteks aplikasi yang berbeda tanpa modifikasi
atau menulis ulang sendiri.
Tidak peduli apakah Anda menggunakan Java, JavaScript, Python, atau Ruby, Anda dapat memanfaatkan
Appkit dengan GraalVM untuk secara drastis menyederhanakan proses
berinteraksi dengan blockchain Ergo sambil membuat (d)Apps yang berjalan native.
Tetap disini. Di pos-pos mendatang kami akan memperkenalkan Anda pada aplikasi menarik lainnya yang didukung oleh Appkit.
Referensi
Share post
13 Agustus 2025
9 Juli 2025
