WALLETS•EXCHANGES•ROADMAP•BLOG•DOCUMENTATION•SIGMAVERSE•ERGOBLOCKCHAIN

Appkit sayesinde Ergo Uygulama Geliştirmenin Sonsuza Dek Değişen 5 Yolu

This page is machine-translated.

Alexander Slesarenko

3 Aralık 2019

Robert Kornacki ve Denys Zadorozhnyi'a teşekkürler.

Ergo Appkit, GraalVM tabanlı Ergo Uygulamaları için çok dilli geliştirme kütüphanesidir. GraalVM'in birçok harika kullanım durumu vardır. Bu makalede, GraalVM'den miras alınan bazı Appkit özelliklerini inceleyecek ve bunlardan nasıl yararlanacağınızı adım adım öğreneceksiniz.

0. Örnek Senaryo
1. Java Ergo Uygulama Geliştirme
2. Düşük Ayak İzi, Hızlı Başlangıçlı Ergo Uygulamaları
3. JavaScript, Python, Ruby ile Ergo Uygulamaları Geliştirin
4. Ergo Yerel Paylaşılan Kütüphaneler
5. Poliglot Ergo Uygulamanızı Hata Ayıklayın

Örnek Senaryo

Appkit kütüphanesini kullanan basit bir konsol uygulaması (adlı FreezeCoin) oluşturacağız. Appkit kullanarak, programatik olarak bir Ergo düğümüne yeni bir işlem gönderebileceğiz. İşlem, aşağıdaki ErgoScript ile yazılmış Ergo sözleşmesi tarafından korunan yeni bir kutuya belirli bir miktar Erg transfer edecektir (ErgoScript hakkında daha fazla bilgi için bu giriş ve daha gelişmiş örnekler bakın).

// Freezer Sözleşmesi
{ 
  // Parametreler
  // freezeDeadline: Int - kutunun harcanabileceği gelecekteki bir blok numarası
  // ownerPk: SigmaProp - yeni kutu sahibinin genel anahtarı
  sigmaProp(HEIGHT > freezeDeadline) && ownerPk
}

Kısacası, bir kutu (ve dolayısıyla kutudaki fonlar) Ergo blok zincirinde bir sözleşme (veya script) altında kilitlenmiştir. Kutunun harcanabilmesi için sözleşmenin doğru olarak değerlendirilmesi gerekir. Bu nedenle, kutuyu harcamak isteyen birey, sözleşmenin içindeki kodlanmış mantığa dayanarak doğru değerlendirildiğinden emin olmalıdır.

Yukarıdaki Freezer sözleşmemiz, kutunun harcanmasına izin vermeden önce aşağıdaki koşulları kontrol eder:

Ergo blok zincirinin mevcut blok numarası (yani blok zinciri YÜKSEKLİĞİ) belirtilen son tarihten büyüktür.
Harcama işlemi, ownerPk genel anahtarına karşılık gelen gizli anahtarın sahibi tarafından imzalanmalıdır.

İlk koşul, Ergo blok zinciri belirtilen yüksekliğe ulaşmadan önce kimsenin kutuyu harcamasını yasaklar. Blok zincirindeki yeni bloklar ortalama her 2 dakikada bir çıkarıldığından, mevcut blok zinciri yüksekliğini kullanarak 1 gün, 1 hafta veya 1 ay gibi istediğimiz herhangi bir gecikme süresini tanımlamak kolaydır. (yani (60 / 2) * 24 * 7 = 5040, bu haftada blok sayısıdır).

