Client de test TON (Telegram Open Network) et nouveau langage Fift pour les smart contracts

Si l'on passe un dossier au client lors de son lancement avec l'option -D, alors il y accumulera le dernier bloc de la chaîne principale :

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

Nous pouvons maintenant passer aux choses plus intéressantes — étudier le langage Fift, tenter de compiler un contrat intelligent (par exemple, créer un portefeuille de test), le télécharger dans le réseau et essayer de transférer des fonds entre des comptes.

Le langage Fift

Dans le document fiftbase.pdf on peut apprendre que pour créer des contrats intelligents, l'équipe de Telegram a développé un nouveau langage de pile Fift (visiblement, dérivé du numéral fifth, par analogie avec Forth — un langage dont Fift a beaucoup en commun).

Le document est assez volumineux, avec 87 pages, et je ne vais pas en résumer le contenu de manière détaillée dans cet article (du moins parce que je ne l'ai pas encore terminé de lire :). Je vais me concentrer sur les points principaux et donner quelques exemples de code dans ce langage.

Au niveau de base, la syntaxe de Fift est assez simple : son code est composé de mots, généralement séparés par des espaces ou des retours à la ligne (sauf cas particuliers : certains mots n'exigent pas de séparateur après eux). Tout — peut être remplacé par — est une séquence de caractères sensible à la casse, correspondant à une certaine définition (en gros, ce que l’interpréteur doit faire quand il rencontre ce mot). Si la définition du mot n'existe pas, l’interpréteur essaie de l'analyser comme un nombre et de le placer sur la pile. À propos, les nombres ici — surprise — sont des entiers de 257 bits, et il n'y a pas de fractions — plutôt, ils se transforment immédiatement en un couple d'entiers qui forment un numérateur et un dénominateur d'une fraction rationnelle.

Les mots interagissent généralement avec les valeurs se trouvant au sommet de la pile. Un type distinct de mots — préfixé — utilise non pas une pile, mais les caractères suivants du fichier source. Par exemple, les littéraux de chaîne sont ainsi implémentés — le caractère «guillemet» (") est un mot préfixe qui recherche le prochain (guillemet fermant) et place la chaîne entre eux sur la pile. De la même manière, les commentaires sur une seule ligne (//) et ceux sur plusieurs lignes (/*) se comportent de la même façon.

C'est presque tout pour la structure interne du langage. Tout le reste (y compris les structures de contrôle) est défini comme des mots (soit internes, comme les opérations arithmétiques et la définition de nouveaux mots ; soit définis dans la «bibliothèque standard» Fift.fif, qui se trouve dans le dossier crypto/fift du code source).

Voici un exemple simple d'un programme en Fift :

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

La première ligne définit un nouveau mot setxy (notez le préfixe {, qui crée un bloc jusqu'au guillemet fermant } et le préfixe :, qui définit effectivement le mot). setxy prend un nombre de la pile, le définit (ou le redéfinit) comme une constante x, et le carré de ce nombre comme une constante y (considérant que les valeurs des constantes peuvent être redéfinies, je les appellerais plutôt des variables, mais je m'en tiens à la nomenclature du langage).

Dans les deux lignes suivantes, un nombre est placé sur la pile, puis est appelé setxy, ensuite les valeurs des constantes x, y sont affichées (pour l'affichage, on utilise le mot .), les deux constantes sont placées sur la pile, additionnées, et le résultat est également affiché. Nous verrons donc :

3 9 12 ok
7 49 56 ok

(La ligne «ok» est affichée par l'interpréteur lorsque le traitement de la ligne actuelle en mode interactif est terminé)

Et un exemple complet de code :

"Asm.fif" inclure

-1 constante wc  
// créer un portefeuille dans workchain -1 (masterchain)

// Créer un nouveau portefeuille simple
<{  SETCP0 DUP IFNOTRET INC 32 THROWIF  
// retourner si recv_internal, échouer à moins de recv_external
    512 INT LDSLICEX DUP 32 PLDU   
// signer cs cnt
    c4 PUSHCTR CTOS 32 LDU 256 LDU ENDS  
// signer cs cnt cnt' pubk
    s1 s2 XCPU            
// signer cs cnt pubk cnt' cnt
    EQUAL 33 THROWIFNOT   
// (écart seqno ? )
    s2 PUSH HASHSU        
// signer cs cnt pubk hash
    s0 s4 s4 XC2PU        
// pubk cs cnt hash signer pubk
    CHKSIGNU              
// pubk cs cnt ?
    34 THROWIFNOT         
// écart de signature
    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
// code
<b 0 32 u, newkeypair swap dup constant wallet_pk "new-wallet.pk" b>fichier
   B, 
b&gt;  // données
// pas de bibliothèques
<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 "nouveau-portefeuille.addr" B&gt;file
<b 0 32 u, b>
dup ."message de signature : " <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 ."Message externe pour l'initialisation est " <s csr. cr
2 boc+>B dup Bx. cr
"nouveau-portefeuille-query.boc" tuck B&gt;file
."(Sauvegardé dans le fichier " type .")" cr

Ce fichier à l'apparence quelque peu effrayante est destiné à créer un smart contract — il sera placé dans le fichier new-wallet-query.boc après exécution. Notez qu'un autre langage, assembleur, est utilisé ici pour la TON Virtual Machine (je ne vais pas le détailler), dont les instructions seront mises dans la blockchain.

Ainsi, l'assembleur pour la TVM est écrit en Fift — les sources de cet assembleur se trouvent dans le fichier crypto/fift/Asm.fif et sont incluses au début du bloc de code ci-dessus.

Que puis-je dire, il semble que Nikolai Durov aime simplement créer de nouveaux langages de programmation 🙂

Création d'un smart contract et interaction avec TON

Supposons donc que nous ayons rassemblé le client TON et l'interpréteur Fift, comme décrit ci-dessus, et que nous nous soyons familiarisés avec le langage. Comment créer un contrat intelligent ? Ceci est expliqué dans le fichier COMMENT FAIRE, joint aux sources.

Comptes dans TON

Comme je l'ai décrit dans la revue TON, ce réseau contient plus d'une blockchain - il y a une chaîne principale, appelée « masterchain », ainsi qu'un nombre arbitraire de « workchains » supplémentaires, identifiés par un nombre en 32 bits. La masterchain a l'identifiant -1, et il peut également y avoir une workchain « de base » avec l'identifiant 0. Chaque workchain peut avoir sa propre configuration. En interne, chaque workchain est divisé en shardchains, mais c'est déjà un détail d'implémentation qu'il n'est pas nécessaire de retenir.

À l'intérieur d'une workchain, il existe de nombreux comptes qui ont leurs propres identifiants account_id. Pour la masterchain et la workchain nulle, ils ont une longueur de 256 bits. Ainsi, l'identifiant du compte est enregistré, par exemple, comme suit :

-1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

C'est le format « brut » : d'abord l'identifiant de la workchain, puis deux-points, et l'identifiant du compte en notation hexadécimale.

De plus, il existe un format abrégé - le numéro de la workchain et l'adresse du compte sont codés en binaire, une somme de contrôle est ajoutée, et le tout est codé en Base64 :

Ef+BVndbeTJeXWLnQtm5bDC2UVpc0vH2TF2ksZPAPwcODSkb

En connaissant ce format d'enregistrement, nous pouvons demander l'état actuel d'un compte via le client de test à l'aide de la commande

getaccount -1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

Nous obtiendrons une réponse comme celle-ci :

[ 3][t 2][1558746708.815218925][test-lite-client.cpp:631][!testnode]    demande d'état du compte pour -1:8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D
[ 3][t 2][1558746708.858564138][test-lite-client.cpp:652][!testnode]    état du compte obtenu pour -1:8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D par rapport aux blocs (-1,8000000000000000,72355):F566005749C1B97F18EDE013EBA7A054B9014961BC1AD91F475B9082919A2296:1BD5DE54333164025EE39D389ECE2E93DA2871DA616D488253953E52B50DC03F et (-1,8000000000000000,72355):F566005749C1B97F18EDE013EBA7A054B9014961BC1AD91F475B9082919A2296:1BD5DE54333164025EE39D389ECE2E93DA2871DA616D488253953E52B50DC03F
l'état du compte est (compte
  addr:(addr_std
    anycast:rien workchain_id:-1 address:x8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D)
  storage_stat:(storage_info
    utilisé:(storage_used
      cellules:(var_uint len:1 value:3)
      bits:(var_uint len:2 value:539)
      cellules_publiques:(var_uint len:0 value:0)) dernier_paiement:0
    dû_paiement:rien)
  stockage:(account_storage last_trans_lt:74208000003
    solde:(currencies
      grammes:(nanograms
        montant:(var_uint len:7 value:999928362430000))
      autres:(extra_currencies
        dict:hme_empty))
    état:(account_active
      (
        profondeur_de_partition:rien
        spécial:rien
        code:(just
          value:(raw@^Cell 
            x{}
             x{FF0020DDA4F260D31F01ED44D0D31FD166BAF2A1F80001D307D4D1821804A817C80073FB0201FB00A4C8CB1FC9ED54}
            ))
        données:(just
          value:(raw@^Cell 
            x{}
             x{0000000D}
            ))
        bibliothèque:hme_empty))))
x{CFF8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D2068086C000000000000000451C90E00DC0E35B7DB5FB8C134_}
 x{FF0020DDA4F260D31F01ED44D0D31FD166BAF2A1F80001D307D4D1821804A817C80073FB0201FB00A4C8CB1FC9ED54}
 x{0000000D}

Nous voyons la structure stockée dans le DHT du workchain spécifié. Par exemple, dans le champ storage.balance se trouve le solde actuel du compte, dans storage.state.code — le code du smart contract, et dans storage.state.data — ses données actuelles. Notez que le stockage de données TON — Cell, les cellules — est arborescent, chaque cellule peut avoir ses propres données ainsi que des cellules filles. Cela est montré par les indentations dans les dernières lignes.

Compilation du smart contract

Maintenant, créons nous-mêmes une telle structure (appelée BOC — bag of cells) à l'aide du langage Fift. Heureusement, nous n'avons pas à écrire le smart contract nous-mêmes — dans le dossier crypto/block de l'archive des sources, il y a un fichier new-wallet.fif, qui va nous aider à créer un nouveau portefeuille. Nous allons le copier dans le dossier avec le client compilé (~\/liteclient-build, si vous avez suivi les instructions ci-dessus). Son contenu, je l'ai déjà fourni comme exemple de code en Fift.

Exécutons ce fichier comme suit :

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

Ici <source-directory> doit être remplacé par le chemin vers les sources décompressées (le symbole «~» ne peut malheureusement pas être utilisé ici, il faut le chemin complet). Au lieu d'utiliser la clé -I vous pouvez définir la variable d'environnement FIFTPATH et y placer ce chemin.

Puisque Fift a été lancé avec le nom de fichier new-wallet.fif, il l'exécutera et se terminera. Si le nom de fichier est omis, vous pouvez jouer avec l'interpréteur en mode interactif.

Il devrait afficher quelque chose comme ceci dans la console après l'exécution :

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

nouvelle adresse de portefeuille = -1 : 4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2 
0f9PzVILj8yglrVn1zS-NSjtxr7QBfaTCp7JrBqnFPIR8nhZ
message de signature : x{00000000}

Message externe pour l'initialisation est x{89FEE120E20C7E953E31546F64C23CD654002C1AA919ADD24DB12DDF85C6F3B58AE41198A28AD8DAF3B9588E7A629252BA3DB88F030D00BC1016110B2073359EAC3C13823C53245B65D056F2C070B940CDA09789585935C7ABA4D2AD4BED139281CFA1200000001_}
 x{FF0020DDA4F260810200D71820D70B1FED44D0D31FD3FFD15112BAF2A122F901541044F910F2A2F80001D31F3120D74A96D307D402FB00DED1A4C8CB1FCBFFC9ED54}
 x{0000000055375F730EDC2292E8CB15C42E8036EE9C25AA958EE002D2DE48A205E3A3426B}

B5EE9C724104030100000000D60002CF89FEE120E20C7E953E31546F64C23CD654002C1AA919ADD24DB12DDF85C6F3B58AE41198A28AD8DAF3B9588E7A629252BA3DB88F030D00BC1016110B2073359EAC3C13823C53245B65D056F2C070B940CDA09789585935C7ABA4D2AD4BED139281CFA1200000001001020084FF0020DDA4F260810200D71820D70B1FED44D0D31FD3FFD15112BAF2A122F901541044F910F2A2F80001D31F3120D74A96D307D402FB00DED1A4C8CB1FCBFFC9ED5400480000000055375F730EDC2292E8CB15C42E8036EE9C25AA958EE002D2DE48A205E3A3426B6290698B
(Sauvegardé dans le fichier new-wallet-query.boc)

Cela signifie que le portefeuille avec l'identifiant -1:4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2 (ou, ce qui est équivalent, 0f9PzVILj8yglrVn1zS-NSjtxr7QBfaTCp7JrBqnFPIR8nhZ) a été créé avec succès. Le code correspondant sera dans le fichier new-wallet-query.boc, son adresse sera dans new-wallet.addr, et la clé privée sera dans new-wallet.pk (faites attention — redémarrer le script écrasera ces fichiers).

Bien sûr, le réseau TON ne connaît pas encore ce portefeuille, il est stocké uniquement sous forme de ces fichiers. Maintenant, il faut le charger dans le réseau. Le problème, c'est que pour créer un contrat smart, il faut payer des frais, et le solde de votre compte est actuellement nul.

En mode opérationnel, ce problème sera résolu par l'achat de grammes sur la bourse (ou un transfert depuis un autre portefeuille). En revanche, en ce moment en mode test, un contrat smart spécial a été mis en place, auquel vous pouvez demander jusqu'à 20 grammes gratuitement.

Formation d'une demande à un contrat smart tiers

La demande au contrat smart qui distribue des grammes à gauche et à droite est faite comme ceci. Dans le même dossier crypto/block nous trouvons le fichier 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 ."message enveloppante: " <s csr. cr
<b b{1000100} s, wc 8 i, wallet_addr 256 u, 0 gram, b{00} s,
 swap <s b>
dup ."message externe résultante: " <s csr. cr
2 boc+>B dup Bx. cr
"wallet-query.boc" B&gt;fichier

Nous allons aussi le sauvegarder dans le dossier du client assemblé, mais nous allons corriger la cinquième ligne — avant la ligne «constant dest_addr«. Remplacez-la par l'adresse du portefeuille que vous avez créé précédemment (complète, pas abrégée). Il n'est pas nécessaire d'écrire «-1:» au début, mais au lieu de cela mettez «0x» au début.

Vous pouvez également changer la ligne 6.666 Gram*/ quantité constante — c'est la somme en grammes que vous demandez (pas plus de 20). Même si vous indiquez un nombre entier, laissez le point décimal.

Enfin, il faut corriger la ligne 0x00000011 seqno constant. Le premier nombre ici est le numéro de séquence actuel, qui est stocké dans le compte émetteur des grammes. Comment l'obtenir ? Comme mentionné plus haut, lancez le client et exécutez :

last
getaccount -1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

À la toute fin dans les données du contrat intelligent, il y aura

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

Le nombre 0000000D (vous en aurez un plus grand) est le numéro de séquence, qui doit être inséré dans testgiver.fif.

Voilà, enregistrons le fichier et exécutons (./crypto/fift testgiver.fif). À la sortie, nous obtiendrons le fichier wallet-query.boc. C'est bien cela qui a été formé message vers un contrat intelligent étranger — demande "transfère autant de grammes à tel compte".

Avec le client, nous le chargeons dans le réseau :

> sendfile wallet-query.boc
[ 1][t 1][1558747399.456575155][test-lite-client.cpp:577][!testnode]    envoi de la requête depuis le fichier wallet-query.boc
[ 3][t 2][1558747399.500236034][test-lite-client.cpp:587][!query]   état du message externe est 1

Si maintenant nous appelons dernier, puis redemandons l'état du compte à partir duquel nous avons demandé les grammes, nous devrions voir que son numéro de séquence a augmenté d'une unité — cela signifie qu'il a envoyé de l'argent à notre compte.

Il nous reste une dernière étape — charger le code de notre portefeuille (son solde est déjà crédité, mais sans le code du contrat intelligent, nous ne pourrons pas le gérer). Nous exécutons sendfile new-wallet-query.boc — et voilà, vous avez votre propre portefeuille dans le réseau TON (même si c'est encore juste un test).

Création de transactions sortantes

Pour transférer de l'argent depuis le solde d'un compte créé, il y a le fichier crypto/block/wallet.fif, qui doit aussi être placé dans le dossier du client compilé.

De manière similaire aux étapes précédentes, il faut corriger le montant que vous transférez, l'adresse du destinataire (dest_addr), et le seqno de votre portefeuille (il est de 1 après l'initialisation du portefeuille et augmente de 1 après chaque transaction sortante — vous pourrez le voir en demandant l'état de votre compte). Pour des tests, vous pouvez utiliser, par exemple, mon portefeuille — 0x4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2.

Lors de l'exécution (./crypto/fift wallet.fif), le script prendra l'adresse de votre portefeuille (d'où vous transférez) et sa clé privée depuis les fichiers new-wallet.addr et new-wallet.pk, et enregistrera le message obtenu dans new-wallet-query.boc.

Comme auparavant, pour effectuer directement la transaction, nous appelons sendfile new-wallet-query.boc dans le client. Après cela, n'oublions pas de mettre à jour l'état de la blockchain (dernier) et vérifions que le solde et le seqno de notre portefeuille ont changé (getaccount).

Voilà, nous savons maintenant comment créer des contrats intelligents dans TON et y envoyer des requêtes. Comme nous le voyons, les fonctionnalités actuelles sont déjà suffisantes pour, par exemple, créer un portefeuille plus convivial avec une interface graphique (il est prévu qu'il soit disponible comme partie intégrante du messager).

Seuls les utilisateurs enregistrés peuvent participer au sondage. Connectez-vous, s'il vous plaît.

Êtes-vous intéressé par la poursuite des articles analysant TON, TVM, Fift ?

• Oui, j'attends la fin du cycle d'articles avec un aperçu général de TON

• Oui, je voudrais en savoir plus sur le langage Fift

• Oui, je veux en savoir plus sur la TON Virtual Machine et son assembleur

• Non, je ne suis pas intéressé par cela

39 utilisateurs ont voté. 12 utilisateurs se sont abstenus.

Que pensez-vous des plans de Telegram pour lancer TON ?

• J'ai de grands espoirs pour ce projet

• Je suis simplement intéressé par son développement

• Je suis sceptique et doute de son succès

• Je considère cette initiative comme vouée à l'échec, inutile pour les masses

47 utilisateurs ont voté. 12 utilisateurs se sont abstenus.

Source : habr.com