Cliente di prova TON (Telegram Open Network) e nuovo linguaggio Fift per smart contracts

Se, avviando il client, gli viene passato un percorso tramite l'opzione -D, salverà in essa 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: studiare il linguaggio Fift, provare a compilare uno smart contract (ad esempio, creare un wallet di test), caricarlo nella rete e provare a trasferire fondi tra conti.

Il linguaggio Fift

Dalla documentazione fiftbase.pdf possiamo scoprire che, per creare smart contract, il team di Telegram ha creato un nuovo linguaggio di programmazione a stack Fift (probabilmente dal numerale fifth, per analogia con Forth — un linguaggio con cui Fift ha molto in comune).

Il documento è piuttosto voluminoso, di 87 pagine, e non intendo riassumerne il contenuto in questo articolo (almeno, perché non ho neppure finito di leggerlo :). Mi concentrerò 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, di solito separate da spazi o ritorni a capo (un caso particolare: alcune parole non richiedono un separatore dopo di esse). Qualsiasi una parola è una sequenza di caratteri case-sensitive, a cui corrisponde una certa definizione (grossomodo, quello che l'interprete deve fare quando incontra questa parola). Se non c'è definizione della parola, l'interprete cerca di interpretarla come un numero e di metterla nello stack. A proposito, i numeri qui sono - sorprendentemente - interi a 257 bit, e non ci sono frazioni - nel senso che vengono immediatamente trasformati in una coppia di interi che formano numeratore e denominatore di una frazione razionale.

Le parole, di norma, interagiscono con i valori che si trovano in cima allo stack. Un tipo separato di parole - prefisso - non utilizza lo stack, ma i caratteri successivi nel file sorgente. Ad esempio, le stringhe letterali sono implementate in questo modo: il carattere "apice" (") è una parola prefissa che cerca il successivo apice di chiusura e colloca la stringa tra di essi nello stack. Allo stesso modo, si comportano i commenti su una sola riga (//) e i commenti su più righe (/*).

Quasi tutto il dispositivo interno del linguaggio finisce qui. 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 del } e il prefisso :, che definisce effettivamente la parola). setxy prende un numero dalla cima dello stack, lo definisce (o lo ridefinisce) come una costante x, e il quadrato di quel numero come una costante y (considerando che i valori delle costanti possono essere ridefiniti, preferirei chiamarli variabili, ma seguo la terminologia del linguaggio).

Nelle due righe seguenti, viene posizionato un numero nello stack, viene chiamato setxy, quindi vengono visualizzati i valori delle costanti x, y (per la visualizzazione viene utilizzata la parola .), entrambe le costanti vengono collocate nello stack, sommate e il risultato viene visualizzato. Di conseguenza vedremo:

3 9 12 ok
7 49 56 ok

