5 spôsobov, ako sa vývoj aplikácií Ergo navždy zmenil vďaka Appkitu
3. decembra 2019
S vďakou Robertovi Kornackému a Denysovi Zadorozhnyimu.
Ergo Appkit je knižnica pre
polyglotný vývoj aplikácií Ergo založená na
GraalVM. GraalVM má mnoho skvelých
prípadov použitia. V tejto článku sa rozšírime o niektoré funkcie Appkitu
zdedené z GraalVM a krok za krokom vás naučíme, ako ich využiť.
- 0. Príklad scenára
- 1. Vývoj aplikácií Java Ergo
- 2. Aplikácie Ergo s nízkou stopou a rýchlym spustením
- 3. Vyvíjajte aplikácie Ergo v JavaScripte, Pythone, Ruby
- 4. Nativné zdieľané knižnice Ergo
- 5. Ladte svoju polyglotnú aplikáciu Ergo
Príklad scenára
Vytvoríme jednoduchú konzolovú aplikáciu (nazvanú
FreezeCoin)
v Jave, ktorá používa knižnicu Appkit. Pomocou Appkitu budeme môcť jednoducho poslať novú transakciu na uzol Ergo programaticky. Transakcia
prenesie danú sumu Erg do novej krabice chránené
nasledujúcim kontraktom Ergo napísaným v ErgoScripte (pozrite si toto
intro a viac pokročilých
príkladov, aby ste sa dozvedeli viac o ErgoScripte).
// Zmluva o zmrazení
{
// Parametre
// freezeDeadline: Int - nejaké budúce číslo bloku, po ktorom môže byť krabica minúta
// ownerPk: SigmaProp - verejný kľúč nového vlastníka krabice
sigmaProp(HEIGHT > freezeDeadline) && ownerPk
}
Stručne povedané, krabica (a teda aj prostriedky v krabici) sú uzamknuté pod zmluvou (alebo skriptom) na blockchaine Ergo. Aby mohla byť krabica minúta, zmluva musí vyhodnotiť na pravdu. Takže osoba, ktorá chce minúť krabicu, musí zabezpečiť, aby zmluva vyhodnotila na pravdu na základe zakódovanej logiky v nej.
Naša zmluva o zmrazení vyššie kontroluje nasledujúce podmienky predtým, ako umožní minúť krabicu:
-
Aktuálne číslo bloku blockchainu Ergo (t.j. výška blockchainu) je
väčšie ako určený termín -
Transakcia minúca musí byť podpísaná vlastníkom tajného kľúča
zodpovedajúceho verejnému kľúču ownerPk.
Prvá podmienka zakazuje komukoľvek minúť krabicu predtým, ako blockchain Ergo dorastie do danej výšky. Pretože nové bloky na blockchainu sa ťažia približne každé 2 minúty v priemere, pomocou aktuálnej
výšky blockchainu je ľahké definovať akúkoľvek dĺžku oneskorenia, ktorú si prajeme, ako napríklad 1 deň, 1 týždeň alebo 1 mesiac. (t.j. (60 / 2) * 24 * 7 = 5040, čo je počet blokov za týždeň).
Teraz sa podrobne pozrieme na to, ako môžeme túto zmluvu o zmrazení integrovať s knižnicou Apkit, aby sme vytvorili konzolovú aplikáciu FreezeCoin, aby si ktokoľvek mohol zvoliť zmraziť svoje mince, ak si to želá. (Priznajme si, táto zmluva/dApp nie je naozaj užitočná, avšak je to efektívny jednoduchý príklad na zobrazenie toho, ako tento technologický stack funguje, aby ste si sami mohli vytvoriť užitočné dApps neskôr.)
1. Vývoj aplikácií Java Ergo
Appkit sa snaží poskytnúť súbor rozhraní, ktoré môžu byť použité idiomaticky
v Jave. Budete sa cítiť ako doma pri používaní Appkitu, ak ste veterán v Jave.
Prosím, postupujte podľa inštrukcií na nastavenie pre GraalVM a
Appkit, ak chcete reprodukovať nižšie uvedené príklady.
Aby sme mohli použiť Appkit v našej implementácii Javy FreezeCoin, musíme pridať
nasledujúcu závislosť do gradle
súboru
dependencies {
implementation("org.ergoplatform", "ergo-appkit_2.12", "3.1.0", "compile")
...
}
Okrem toho musí Appkit/naša aplikácia počas behu nadviazať spojenie s uzlom Ergo cez REST API. Často,
uzol bude bežať lokálne a bude dostupný na http://localhost:9052/. Toto je štandardný scenár pre každého, kto nastavil plný uzol podľa týchto
inštrukcií a používa predvolenú konfiguráciu.
Odteraz predpokladáme, že ste nastavili a spustili svoj uzol Ergo, aby bol dostupný na testovanie aplikácie.
Ďalej, naša aplikácia bude potrebovať vedieť, ako sa pripojiť k nášmu lokálne bežiacemu uzlu, okrem iných rôznych nastavení, aby správne fungovala. Použijeme json súbor s nasledujúcimi
konfiguračnými parametrami, ktoré naša aplikácia FreezeCoin načíta pri spustení.
{
"node": {
"nodeApi": {
"apiUrl": "http://localhost:9052/",
"apiKey": "vložiť svoj tajný apiKey generovaný počas nastavenia uzla sem"
},
"wallet": {
"mnemonic": "mnemonic kľúč použitý na inicializáciu alebo obnovenie peňaženky uzla",
"password": "heslo, ktoré ste si vybrali na ochranu peňaženky",
"mnemonicPassword": "heslo, ktoré ste si vybrali na ochranu mnemonického kľúča"
},
"networkType": "TESTNET"
},
"parameters": {
"newBoxSpendingDelay": "30",
"ownerAddress": "3WzR39tWQ5cxxWWX6ys7wNdJKLijPeyaKgx72uqg9FJRBCdZPovL"
}
}
Tu apiKey je tajný kľúč potrebný na autentifikáciu API, ktorý možno získať, ako je popísané
tu.
Váš mnemonický kľúč je tajná fráza získaná počas nastavenia novej
peňaženky.
Naša aplikácia bude fungovať tak, že používateľ ju spustí z príkazového riadku a poskytne jeden argument. Tento argument je suma hodnoty (v NanoErgoch), ktorú si želajú zmraziť/uzamknúť pod zmluvou o zmrazení, ktorú sme napísali vyššie.
Naším prvým krokom pre našu aplikáciu FreezeCoin bude prečítať konfiguračný json súbor, ktorý sme práve vytvorili, a prijať argument príkazového riadku od používateľa:
public static void main(String[] args) {
long amountToSend = Long.parseLong(args[0]); // kladná hodnota v NanoErg
ErgoToolConfig conf = ErgoToolConfig.load("freeze_coin_config.json");
// zvyšok kódu, o ktorom sa diskutuje nižšie
...
}
S týmito získanými údajmi môžeme teraz získať oneskorenie minúť a adresu vlastníka, ktoré boli definované v json konfiguračnom súbore.
int newBoxSpendingDelay = Integer.parseInt(conf.getParameters().get("newBoxSpendingDelay"));
Address ownerAddress = Address.create(conf.getParameters().get("ownerAddress"));
Ďalej sa musíme pripojiť k bežiacemu uzlu Ergo z našej aplikácie Java, aby sme mohli použiť údaje, ktoré sme práve analyzovali, a niečo zverejniť na reťazci. To sa robí vytvorením
inštancie ErgoClient, ktorá používa naše preddefinované hodnoty pre náš uzol z json konfiguračného súboru.
ErgoNodeConfig nodeConf = conf.getNode();
ErgoClient ergoClient = RestApiErgoClient.create(nodeConf);
Teraz, keď máme inštanciu ErgoClient,
môžeme vykonať akýkoľvek blok kódu a mať prístup k aktuálnemu kontextu blockchainu.
String txJson = ergoClient.execute((BlockchainContext ctx) -> {
// použite ctx tu na vytvorenie a podpísanie novej transakcie
// potom ju pošlite na uzol
});
Lambda odovzdaná do execute sa volá, keď je aktuálny kontext blockchainu načítaný z uzla Ergo. V tejto lambda
vložíme našu aplikačnú logiku.
Najprv začneme s niektorými pomocnými krokmi.
// prístup k peňaženke zabudovanej v uzle Ergo
// (použitím peňaženky špecifikovanej cez mnemonický kľúč, ktorý sme vložili do freeze_coin_config.json)
ErgoWallet wallet = ctx.getWallet();
// vypočítajte celkovú sumu NanoErgov, ktorú musíme poslať do novej krabice
// vrátane zaplatenia poplatkov za transakcie
long totalToSpend = amountToSend + Parameters.MinFee;
// požiadajte o nevyužité krabice, ktoré pokrývajú požadovanú sumu NanoErgov z peňaženky
Optional<List<InputBox>> boxes = wallet.getUnspentBoxes(totalToSpend);
if (!boxes.isPresent())
throw new ErgoClientException(
"Nedostatok mincí vo vašej špecifikovanej peňaženke na zaplatenie " + totalToSpend, null);
// vytvorte "prover", čo je špeciálny objekt, ktorý sa použije na podpisovanie transakcie
// prover by mal byť nakonfigurovaný s tajomstvami vašej peňaženky, ktoré sú potrebné na generovanie podpisov (t.j. dôkazov)
ErgoProver prover = ctx.newProverBuilder()
.withMnemonic(
nodeConf.getWallet().getMnemonic(),
nodeConf.getWallet().getPassword())
.build();
V tomto bode máme vybrané vstupné krabice pre našu transakciu minúcu, ale teraz musíme vytvoriť výstupnú krabicu so špecifikovanou amountToSend a uzamknutú pod zmluvou o zmrazení.
// jediný spôsob, ako vytvoriť transakciu, je pomocou tx buildera získaného z kontextu
// builder používa kontext na prístup k potrebným údajom blockchainu.
UnsignedTransactionBuilder txB = ctx.newTxBuilder();
// vytvorte novú krabicu pomocou nového buildera získaného z transakčného buildera
// v tomto prípade zostavíme novú ErgoContract z kódu ErgoScripta zmluvy o zmrazení
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();
Poznámka, na zostavenie ErgoContract z zdrojového kódu zmluvy o zmrazení metóda compileContract
vyžaduje, aby sme poskytli hodnoty pre pomenované konštanty, ktoré sa používajú v skripte.
Ak sa takéto konštanty nepoužívajú, potom sa môže odovzdať ConstantsBuilder.empty().
V tomto prípade odovzdávame verejný kľúč nového vlastníka krabice do
miesta ownerPk v skripte. Aby sme to zopakovali, to znamená, že krabicu môže minúť iba vlastník
zodpovedajúceho tajného kľúča.
Ďalej vytvoríme nepodpísanú transakciu pomocou všetkých údajov, ktoré sme doteraz poskladali.
// poskytnite transakčnému builderu, ktoré krabice ideme minúť, ktoré výstupy
// by mali byť vytvorené, celkové poplatky za transakcie a adresu pre zmenu, ktorá má byť odoslaná
UnsignedTransaction tx = txB.boxesToSpend(boxes.get())
.outputs(newBox)
.fee(Parameters.MinFee)
.sendChangeTo(prover.getP2PKAddress())
.build();
A nakoniec:
- Použite prover na podpísanie vytvorenej transakcie
- Týmto získate inštanciu
SignedTransaction - Použite kontext blockchainu na odoslanie podpísanej transakcie na
uzol Ergo.
Výsledný txId môže byť použitý na odkazovanie na túto transakciu
neskôr, avšak tu ho nepoužívame.
SignedTransaction signed = prover.sign(tx);
String txId = ctx.sendTransaction(signed);
return signed.toJson(true);
Ako ste si možno všimli, v našom poslednom kroku ukazujeme, že je možné serializovať podpísanú
transakciu do Json reťazca s povoleným pekným tlačením. Pozrite si celý
zdrojový kód
príkladu pre viac podrobností a na jeho použitie ako šablóny vo vašej vlastnej
aplikácii.
Teraz, keď je celý kód nastavený, môžeme spustiť našu aplikáciu FreezeCoin pomocou nasledujúcich krokov
(predpokladajme, že ste v adresári, kde ste sklonovali
ergo-appkit-examples).
$ pwd
the/directory/you/cloned/ergo-appkit-examples
$ ./gradlew clean shadowJar
Toto zostaví súbor build/libs/appkit-examples-3.1.0-all.jar, ktorý obsahuje
našu aplikáciu FreezeCoin Java a všetky jej závislosti v jednom fat jar.
Poznámka, tento krok sa musí opakovať po akýchkoľvek zmenách v zdrojovom kóde Javy našej aplikácie.
Po vytvorení našej aplikácie môžeme teraz použiť našu aplikáciu FreezeCoin:
$ java -cp build/libs/appkit-examples-3.1.0-all.jar \
org.ergoplatform.appkit.examples.FreezeCoin 1000000000
Dostanete niečo podobné tomuto výstupu v konzole.
A s tým bola vaša transakcia prijatá uzlom Ergo a vysielaná do siete, kde bude čakať v transakčnom bazéne, aby bola pridaná do bloku. Keď ťažiari vyberú a pridajú ju do bloku, vaše mince budú oficiálne "zmrazené" v novo vytvorenej krabici na základe hodnôt, ktoré ste poskytli aplikácii FreezeCoin.
Príklad predpokladá, že uzol Ergo (a zabudovaná peňaženka) je vlastnený používateľom
FreezeCoin. Avšak to nie je striktne požadované a rozhrania Appkit
môžu byť použité na vytvorenie a odoslanie nových transakcií pomocou ľubovoľných verejných uzlov Ergo.
2. Aplikácie Ergo s nízkou stopou a rýchlym spustením
Ako možno viete, používanie Javy pre krátkodobé procesy má veľa nevýhod.
Aplikácie majú tendenciu trpieť dlhými časmi spustenia a relatívne vysokou spotrebou pamäte.
Spustime FreezeCoin pomocou príkazu time, aby sme
získali skutočný (reálny čas uplynulý) čas, ktorý trvá celému programu bežať od
začiatku do konca. Používame prepínač -l, aby sme vytlačili aj spotrebu pamäte.
$ /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 maximálna veľkosť rezidentnej sady
0 priemerná veľkosť zdieľanej pamäte
0 priemerná veľkosť nezdieľaných údajov
0 priemerná veľkosť nezdieľanej zásobníka
125010 obnovenia strán
1216 chyby strán
0 swap
0 blokové vstupné operácie
0 blokové výstupné operácie
13 odoslané správy
86 prijaté správy
1 prijaté signály
2384 dobrovoľné prepínania kontextu
17409 nedobrovoľné prepínania kontextu
Ako je vidieť vyššie, táto malá aplikácia trvala 2 paralelným vláknam takmer 4
sekundy na beh. Väčšina tohto času môže byť pripísaná spusteniu JVM a
bežnému JIT kompilátoru. Toto je dosť podpriemerný výkon a vieme, že môžeme urobiť oveľa lepšie.
Našťastie, GraalVM nám poskytuje dokonalé riešenie.
Tento inherentný problém s JVM môžeme vyriešiť kompilovaním Java kódu
ahead-of-time do natívneho spustiteľného obrazu prostredníctvom GraalVM. To preskočí potrebu používať Java just-in-time kompilátor
počas behu.
Skúsenosť pre nás (vývojára používajúceho GraalVM) je veľmi podobná konvenčnému kompilátoru ako gcc. Poznámka,
možno budeme musieť najprv spustiť ./gradlew clean shadowJar.
$ ./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] analýza: 102,876.01 ms
[freezecoin:3133] (clinit): 11,642.43 ms
[freezecoin:3133] univerzum: 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
Jednoduchý príkaz vyššie vytvára kompletný natívny spustiteľný súbor nazvaný freezecoin.
Aby sme zdôraznili, tento spustiteľný súbor nie je len spúšťač pre JVM. V skutočnosti sa nespája s JVM ani nebalí
JVM akýmkoľvek spôsobom. native-image kompiluje kód FreezeCoin, ako aj akékoľvek
Java knižnice, na ktorých závisí, až na jednoduchý strojový kód.
Ak sa pozrieme na knižnice, ktoré freezecoin používa, môžete vidieť, že používa iba štandardné systémové knižnice. Takže môžeme presunúť len tento jeden spustiteľný súbor na iný systém,
ktorý nemá nainštalovanú JVM a bude tam fungovať bez problémov.
$ otool -L freezecoin # ldd freezecoin na Linuxe
freezecoin:
/usr/lib/libSystem.B.dylib (verzia kompatibility 1.0.0, aktuálna verzia 1252.50.4)
/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation (verzia kompatibility 150.0.0, aktuálna verzia 1455.12.0)
/usr/lib/libz.1.dylib (verzia kompatibility 1.0.0, aktuálna verzia 1.2.11)
Ak časujeme tento nový spustiteľný súbor freezecoin, môžeme vidieť, že sa spúšťa približne 8x rýchlejšie a používa
približne 6x menej pamäte. To znamená, že necítite tú hmatateľnú pauzu, ktorú vždy dostanete pri spúšťaní
krátkodobej aplikácie s JVM.
$ DYLD_LIBRARY_PATH=$GRAAL_HOME/jre/lib /usr/bin/time -l ./freezecoin 1800000000
0.43 real 0.15 user 0.03 sys
81289216 maximálna veľkosť rezidentnej sady
0 priemerná veľkosť zdieľanej pamäte
0 priemerná veľkosť nezdieľaných údajov
0 priemerná veľkosť nezdieľanej zásobníka
20079 obnovenia strán
0 chyby strán
0 swap
0 blokové vstupné operácie
0 blokové výstupné operácie
13 odoslané správy
86 prijaté správy
0 prijaté signály
11 dobrovoľné prepínania kontextu
138 nedobrovoľné prepínania kontextu
Toto je len jedna z veľkých výhod GraalVM, ktoré môžeme využiť s Appkit.
3. Vyvíjajte aplikácie Ergo v JavaScripte, Pythone, Ruby
GraalVM podporuje takzvané polyglotné programovanie, v ktorom môžu byť rôzne komponenty
aplikácie vyvinuté pomocou najvhodnejšieho jazyka a potom
bezproblémovo skombinované počas behu. Týmto spôsobom môže byť jedinečná knižnica napísaná napríklad
v Jave použitá v aplikácii node.js napísanej v JavaScripte.
Na podporu polyglotného programovania má platforma GraalVM svoje vlastné vysoko výkonné
implementácie populárnych jazykov. Využijeme to pre
náš projekt FreezeCoin, aby sme vám ukázali, aké jednoduché je používať váš preferovaný jazyk.
Pred spustením nižšie uvedených príkladov (v JavaScripte, Pythone a Ruby) sa prosím uistite, že máte
verziu FreezeCoin v Jave fungujúcu lokálne, aby ste zabezpečili, že všetko je nastavené správne.
JavaScript
GraalVM môže spúšťať JavaScript a
Node.js
aplikácie priamo. Je kompatibilný s špecifikáciou ECMAScript 2019.
Okrem toho, spúšťače js a node akceptujú špeciálne príkazy --jvm a --polyglot
príkazového riadku, ktoré umožňujú JS skriptom pristupovať k Java objektom a triedam.
Keďže to tak je, implementáciu FreezeCoin v JS je možné ľahko napísať pomocou rozhrania API Appkit.
Prosím, pozrite si celý zdrojový kód implementácie FreezeCoin JS
pre podrobnosti.
Nasledujúci príkaz používa spúšťač node na vykonanie skriptu FreezeCoin.js.
$ node --jvm --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
js-examples/FreezeCoin.js 1000000000
Poznámka, cesty v príkaze sú relatívne k koreňovému adresáru
projektu ergo-appkit-examples.
Python
GraalVM môže spúšťať Python
skripty, hoci
implementácia Pythonu je stále experimentálna (pozrite si tiež
sekciu kompatibility
pre podrobnosti).
Python príklad
FreezeCoin
možno vykonať pomocou nasledujúceho príkazu
$ graalpython --jvm --polyglot --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
python-examples/FreezeCoin.py 1900000000
Ruby
GraalVM môže spúšťať Ruby
skripty pomocou
implementácie TruffleRuby, ktorá je však stále experimentálna (pozrite si tiež
sekciu kompatibility
pre podrobnosti).
TruffleRuby sa snaží byť plne kompatibilný so štandardnou implementáciou Ruby, MRI, verzia 2.6.2
Ruby príklad
FreezeCoin
možno vykonať pomocou nasledujúceho príkazu
$ truffleruby --polyglot --jvm --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
ruby-examples/FreezeCoin.rb 1900000000
4. Nativné zdieľané knižnice Ergo
Ďalšou skvelou výhodou GraalVM je, že môžeme kompilovať Java triedy do natívnej zdieľanej knižnice namiesto spustiteľného súboru.
Aby sme to dosiahli, deklarujeme jednu alebo viac statických metód ako @CEntryPoint.
public class FreezeCoin {
...
/**
* Vstupný bod volateľný z C, ktorý obalí {@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();
// Preveďte C reťazce na cieľové Java reťazce.
String configFileName = CTypeConversion.toJavaString(configFileNameC);
String txJson = sendTx(amountToSend, configFileName);
// vložte výsledný reťazec do poskytnutého buffera
CTypeConversion.toCString(txJson, resBuffer, bufferSize);
}
...
}
Potom môžeme kompilovať do zdieľanej knižnice a automaticky generovaného hlavičkového
súboru. Všimnite si použitie možnosti --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 (verzia kompatibility 0.0.0, aktuálna verzia 0.0.0)
/usr/lib/libSystem.B.dylib (verzia kompatibility 1.0.0, aktuálna verzia 1252.50.4)
/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation (verzia kompatibility 150.0.0, aktuálna verzia 1455.12.0)
/usr/lib/libz.1.dylib (verzia kompatibility 1.0.0, aktuálna verzia 1.2.11)
Teraz máme možnosť napísať C
program
, ktorý používa knižnicu.
Rozhranie k našej natívnej knižnici má trochu
boilerplate (pretože VM musí spravovať haldu, vlákna, garbage collector
atď.), a preto musíme vytvoriť inštanciu a poskytnúť ju
nášmu hlavnému vláknu.
#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";
// získajte amountToSend z cmd args a zavolajte vytvorenie transakcie
long amountToSend = atol(argv[1]);
char result[1024 * 16];
sendTx(thread, amountToSend, configFileName, result, sizeof(result));
// vytlačte serializovaný výsledok
printf("%s\n", result);
if (graal_detach_thread(thread) != 0) {
fprintf(stderr, "graal_detach_thread error\n");
return 1;
}
return 0;
}
Toto môžeme kompilovať s našimi štandardnými systémovými nástrojmi a ľahko spustiť náš spustiteľný súbor (nastavte LD_LIBRARY_PATH=. na Linuxe).
$ 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. Ladte svoju polyglotnú aplikáciu Ergo
Môžete ladit JS, Python a Ruby v IntelliJ, ale ak z nejakého dôvodu to nefunguje pre vás alebo nezapadá do vášho preferovaného editora, GraalVM ponúka ďalšiu možnosť.
Všetky jazyky GraalVM (okrem Javy) sú implementované pomocou spoločného
Truffle frameworku.
Truffle umožňuje nástroje ako ladice implementovať raz a sprístupniť
pre všetky podporované jazyky.
Takže môžeme spustiť náš program s prepínačom --inspect, ktorý nám dá odkaz na
otvorenie v Chrome a pozastaví program v ladici.
$ ruby --polyglot --jvm --inspect --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
ruby-examples/FreezeCoin.rb 1900000000
Ladica počúva na porte 9229.
Ak chcete začať ladit, otvorte nasledujúcu URL v Chrome:
chrome-devtools://devtools/bundled/js_app.html?ws=127.0.0.1:9229/30c7da1e-7558a47d09b
...
Odtiaľ môžeme nastaviť zarážky a pokračovať v vykonávaní. Keď sa to zastaví, uvidíme
hodnoty premenných, môžeme pokračovať znova až do ďalšej zarážky a robiť všetko, čo sme sa naučili očakávať od ladíc.
Závery
A s tým všetkým povedaným a vykonaným vidíme, aké jednoduché je používať Appkit na
devlopovanie aplikácií Ergo. Appkit sa spolieha na presne tie isté základné knižnice, ktoré
boli použité pri implementácii konsenzuálneho protokolu Ergo. Tieto knižnice zahŕňajú
kompilátor ErgoScript, kryptografiu, interpret byte kódu, serializéry údajov
a ďalšie základné komponenty. Použitím GraalVM môžeme znovu použiť tieto osvedčené
komponenty v rôznych aplikačných kontextoch bez akýchkoľvek úprav
alebo prepisovania sami.
Nezáleží na tom, či používate Javu, JavaScript, Python alebo Ruby, môžete využiť
Appkit s GraalVM na dramatické zjednodušenie procesu
interakcie s blockchainom Ergo pri vytváraní natívne bežiacich (d)Apps.
Sledujte nás. V budúcich príspevkoch vás oboznámime s ďalšími zaujímavými potenciálnymi
aplikáciami poháňanými Appkit.
Odkazy
Share post
9. júla 2025