Artık bu Freezer Sözleşmesini alıp Appkit kütüphanesi ile entegre ederek, herkesin isterse paralarını dondurabileceği FreezeCoin konsol uygulamasını oluşturma konusunda derinlemesine gideceğiz. (Kabul edelim ki, bu sözleşme/dApp aslında faydalı değildir, ancak bu teknoloji yığınının nasıl çalıştığını göstermek için etkili bir basit örnektir, böylece siz de ileride faydalı dApp'ler oluşturabilirsiniz.)

1. Java Ergo Uygulama Geliştirme

Appkit, Java'da deyimsel olarak kullanılabilecek bir dizi arayüz sağlamayı hedefliyor. Eğer bir Java veteranıysanız, Appkit'i kullanırken kendinizi evinizde gibi hissedeceksiniz.

Aşağıdaki örnekleri yeniden üretmek istiyorsanız, GraalVM ve Appkit için lütfen kurulum talimatlarını takip edin.

FreezeCoin'un Java uygulamasında Appkit'i kullanmak için, gradle dosyasına aşağıdaki bağımlılığı eklememiz gerekiyor.

dependencies {
    implementation("org.ergoplatform", "ergo-appkit_2.12", "3.1.0", "compile")
    ...
}

Ayrıca, çalışma zamanında Appkit/uygulamamızın bir Ergo Düğümü ile REST API aracılığıyla bağlantı kurması gerekiyor. Genellikle, düğüm yerel olarak çalışacak ve http://localhost:9052/ adresinde erişilebilir olacaktır. Bu, bu talimatları takip ederek tam düğüm kuran herkes için standart bir senaryodur ve varsayılan yapılandırmayı kullanmaktadır.

Bundan sonra, uygulamamızın düzgün çalışabilmesi için yerel çalışan düğümümüze nasıl bağlanacağını bilmesi gerekecek, ayrıca diğer çeşitli ayarları da bilmesi gerekecek. FreezeCoin uygulamamızın başlangıçta yükleyeceği aşağıdaki yapılandırma parametrelerine sahip bir json dosyası kullanacağız.

freeze_coin_config.json:

{
  "node": {
    "nodeApi": {
      "apiUrl": "http://localhost:9052/",
      "apiKey": "buraya düğüm kurulumu sırasında oluşturulan gizli apiKey'inizi koyun"
    },
    "wallet": {
      "mnemonic": "düğümün cüzdanını başlatmak veya geri yüklemek için kullanılan mnemonik anahtar",
      "password": "cüzdanı korumak için seçtiğiniz şifre",
      "mnemonicPassword": "mnemonik anahtarı korumak için seçtiğiniz şifre"
    },
    "networkType": "TESTNET"
  },
  "parameters": {
    "newBoxSpendingDelay": "30",
    "ownerAddress": "3WzR39tWQ5cxxWWX6ys7wNdJKLijPeyaKgx72uqg9FJRBCdZPovL"
  }
}

Burada apiKey, API kimlik doğrulaması için gereken gizli anahtardır ve burada açıklandığı gibi edinilebilir. Mnemonik anahtarınız, yeni bir cüzdanın kurulumu sırasında elde edilen gizli ifadedir.

Uygulamamızın çalışma şekli, kullanıcının komut satırından başlatması ve bir argüman sağlamasıdır. Bu argüman, Freezer sözleşmesi altında dondurmak/kapamak istedikleri değer miktarıdır (NanoErg cinsinden).

FreezeCoin uygulamamız için ilk adım, oluşturduğumuz yapılandırma json dosyasını okumak ve kullanıcıdan komut satırı argümanını kabul etmektir:

public static void main(String[] args) {
    long amountToSend = Long.parseLong(args[0]);  // NanoErg cinsinden pozitif değer
    ErgoToolConfig conf = ErgoToolConfig.load("freeze_coin_config.json");
    // aşağıda tartışılan kodun geri kalanı 
    ...
}

Bunları elde ettikten sonra, artık json yapılandırma dosyasında tanımlanan harcama gecikmesini ve sahibi adresini alabiliriz.

  int newBoxSpendingDelay = Integer.parseInt(conf.getParameters().get("newBoxSpendingDelay"));
  Address ownerAddress = Address.create(conf.getParameters().get("ownerAddress"));

Sonraki adım, Java uygulamamızdan çalışan Ergo düğümüne bağlanmak, böylece yeni ayrıştırdığımız verileri kullanabilir ve zincir üzerinde bir şey gönderebiliriz. Bu, json yapılandırma dosyasından düğüm için önceden tanımlanmış değerlerimizi kullanan bir ErgoClient örneği oluşturarak yapılır.

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

Artık ErgoClient örneğimiz var, herhangi bir kod bloğunu çalıştırabilir ve mevcut blok zinciri bağlamına erişebiliriz.

String txJson = ergoClient.execute((BlockchainContext ctx) -> {
    // burada ctx kullanarak yeni bir işlem oluşturun ve imzalayın
    // ardından düğüme gönderin 
});

execute'ye geçirilen lambda, mevcut blok zinciri bağlamı Ergo düğümünden yüklendiğinde çağrılır. Bu lambda içinde uygulama mantığımızı koyacağız.

Öncelikle bazı yardımcı adımlarla başlayalım.

// Ergo düğümünde gömülü cüzdana erişim 
// (freeze_coin_config.json dosyasında belirttiğimiz mnemonik ile belirtilen cüzdanı kullanarak)
ErgoWallet wallet = ctx.getWallet();

// yeni kutuya göndermemiz gereken toplam NanoErg miktarını hesaplayın 
// işlem ücretlerini de dahil ederek
long totalToSpend = amountToSend + Parameters.MinFee;

// cüzdandan gerekli NanoErg miktarını karşılayan harcanmamış kutular için istek yapın
Optional<List<InputBox>> boxes = wallet.getUnspentBoxes(totalToSpend);
if (!boxes.isPresent())
    throw new ErgoClientException(
        "Belirtilen cüzdanınızda toplam harcama için yeterli coin yok: " + totalToSpend, null);
    
// işlemi imzalamak için kullanılacak özel bir nesne olan "prover" oluşturun
// prover, imzaları (yani kanıtları) oluşturmak için gerekli olan cüzdanınızın gizli anahtarları ile yapılandırılmalıdır
ErgoProver prover = ctx.newProverBuilder()
    .withMnemonic(
            nodeConf.getWallet().getMnemonic(),
            nodeConf.getWallet().getPassword())
    .build();

Bu noktada, harcama işlemi için seçilen giriş kutularına sahibiz, ancak şimdi belirtilen amountToSend ile Freezer sözleşmesi altında kilitlenmiş bir çıkış kutusu oluşturmamız gerekiyor.

// bir işlemi oluşturmanın tek yolu, bağlamdan elde edilen işlem oluşturucusunu kullanmaktır
// oluşturucu, gerekli blok zinciri verilerine erişmek için bağlamı kullanır.
UnsignedTransactionBuilder txB = ctx.newTxBuilder();

// işlem oluşturucusundan elde edilen yeni oluşturucu kullanarak yeni bir kutu oluşturun
// bu durumda Freezer ErgoScript kodundan yeni bir ErgoContract derliyoruz
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();

Not: Freezer script kaynak kodundan ErgoContract derlemek için compileContract metodunun, script içinde kullanılan adlandırılmış sabitler için değerler sağlamamız gerekir. Eğer böyle sabitler kullanılmıyorsa, ConstantsBuilder.empty() geçilebilir.

Bu durumda, yeni kutu sahibinin genel anahtarını scriptteki ownerPk yer tutucusuna geçiriyoruz. Daha önce tekrar etmek gerekirse, bu, kutunun yalnızca ilgili gizli anahtarın sahibi tarafından harcanabileceği anlamına gelir.

Sonraki adım, şimdiye kadar bir araya getirdiğimiz tüm verileri kullanarak imzasız bir işlem oluşturmaktır.

// hangi kutuları harcayacağımızı, hangi çıkışların oluşturulacağını,
// toplam işlem ücretlerini ve değişikliklerin gönderileceği adresi sağlayın
UnsignedTransaction tx = txB.boxesToSpend(boxes.get())
        .outputs(newBox)
        .fee(Parameters.MinFee)
        .sendChangeTo(prover.getP2PKAddress())
        .build();

Ve nihayet:

Oluşturulan işlemi imzalamak için prover'ı kullanın
Böylece bir SignedTransaction örneği elde edin
İmzalı işlemi Ergo düğümüne göndermek için blok zinciri bağlamını kullanın.

Elde edilen txId, bu işlemi daha sonra referans almak için kullanılabilir, ancak burada kullanmıyoruz.

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

Gördüğünüz gibi, son adımımızda imzalı işlemi Json dizesine serileştirmenin mümkün olduğunu gösteriyoruz ve bu işlem güzel bir biçimlendirme ile yapılmaktadır. Örneğin, tam kaynak koduna bakarak daha fazla ayrıntı ve kendi uygulamanızda bir şablon olarak kullanabilirsiniz.

Artık tüm kod sabitlendikten sonra, FreezeCoin uygulamamızı aşağıdaki adımları izleyerek çalıştırabiliriz (ergo-appkit-examples'ı klonladığınız dizinde olduğunuzu varsayarak).

$ pwd
the/directory/you/cloned/ergo-appkit-examples
$ ./gradlew clean shadowJar

Bu, FreezeCoin Java uygulamamız ve tüm bağımlılıklarını tek bir büyük jar dosyasında içeren build/libs/appkit-examples-3.1.0-all.jar dosyasını oluşturacaktır. Not: Bu adım, uygulamamızın Java kaynak kodunda herhangi bir değişiklik yapıldığında tekrarlanmalıdır.

Uygulamamızı oluşturduktan sonra, artık FreezeCoin uygulamamızı kullanabiliriz:

$ java -cp build/libs/appkit-examples-3.1.0-all.jar \
      org.ergoplatform.appkit.examples.FreezeCoin  1000000000

Konsolda bu çıktıya benzer bir şey alacaksınız.

Ve böylece işleminiz Ergo düğümü tarafından kabul edildi ve ağa yayıldı, burada işlem havuzunda bir blok eklenmeyi bekleyecektir. Bir madenci bunu seçip bir bloğa eklediğinde, paralarınız FreezeCoin uygulamasına sağladığınız değerlere dayalı olarak yeni oluşturulan kutuda resmi olarak "dondurulmuş" olacaktır.

Örnek, Ergo düğümünün (ve gömülü cüzdanın) FreezeCoin kullanıcısına ait olduğunu varsayıyor. Ancak bu kesinlikle gerekli değildir ve Appkit arayüzleri, keyfi genel Ergo düğümlerini kullanarak yeni işlemler oluşturmak ve göndermek için kullanılabilir.

2. Düşük Ayak İzi, Hızlı Başlangıçlı Ergo Uygulamaları

Bildiğiniz gibi, kısa süreli işlemler için Java kullanmanın birçok dezavantajı vardır. Uygulamalar genellikle uzun başlangıç süreleri ve nispeten yüksek bellek kullanımı ile karşılaşır.

FreezeCoin'u çalıştırmak için zaman komutunu kullanarak, programın baştan sona çalışması için geçen gerçek (duvar saati geçen zamanı) süreyi alalım. Ayrıca bellek kullanımını yazdırmak için -l bayrağını kullanıyoruz.

$ /usr/bin/time -l java -cp build/libs/appkit-examples-3.1.0-all.jar \
   org.ergoplatform.appkit.examples.FreezeCoin 1000000000
...
       4.97 gerçek         8.41 kullanıcı         0.69 sistem
 513703936  maksimum ikamet eden set boyutu
         0  ortalama paylaşılan bellek boyutu
         0  ortalama paylaşılamayan veri boyutu
         0  ortalama paylaşılamayan yığın boyutu
    125010  sayfa geri kazanımları
      1216  sayfa hataları
         0  takaslar
         0  blok girdi işlemleri
         0  blok çıktı işlemleri
        13  gönderilen mesajlar
        86  alınan mesajlar
         1  alınan sinyaller
      2384  isteğe bağlı bağlam geçişleri
     17409  zorunlu bağlam geçişleri

Yukarıda görüldüğü gibi, bu küçük uygulama 2 paralel iş parçacığına neredeyse 4 saniye sürdü. Bu sürenin çoğu JVM başlangıcına ve arka planda çalışan JIT derleyicisine atfedilebilir. Bu oldukça düşük bir performanstır ve daha iyi yapabileceğimizi biliyoruz.

Neyse ki, GraalVM bize mükemmel bir çözüm sunuyor.

JVM ile bu içsel sorunu, Java kodunu önceden derleyerek yerel bir çalıştırılabilir görüntüye dönüştürerek çözebiliriz. Bu, çalışma zamanında Java just-in-time derleyicisini kullanma ihtiyacını atlar.

GraalVM'i kullanan geliştirici olarak deneyimimiz, geleneksel bir derleyici olan gcc'ye oldukça benzer. Not: Öncelikle ./gradlew clean shadowJar komutunu çalıştırmamız gerekebilir.

$ ./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]      [toplam]: 243,813.30 ms

Yukarıdaki basit komut, freezecoin adında tam bir yerel çalıştırılabilir dosya üretir.

Vurgulamak gerekirse, bu çalıştırılabilir dosya yalnızca JVM için bir başlatıcı değildir. Aslında, JVM ile bağlantı kurmaz veya JVM'i herhangi bir şekilde paketlemez. native-image, FreezeCoin kodunu ve bağımlı olduğu Java kütüphanelerini basit makine koduna kadar derler.

freezecoin'in kullandığı kütüphanelere bakarsak, yalnızca standart sistem kütüphanelerini kullandığını görebilirsiniz. Böylece, bu tek çalıştırılabilir dosyayı başka bir sistemde JVM yüklü olmadan çalıştırabiliriz.

$ otool -L freezecoin    # Linux'ta ldd freezecoin
freezecoin:
	/usr/lib/libSystem.B.dylib (uyumluluk sürümü 1.0.0, mevcut sürüm 1252.50.4)
	/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation (uyumluluk sürümü 150.0.0, mevcut sürüm 1455.12.0)
	/usr/lib/libz.1.dylib (uyumluluk sürümü 1.0.0, mevcut sürüm 1.2.11)

Bu yeni freezecoin çalıştırılabilir dosyasının zamanını ölçersek, yaklaşık 8 kat daha hızlı başladığını ve yaklaşık 6 kat daha az bellek kullandığını görebiliriz. Bu, JVM ile kısa süreli bir program çalıştırdığınızda her zaman hissettiğiniz o belirgin duraksamayı hissetmeyeceğiniz anlamına gelir.

$ DYLD_LIBRARY_PATH=$GRAAL_HOME/jre/lib /usr/bin/time -l ./freezecoin 1800000000
        0.43 gerçek         0.15 kullanıcı         0.03 sistem
  81289216  maksimum ikamet eden set boyutu
         0  ortalama paylaşılan bellek boyutu
         0  ortalama paylaşılamayan veri boyutu
         0  ortalama paylaşılamayan yığın boyutu
     20079  sayfa geri kazanımları
         0  sayfa hataları
         0  takaslar
         0  blok girdi işlemleri
         0  blok çıktı işlemleri
        13  gönderilen mesajlar
        86  alınan mesajlar
         0  alınan sinyaller
        11  isteğe bağlı bağlam geçişleri
       138  zorunlu bağlam geçişleri

Bu, Appkit ile yararlandığımız GraalVM'in harika avantajlarından sadece biridir.

3. JavaScript, Python, Ruby ile Ergo Uygulamaları Geliştirin

GraalVM, uygulamanın farklı bileşenlerinin en uygun dil kullanılarak geliştirilebildiği ve ardından çalışma zamanında sorunsuz bir şekilde birleştirilebildiği poliglot programlama olarak adlandırılan bir yaklaşımı destekler. Bu şekilde, örneğin Java'da yazılmış benzersiz bir kütüphane, JavaScript ile yazılmış bir node.js uygulamasında kullanılabilir.

Poliglot programlamayı desteklemek için GraalVM platformunun popüler dillerin yüksek performanslı uygulamaları vardır. FreezeCoin örnek projemiz için bunu kullanarak, tercih ettiğiniz dili kullanmanın ne kadar kolay olduğunu göstereceğiz.

Aşağıdaki örnekleri (JavaScript, Python ve Ruby) çalıştırmadan önce, her şeyin doğru bir şekilde ayarlandığından emin olmak için FreezeCoin'un Java sürümünün yerel olarak çalıştığından emin olun.

JavaScript

GraalVM, JavaScript ve Node.js uygulamalarını kutudan çıkar çıkmaz çalıştırabilir. ECMAScript 2019 spesifikasyonu ile uyumludur. Ayrıca, js ve node başlatıcıları, JS betiklerinin Java nesnelerine ve sınıflarına erişmesine izin veren özel --jvm ve --polyglot komut satırı seçeneklerini kabul eder.

Bunun böyle olması durumunda, FreezeCoin'un JS uygulaması, Appkit API arayüzünü kullanarak kolayca yazılabilir. Lütfen FreezeCoin JS uygulamasının tam kaynak koduna ayrıntılar için bakın. Aşağıdaki komut, FreezeCoin.js betiğini çalıştırmak için node başlatıcısını kullanır.

$ node --jvm --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
  js-examples/FreezeCoin.js  1000000000

Not: Komuttaki yollar, ergo-appkit-examples proje dizininin köküne göredir.

Python

GraalVM, Python betiklerini çalıştırabilir, ancak Python uygulaması hala deneysel bir aşamadadır (ayrıca uyumluluk bölümü için ayrıntılara bakın).

FreezeCoin'un Python örneği, aşağıdaki komut kullanılarak çalıştırılabilir.

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

Ruby

GraalVM, Ruby betiklerini TruffleRuby uygulaması kullanarak çalıştırabilir, ancak bu hala deneysel bir aşamadadır (ayrıca uyumluluk bölümü için ayrıntılara bakın). TruffleRuby, Ruby'nin standart uygulaması olan MRI ile tamamen uyumlu olmayı hedeflemektedir, sürüm 2.6.2.

FreezeCoin'un Ruby örneği, aşağıdaki komut kullanılarak çalıştırılabilir.

$ truffleruby --polyglot --jvm --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
    ruby-examples/FreezeCoin.rb 1900000000

4. Ergo Yerel Paylaşılan Kütüphaneler

GraalVM'in bir diğer harika avantajı, Java sınıflarını çalıştırılabilir yerine yerel bir paylaşılan kütüphaneye derleyebilmemizdir.

Bunu yapmak için bir veya daha fazla statik metodu @CEntryPoint olarak tanımlarız.

public class FreezeCoin {
    ...
     /**
     * C'den çağrılabilir giriş noktası, {@link FreezeCoin#sendTx} sarmalar
     */
    @CEntryPoint(name = "sendTx")
    public static void sendTxEntryPoint(
            IsolateThread thread,
            SignedWord amountToSendW,
            CCharPointer configFileNameC,
            CCharPointer resBuffer, UnsignedWord bufferSize) throws FileNotFoundException {
        long amountToSend = amountToSendW.rawValue();
        // C dizelerini hedef Java dizelerine dönüştürün.
        String configFileName = CTypeConversion.toJavaString(configFileNameC);
        String txJson = sendTx(amountToSend, configFileName);

        // sonuç dizesini sağlanan tampon içine koyun
        CTypeConversion.toCString(txJson, resBuffer, bufferSize);
    }  
    ...
}

Sonrasında paylaşılan bir kütüphaneye ve otomatik olarak oluşturulan bir başlık dosyasına derleyebiliriz. --shared seçeneğinin kullanımına dikkat edin.

$ 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 (uyumluluk sürümü 0.0.0, mevcut sürüm 0.0.0)
	/usr/lib/libSystem.B.dylib (uyumluluk sürümü 1.0.0, mevcut sürüm 1252.50.4)
	/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation (uyumluluk sürümü 150.0.0, mevcut sürüm 1455.12.0)
	/usr/lib/libz.1.dylib (uyumluluk sürümü 1.0.0, mevcut sürüm 1.2.11)

Artık kütüphaneyi kullanan bir C programı yazma yeteneğine sahibiz. Yerel kütüphanemize arayüz, biraz fazla kod gerektirir (çünkü VM bir yığın, iş parçacıkları, bir çöp toplayıcı ve daha fazlasını yönetmelidir), bu nedenle bir örnek oluşturmalı ve ana iş parçacığımızı sağlamalıyız.

#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 hatası\n");
    return 1;
  }

  char * configFileName = "freeze_coin_config.json";

  // komut argümanlarından amountToSend'i alın ve işlem oluşturma çağrısını yapın
  long amountToSend = atol(argv[1]);
  char result[1024 * 16];
  sendTx(thread, amountToSend, configFileName, result, sizeof(result));

  // serileştirilmiş sonucu yazdırın
  printf("%s\n", result);

  if (graal_detach_thread(thread) != 0) {
    fprintf(stderr, "graal_detach_thread hatası\n");
    return 1;
  }
  return 0;
}

