5 mód, ahogyan az Ergo alkalmazásfejlesztés örökre megváltozott az Appkitnek köszönhetően

This page is machine-translated.
Alexander Slesarenko

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 számos nagyszerű felhasználási esete van. Ezen túlmenően, ebben a cikkben áttekintjük az Appkit néhány olyan funkcióját, amelyet a GraalVM-től örökölt, és lépésről lépésre bemutatjuk, hogyan lehet kihasználni ezeket.

Példa forgatókönyv

Készítünk egy egyszerű konzolalkalmazást (amelyet FreezeCoin néven hívunk) 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ő ErgoScript-ben írt Ergo szerződés véd: (lásd ezt az bevezető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 vannak az Ergo blokkláncon. Ahhoz, hogy a doboz felhasználható legyen, a szerződésnek igaznak kell lennie. Így az egyén, aki fel szeretné használni a dobozt, 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:

  1. Az Ergo blokklánc aktuális blokk száma (más néven blokklánc HEIGHT) nagyobb, mint a megadott határidő.

  2. A felhasználási tranzakciót a titkos kulcs tulajdonosa kell, hogy aláírja, amely a ownerPk nyilvános kulcshoz tartozik.

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észeket biztosítson, amelyeket idiomatikusan használhatunk 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 az Appkit számára, 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ópontunkhoz, 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.

freeze_coin_config.json:

{
  "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 az a titkos kifejezés, amelyet ú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ünk 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 éppen 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 használja a csomópontunkhoz.

ErgoNodeConfig nodeConf = conf.getNode();
ErgoClient ergoClient = RestApiErgoClient.create(nodeConf);

Most, hogy van egy példányunk az ErgoClient, végrehajthatunk bármilyen kódrészletet, é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 végzünk.

// hozzáférés a pénztárcához, amely be van ágyazva az Ergo csomópontba 
// (a mnemonikus alapján, 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üldenünk 
// 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 érméd 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 megvannak a költési tranzakciónkhoz kiválasztott bemeneti dobozok, de most létre kell hoznunk egy kimeneti dobozt a megadott amountToSend értékkel, amely a Freezer szerződés alatt zárolva van.

// a tranzakció létrehozásának egyetlen módja a tx builder használata, amelyet a kontextusból kapunk
// 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 kaptunk
// 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: az ErgoContract lefordításához a Freezer script forráskódjából 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őnek 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 fogjuk felhasználni, mely kimenetek
// kell létrehozni, a tranzakciós díjak összegét, és a címét a változásnak, amelyet el kell küldeni
UnsignedTransaction tx = txB.boxesToSpend(boxes.get())
        .outputs(newBox)
        .fee(Parameters.MinFee)
        .sendChangeTo(prover.getP2PKAddress())
        .build();

És végül:

  1. Használjuk a prover-t az elkészített tranzakció aláírásához
  2. Így megszerezzük a SignedTransaction példányt
  3. 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, azonban itt nem használjuk.

SignedTransaction signed = prover.sign(tx);
String txId = ctx.sendTransaction(signed);
return signed.toJson(true);

Ahogy észrevehetted, az utolsó lépésünkben bemutatjuk, hogy lehetséges az aláírt tranzakciót Json karakterlánccá sorosítani, a szép nyomtatás bekapcsolásával. Nézd meg a teljes forráskódot a példáról további részletekért és hogy használd sablonként a saját alkalmazásodban.


Most, hogy minden kódot rögzítettünk, futtathatjuk a FreezeCoin alkalmazásunkat a következő lépésekkel (feltételezve, hogy abban a könyvtárban vagy, ahol klónoztad az ergo-appkit-examples projektet).

$ 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.

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észeket fel lehet használni új tranzakciók létrehozására és küldésére tetszőleges nyilvános Ergo csomópontok használatával.

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 általában hosszú indítási időkkel és viszonylag magas memóriahasználattal szenvednek.

Futtassuk a FreezeCoin-t a time parancs segítségével, hogy megtudjuk, mennyi időt vesz igénybe az egész program futása a kezdetektől a végéig. Az -l kapcsolót is használjuk a memóriahasználat kiírásához.

$ /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  önkénytelen kontextus váltások

Ahogy fent 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 tudunk.

Szerencsére a GraalVM tökéletes megoldást kínál számunkra.

Megoldhatjuk ezt a JVM-ből adódó problémát azzal, 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ának szükségességét futásidőben.

A GraalVM használó fejlesztők számára a tapasztalatunk 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 be 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 egyszerű gépi kódig.

Ha megnézzük a freezecoin által használt könyvtárakat, láthatjuk, hogy csak a standard rendszerkönyvtárakat használja. Így ezt az egy 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  önkénytelen 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őit a legmegfelelőbb nyelven fejleszthetjük, majd zökkenőmentesen kombinálhatjuk őket 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 FreezeCoin Java verziója helyben működik, hogy biztosítsd, hogy minden helyesen van beállítva.

JavaScript

A GraalVM futtathat JavaScript és Node.js alkalmazásokat dobozból. Kompatibilis az ECMAScript 2019 specifikációval.
Továbbá, a js és node indítók különleges --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ő útvonalak a ergo-appkit-examples projekt könyvtárának gyökeréhez viszonyítva relatívak.

Python

A GraalVM futtathat Python szkripteket, bár a Python implementáció még kísérleti (lásd még a kompatibilitási szakaszt a részletekért).

A Python példa a FreezeCoin-ra a következő parancs használatával futtatható:

$ graalpython --jvm --polyglot --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
   python-examples/FreezeCoin.py 1900000000

Ruby

A GraalVM futtathat Ruby szkripteket a TruffleRuby implementációval, amely azonban még kísérleti (lásd még a kompatibilitási szakaszt a 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óval.

A Ruby példa a FreezeCoin-ra a következő parancs használatával futtatható:

$ 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 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();
        // Konvertáld a C karakterláncokat a cél Java karakterláncokká.
        String configFileName = CTypeConversion.toJavaString(configFileNameC);
        String txJson = sendTx(amountToSend, configFileName);

        // tedd a kapott karakterláncot a megadott pufferbe
        CTypeConversion.toCString(txJson, resBuffer, bufferSize);
    }  
    ...
}

Ezután lefordíthatjuk egy megosztott könyvtárra és egy automatikusan generált fejlécfájlra. Figyeld 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 lehetőségünk van arra, hogy írjunk egy C programot, amely a könyvtárat használja.
Az interfész a natív könyvtárunkhoz egy kicsit bonyolult (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";

  // szerezd meg az amountToSend-t a cmd argumentumokból é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özökkel 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

A JS, Python és Ruby hibakeresése az IntelliJ-ben lehetséges, de ha valamilyen okból ez nem működik számodra, vagy nem illeszkedik a preferált szerkesztődbe, a GraalVM egy 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 olyan eszközöket, mint a hibakeresők, egyszer implementáljanak, és elérhetők legyenek az összes támogatott nyelv számára.

Így futtathatjuk a programunkat az --inspect kapcsolóval, amely egy linket ad, amelyet megnyithatunk 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 a változók értékeit, folytathatjuk újra a következő töréspontig, és mindent megtehetünk, amit a hibakeresőktől elvárunk.

Debugger

Következtetések

És mindezen mondandó után láthatjuk, mennyire egyszerű az Appkit használata az Ergo alkalmazások fejlesztéséhez. Az Appkit ugyanazokat a pontosan ugyanazokat a magkönyvtárakat használja, amelyeket az Ergo konszenzus protokoll megvalósításához használtak. Ezek a könyvtárak tartalmazzák az ErgoScript fordítót, a kriptográfiát, a bájt kód értelmezőt, az adatsorozókat és a többi alapvető összetevőt. A GraalVM használatával képesek vagyunk újra felhasználni ezeket a kipróbált és tesztelt összetevőket különböző alkalmazási kontextusokban, anélkül, hogy bármilyen módosítást végeznénk rajtuk, vagy újraírnánk őket.

Nem számít, hogy Java-t, JavaScript-et, Python-t vagy Ruby-t használsz, kihasználhatod az Appkit-et a GraalVM-mel, hogy drámaian leegyszerűsítsd az Ergo blokklánccal való interakció folyamatát, miközben natívan futó (d)App-okat 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

  1. Ergo weboldal
  2. Ergo források
  3. Ergo Appkit
  4. Ergo Appkit példák
  5. GraalVM

Share post

Ergo Infrastructure DAO: Az Ergo Ökoszisztéma Gerincének Decentralizálása

Ergo Infrastructure DAO: Az Ergo Ökoszisztéma Gerincének Decentralizálása

Az Ergo küldetése mindig is a decentralizáción alapult, nemcsak a konszenzus rétegén, hanem az egész stack-en.

Ergo Platform

2025. augusztus 13.

Mew Finance: Egy Játékos DeFi Eszközkészlet az Ergo Ökoszisztémához

Mew Finance: Egy Játékos DeFi Eszközkészlet az Ergo Ökoszisztémához

A Mew Finance egy decentralizált alkalmazáscsomag az Ergo Blockchain-en.

Ergo Platform

2025. augusztus 12.

Lithos: A Bányászat Decentralizálása On-Chain Poolokkal

Lithos: A Bányászat Decentralizálása On-Chain Poolokkal

A Lithos egy új protokoll, amely a bányászati poolok működésének átalakítására készült azáltal, hogy azokat on-chain helyezi, telj.

Ergo Platform

2025. július 24.

Sigma 6.0: Egy Okosabb, Rugalmasabb Ergo

Sigma 6.0: Egy Okosabb, Rugalmasabb Ergo

Sigma 6.0 egy jelentős javasolt frissítés az Ergo blokklánc számára.

Ergo Platform

2025. július 23.

Rosen Jövőjének Formálása: Közösségi Felhívás Öt Kulcsfontosságú Kincstári Javaslatra

Rosen Jövőjének Formálása: Közösségi Felhívás Öt Kulcsfontosságú Kincstári Javaslatra

A Rosen társalapítója, Armeanio, öt új javaslatot nyújtott be a Rosen Kincstárhoz.

Ergo Platform

2025. július 9.

Ergo kibővített UTXO-ja és a mesterséges gazdasági intelligencia felemelkedése

Ergo kibővített UTXO-ja és a mesterséges gazdasági intelligencia felemelkedése

Gyakorlati vízió az autonóm gazdasági ügynökök számára Az autonóm gazdasági ügynökök az Ergo blokkláncon hasznos munkát végeznek .

Ergo Platform

2025. május 12.

ErgoHACK X: Mesterséges Intelligencia az Ergo Blockchain-en

ErgoHACK X: Mesterséges Intelligencia az Ergo Blockchain-en

Ünnepeljük a Decentralizált Innováció Egy Évtizedét Csatlakozz a 10.

Ergo Platform

2025. április 10.