5 mód, ahogyan az Ergo alkalmazásfejlesztés örökre megváltozott az Appkitnek köszönhetően
2019. december 3.
Köszönet Robert Kornacki és Denys Zadorozhnyi munkájának.
Ergo Appkit egy könyvtár az
Ergo alkalmazások poliglot fejlesztéséhez, amely a
GraalVM alapjaira épül. A GraalVM-nek sok nagyszerű
felhasználási esete van. Ezen túlmenően, ebben a cikkben áttekintjük az Appkit
funkcióit, amelyeket a GraalVM-től örökölt, és lépésről lépésre bemutatjuk, hogyan lehet kihasználni őket.
- 0. Példa forgatókönyv
- 1. Java Ergo alkalmazásfejlesztés
- 2. Alacsony lábnyomú, gyorsan induló Ergo alkalmazások
- 3. Ergo alkalmazások fejlesztése JavaScript, Python, Ruby nyelveken
- 4. Ergo natív megosztott könyvtárak
- 5. Hibakeresés a poliglot Ergo alkalmazásban
Példa forgatókönyv
Készítünk egy egyszerű konzolalkalmazást (amelyet
FreezeCoin)
Java nyelven, amely az Appkit könyvtárat használja. Az Appkit használatával könnyedén küldhetünk új tranzakciót egy Ergo csomópontnak programozott módon. A
tranzakció egy adott mennyiségű Erg-t fog átutalni egy új dobozba, amelyet a
következő Ergo szerződés véd, amely ErgoScript nyelven íródott (lásd ezt az
introdukciót és további haladó
példákat az ErgoScript-ről).
// Freezer szerződés
{
// Paraméterek
// freezeDeadline: Int - egy jövőbeli blokk szám, amely után a doboz felhasználható
// ownerPk: SigmaProp - az új doboz tulajdonosának nyilvános kulcsa
sigmaProp(HEIGHT > freezeDeadline) && ownerPk
}
Röviden, egy doboz (és így a dobozban lévő alapok) egy szerződés (vagy script) alatt zárolva van az Ergo blokkláncon. Ahhoz, hogy a doboz felhasználható legyen, a szerződésnek igaznak kell lennie. Így az egyén, aki a dobozt fel szeretné használni, biztosítania kell, hogy a szerződés az abban kódolt logika alapján igaznak értékelődjön.
A fenti Freezer szerződésünk az alábbi feltételeket ellenőrzi, mielőtt engedélyezné a doboz felhasználását:
-
Az Ergo blokklánc aktuális blokk száma (más néven blokklánc HEIGHT) nagyobb, mint a megadott határidő
-
A felhasználási tranzakciót a titkos kulcs tulajdonosa kell, hogy aláírja,
az ownerPk nyilvános kulcshoz tartozó.
Az első feltétel megtiltja bárkinek, hogy a dobozt felhasználja, mielőtt az Ergo
blokklánc elérné a megadott magasságot. Mivel az új blokkok a blokkláncon körülbelül 2 percenként bányásznak, a jelenlegi
blokklánc magasságának használatával könnyen meghatározhatunk bármilyen késleltetési időt, amelyet szeretnénk, például 1 nap, 1 hét vagy 1 hónap. (azaz (60 / 2) * 24 * 7 = 5040, ami a heti blokkok száma).
Most részletesen megvizsgáljuk, hogyan integrálhatjuk ezt a Freezer szerződést az Apkit könyvtárral, hogy létrehozzuk a FreezeCoin konzolalkalmazást, így bárki és mindenki választhatja, hogy befagyasztja a pénzét, ha úgy kívánja. (Bár ez a szerződés/dApp valójában nem hasznos, azonban hatékony egyszerű példa arra, hogy bemutassuk, hogyan működik ez a technológiai stack, így te magad is hasznos dApp-okat építhetsz a jövőben.)
1. Java Ergo alkalmazásfejlesztés
Az Appkit célja, hogy egy olyan interfészkészletet biztosítson, amely idiomatikusan használható
Java nyelven. Ha Java veterán vagy, az Appkit használata otthonos érzést fog adni.
Kérjük, kövesd a beállítási
utasításokat a GraalVM és
Appkit esetében, ha reprodukálni szeretnéd az alábbi példákat.
Az Appkit használatához a FreezeCoin Java implementációnkban hozzá kell adnunk a
következő függőséget a gradle
fájlban
dependencies {
implementation("org.ergoplatform", "ergo-appkit_2.12", "3.1.0", "compile")
...
}
Továbbá, futásidőben az Appkit/alkalmazásunknak kapcsolódnia kell egy Ergo Node-hoz REST API-n keresztül. Gyakran,
a csomópont helyben fut, és elérhető a http://localhost:9052/ címen. Ez a standard forgatókönyv bárki számára, aki teljes csomópontot állított be a következő
utasítások követésével, és az alapértelmezett konfigurációt használja.
Ezután feltételezzük, hogy beállítottad és elindítottad az Ergo Node-ot, hogy az elérhető legyen az alkalmazás teszteléséhez.
Következő lépésként az alkalmazásunknak tudnia kell, hogyan tud kapcsolódni a helyben futó csomóponthoz, a megfelelő működés érdekében különböző beállítások mellett. Egy json fájlt fogunk használni a következő
konfigurációs paraméterekkel, amelyeket a FreezeCoin alkalmazásunk betölt a startup során.
{
"node": {
"nodeApi": {
"apiUrl": "http://localhost:9052/",
"apiKey": "tedd ide a titkos apiKey-t, amelyet a csomópont beállítása során generáltál"
},
"wallet": {
"mnemonic": "a mnemonikus kulcs, amelyet a csomópont pénztárcájának inicializálásához vagy helyreállításához használtál",
"password": "a jelszó, amelyet a pénztárca védelmére választottál",
"mnemonicPassword": "a jelszó, amelyet a mnemonikus védelmére választottál"
},
"networkType": "TESTNET"
},
"parameters": {
"newBoxSpendingDelay": "30",
"ownerAddress": "3WzR39tWQ5cxxWWX6ys7wNdJKLijPeyaKgx72uqg9FJRBCdZPovL"
}
}
Itt az apiKey a titkos kulcs, amely az API hitelesítéséhez szükséges, amelyet a
itt leírtak szerint lehet megszerezni.
A mnemonikusod a titkos kifejezés, amelyet a új
pénztárca beállítása során kaptál.
Az alkalmazásunk úgy fog működni, hogy a felhasználó a parancssorból indítja el, és megad egy argumentumot. Ez az argumentum az az érték (NanoErg-ben), amelyet befagyasztani/zárolni kíván a fenti Freezer szerződés alatt.
Az első lépés a FreezeCoin alkalmazásunk számára az lesz, hogy beolvassuk a konfigurációs json fájlt, amelyet most hoztunk létre, és elfogadjuk a felhasználótól a parancssori argumentumot:
public static void main(String[] args) {
long amountToSend = Long.parseLong(args[0]); // pozitív érték NanoErg-ben
ErgoToolConfig conf = ErgoToolConfig.load("freeze_coin_config.json");
// a további kód, amelyről alább beszélünk
...
}
Ezekkel a megszerzett adatokkal most megszerezhetjük a költési késleltetést és a tulajdonos címet, amelyeket a json konfigurációs fájlban definiáltunk.
int newBoxSpendingDelay = Integer.parseInt(conf.getParameters().get("newBoxSpendingDelay"));
Address ownerAddress = Address.create(conf.getParameters().get("ownerAddress"));
Következő lépésként csatlakoznunk kell a futó Ergo csomóponthoz a Java alkalmazásunkból, hogy felhasználhassuk az imént elemzett adatokat, és valamit közzétehessünk a láncon. Ezt egy ErgoClient példány létrehozásával végezzük, amely a json konfigurációs fájlunkból származó előre definiált értékeket is használja.
ErgoNodeConfig nodeConf = conf.getNode();
ErgoClient ergoClient = RestApiErgoClient.create(nodeConf);
Most, hogy van egy példányunk az ErgoClient,
bármilyen kódrészletet végrehajthatunk, és hozzáférhetünk az aktuális blokklánc kontextushoz.
String txJson = ergoClient.execute((BlockchainContext ctx) -> {
// használd ctx-t itt egy új tranzakció létrehozásához és aláírásához
// majd küldd el a csomópontnak
});
A execute-hoz átadott lambda akkor hívódik meg, amikor az aktuális blokklánc kontextus betöltődik az Ergo csomópontból. Ebben a lambda-ban
fogjuk elhelyezni az alkalmazás logikáját.
Először néhány segédlépést kezdünk.
// hozzáférés a pénztárcához, amely be van ágyazva az Ergo csomópontba
// (a mnemonikus használatával, amelyet a freeze_coin_config.json fájlban adtunk meg)
ErgoWallet wallet = ctx.getWallet();
// számítsd ki a NanoErg összesített mennyiségét, amelyet az új dobozba kell küldeni
// beleértve a tranzakciós díjak kifizetését
long totalToSpend = amountToSend + Parameters.MinFee;
// kérj unspent dobozokat, amelyek fedezik a szükséges NanoErg mennyiséget a pénztárcából
Optional<List<InputBox>> boxes = wallet.getUnspentBoxes(totalToSpend);
if (!boxes.isPresent())
throw new ErgoClientException(
"Nincs elég pénz a megadott pénztárcádban a " + totalToSpend + " kifizetésére", null);
// hozz létre egy "prover"-t, amely egy speciális objektum, amelyet a tranzakció aláírásához használnak
// a prover-t a pénztárcád titkaival kell konfigurálni, amelyek szükségesek az aláírások (azaz bizonyítékok) generálásához
ErgoProver prover = ctx.newProverBuilder()
.withMnemonic(
nodeConf.getWallet().getMnemonic(),
nodeConf.getWallet().getPassword())
.build();
Ezen a ponton már kiválasztottuk a költési tranzakcióhoz szükséges input dobozokat, de most létre kell hoznunk egy output dobozt a megadott amountToSend értékkel, amely a Freezer szerződés alatt van zárolva.
// a tranzakció létrehozásának egyetlen módja a tx builder használata, amelyet a kontextusból nyerünk
// a builder a kontextust használja a szükséges blokklánc adatok eléréséhez.
UnsignedTransactionBuilder txB = ctx.newTxBuilder();
// új doboz létrehozása az új builder használatával, amelyet a tranzakció builderből nyertünk
// ebben az esetben egy új ErgoContract-ot állítunk össze a Freezer ErgoScript kódjából
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();
Megjegyzés, a Freezer script forráskódjából az ErgoContract lefordításához a compileContract
metódus megköveteli, hogy értékeket adjunk meg a scriptben használt névleges konstansokhoz.
Ha nincsenek ilyen konstansok, akkor a ConstantsBuilder.empty() is átadható.
Ebben az esetben a doboz új tulajdonosának nyilvános kulcsát adjuk át az ownerPk
helyettesítőbe a scriptben. Ismételjük meg, hogy ez azt jelenti, hogy a dobozt csak a megfelelő titkos kulcs tulajdonosa használhatja fel.
Következő lépésként létrehozunk egy aláíratlan tranzakciót az összes eddig összegyűjtött adatok felhasználásával.
// add meg a tranzakció buildernek, hogy mely dobozokat fogunk költeni, mely outputokat
// kell létrehozni, a tranzakciós díjak összegét, és a címét a visszajáró összegnek
UnsignedTransaction tx = txB.boxesToSpend(boxes.get())
.outputs(newBox)
.fee(Parameters.MinFee)
.sendChangeTo(prover.getP2PKAddress())
.build();
Végül:
- Használjuk a prover-t az elkészített tranzakció aláírásához
- Így megszerezzük a
SignedTransactionpéldányt - Használjuk a blokklánc kontextust, hogy elküldjük az aláírt tranzakciót az
Ergo csomópontnak.
A kapott txId később hivatkozható erre a tranzakcióra,
de itt nem használjuk.
SignedTransaction signed = prover.sign(tx);
String txId = ctx.sendTransaction(signed);
return signed.toJson(true);
Ahogy észrevetted, az utolsó lépésben bemutatjuk, hogy lehetséges az aláírt
tranzakciót Json stringgé sorosítani, a szép nyomtatás bekapcsolásával. Nézd meg a teljes
forráskódot
a példa részleteiért és hogy használd sablonként a saját
alkalmazásodban.
Most, hogy minden kódot rögzítettünk, a következő lépésekkel futtathatjuk a FreezeCoin alkalmazásunkat
(feltételezve, hogy abban a könyvtárban vagy, ahol klónoztad
ergo-appkit-examples).
$ pwd
a könyvtár, ahová klónoztad az ergo-appkit-examples-t
$ ./gradlew clean shadowJar
Ez összeállítja a build/libs/appkit-examples-3.1.0-all.jar fájlt, amely tartalmazza
a FreezeCoin Java alkalmazásunkat és az összes függőségét egyetlen fat jar-ban.
Megjegyzés, ezt a lépést meg kell ismételni, miután bármilyen változtatást végeztél az alkalmazásunk Java forráskódján.
Miután létrehoztuk az alkalmazásunkat, most használhatjuk a FreezeCoin alkalmazásunkat:
$ java -cp build/libs/appkit-examples-3.1.0-all.jar \
org.ergoplatform.appkit.examples.FreezeCoin 1000000000
Valami ilyesmit fogsz kapni a konzolban megjelenő kimenet.
Ezzel a tranzakciódat elfogadta az Ergo csomópont, és továbbította a hálózatra, ahol várakozni fog a tranzakciós medencében, hogy hozzáadják egy blokkhoz. Miután egy bányász kiválasztja és hozzáadja egy blokkhoz, a pénzed hivatalosan "befagyasztva" lesz az újonnan létrehozott dobozban, a FreezeCoin alkalmazásnak megadott értékek alapján.
A példa feltételezi, hogy az Ergo csomópont (és a beágyazott pénztárca) a
FreezeCoin felhasználó tulajdonában van. Ez azonban nem szigorúan szükséges, és az Appkit interfészek
használhatók új tranzakciók létrehozására és küldésére tetszőleges nyilvános Ergo
csomópontokkal.
2. Alacsony lábnyomú, gyorsan induló Ergo alkalmazások
Ahogy tudod, a Java használata rövid futásidejű folyamatokhoz sok hátránnyal jár.
Az alkalmazások hajlamosak hosszú indítási időkkel és viszonylag magas memóriahasználattal szenvedni.
Futtassuk a FreezeCoin-t a time parancs segítségével, hogy
megtudjuk a valós (falóra vonatkozó eltelt időt), amely alatt a teljes program fut a
kezdetétől a végéig. Az -l kapcsolót használjuk a memóriahasználat kiírásához is.
$ /usr/bin/time -l java -cp build/libs/appkit-examples-3.1.0-all.jar \
org.ergoplatform.appkit.examples.FreezeCoin 1000000000
...
4.97 valós 8.41 felhasználói 0.69 rendszer
513703936 maximális lakóhely méret
0 átlagos megosztott memória méret
0 átlagos megosztatlan adatmennyiség
0 átlagos megosztatlan verem méret
125010 oldal újrahasználatok
1216 oldal hibák
0 cserék
0 blokk bemeneti műveletek
0 blokk kimeneti műveletek
13 küldött üzenetek
86 fogadott üzenetek
1 fogadott jelzések
2384 önkéntes kontextus váltások
17409 kényszerített kontextus váltások
Ahogy látható, ez a kis alkalmazás 2 párhuzamos szálat közel 4
másodpercig futott. Ennek a legtöbb ideje a JVM indításának és
a háttérben futó JIT fordítónak tulajdonítható. Ez elég gyenge teljesítmény, és tudjuk, hogy sokkal jobbat is elérhetünk.
Szerencsére a GraalVM tökéletes megoldást kínál.
Megoldhatjuk ezt a JVM-ből adódó problémát azáltal, hogy a Java kódot
előre lefordítjuk egy natív végrehajtható képre a GraalVM segítségével. Ez megkerüli a Java just-in-time fordító használatát
futásidőben.
A GraalVM használó fejlesztő számára a tapasztalat meglehetősen hasonló egy hagyományos fordítóhoz, mint a gcc. Megjegyzés,
lehet, hogy először futtatnunk kell a ./gradlew clean shadowJar parancsot.
$ ./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
A fenti egyszerű parancs egy teljes natív végrehajthatót hoz létre, amelyet freezecoin-nak hívunk.
Hangsúlyozni kell, hogy ez a végrehajtható nem csupán a JVM indítója. Valójában nem kapcsolódik a JVM-hez, és nem is csomagolja
a JVM-t semmilyen módon. A native-image lefordítja a FreezeCoin kódot, valamint az összes
Java könyvtárat, amelyre szüksége van, egészen az egyszerű gépi kódig.
Ha megnézzük a freezecoin által használt könyvtárakat, láthatjuk, hogy csak a standard rendszer könyvtárakat használja. Így ezt az egyetlen végrehajthatót áthelyezhetjük egy másik rendszerre,
amelyen nincs telepítve JVM, és ott problémamentesen fog futni.
$ otool -L freezecoin # ldd freezecoin Linuxon
freezecoin:
/usr/lib/libSystem.B.dylib (kompatibilitási verzió 1.0.0, aktuális verzió 1252.50.4)
/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation (kompatibilitási verzió 150.0.0, aktuális verzió 1455.12.0)
/usr/lib/libz.1.dylib (kompatibilitási verzió 1.0.0, aktuális verzió 1.2.11)
Ha időt mérünk ezzel az új freezecoin végrehajthatóval, láthatjuk, hogy körülbelül 8x gyorsabban indul, és körülbelül 6x kevesebb memóriát használ. Ez azt jelenti, hogy nem érzed azt a kézzelfogható szünetet, amit mindig tapasztalsz, amikor egy
rövid futásidejű programot futtatsz a JVM-mel.
$ DYLD_LIBRARY_PATH=$GRAAL_HOME/jre/lib /usr/bin/time -l ./freezecoin 1800000000
0.43 valós 0.15 felhasználói 0.03 rendszer
81289216 maximális lakóhely méret
0 átlagos megosztott memória méret
0 átlagos megosztatlan adatmennyiség
0 átlagos megosztatlan verem méret
20079 oldal újrahasználatok
0 oldal hibák
0 cserék
0 blokk bemeneti műveletek
0 blokk kimeneti műveletek
13 küldött üzenetek
86 fogadott üzenetek
0 fogadott jelzések
11 önkéntes kontextus váltások
138 kényszerített kontextus váltások
Ez csak egy a GraalVM nagyszerű előnyei közül, amelyeket az Appkit segítségével kihasználhatunk.
3. Ergo alkalmazások fejlesztése JavaScript, Python, Ruby nyelveken
A GraalVM támogatja a úgynevezett poliglot programozást, amelyben egy alkalmazás különböző összetevői a legmegfelelőbb nyelv használatával fejleszthetők, majd
zökkenőmentesen egyesíthetők futásidőben. Ily módon egy Java nyelven írt egyedi könyvtár például felhasználható egy JavaScript nyelven írt node.js alkalmazásban.
A poliglot programozás támogatására a GraalVM platform saját, nagy teljesítményű
implementációkkal rendelkezik népszerű nyelvekből. Ezt fogjuk kihasználni a
FreezeCoin példa projektünkben, hogy megmutassuk, mennyire egyszerű a preferált nyelved használata.
Mielőtt futtatnád az alábbi példákat (JavaScript, Python és Ruby nyelven), kérlek, győződj meg róla, hogy a
Java verziójú FreezeCoin helyben működik, hogy biztosítsd, hogy minden helyesen van beállítva.
JavaScript
A GraalVM képes JavaScript és
Node.js
alkalmazásokat futtatni azonnal. Kompatibilis az ECMAScript 2019
specifikációval.
Ezenkívül a js és node indítók speciális --jvm és --polyglot
parancssori opciókat fogadnak el, amelyek lehetővé teszik a JS szkriptek számára, hogy hozzáférjenek Java objektumokhoz és osztályokhoz.
Ezért egy JS implementáció a FreezeCoin-ból könnyen megírható az Appkit
API interfész használatával.
Kérlek, nézd meg a FreezeCoin JS
implementáció
teljes forráskódját a részletekért.
A következő parancs a node indítót használja a FreezeCoin.js szkript végrehajtásához.
$ node --jvm --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
js-examples/FreezeCoin.js 1000000000
Megjegyzés, a parancsban szereplő elérési utak a gyökér
ergo-appkit-examples projekt könyvtárához viszonyítva relatívak.
Python
A GraalVM képes Python
szkriptek futtatására, bár
a Python implementáció még kísérleti (lásd még a
kompatibilitási szakaszt
részletekért).
A Python példa a
FreezeCoin
teljesítése a következő parancs használatával történhet:
$ graalpython --jvm --polyglot --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
python-examples/FreezeCoin.py 1900000000
Ruby
A GraalVM képes Ruby
szkriptek futtatására a
TruffleRuby implementációval, amely azonban még kísérleti (lásd még a
kompatibilitási szakaszt
részletekért).
A TruffleRuby célja, hogy teljes mértékben kompatibilis legyen a Ruby standard implementációjával, az MRI 2.6.2 verziójával.
A Ruby példa a
FreezeCoin
teljesítése a következő parancs használatával történhet:
$ truffleruby --polyglot --jvm --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
ruby-examples/FreezeCoin.rb 1900000000
4. Ergo natív megosztott könyvtárak
A GraalVM másik nagyszerű előnye, hogy a Java osztályokat natív megosztott könyvtárrá fordíthatjuk le végrehajtható helyett.
Ehhez egy vagy több statikus metódust @CEntryPoint-ként kell deklarálnunk.
public class FreezeCoin {
...
/**
* C-ből hívható belépési pont, amely a {@link FreezeCoin#sendTx} -t csomagolja
*/
@CEntryPoint(name = "sendTx")
public static void sendTxEntryPoint(
IsolateThread thread,
SignedWord amountToSendW,
CCharPointer configFileNameC,
CCharPointer resBuffer, UnsignedWord bufferSize) throws FileNotFoundException {
long amountToSend = amountToSendW.rawValue();
// A C karakterláncokat a cél Java karakterláncokká konvertáljuk.
String configFileName = CTypeConversion.toJavaString(configFileNameC);
String txJson = sendTx(amountToSend, configFileName);
// a kapott karakterláncot a megadott pufferbe helyezzük
CTypeConversion.toCString(txJson, resBuffer, bufferSize);
}
...
}
Ezután lefordíthatjuk egy megosztott könyvtárra és egy automatikusan generált fejléc
fájlra. Figyeljük meg a --shared opció használatát.
$ 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 (kompatibilitási verzió 0.0.0, aktuális verzió 0.0.0)
/usr/lib/libSystem.B.dylib (kompatibilitási verzió 1.0.0, aktuális verzió 1252.50.4)
/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation (kompatibilitási verzió 150.0.0, aktuális verzió 1455.12.0)
/usr/lib/libz.1.dylib (kompatibilitási verzió 1.0.0, aktuális verzió 1.2.11)
Most már képesek vagyunk írni egy C
programot
, amely a könyvtárat használja.
A natív könyvtárunk interfésze egy kicsit
boilerplate-tel rendelkezik (mivel a VM-nek kezelnie kell egy halmot, szálakat, egy szemétgyűjtőt
és még sok mást), ezért létre kell hoznunk egy példányt, és meg kell adnunk neki
a fő szálunkat.
#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 hiba\n");
return 1;
}
char * configFileName = "freeze_coin_config.json";
// a cmd argumentumokból szerezd meg az amountToSend-t és hívd meg a tranzakció létrehozását
long amountToSend = atol(argv[1]);
char result[1024 * 16];
sendTx(thread, amountToSend, configFileName, result, sizeof(result));
// írd ki a sorosított eredményt
printf("%s\n", result);
if (graal_detach_thread(thread) != 0) {
fprintf(stderr, "graal_detach_thread hiba\n");
return 1;
}
return 0;
}
Ezt a standard rendszereszközeinkkel lefordíthatjuk, és könnyen futtathatjuk a végrehajthatónkat (állítsd be LD_LIBRARY_PATH=. Linuxon).
$ 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. Hibakeresés a poliglot Ergo alkalmazásban
JS, Python és Ruby nyelveken az IntelliJ-ben hibakereshetsz, de ha valamilyen okból ez
nem működik számodra, vagy nem illeszkedik a preferált szerkesztődbe, a GraalVM másik lehetőséget kínál.
A GraalVM összes nyelve (kivéve a Java-t) a közös
Truffle keretrendszer segítségével van implementálva.
A Truffle lehetővé teszi, hogy az eszközök, mint például a hibakeresők egyszer legyenek implementálva, és minden támogatott nyelv számára elérhetők legyenek.
Így a programunkat a --inspect kapcsolóval futtathatjuk, amely egy linket ad nekünk,
hogy megnyithassuk a Chrome-ban, és megállítja a programot a hibakeresőben.
$ ruby --polyglot --jvm --inspect --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
ruby-examples/FreezeCoin.rb 1900000000
A hibakereső a 9229-es porton hallgat.
A hibakeresés megkezdéséhez nyisd meg a következő URL-t a Chrome-ban:
chrome-devtools://devtools/bundled/js_app.html?ws=127.0.0.1:9229/30c7da1e-7558a47d09b
...
Itt beállíthatunk töréspontokat és folytathatjuk a végrehajtást. Amikor megáll, látni fogjuk
az változók értékeit, folytathatjuk újra a következő töréspontig, és mindent megtehetünk, amit a hibakeresőktől elvárunk.
Következtetések
Mindezek után láthatjuk, mennyire egyszerű az Appkit használata az Ergo alkalmazások fejlesztéséhez. Az Appkit ugyanazokat a pontosan az Ergo konszenzus protokoll megvalósításához használt alapkönyvtárakat használja. Ezek a könyvtárak tartalmazzák
a ErgoScript fordítót, a kriptográfiát, a byte kód értelmezőt, az adatsorozókat
és a többi alapvető komponenst. A GraalVM használatával képesek vagyunk ezeket a kipróbált
és tesztelt komponenseket különböző alkalmazási kontextusokban újrahasználni, bármilyen módosítás vagy
újraírás nélkül.
Nem számít, hogy Java, JavaScript, Python vagy Ruby nyelvet használsz, kihasználhatod
az Appkit-et a GraalVM segítségével, hogy drámaian leegyszerűsítsd a folyamatot,
az Ergo blokklánccal való interakció során, miközben natívan futó (d)Appokat hozol létre.
Maradj velünk. A jövőbeli bejegyzésekben bemutatunk más érdekes potenciális
alkalmazásokat, amelyeket az Appkit hajt.
Hivatkozások
Share post
2025. augusztus 13.
2025. augusztus 12.
2025. július 9.
2025. május 12.