Bunu standart sistem araçlarımızla derleyebilir ve çalıştırılabilir dosyamızı kolayca çalıştırabiliriz (Linux'ta LD_LIBRARY_PATH=. ayarlayın).

$ 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. Poliglot Ergo Uygulamanızı Hata Ayıklayın

JS, Python ve Ruby'yi IntelliJ'de hata ayıklayabilirsiniz, ancak bu bir nedenle sizin için çalışmıyorsa veya tercih ettiğiniz editörle uyumlu değilse, GraalVM başka bir seçenek sunar.

GraalVM dillerinin tamamı (Java hariç) ortak Truffle çerçevesi kullanılarak uygulanmıştır. Truffle, hata ayıklayıcılar gibi araçların bir kez uygulanmasını ve tüm desteklenen diller için kullanılabilir olmasını sağlar.

Bu nedenle, programımızı --inspect bayrağı ile çalıştırabiliriz, bu da bize Chrome'da açmamız için bir bağlantı verecek ve programı hata ayıklayıcıda durduracaktır.

$ ruby --polyglot --jvm --inspect --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
    ruby-examples/FreezeCoin.rb 1900000000
Debugger 9229 numaralı portta dinliyor.
Hata ayıklamaya başlamak için, Chrome'da aşağıdaki URL'yi açın:
    chrome-devtools://devtools/bundled/js_app.html?ws=127.0.0.1:9229/30c7da1e-7558a47d09b
...

Buradan, kesme noktaları ayarlayabilir ve yürütmeyi devam ettirebiliriz. Kırıldığında, değişkenlerin değerlerini göreceğiz, bir sonraki kesme noktasına kadar devam edebiliriz ve hata ayıklayıcılardan beklediğimiz her şeyi yapabiliriz.

Debugger

Sonuçlar

Tüm bunlar söylendikten sonra, Appkit'i kullanarak Ergo Uygulamaları geliştirmenin ne kadar kolay olduğunu görüyoruz. Appkit, Ergo konsensüs protokolünü uygulamak için kullanılan tam olarak aynı temel kütüphanelere dayanır. Bu kütüphaneler, ErgoScript derleyicisi, kriptografi, bayt kodu yorumlayıcı, veri serileştiricileri ve diğer temel bileşenleri içerir. GraalVM kullanarak, bu test edilmiş bileşenleri farklı uygulama bağlamlarında herhangi bir değişiklik yapmadan veya kendimiz yeniden yazmadan yeniden kullanabiliyoruz.

Java, JavaScript, Python veya Ruby kullanıyor olsanız da, Appkit ile GraalVM'den yararlanarak Ergo blok zinciri ile etkileşim sürecini büyük ölçüde basitleştirebilir ve yerel çalışan (d)App'ler oluşturabilirsiniz.

Bizi izlemeye devam edin. Gelecek yazılarda, Appkit ile desteklenen diğer ilginç potansiyel uygulamaları tanıtacağız.