(La riga "ok" viene visualizzata dall'interprete quando ha finito di elaborare la riga corrente in modalità interattiva di input)

E un esempio completo di codice:

"Asm.fif" include

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

\/\/ Crea un nuovo portafoglio semplice
<{  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' pubk
    s1 s2 XCPU            \/\/ firma cs cnt pubk cnt' 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 firma
    ACCEPT
    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>$ type cr
256 u&gt;B "new-wallet.addr" B&gt;file
<b 0 32 u, b>
dup ."firma 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 l'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 inquietante è destinato alla creazione di un contratto intelligente - sarà posizionato nel file new-wallet-query.boc dopo l'esecuzione. Si noti che qui viene utilizzato un ulteriore linguaggio assemblatore per la TON Virtual Machine (non approfondirò qui), le cui istruzioni verranno inserite nella blockchain.

Pertanto, l'assemblatore per TVM è scritto in Fift — i sorgenti di questo assemblatore si trovano nel file crypto/fift/Asm.fif e vengono collegati all'inizio del codice sopra menzionato.

Cosa posso dire, evidentemente Nikolai Durov ama semplicemente creare nuovi linguaggi di programmazione 🙂

Creazione di un contratto intelligente e interazione con TON

Quindi, supponiamo di aver raccolto il client TON e l'interprete Fift, come descritto sopra, e di aver familiarizzato con il linguaggio. Come creare ora un contratto intelligente? Questo viene descritto nel file HOWTO, allegato ai sorgenti.

Account in TON

Come ho descritto in una recensione su TON, questa rete contiene più di una blockchain — c'è una blockchain principale, il cosiddetto "masterchain", e un numero arbitrario di "workchains" aggiuntive, identificate da un numero a 32 bit. Il masterchain ha un identificatore -1, oltre a esso può essere utilizzata anche una "workchain" di base con identificatore 0. Ogni workchain può avere la propria configurazione. Internamente, ogni workchain è suddivisa in shardchains, ma questo è già un dettaglio di implementazione che non è necessario tenere a mente.

All'interno di una workchain vengono memorizzati numerosi account, ciascuno con il proprio identificatore account_id. Per il masterchain e la workchain zero hanno una lunghezza di 256 bit. Pertanto, l'identificatore dell'account è scritto, ad esempio, in questo modo:

-1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

Questo è un 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, vi è aggiunta una somma di controllo e tutto questo è codificato in Base64:

Ef+BVndbeTJeXWLnQtm5bDC2UVpc0vH2TF2ksZPAPwcODSkb

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

getaccount -1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

Otterremo una risposta approssimativa di questo tipo:

[ 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}

Vediamo la struttura memorizzata nel DHT della workchain specificata. Ad esempio, nel campo storage.balance si trova il saldo attuale dell'account, in storage.state.code — il codice del contratto intelligente, e in storage.state.data — i suoi dati attuali. Si noti che lo storage dei dati di TON — Cell, è ad albero, ogni cella può avere sia i propri dati che celle figlie. Questo è mostrato con rientri nelle ultime righe.

Costruzione di un contratto intelligente

Ora creiamo noi stessi una struttura del genere (chiamata BOC — bag of cells) usando il linguaggio Fift. Fortunatamente, non dovremo scrivere noi stessi il contratto intelligente — nella cartella crypto/block dall'archivio con i sorgenti c'è un file new-wallet.fif, che ci aiuterà a creare un nuovo portafoglio. Copiamolo nella cartella con il client costruito (~\/liteclient-build, se hai seguito le istruzioni sopra). Il suo contenuto lo ho riportato 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 agli sorgenti estratti (sfortunatamente, non è possibile usare il simbolo «~», è necessario il percorso completo). Invece di utilizzare la chiave -I è possibile definire la variabile d'ambiente FIFTPATH e inserire questo percorso in essa.

Poiché Fift è stato avviato con il nome del file new-wallet.fif, lo eseguirà e terminerà. Se si omette il nome del file, è possibile interagire con l'interprete in modalità interattiva.

Dopo l'esecuzione, in console dovrebbe comparire qualcosa del genere:

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

nuovo indirizzo del wallet = -1 : 4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2 
0f9PzVILj8yglrVn1zS-NSjtxr7QBfaTCp7JrBqnFPIR8nhZ
firma messaggio: x{00000000}

Messaggio esterno per l'inizializzazione è x{89FEE120E20C7E953E31546F64C23CD654002C1AA919ADD24DB12DDF85C6F3B58AE41198A28AD8DAF3B9588E7A629252BA3DB88F030D00BC1016110B2073359EAC3C13823C53245B65D056F2C070B940CDA09789585935C7ABA4D2AD4BED139281CFA1200000001_}
 x{FF0020DDA4F260810200D71820D70B1FED44D0D31FD3FFD15112BAF2A122F901541044F910F2A2F80001D31F3120D74A96D307D402FB00DED1A4C8CB1FCBFFC9ED54}
 x{0000000055375F730EDC2292E8CB15C42E8036EE9C25AA958EE002D2DE48A205E3A3426B}

B5EE9C724104030100000000D60002CF89FEE120E20C7E953E31546F64C23CD654002C1AA919ADD24DB12DDF85C6F3B58AE41198A28AD8DAF3B9588E7A629252BA3DB88F030D00BC1016110B2073359EAC3C13823C53245B65D056F2C070B940CDA09789585935C7ABA4D2AD4BED139281CFA1200000001001020084FF0020DDA4F260810200D71820D70B1FED44D0D31FD3FFD15112BAF2A122F901541044F910F2A2F80001D31F3120D74A96D307D402FB00DED1A4C8CB1FCBFFC9ED5400480000000055375F730EDC2292E8CB15C42E8036EE9C25AA958EE002D2DE48A205E3A3426B6290698B
(Salvato nel file new-wallet-query.boc)

Questo significa che il wallet con l'identificativo -1:4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2 (o, in altre parole, 0f9PzVILj8yglrVn1zS-NSjtxr7QBfaTCp7JrBqnFPIR8nhZ) è stato creato con successo. Il codice corrispondente sarà nel file new-wallet-query.boc, il cui indirizzo è in new-wallet.addr, e la chiave privata è in new-wallet.pk (fai attenzione: eseguire di nuovo lo script sovrascriverà questi file).

Naturalmente, la rete TON non sa ancora di questo wallet; esso esiste solo in forma di questi file. Ora deve essere caricato nella rete. Tuttavia, il problema è che per creare un contratto intelligente è necessario pagare una commissione, e il bilancio del tuo account è attualmente zero.

In modalità operativa, questo problema si risolverà acquistando grammi su un exchange (o trasferendoli da un altro wallet). Ma nell'attuale modalità di test, è stato creato uno speciale contratto intelligente da cui è possibile richiedere fino a 20 grammi gratuitamente.

Formare una richiesta a un contratto intelligente di terze parti

La richiesta al contratto intelligente che distribuisce grammi a destra e a sinistra viene effettuata 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

Lo salveremo anch'esso nella cartella con il client assemblato, ma modificheremo la quinta riga — prima della riga «constant dest_addr«. Sostituiscila con l'indirizzo del wallet che hai creato prima (completo, non abbreviato). Non è necessario scrivere all'inizio «-1:», ma all'inizio metti «0x».

È possibile anche modificare la riga 6.666 Gram* / quantità costante — è la somma in grammi che stai richiedendo (non superiore a 20). Anche se indichi un numero intero, lascia il punto decimale.

Infine, bisogna correggere la stringa 0x00000011 numero di sequenza costante. Il primo numero qui è l'attuale numero di sequenza, che è conservato nell'account che emette i grammi. Da dove prenderlo? Come accennato sopra, avvia il client e esegui:

last
getaccount -1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

Alla fine dei dati del contratto intelligente ci sarà

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

Il numero 0000000D (il tuo sarà maggiore) è il numero di sequenza che deve essere inserito in testgiver.fif.

Tutto, salviamo il file e avviamo (./crypto/fift testgiver.fif). In output otterremo il file wallet-query.boc. Questo è il messaggio a un contratto intelligente esterno — richiesta "invia quanti grammi a questo account".

Utilizzando il client, lo carichiamo nella rete:

> sendfile wallet-query.boc
[ 1][t 1][1558747399.456575155][test-lite-client.cpp:577][!testnode]    invio 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 chiami last, e poi richiedi di nuovo lo stato dell'account da cui abbiamo richiesto i grammi, vedremo che il numero di sequenza è aumentato di uno — ciò significa che ha inviato i soldi al nostro account.

Rimane un ultimo passo — carichiamo il codice del nostro portafoglio (il suo saldo è già stato rifornito, ma senza il codice del contratto intelligente non possiamo gestirlo). Eseguiamo sendfile new-wallet-query.boc — e tutto, ora hai il tuo portafoglio nella rete TON (anche se per ora è solo di prova).

Creazione di transazioni in uscita

Per trasferire denaro dal saldo dell'account creato, esiste un file crypto/block/wallet.fif, che deve essere inserito nella cartella con il client compilato.

Analogamente ai passaggi precedenti, lì dovrai modificare la somma che stai trasferendo, l'indirizzo del destinatario (dest_addr) e il seqno del tuo portafoglio (è uguale a 1 dopo l'inizializzazione del portafoglio 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 portafoglio — 0x4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2.

Quando avvii (./crypto/fift wallet.fif) lo script prenderà l'indirizzo del tuo portafoglio (da cui trasferisci) e la sua chiave privata dai file new-wallet.addr e new-wallet.pk, e scriverà il messaggio ottenuto 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 (last) e controlliamo che il saldo e seqno del nostro portafoglio siano cambiati (getaccount).

Ecco fatto, ora sappiamo come creare smart contract in TON e inviare loro richieste. Come vediamo, l'attuale funzionalità è già sufficiente per, ad esempio, realizzare un portafoglio più user-friendly con interfaccia grafica (si prevede, comunque, che sarà disponibile come parte del messenger).

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

Siete interessati a continuare gli articoli sull'analisi di TON, TVM, Fift?

• Sì, aspetto la conclusione del ciclo di articoli con una panoramica generale su TON

• Sì, mi interessa leggere di più sul linguaggio Fift

• Sì, voglio saperne di più sulla TON Virtual Machine e sull'assembly per essa

• No, non mi interessa niente di tutto ciò

Hanno votato 39 utenti. Si sono astenuti 12 utenti.

Cosa ne pensate dei piani di Telegram per lanciare TON?

• Ripongo grandi speranze in questo progetto

• Seguo semplicemente con interesse il suo sviluppo

• Ho un atteggiamento scettico, dubito del suo successo

• Tendo a considerare questa iniziativa come fallimentare, inutile per le masse

Hanno votato 47 utenti. Si sono astenuti 12 utenti.

Fonte: habr.com