5 Modi in cui lo Sviluppo di Applicazioni Ergo è Cambiato per Sempre Grazie ad Appkit
3 dicembre 2019
Con grazie a Robert Kornacki e Denys Zadorozhnyi.
Ergo Appkit è una libreria per
lo sviluppo poliglotta di Applicazioni Ergo basata su
GraalVM. GraalVM ha molti ottimi
casi d'uso. Espandendo su questo, in questo articolo passeremo in rassegna alcune delle funzionalità di Appkit
ereditate da GraalVM e ti guideremo passo dopo passo nell'apprendimento di come sfruttarle.
- 0. Scenario Esemplare
- 1. Sviluppo di App Ergo in Java
- 2. Applicazioni Ergo a Basso Impatto e Avvio Veloce
- 3. Sviluppa Applicazioni Ergo in JavaScript, Python, Ruby
- 4. Librerie Condivise Native di Ergo
- 5. Debugga la Tua Applicazione Ergo Poliglotta
Scenario Esemplare
Creeremo una semplice applicazione console (chiamata
FreezeCoin)
in Java che utilizza la libreria Appkit. Utilizzando Appkit, saremo in grado di inviare facilmente una nuova transazione a un nodo Ergo in modo programmatico. La
transazione trasferirà un determinato importo di Erg in un nuovo box protetto dal
seguente contratto Ergo scritto in ErgoScript (vedi questa
introduzione e altri esempi
avanzati per saperne di più su ErgoScript).
// Contratto Freezer
{
// Parametri
// freezeDeadline: Int - un numero di blocco futuro dopo il quale il box può essere speso
// ownerPk: SigmaProp - chiave pubblica del nuovo proprietario del box
sigmaProp(HEIGHT > freezeDeadline) && ownerPk
}
In breve, un box (e quindi i fondi all'interno del box) sono bloccati sotto un contratto (o script) sulla blockchain di Ergo. Affinché il box possa essere speso, il contratto deve valutarsi come vero. Pertanto, l'individuo che desidera spendere il box deve assicurarsi che il contratto si valuti come vero in base alla logica codificata al suo interno.
Il nostro contratto Freezer sopra controlla le seguenti condizioni prima di consentire che il box venga speso:
-
Il numero di blocco attuale della blockchain di Ergo (alias altezza della blockchain) è
maggiore della scadenza specificata -
La transazione di spesa deve essere firmata dal proprietario della chiave segreta
corrispondente alla chiave pubblica ownerPk.
La prima condizione vieta a chiunque di spendere il box prima che la blockchain di Ergo
cresca all'altezza data. Poiché i nuovi blocchi sulla blockchain vengono estratti circa ogni 2 minuti in media, utilizzando l'altezza
attuale della blockchain è facile definire qualsiasi durata di ritardo desideriamo, come 1 giorno, 1 settimana o 1 mese. (cioè (60 / 2) * 24 * 7 = 5040, che è il numero di blocchi a settimana).
Ora approfondiremo come possiamo prendere questo Contratto Freezer e integrarlo con la libreria Apkit per creare l'applicazione console FreezeCoin in modo che chiunque possa scegliere di congelare i propri coin se lo desidera. (Va detto che questo contratto/dApp non è realmente utile, tuttavia è un esempio semplice ed efficace per mostrare come funziona questo stack tecnologico in modo che tu stesso possa costruire dApps utili in futuro.)
1. Sviluppo di App Ergo in Java
Appkit mira a fornire un insieme di interfacce che possono essere utilizzate in modo idiomatico
in Java. Ti sentirai a casa utilizzando Appkit se sei un veterano di Java.
Si prega di seguire le istruzioni di
installazione per GraalVM e
Appkit se desideri riprodurre gli esempi qui sotto.
Per utilizzare Appkit nella nostra implementazione Java di FreezeCoin dobbiamo aggiungere la
seguente dipendenza nel file gradle
dependencies {
implementation("org.ergoplatform", "ergo-appkit_2.12", "3.1.0", "compile")
...
}
Inoltre, durante l'esecuzione, Appkit/la nostra applicazione deve connettersi a un nodo Ergo tramite REST API. Spesso,
il nodo verrà eseguito localmente e reso disponibile su http://localhost:9052/. Questo è lo scenario standard per chiunque abbia impostato un nodo completo seguendo queste
istruzioni e sta utilizzando la configurazione predefinita.
D'ora in poi, presumeremo che tu abbia configurato e avviato il tuo nodo Ergo in modo che sia disponibile per il test dell'applicazione.
Successivamente, la nostra applicazione avrà bisogno di sapere come connettersi al nostro nodo locale in esecuzione, oltre ad altre varie impostazioni per funzionare correttamente. Utilizzeremo un file json con i seguenti
parametri di configurazione che la nostra app FreezeCoin caricherà all'avvio.
{
"node": {
"nodeApi": {
"apiUrl": "http://localhost:9052/",
"apiKey": "inserisci qui la tua chiave api segreta generata durante la configurazione del nodo"
},
"wallet": {
"mnemonic": "la chiave mnemonica utilizzata per inizializzare o ripristinare il portafoglio del nodo",
"password": "la password che hai scelto per proteggere il portafoglio",
"mnemonicPassword": "la password che hai scelto per proteggere la mnemonica"
},
"networkType": "TESTNET"
},
"parameters": {
"newBoxSpendingDelay": "30",
"ownerAddress": "3WzR39tWQ5cxxWWX6ys7wNdJKLijPeyaKgx72uqg9FJRBCdZPovL"
}
}
Qui apiKey è la chiave segreta richiesta per l'autenticazione API che può essere
acquisita come descritto
qui.
La tua mnemonica è la frase segreta ottenuta durante la configurazione di un nuovo
portafoglio.
Il funzionamento della nostra app sarà che l'utente la avvierà dalla riga di comando e fornirà un argomento. Questo argomento è l'importo di valore (in NanoErgs) che desidera congelare/bloccare sotto il contratto Freezer che abbiamo scritto sopra.
Il nostro primo passo per la nostra app FreezeCoin sarà leggere il file di configurazione json che abbiamo appena creato e accettare l'argomento della riga di comando dall'utente:
public static void main(String[] args) {
long amountToSend = Long.parseLong(args[0]); // valore positivo in NanoErg
ErgoToolConfig conf = ErgoToolConfig.load("freeze_coin_config.json");
// il resto del codice discusso di seguito
...
}
Con questi acquisiti, ora possiamo ottenere il ritardo di spesa e l'indirizzo del proprietario che sono stati definiti nel file di configurazione json.
int newBoxSpendingDelay = Integer.parseInt(conf.getParameters().get("newBoxSpendingDelay"));
Address ownerAddress = Address.create(conf.getParameters().get("ownerAddress"));
Successivamente, dobbiamo connetterci al nodo Ergo in esecuzione dalla nostra applicazione Java in modo da poter utilizzare i dati che abbiamo appena analizzato e pubblicare qualcosa sulla blockchain. Questo viene fatto creando
un'istanza di ErgoClient che utilizza i nostri valori predefiniti per il nostro nodo dal file di configurazione json.
ErgoNodeConfig nodeConf = conf.getNode();
ErgoClient ergoClient = RestApiErgoClient.create(nodeConf);
Ora che abbiamo un'istanza di ErgoClient,
possiamo eseguire qualsiasi blocco di codice e avere accesso al contesto attuale della blockchain.
String txJson = ergoClient.execute((BlockchainContext ctx) -> {
// usa ctx qui per creare e firmare una nuova transazione
// poi inviala al nodo
});
Il lambda passato a execute viene chiamato quando il contesto attuale della blockchain
viene caricato dal nodo Ergo. In questo lambda metteremo la nostra logica applicativa.
Iniziamo con alcuni passaggi ausiliari.
// accedi al portafoglio incorporato nel nodo Ergo
// (utilizzando il portafoglio specificato tramite mnemonica che abbiamo messo in freeze_coin_config.json)
ErgoWallet wallet = ctx.getWallet();
// calcola l'importo totale di NanoErgs che dobbiamo inviare al nuovo box
// inclusi i costi di transazione
long totalToSpend = amountToSend + Parameters.MinFee;
// richiedi box non spesi che coprano l'importo richiesto di NanoErgs dal portafoglio
Optional<List<InputBox>> boxes = wallet.getUnspentBoxes(totalToSpend);
if (!boxes.isPresent())
throw new ErgoClientException(
"Non ci sono abbastanza coin nel tuo portafoglio specificato per pagare " + totalToSpend, null);
// crea un "prover", che è un oggetto speciale che verrà utilizzato per firmare la transazione
// il prover deve essere configurato con i segreti del tuo portafoglio, necessari per generare firme (alias prove)
ErgoProver prover = ctx.newProverBuilder()
.withMnemonic(
nodeConf.getWallet().getMnemonic(),
nodeConf.getWallet().getPassword())
.build();
A questo punto abbiamo scelto i box di input per la nostra transazione di spesa, ma ora dobbiamo creare un box di output con l'importo specificato amountToSend e bloccato sotto il contratto Freezer.
// l'unico modo per creare una transazione è utilizzare il builder tx ottenuto dal contesto
// il builder utilizza il contesto per accedere ai dati necessari della blockchain.
UnsignedTransactionBuilder txB = ctx.newTxBuilder();
// crea un nuovo box utilizzando il nuovo builder ottenuto dal builder della transazione
// in questo caso compiliamo un nuovo ErgoContract dal codice ErgoScript del Freezer
OutBox newBox = txB.outBoxBuilder()
.value(amountToPay)
.contract(ctx.compileContract(
ConstantsBuilder.create()
.item("freezeDeadline", ctx.getHeight() + newBoxSpendingDelay)
.item("ownerPk", ownerAddress.getPublicKey())
.build(),
"{ sigmaProp(HEIGHT > freezeDeadline) && ownerPk }"))
.build();
Nota, per compilare ErgoContract dal codice sorgente dello script Freezer il metodo compileContract
richiede che forniamo valori per le costanti nominate utilizzate all'interno dello script.
Se non vengono utilizzate tali costanti, allora ConstantsBuilder.empty() può essere passato a esso.
In questo caso passiamo la chiave pubblica del nuovo proprietario del box nel segnaposto ownerPk
nel script. Per ripetere quanto detto in precedenza, questo significa che il box può essere speso solo dal proprietario della
corrispondente chiave segreta.
Successivamente, creiamo una transazione non firmata utilizzando tutti i dati che abbiamo messo insieme finora.
// fornisci al builder della transazione quali box stiamo per spendere, quali output
// devono essere creati, le spese totali della transazione e l'indirizzo per il cambiamento da inviare
UnsignedTransaction tx = txB.boxesToSpend(boxes.get())
.outputs(newBox)
.fee(Parameters.MinFee)
.sendChangeTo(prover.getP2PKAddress())
.build();
E infine:
- Usa il prover per firmare la transazione costruita
- Così otteniamo un'istanza di
SignedTransaction - Usa il contesto della blockchain per inviare la transazione firmata al
nodo Ergo.
Il txId risultante può essere utilizzato per riferirsi a questa transazione
in seguito, tuttavia non lo utilizziamo qui.
SignedTransaction signed = prover.sign(tx);
String txId = ctx.sendTransaction(signed);
return signed.toJson(true);
Come avrai notato, per il nostro passo finale mostriamo che è possibile serializzare la transazione firmata in una stringa Json con la stampa formattata attivata. Dai un'occhiata al codice sorgente
completo
dell'esempio per ulteriori dettagli e per utilizzarlo come modello nella tua
applicazione.
Ora che tutto il codice è stato fissato, possiamo eseguire la nostra applicazione FreezeCoin utilizzando i seguenti passaggi
(presumendo che tu sia nella directory in cui hai clonato
ergo-appkit-examples).
$ pwd
the/directory/you/cloned/ergo-appkit-examples
$ ./gradlew clean shadowJar
Questo assemblerà il file build/libs/appkit-examples-3.1.0-all.jar contenente
la nostra applicazione Java FreezeCoin e tutte le sue dipendenze in un unico jar pesante.
Nota, questo passaggio deve essere ripetuto dopo qualsiasi modifica apportata al codice sorgente Java della nostra applicazione.
Avendo creato la nostra applicazione, ora possiamo utilizzare la nostra app FreezeCoin:
$ java -cp build/libs/appkit-examples-3.1.0-all.jar \
org.ergoplatform.appkit.examples.FreezeCoin 1000000000
Otterrai qualcosa del genere output nella console.
E con questo la tua transazione è stata accettata dal nodo Ergo e trasmessa nella rete dove attenderà nel pool delle transazioni per essere aggiunta a un blocco. Una volta che un miner la seleziona e la aggiunge a un blocco, i tuoi coin saranno ufficialmente "congelati" all'interno del nuovo box basato sui valori che hai fornito all'applicazione FreezeCoin.
L'esempio presuppone che il nodo Ergo (e il portafoglio incorporato) sia di proprietà dell'utente di FreezeCoin. Tuttavia, questo non è strettamente necessario e le interfacce di Appkit
possono essere utilizzate per creare e inviare nuove transazioni utilizzando nodi pubblici Ergo arbitrari.
2. Applicazioni Ergo a Basso Impatto e Avvio Veloce
Come saprai, utilizzare Java per processi a breve termine ha molti svantaggi.
Le applicazioni tendono a soffrire di lunghi tempi di avvio e di un utilizzo di memoria relativamente elevato.
Eseguiamo FreezeCoin utilizzando il comando time per
ottenere il tempo reale (tempo trascorso in wall-clock) necessario all'intero programma per eseguire dall'inizio alla fine. Utilizziamo il flag -l per stampare anche l'utilizzo della memoria.
$ /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 dimensione massima del set residente
0 dimensione media della memoria condivisa
0 dimensione media dei dati non condivisi
0 dimensione media dello stack non condiviso
125010 recuperi di pagina
1216 errori di pagina
0 scambi
0 operazioni di input bloccate
0 operazioni di output bloccate
13 messaggi inviati
86 messaggi ricevuti
1 segnali ricevuti
2384 cambi di contesto volontari
17409 cambi di contesto involontari
Come si vede sopra, questa piccola applicazione ha impiegato 2 thread paralleli quasi 4
secondi per eseguire. La maggior parte di quel tempo può essere attribuita all'avvio della JVM e
al funzionamento del compilatore JIT in background. Questa è una prestazione piuttosto scadente, e sappiamo che possiamo fare molto meglio.
Fortunatamente, GraalVM ci offre la soluzione perfetta.
Possiamo risolvere questo problema intrinseco con la JVM compilando il codice Java
a priori in un'immagine eseguibile nativa tramite GraalVM. Questo salta la necessità di utilizzare il compilatore just-in-time di Java
in fase di esecuzione.
L'esperienza per noi (lo sviluppatore che utilizza GraalVM) è piuttosto simile a un compilatore convenzionale come gcc. Nota,
potremmo dover eseguire prima ./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] 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
Il semplice comando sopra produce un eseguibile nativo completo chiamato freezecoin.
Per enfatizzare, questo eseguibile non è un semplice launcher per la JVM. Infatti non si collega alla JVM né include
the JVM in alcun modo. native-image compila il codice di FreezeCoin, così come qualsiasi
libreria Java di cui dipende, fino a semplice codice macchina.
Se guardiamo le librerie che freezecoin utilizza, possiamo vedere che utilizza solo librerie di sistema standard. Pertanto, possiamo spostare solo questo eseguibile su un altro sistema
che non ha una JVM installata e funzionerà senza problemi.
$ otool -L freezecoin # ldd freezecoin su Linux
freezecoin:
/usr/lib/libSystem.B.dylib (versione di compatibilità 1.0.0, versione attuale 1252.50.4)
/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation (versione di compatibilità 150.0.0, versione attuale 1455.12.0)
/usr/lib/libz.1.dylib (versione di compatibilità 1.0.0, versione attuale 1.2.11)
Se misuriamo questo nuovo eseguibile freezecoin, possiamo vedere che si avvia circa 8 volte più velocemente e utilizza
circa 6 volte meno memoria. Ciò significa che non si avverte quella pausa palpabile che si ha sempre quando si esegue un
programma a breve termine con la JVM.
$ DYLD_LIBRARY_PATH=$GRAAL_HOME/jre/lib /usr/bin/time -l ./freezecoin 1800000000
0.43 real 0.15 user 0.03 sys
81289216 dimensione massima del set residente
0 dimensione media della memoria condivisa
0 dimensione media dei dati non condivisi
0 dimensione media dello stack non condiviso
20079 recuperi di pagina
0 errori di pagina
0 scambi
0 operazioni di input bloccate
0 operazioni di output bloccate
13 messaggi inviati
86 messaggi ricevuti
0 segnali ricevuti
11 cambi di contesto volontari
138 cambi di contesto involontari
Questo è solo uno dei grandi vantaggi di GraalVM di cui possiamo approfittare con Appkit.
3. Sviluppa Applicazioni Ergo in JavaScript, Python, Ruby
GraalVM supporta la cosiddetta programmazione poliglotta in cui diversi componenti di
un'applicazione possono essere sviluppati utilizzando il linguaggio più adatto e poi
combinati senza problemi in fase di esecuzione. In questo modo, una libreria unica scritta in Java può essere utilizzata in un'applicazione node.js scritta in JavaScript, ad esempio.
Per supportare la programmazione poliglotta, la piattaforma GraalVM ha le proprie implementazioni ad alte prestazioni
di linguaggi popolari. Approfitteremo di questo per
il nostro progetto esemplare FreezeCoin per mostrarti quanto sia facile utilizzare il tuo linguaggio preferito.
Prima di eseguire gli esempi qui sotto (in JavaScript, Python e Ruby), assicurati di avere la
versione Java di FreezeCoin funzionante localmente per garantire che tutto sia impostato correttamente.
JavaScript
GraalVM può eseguire JavaScript e
Node.js
applicazioni out of the box. È compatibile con la specifica ECMAScript 2019
.
Inoltre, i launcher js e node accettano opzioni speciali da riga di comando --jvm e --polyglot
che consentono agli script JS di accedere a oggetti e classi Java.
Detto ciò, un'implementazione JS di FreezeCoin può essere facilmente scritta utilizzando l'API di Appkit.
Si prega di vedere il codice sorgente completo dell'implementazione JS di FreezeCoin
per dettagli.
Il seguente comando utilizza il launcher node per eseguire lo script FreezeCoin.js.
$ node --jvm --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
js-examples/FreezeCoin.js 1000000000
Nota, i percorsi nel comando sono relativi alla radice della
cartella del progetto ergo-appkit-examples.
Python
GraalVM può eseguire script Python
, anche se
gli script Python sono ancora sperimentali (vedi anche
sezione di compatibilità
per dettagli).
L'esempio Python di
FreezeCoin
può essere eseguito utilizzando il seguente comando
$ graalpython --jvm --polyglot --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
python-examples/FreezeCoin.py 1900000000
Ruby
GraalVM può eseguire script Ruby
utilizzando
l'implementazione TruffleRuby, che è comunque ancora sperimentale (vedi anche
sezione di compatibilità
per dettagli).
TruffleRuby mira a essere completamente compatibile con l'implementazione standard di Ruby, MRI, versione 2.6.2
L'esempio Ruby di
FreezeCoin
può essere eseguito utilizzando il seguente comando
$ truffleruby --polyglot --jvm --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
ruby-examples/FreezeCoin.rb 1900000000
4. Librerie Condivise Native di Ergo
Un altro grande vantaggio di GraalVM è che possiamo compilare classi Java in una libreria condivisa nativa invece di un eseguibile.
Per fare ciò dichiariamo uno o più metodi statici come @CEntryPoint.
public class FreezeCoin {
...
/**
* Punto di ingresso chiamabile da C che avvolge {@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();
// Converti le stringhe C nelle stringhe Java di destinazione.
String configFileName = CTypeConversion.toJavaString(configFileNameC);
String txJson = sendTx(amountToSend, configFileName);
// metti la stringa risultante nel buffer fornito
CTypeConversion.toCString(txJson, resBuffer, bufferSize);
}
...
}
Possiamo quindi compilare in una libreria condivisa e un file header generato automaticamente.
Nota l'uso dell'opzione --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 (versione di compatibilità 0.0.0, versione attuale 0.0.0)
/usr/lib/libSystem.B.dylib (versione di compatibilità 1.0.0, versione attuale 1252.50.4)
/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation (versione di compatibilità 150.0.0, versione attuale 1455.12.0)
/usr/lib/libz.1.dylib (versione di compatibilità 1.0.0, versione attuale 1.2.11)
Ora abbiamo la possibilità di scrivere un programma C
che utilizza la libreria.
L'interfaccia alla nostra libreria nativa ha un po' di
boilerplate (perché la VM deve gestire un heap, thread, un garbage collector
e altro), e quindi dobbiamo creare un'istanza e fornirla
al nostro thread principale.
#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, "errore graal_create_isolate\n");
return 1;
}
char * configFileName = "freeze_coin_config.json";
// ottieni amountToSend dagli argomenti cmd e chiama la creazione della transazione
long amountToSend = atol(argv[1]);
char result[1024 * 16];
sendTx(thread, amountToSend, configFileName, result, sizeof(result));
// stampa il risultato serializzato
printf("%s\n", result);
if (graal_detach_thread(thread) != 0) {
fprintf(stderr, "errore graal_detach_thread\n");
return 1;
}
return 0;
}
Possiamo compilare questo con i nostri strumenti di sistema standard e facilmente eseguire il nostro eseguibile (imposta LD_LIBRARY_PATH=. su Linux).
$ clang -Ic-examples -Lc-examples -lfreezecoin c-examples/freezecoin.c -o call_freezecoin
$ otool -L call_freezecoin
$ DYLD_LIBRARY_PATH=$GRAAL_HOME/jre/lib ./call_freezecoin 1000000000
5. Debugging della Tua Applicazione Ergo Poliglotta
Puoi eseguire il debug di JS, Python e Ruby in IntelliJ, ma se per qualche motivo questo
non funziona per te o non si adatta al tuo editor preferito, GraalVM offre un'altra opzione.
Tutti i linguaggi di GraalVM (eccetto Java) sono implementati utilizzando il comune
framework Truffle.
Truffle consente di implementare strumenti come debugger una volta e renderli disponibili
per tutti i linguaggi supportati.
Pertanto, possiamo eseguire il nostro programma con il flag --inspect che ci darà un link da
aprire in Chrome e metterà in pausa il programma nel debugger.
$ ruby --polyglot --jvm --inspect --vm.cp=build/libs/appkit-examples-3.1.0-all.jar \
ruby-examples/FreezeCoin.rb 1900000000
Debugger in ascolto sulla porta 9229.
Per iniziare il debug, apri il seguente URL in Chrome:
chrome-devtools://devtools/bundled/js_app.html?ws=127.0.0.1:9229/30c7da1e-7558a47d09b
...
Da qui possiamo impostare punti di interruzione e continuare l'esecuzione. Quando si interrompe, vedremo
valori delle variabili, possiamo continuare di nuovo fino al prossimo punto di interruzione e fare tutto ciò che ci aspettiamo dai debugger.
Conclusioni
E con tutto ciò detto e fatto, vediamo quanto sia facile utilizzare Appkit per
desarrollare Applicazioni Ergo. Appkit si basa sulle stesse identiche librerie core che
sono state utilizzate per implementare il protocollo di consenso di Ergo. Queste librerie includono
il compilatore ErgoScript, la crittografia, l'interprete di bytecode, i serializzatori di dati
e gli altri componenti core. Utilizzando GraalVM siamo in grado di riutilizzare questi componenti collaudati
in diversi contesti applicativi senza alcuna modifica
o riscrittura da parte nostra.
Non importa se stai utilizzando Java, JavaScript, Python o Ruby, puoi approfittare di Appkit con GraalVM per semplificare drasticamente il processo di
interazione con la blockchain di Ergo mentre crei (d)App native.
Resta sintonizzato. Nei prossimi post ti presenteremo altre interessanti potenziali
applicazioni alimentate da Appkit.
Riferimenti
Share post
13 agosto 2025
9 luglio 2025
12 maggio 2025
7 agosto 2022
