🥇Client di test TON (Telegram Open Network) e nuovo linguaggio Fift per smart contracts

Più di un anno fa sono emerse notizie sui piani di Telegram di lanciare una propria rete decentralizzata. Telegram Open Network. In quell'occasione è stato reso disponibile un ampio documento tecnico, presumibilmente scritto da Nikolai Durov, che descriveva la struttura della futura rete. Per chi se lo fosse perso, consiglio di dare un'occhiata al mio riassunto di questo documento (parte 1, parte 2; la terza parte, purtroppo, è ancora in bozza).

Da allora, non ci sono state notizie significative sullo stato dello sviluppo di TON, fino a quando, pochi giorni fa (in uno dei canali non ufficiali) è apparso un link a una pagina https://test.ton.org/download.html, dove sono disponibili:
◦ ton-test-liteclient-full.tar.xz — sorgenti del client leggero per la rete di test di TON;
◦ ton-lite-client-test1.config.json — file di configurazione per la connessione alla rete di test;
◦ README — informazioni sulla compilazione e l'avvio del client;
◦ HOWTO — guida passo-passo per creare un contratto smart utilizzando il client;
◦ ton.pdf — documento aggiornato (del 2 marzo 2019) con una panoramica tecnica della rete TON;
◦ tvm.pdf — descrizione tecnica della TVM (TON Virtual Machine, macchina virtuale TON);
◦ tblkch.pdf — descrizione tecnica della blockchain TON;
◦ fiftbase.pdf — descrizione del nuovo linguaggio Fift, progettato per creare contratti smart in TON.

Ribadisco, non ci sono state conferme ufficiali da parte di Telegram riguardo a questa pagina e a tutti questi documenti, ma la quantità di materiali rende l'argomento abbastanza plausibile. Effettuate il lancio del client pubblicato a vostro rischio e pericolo.

Compilazione del client di test

Iniziamo a provare a compilare e avviare il client di test — fortunatamente, README viene descritto dettagliatamente questo processo semplice. Lo farò utilizzando come esempio macOS 10.14.5, non posso garantire il successo della compilazione su altri sistemi.

Scarichiamo e decompattiamo l'archivio con i sorgenti. È importante scaricare l'ultima versione, poiché la retrocompatibilità in questo stadio non è garantita.
Assicuriamoci che sul sistema siano installate le ultime versioni di make, cmake (versioni 3.0.2 o superiori), OpenSSL (inclusi i file di intestazione C), g++ o clang. Non ho dovuto installare nulla, è andato tutto a buon fine.
Supponiamo che i sorgenti siano stati decompattati nella cartella ~/lite-client. Separatamente, creiamo una cartella vuota per il progetto compilato (ad esempio, ~/liteclient-build), e da essa (cd ~/liteclient-build) invochiamo i comandi:
```
cmake ~/lite-client
cmake --build . --target test-lite-client
```
Per assemblare l'interprete del linguaggio Fift per smart contracts (di cui parlerò più avanti), chiamiamo anche
```
cmake --build . --target fift
```
Scarichiamo l'ultima versione un file di configurazione per connettersi alla rete di test e la mettiamo nella cartella con il client assemblato.

Fatto, è possibile avviare il client:

./test-lite-client -C ton-lite-client-test1.config.json

Se tutto è stato fatto correttamente, dovresti vedere qualcosa del genere:

Ci sono poche comandi disponibili:
◦ help — mostrare questo elenco di comandi;
◦ quit — uscire;
◦ ora — mostrare l'ora attuale sul server;
◦ status — mostrare lo stato della connessione e del DB locale;
◦ ultimo — aggiornare lo stato della blockchain (caricare l'ultimo blocco). È importante eseguire questo comando prima di qualsiasi richiesta per garantire di vedere lo stato attuale della rete.
◦ inviafile <filename> — caricare un file locale nella rete TON. Questo avviene nell'interazione con la rete, incluso, ad esempio, la creazione di nuovi smart contracts e richieste di trasferimento di fondi tra conti;
◦ ottieniaccount <address> — mostrare lo stato attuale (al momento dell'esecuzione del comando ultimo) dell'account con l'indirizzo specificato;
◦ chiaveprivata <filename> — caricare la chiave privata da un file locale.

Se si passa a un client una cartella utilizzando un'opzione -D, allora esso conterrà l'ultimo blocco del masterchain:

./test-lite-client -C ton-lite-client-test1.config.json -D ~/ton-db-dir

Ora possiamo passare a cose più interessanti: esplorare il linguaggio Fift, provare a compilare un smart contract (ad esempio, creare un wallet di test), caricarlo sulla rete e provare a trasferire fondi tra gli account.

Il linguaggio Fift

Dal documento fiftbase.pdf si può apprendere che per creare smart contract il team di Telegram ha creato un nuovo linguaggio stack-based Fift (probabilmente dal numero fifth, per analogia con Forth, un linguaggio con cui Fift ha molte somiglianze).

Il documento è abbastanza ampio, composto da 87 pagine, e non ripeterò dettagliatamente il suo contenuto in questo articolo (almeno perché non l'ho ancora finito di leggere :). Mi soffermerò sui punti principali e fornirò un paio di esempi di codice in questo linguaggio.

A un livello base, la sintassi di Fift è abbastanza semplice: il suo codice è composto da parole, generalmente separate da spazi o a capo (un caso particolare: alcune parole non richiedono un delimitatore dopo di esse). Qualsiasi una parola è una sequenza di caratteri case-sensitive che corrisponde a una certa definizione (in termini semplici, ciò che l'interprete deve fare quando incontra questa parola). Se non c'è una definizione per la parola, l'interprete cerca di analizzarla come un numero e di metterla nello stack. A proposito, i numeri qui sono — sorprendentemente — interi a 257 bit, e non ci sono numeri decimali — anzi, vengono immediatamente trasformati in una coppia di interi che formano il numeratore e il denominatore di una frazione razionale.

Le parole, in genere, interagiscono con i valori in cima allo stack. Un tipo particolare di parole — prefisso — utilizza non lo stack, ma i caratteri successivi nel file sorgente. Ad esempio, i letterali di stringa sono implementati in questo modo: il simbolo ' (") è una parola prefisso che cerca il successivo (simbolo di chiusura) e mette la stringa tra di essi nello stack. Allo stesso modo operano i commenti su singola riga (//) e su più righe (/*).

A questo punto termina quasi tutta la struttura interna del linguaggio. Tutto il resto (compresi i costrutti di controllo) è definito come parole (o interne, come le operazioni aritmetiche e la definizione di nuove parole; o definite nella 'libreria standard' Fift.fif, che si trova nella cartella crypto/fift nei sorgenti).

Un semplice esempio di programma in Fift:

{ dup =: x dup * =: y } : setxy
3 setxy x . y . x y + .
7 setxy x . y . x y + .

Nella prima riga viene definita una nuova parola setxy (nota il prefisso {, che crea un blocco fino alla chiusura } e il prefisso :, che definisce effettivamente la parola). setxy prende un numero dalla cima dello stack, lo definisce (o ridefinisce) come una costante globale x, e il quadrato di questo numero — come costante y (considerando che i valori delle costanti possono essere ridefiniti, li definirei più come variabili, ma seguo la nomenclatura del linguaggio).

Nelle due righe successive, viene messo nello stack un numero, viene chiamato setxy, poi vengono visualizzati i valori delle costanti x, y (per la visualizzazione si utilizza la parola .), entrambe le costanti vengono messe nello stack, sommati e il risultato viene anch'esso visualizzato. Di conseguenza vedremo:

3 9 12 ok
7 49 56 ok

(La riga «ok» viene visualizzata dall'interprete quando finisce di elaborare la riga corrente in modalità di input interattivo)

Ecco un esempio completo di codice:

"Asm.fif" include

-1 costante wc  \/\/ crea un portafoglio nella workchain -1 (masterchain)

\/\/ Crea un nuovo portafoglio semplice
&lt;{  SETCP0 DUP IFNOTRET INC 32 THROWIF  \/\/ restituisci se recv_internal, fallisci a meno che non sia recv_external
    512 INT LDSLICEX DUP 32 PLDU   \/\/ firma cs cnt
    c4 PUSHCTR CTOS 32 LDU 256 LDU ENDS  \/\/ firma cs cnt cnt&#039; pubk
    s1 s2 XCPU            \/\/ firma cs cnt pubk cnt&#039; cnt
    EQUAL 33 THROWIFNOT   \/\/ ( mismatch seqno? )
    s2 PUSH HASHSU        \/\/ firma cs cnt pubk hash
    s0 s4 s4 XC2PU        \/\/ pubk cs cnt hash firma pubk
    CHKSIGNU              \/\/ pubk cs cnt ?
    34 THROWIFNOT         \/\/ mismatch di firma
    ACCETTA
    SWAP 32 LDU NIP 
    DUP SREFS IF:<{
      8 LDU LDREF         // pubk cnt mode msg cs
      s0 s2 XCHG SENDRAWMSG  // pubk cnt cs ; ( message sent )
    }>
    ENDS
    INC NEWC 32 STU 256 STU ENDC c4 POPCTR
}&gt;c
\/\/ codice
<b 0 32 u, newkeypair swap dup constant wallet_pk "new-wallet.pk" b>file
   B, 
b&gt; \/\/ dati
\/\/ nessuna libreria
<b b{00110} s, rot ref, swap b>  // create StateInit
dup ."StateInit: " <s csr. cr
dup hash dup constant wallet_addr
."new wallet address = " wc . .": " x. cr
wc over 7 smca>$ tipo cr
256 u&gt;B "new-wallet.addr" B&gt;file
<b 0 32 u, b>
dup ."firma il messaggio: " <s csr. cr
dup hash wallet_pk ed25519_sign_uint rot
<b b{1000100} s, wc 8 i, wallet_addr 256 u, b{000010} swap <s b{0} b, b>
dup ."Messaggio esterno per inizializzazione è " <s csr. cr
2 boc+>B dup Bx. cr
"new-wallet-query.boc" tuck B&gt;file
."(Salvato nel file " type .")" cr

Questo file dall'aspetto piuttosto spaventoso è destinato a creare un contratto intelligente — verrà posizionato nel file new-wallet-query.boc Dopo l'esecuzione. Si noti che qui si utilizza un altro linguaggio, Assembly, per la TON Virtual Machine (su cui non mi soffermerò), le cui istruzioni verranno inserite nella blockchain.

Pertanto, l'assembly per TVM è scritto in Fift — il codice sorgente di questo assembler si trova nel file crypto/fift/Asm.fif e viene collegato all'inizio del pezzo di codice sopra riportato.

Cosa posso dire, sembra che Nikolai Durov ami semplicemente creare nuovi linguaggi di programmazione 🙂

Creazione di smart contract e interazione con TON

Supponiamo di aver raccolto il client TON e l'interprete Fift, come descritto sopra, e di aver familiarizzato con il linguaggio. Come si crea ora uno smart contract? Di questo si parla nel file HOWTO, allegato ai sorgenti.

Account in TON

Come ho descritto in una panoramica di TON, questa rete contiene più di una blockchain: c'è una blockchain principale, chiamata «masterchain», e un numero arbitrario di «workchain» aggiuntivi, identificabili tramite un numero a 32 bit. La masterchain ha un identificatore di -1, e inoltre può essere utilizzata una «workchain» di base con identificatore 0. Ogni workchain può avere la propria configurazione. Internamente, ogni workchain è suddiviso in shardchain, ma questo è un dettaglio di implementazione che non è necessario tenere a mente.

All'interno di una workchain ci sono molti account, ognuno con i propri identificatori account_id. Per la masterchain e la workchain zero, hanno una lunghezza di 256 bit. Pertanto, l'identificatore dell'account è registrato, ad esempio, in questo modo:

-1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

Questo è il formato «grezzo»: prima l'identificatore della workchain, poi i due punti e l'identificatore dell'account in notazione esadecimale.

Inoltre, esiste un formato abbreviato: il numero della workchain e l'indirizzo dell'account sono codificati in forma binaria, a cui è aggiunta una somma di controllo e tutto è codificato in Base64:

Ef+BVndbeTJeXWLnQtm5bDC2UVpc0vH2TF2ksZPAPwcODSkb

Conoscendo questo formato di registrazione, possiamo richiedere lo stato attuale di un account tramite il client di test usando il comando

getaccount -1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

Otterremo una risposta simile:

[ 3][t 2][1558746708.815218925][test-lite-client.cpp:631][!testnode]    richiesta dello stato dell'account per -1:8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D
[ 3][t 2][1558746708.858564138][test-lite-client.cpp:652][!testnode]    ricevuto lo stato dell'account per -1:8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D rispetto ai blocchi (-1,8000000000000000,72355):F566005749C1B97F18EDE013EBA7A054B9014961BC1AD91F475B9082919A2296:1BD5DE54333164025EE39D389ECE2E93DA2871DA616D488253953E52B50DC03F e (-1,8000000000000000,72355):F566005749C1B97F18EDE013EBA7A054B9014961BC1AD91F475B9082919A2296:1BD5DE54333164025EE39D389ECE2E93DA2871DA616D488253953E52B50DC03F
lo stato dell'account è (account
  addr:(addr_std
    anycast:niente workchain_id:-1 indirizzo:x8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D)
  storage_stat:(storage_info
    used:(storage_used
      cells:(var_uint len:1 value:3)
      bits:(var_uint len:2 value:539)
      public_cells:(var_uint len:0 value:0)) last_paid:0
    due_payment:niente)
  storage:(account_storage last_trans_lt:74208000003
    balance:(currencies
      grams:(nanograms
        amount:(var_uint len:7 value:999928362430000))
      other:(extra_currencies
        dict:hme_empty))
    state:(account_active
      (
        split_depth:niente
        special:niente
        code:(just
          value:(raw@^Cell 
            x{}
             x{FF0020DDA4F260D31F01ED44D0D31FD166BAF2A1F80001D307D4D1821804A817C80073FB0201FB00A4C8CB1FC9ED54}
            ))
        data:(just
          value:(raw@^Cell 
            x{}
             x{0000000D}
            ))
        library:hme_empty))))
x{CFF8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D2068086C000000000000000451C90E00DC0E35B7DB5FB8C134_}
 x{FF0020DDA4F260D31F01ED44D0D31FD166BAF2A1F80001D307D4D1821804A817C80073FB0201FB00A4C8CB1FC9ED54}
 x{0000000D}

Mostriamo la struttura memorizzata nel DHT del wallet specificato. Ad esempio, nel campo storage.balance si trova il saldo attuale dell'account, in storage.state.code — il codice del contratto intelligente, mentre in storage.state.data — ci sono i suoi dati attuali. Si noti che il deposito dati TON — Cell, le celle — è gerarchico, ogni cella può avere sia i propri dati che celle figlie. Questo è mostrato sotto forma di rientri nelle ultime righe.

Assemblaggio del contratto intelligente

Ora creiamo questa struttura (chiamata BOC — bag of cells) utilizzando il linguaggio Fift. Fortunatamente, non è necessario scrivere il contratto intelligente da soli — nella cartella crypto/block nell'archivio con i sorgenti c'è il file new-wallet.fif, che ci aiuterà a creare un nuovo portafoglio. Copiamolo nella cartella con il client compilato (~/liteclient-build, se hai seguito le istruzioni sopra). Lo stesso contenuto lo ho fornito sopra come esempio di codice in Fift.

Eseguiamo questo file nel seguente modo:

./crypto/fift -I"/crypto/fift" new-wallet.fif

Qui <source-directory> deve essere sostituito con il percorso ai sorgenti estratti (sfortunatamente, il simbolo “~” non può essere utilizzato qui, è necessario un percorso completo). Invece di usare l'opzione -I è possibile definire una variabile d'ambiente FIFTPATH e inserire questo percorso in essa.

Poiché abbiamo avviato Fift con il nome del file new-wallet.fif, esso verrà eseguito e terminerà. Se il nome del file viene omesso, si può giocare con l'interprete in modalità interattiva.

Dopo l'esecuzione, dovrebbe apparire qualcosa del genere nella console:

StateInit: x{34_}
 x{FF0020DDA4F260810200D71820D70B1FED44D0D31FD3FFD15112BAF2A122F901541044F910F2A2F80001D31F3120D74A96D307D402FB00DED1A4C8CB1FCBFFC9ED54}
 x{0000000055375F730EDC2292E8CB15C42E8036EE9C25AA958EE002D2DE48A205E3A3426B}

new wallet address = -1 : 4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2 
0f9PzVILj8yglrVn1zS-NSjtxr7QBfaTCp7JrBqnFPIR8nhZ
signing message: x{00000000}

External message for initialization is x{89FEE120E20C7E953E31546F64C23CD654002C1AA919ADD24DB12DDF85C6F3B58AE41198A28AD8DAF3B9588E7A629252BA3DB88F030D00BC1016110B2073359EAC3C13823C53245B65D056F2C070B940CDA09789585935C7ABA4D2AD4BED139281CFA1200000001_}
 x{FF0020DDA4F260810200D71820D70B1FED44D0D31FD3FFD15112BAF2A122F901541044F910F2A2F80001D31F3120D74A96D307D402FB00DED1A4C8CB1FCBFFC9ED54}
 x{0000000055375F730EDC2292E8CB15C42E8036EE9C25AA958EE002D2DE48A205E3A3426B}

B5EE9C724104030100000000D60002CF89FEE120E20C7E953E31546F64C23CD654002C1AA919ADD24DB12DDF85C6F3B58AE41198A28AD8DAF3B9588E7A629252BA3DB88F030D00BC1016110B2073359EAC3C13823C53245B65D056F2C070B940CDA09789585935C7ABA4D2AD4BED139281CFA1200000001001020084FF0020DDA4F260810200D71820D70B1FED44D0D31FD3FFD15112BAF2A122F901541044F910F2A2F80001D31F3120D74A96D307D402FB00DED1A4C8CB1FCBFFC9ED5400480000000055375F730EDC2292E8CB15C42E8036EE9C25AA958EE002D2DE48A205E3A3426B6290698B
(Saved to file new-wallet-query.boc)

Questo significa che il portafoglio con l'identificatore -1:4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2 (o, ciò che equivale a 0f9PzVILj8yglrVn1zS-NSjtxr7QBfaTCp7JrBqnFPIR8nhZ) creato con successo. Il codice corrispondente sarà presente nel file new-wallet-query.boc, il cui indirizzo è new-wallet.addr, e la chiave privata sarà in new-wallet.pk (stai attento — eseguire di nuovo lo script sovrascriverà questi file).

Certo, la rete TON non sa ancora di questo portafoglio, è conservato solo in questi file. Ora deve essere caricato nella rete. Tuttavia, il problema è che per creare un contratto smart è necessaria una commissione, e il saldo del tuo account è attualmente zero.

In modalità operativa, questo problema si risolverà acquistando grammi su un exchange (o trasferendoli da un altro portafoglio). Nel frattempo, in questa modalità di test è stato creato un contratto smart speciale, dal quale puoi richiedere fino a 20 grammi gratuitamente.

Creazione di una richiesta a un contratto smart di terzi

Effettuiamo la richiesta al contratto smart che distribuisce grammi a destra e a sinistra in questo modo. Nella stessa cartella crypto/block troviamo il file testgiver.fif:

// "testgiver.addr" file>B 256 B>u@ 
0x8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d
dup constant wallet_addr ."Test giver address = " x. cr

0x4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2
constant dest_addr

-1 constant wc
0x00000011 constant seqno

1000000000 constant Gram
{ Gram swap */ } : Gram*/

6.666 Gram*/ constant amount

// b x --> b'  ( serializes a Gram amount )
{ -1 { 1+ 2dup 8 * ufits } until
  rot over 4 u, -rot 8 * u, } : Gram, 

// create a message (NB: 01b00.., b = bounce)
<b b{010000100} s, wc 8 i, dest_addr 256 u, amount gram, 0 9 64 32 + 1+ "gift" $, b>
<b seqno 32 u, 1 8 swap ref, b>
dup ."messaggio di avvolgimento: " <s csr. cr
<b b{1000100} s, wc 8 i, wallet_addr 256 u, 0 gram, b{00} s,
 swap <s b>
dup ."messaggio esterno risultante: " <s csr. cr
2 boc+>B dup Bx. cr
"wallet-query.boc" B&gt;file

Anche questo lo salveremo nella cartella con il client raccolto, ma modificheremo la quinta riga — prima della riga «constant dest_addr«. Sostituiremo con l'indirizzo del portafoglio che hai creato in precedenza (completo, non abbreviato). Non è necessario scrivere «-1:» all'inizio, invece metti «0x» all'inizio.

Puoi anche cambiare la riga 6.666 Gram*/ quantità costante — questa è la quantità in grammi che richiedi (non più di 20). Anche se specifichi un numero intero, lascia il punto decimale.

Infine, bisogna modificare la riga 0x00000011 seqno costante. Il primo numero qui è il numero di sequenza attuale, che viene memorizzato nell'account che emette i grammi. Da dove ottenerlo? Come detto in precedenza, avvia il client ed esegui:

last
getaccount -1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

Alla fine, nei dati del contratto smart ci sarà

...
x{FF0020DDA4F260D31F01ED44D0D31FD166BAF2A1F80001D307D4D1821804A817C80073FB0201FB00A4C8CB1FC9ED54}
 x{0000000D}

Il numero 0000000D (sarà maggiore nel tuo caso) è il numero di sequenza da inserire in testgiver.fif.

Tutto, salviamo il file e avviamo (./crypto/fift testgiver.fif). In uscita otterremo il file wallet-query.boc. Questo è il messaggio verso un contratto smart esterno — richiesta «trasferisci tanti grammi a tale account».

Utilizzando il client, lo carichiamo nella rete:

> sendfile wallet-query.boc
[ 1][t 1][1558747399.456575155][test-lite-client.cpp:577][!testnode]    invio della query dal file wallet-query.boc
[ 3][t 2][1558747399.500236034][test-lite-client.cpp:587][!query]   lo stato del messaggio esterno è 1

Se ora chiamiamo ultimo, e poi richiediamo nuovamente lo stato dell'account a cui abbiamo inviato i fondi, dovremmo vedere che il suo numero di sequenza è aumentato di uno — questo significa che ha inviato denaro al nostro account.

Resta l'ultimo passo — carichiamo il codice del nostro wallet (il suo bilancio è già stato ricaricato, ma senza il codice del contratto smart non possiamo gestirlo). Eseguiamo sendfile new-wallet-query.boc — e voilà, hai il tuo wallet nella rete TON (anche se per ora solo in fase di test).

Creazione di transazioni in uscita

Per trasferire denaro dal bilancio dell'account creato, c'è un file crypto/block/wallet.fif, che deve essere posizionato nella cartella del client assemblato.

Analogamente ai passaggi precedenti, in esso devi correggere l'importo che stai trasferendo, l'indirizzo del destinatario (dest_addr) e il seqno del tuo wallet (che è 1 dopo l'inizializzazione del wallet e aumenta di 1 dopo ogni transazione in uscita — potrai vederlo richiedendo lo stato del tuo account). Per i test puoi usare, ad esempio, il mio wallet — 0x4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2.

All'avvio (./crypto/fift wallet.fif) lo script prenderà l'indirizzo del tuo portafoglio (da dove effettui la trasmissione) e la sua chiave privata dai file new-wallet.addr e new-wallet.pk, e il messaggio ottenuto verrà registrato in new-wallet-query.boc.

Come prima, per eseguire direttamente la transazione, chiamiamo sendfile new-wallet-query.boc nel client. Dopo di che, non dimentichiamo di aggiornare lo stato della blockchain (ultimo) e verifichiamo che il saldo e il seqno del nostro portafoglio siano cambiati (getaccount <account_id>).

Ecco fatto, ora sappiamo come creare contratti smart in TON e inviare loro richieste. Come vediamo, le funzionalità attuali sono già sufficienti per, ad esempio, realizzare un portafoglio più user-friendly con interfaccia grafica (tuttavia, ci si aspetta che sarà comunque accessibile come parte del messenger).

Solo gli utenti registrati possono partecipare al sondaggio. Accedi, per favore.

Sei interessato a continuare gli articoli sull'analisi di TON, TVM, Fift?

Sì, aspetto la conclusione del ciclo di articoli con una panoramica generale di TON
Sì, mi interessa leggere di più sul linguaggio Fift
Sì, voglio sapere di più sulla TON Virtual Machine e sull'assemblatore per essa
No, non mi interessa nulla di questo

Hanno votato 39 utenti. 12 utenti si sono astenuti.