Testclient TON (Telegram Open Network) en nieuwe Fift-taal voor slimme contracten

Ruim een ​​jaar geleden werd bekend over de plannen van de Telegram-messenger om een ​​eigen gedecentraliseerd netwerk uit te brengen Telegram Open Network. Toen kwam er een omvangrijk technisch document beschikbaar, dat naar verluidt door Nikolai Durov was geschreven en de structuur van het toekomstige netwerk beschreef. Voor degenen die het gemist hebben, raad ik u aan mijn hervertelling van dit document te lezen (Deel 1, Deel 2; het derde deel verzamelt helaas nog steeds stof in de tocht).

Sindsdien is er tot een paar dagen geleden geen noemenswaardig nieuws meer geweest over de status van de TON-ontwikkeling onofficiële kanalen) de link naar de pagina is niet verschenen https://test.ton.org/download.html, waar bevinden zich:
◦ ton-test-liteclient-full.tar.xz — bronnen van een light client voor het TON-testnetwerk;
◦ ton-lite-client-test1.config.json — configuratiebestand voor verbinding met het testnetwerk;
◦ README — informatie over het bouwen en lanceren van de client;
◦ HOE — stapsgewijze instructies voor het maken van een slim contract met behulp van een client;
◦ ton.pdf — bijgewerkt document (dd 2 maart 2019) met een technisch overzicht van het TON-netwerk;
◦ tvm.pdf — technische beschrijving van TVM (TON Virtual Machine, TON virtuele machine);
◦ tblkch.pdf — technische beschrijving van de TON-blockchain;
◦ vijfdebase.pdf – beschrijving van de nieuwe Fift-taal, ontworpen voor het maken van slimme contracten in TON.

Ik herhaal: er was geen officiële bevestiging van de pagina en al deze documenten van Telegram, maar de omvang van dit materiaal maakt ze behoorlijk plausibel. Start de gepubliceerde client op eigen risico.

Een testclient bouwen

Laten we eerst proberen een testclient te bouwen en uit te voeren. Gelukkig README beschrijft dit eenvoudige proces in detail. Ik zal dit doen met macOS 10.14.5 als voorbeeld; ik kan niet instaan ​​voor het succes van de build op andere systemen.

1. Downloaden en uitpakken bronarchief. Het is belangrijk om de nieuwste versie te downloaden, aangezien achterwaartse compatibiliteit in dit stadium niet kan worden gegarandeerd.

2. Zorg ervoor dat de nieuwste versies van make, cmake (versie 3.0.2 of hoger), OpenSSL (inclusief C header-bestanden), g++ of clang op het systeem zijn geïnstalleerd. Ik hoefde niets te installeren, alles kwam meteen in elkaar.

3. Laten we aannemen dat de bronnen zijn uitgepakt in een map ~/lite-client. Maak afzonderlijk daarvan een lege map voor het samengestelde project (bijvoorbeeld ~/liteclient-build), en daaruit (cd ~/liteclient-build) roep de commando's:

   cmake ~/lite-client
   cmake --build . --target test-lite-client

   
   
   Om de Vijftalige tolk voor slimme contracten te bouwen (meer daarover hieronder), bellen we ook

   cmake --build . --target fift

4. Download de huidige configuratiebestand om verbinding te maken met het testnetwerk en deze in de map met de samengestelde client te plaatsen.

5. Afwerking, kunt u de client starten:

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

Als alles correct is gedaan, zou je zoiets als dit moeten zien:

Zoals we kunnen zien, zijn er weinig beschikbare opdrachten:
◦ help — deze lijst met opdrachten weergeven;
◦ quit - uitgaan;
◦ time — toon de huidige tijd op de server;
◦ status — toon de verbinding en de lokale databasestatus;
◦ last — update de status van de blockchain (download het laatste blok). Het is belangrijk om deze opdracht vóór elk verzoek uit te voeren, om er zeker van te zijn dat u de huidige status van het netwerk ziet.
◦ sendfile <filename> — upload een lokaal bestand naar het TON-netwerk. Dit is hoe interactie met het netwerk plaatsvindt – inclusief bijvoorbeeld het creëren van nieuwe slimme contracten en verzoeken om geld over te maken tussen accounts;
◦ getaccount <address> — toon de huidige (op het moment dat de opdracht werd uitgevoerd) last) de status van het account met het opgegeven adres;
◦ privkey <filename> — laad de privésleutel uit een lokaal bestand.

Als u bij het starten van de client een map ernaar overzet met behulp van de optie -D, dan zal hij het laatste blok van de masterchain eraan toevoegen:

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

Nu kunnen we verder gaan met interessantere dingen: leer de Fift-taal, probeer een slim contract samen te stellen (maak bijvoorbeeld een testportemonnee), upload deze naar het netwerk en probeer geld over te maken tussen accounts.

Taal Vijf

Van document vijfdebase.pdf je kunt erachter komen dat het Telegram-team een ​​nieuwe stapeltaal heeft gemaakt om slimme contracten te maken Vijf (blijkbaar uit het cijfer vijfde, vergelijkbaar met Forth, een taal waarmee Fifth veel gemeen heeft).

Het document is behoorlijk omvangrijk, 87 pagina's, en ik zal de inhoud ervan niet in detail vertellen in het kader van dit artikel (tenminste omdat ik het zelf nog niet heb gelezen :). Ik zal me concentreren op de hoofdpunten en een paar codevoorbeelden in deze taal geven.

Op basisniveau is de syntaxis van Fift vrij eenvoudig: de code bestaat uit woorden, meestal gescheiden door spaties of regeleinden (speciaal geval: sommige woorden hebben geen scheidingsteken achter zichzelf nodig). Elk слово is een hoofdlettergevoelige reeks tekens die met een bepaald getal overeenkomt определение (wat de tolk grofweg moet doen als hij dit woord tegenkomt). Als er geen definitie van een woord bestaat, probeert de tolk het als een getal te ontleden en op de stapel te plaatsen. Trouwens, de getallen hier zijn - plotseling - gehele getallen van 257 bits, en er zijn helemaal geen breuken - preciezer gezegd, ze veranderen onmiddellijk in een paar gehele getallen, die de teller en de noemer van een rationale breuk vormen.

Woorden hebben de neiging om te interageren met waarden bovenaan de stapel. Een apart soort woorden - voorvoegsel — gebruikt niet de stapel, maar de daaropvolgende tekens uit het bronbestand. Dit is bijvoorbeeld hoe letterlijke tekenreeksen worden geïmplementeerd: het aanhalingsteken (") is een voorvoegselwoord dat zoekt naar het volgende (afsluitende) citaat, en de string ertussen op de stapel duwt. Oneliners gedragen zich op dezelfde manier (//) en meerdere regels (/*) opmerkingen.

Dit is waar bijna de gehele interne structuur van de taal eindigt. Al het andere (inclusief controleconstructies) wordt gedefinieerd als woorden (hetzij intern, zoals rekenkundige bewerkingen en de definitie van nieuwe woorden, hetzij gedefinieerd in de "standaardbibliotheek" Fift.fif, die zich in de map bevindt crypto/fift bij de bronnen).

Een eenvoudig voorbeeldprogramma in Fift:

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

De eerste regel definieert een nieuw woord setxy (let op het voorvoegsel {, waardoor een blok wordt gemaakt vóór het sluitende blok } en voorvoegsel :, wat het woord feitelijk definieert). setxy neemt een getal van de bovenkant van de stapel, definieert (of herdefinieert) het als globaal constante x, en het kwadraat van dit getal als constante y (Aangezien de waarden van constanten opnieuw kunnen worden gedefinieerd, zou ik ze liever variabelen noemen, maar ik volg de naamgevingsconventie in de taal).

De volgende twee lijnen plaatsen een nummer op de stapel en callen setxy, vervolgens worden de waarden van de constanten weergegeven x, y (het woord wordt gebruikt voor uitvoer .), worden beide constanten op de stapel geplaatst, opgeteld en wordt het resultaat ook afgedrukt. Als resultaat zullen we zien:

3 9 12 ok
7 49 56 ok

(De regel “ok” wordt door de tolk afgedrukt wanneer deze klaar is met het verwerken van de huidige regel in de interactieve invoermodus)

Nou ja, een volledig codevoorbeeld:

"Asm.fif" include

-1 constant wc  // create a wallet in workchain -1 (masterchain)

// Create new simple wallet
<{  SETCP0 DUP IFNOTRET INC 32 THROWIF  // return if recv_internal, fail unless recv_external
    512 INT LDSLICEX DUP 32 PLDU   // sign cs cnt
    c4 PUSHCTR CTOS 32 LDU 256 LDU ENDS  // sign cs cnt cnt' pubk
    s1 s2 XCPU            // sign cs cnt pubk cnt' cnt
    EQUAL 33 THROWIFNOT   // ( seqno mismatch? )
    s2 PUSH HASHSU        // sign cs cnt pubk hash
    s0 s4 s4 XC2PU        // pubk cs cnt hash sign pubk
    CHKSIGNU              // pubk cs cnt ?
    34 THROWIFNOT         // signature mismatch
    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
}>c
// code
<b 0 32 u, 
   newkeypair swap dup constant wallet_pk 
   "new-wallet.pk" B>file
   B, 
b> // data
// no libraries
<b b{00110} s, rot ref, swap ref, b>  // create StateInit
dup ."StateInit: " <s csr. cr
dup hash dup constant wallet_addr
."new wallet address = " wc . .": " dup x. cr
wc over 7 smca>$ type cr
256 u>B "new-wallet.addr" B>file
<b 0 32 u, b>
dup ."signing message: " <s csr. cr
dup hash wallet_pk ed25519_sign_uint rot
<b b{1000100} s, wc 8 i, wallet_addr 256 u, b{000010} s, swap <s s, b{0} s, swap B, swap <s s, b>
dup ."External message for initialization is " <s csr. cr
2 boc+>B dup Bx. cr
"new-wallet-query.boc" tuck B>file
."(Saved to file " type .")" cr

Dit eng uitziende bestand is bedoeld voor het maken van een slim contract - het wordt in een bestand geplaatst new-wallet-query.boc na executie. Houd er rekening mee dat hier een andere assembleertaal wordt gebruikt voor TON Virtual Machine (ik zal er niet in detail op ingaan), waarvan de instructies op de blockchain worden geplaatst.

De assembler voor TVM is dus geschreven in Fift - de bronnen van deze assembler staan ​​in het bestand crypto/fift/Asm.fif en zijn verbonden aan het begin van het bovenstaande stukje code.

Wat kan ik zeggen, Nikolai Durov houdt blijkbaar gewoon van het maken van nieuwe programmeertalen :)

Een slim contract creëren en communiceren met TON

Laten we dus aannemen dat we de TON-client en de Fift-tolk hebben samengesteld zoals hierboven beschreven en vertrouwd zijn geraakt met de taal. Hoe maak je nu een slim contract? Dit staat beschreven in het bestand HOE, bijgevoegd bij de bronnen.

Rekeningen in TON

Zoals ik beschreef in TON-recensie, bevat dit netwerk meer dan één blockchain - er is één gemeenschappelijke, de zogenaamde. "masterketen", evenals een willekeurig aantal extra "werkketens", geïdentificeerd door een 32-bits nummer. De masterchain heeft de identifier -1, daarnaast kan er ook een “base” workchain gebruikt worden met de identifier 0. Elke workchain kan zijn eigen configuratie hebben. Intern is elke werkketen verdeeld in shardchains, maar dit is een implementatiedetail waarmee u geen rekening hoeft te houden.

Binnen één werkketen worden veel accounts opgeslagen die hun eigen account_id-ID's hebben. Voor de hoofdketen en de nulwerkketen zijn ze 256 bits lang. De account-ID wordt dus bijvoorbeeld als volgt geschreven:

-1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

Dit is het “ruwe” formaat: eerst de werkketen-ID, dan een dubbele punt en de account-ID in hexadecimale notatie.

Daarnaast is er een verkort formaat: het werkketennummer en het accountadres zijn gecodeerd in binaire vorm, er wordt een controlesom aan toegevoegd en dit alles is gecodeerd in Base64:

Ef+BVndbeTJeXWLnQtm5bDC2UVpc0vH2TF2ksZPAPwcODSkb

Als we dit recordformaat kennen, kunnen we via een testclient de huidige status van een account opvragen met behulp van de opdracht

getaccount -1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

We krijgen zoiets als dit:

[ 3][t 2][1558746708.815218925][test-lite-client.cpp:631][!testnode]    requesting account state for -1:8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D
[ 3][t 2][1558746708.858564138][test-lite-client.cpp:652][!testnode]    got account state for -1:8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D with respect to blocks (-1,8000000000000000,72355):F566005749C1B97F18EDE013EBA7A054B9014961BC1AD91F475B9082919A2296:1BD5DE54333164025EE39D389ECE2E93DA2871DA616D488253953E52B50DC03F and (-1,8000000000000000,72355):F566005749C1B97F18EDE013EBA7A054B9014961BC1AD91F475B9082919A2296:1BD5DE54333164025EE39D389ECE2E93DA2871DA616D488253953E52B50DC03F
account state is (account
  addr:(addr_std
    anycast:nothing workchain_id:-1 address: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:nothing)
  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:nothing
        special:nothing
        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}

We zien de structuur die is opgeslagen in de DHT van de opgegeven werkketen. In het veld bijvoorbeeld storage.balance is het saldo op de lopende rekening, in storage.state.code - slimme contractcode, en in storage.state.data - de huidige gegevens. Houd er rekening mee dat de TON-gegevensopslag - Cel, cellen - boomachtig is, elke cel kan zowel zijn eigen gegevens als onderliggende cellen hebben. Dit wordt weergegeven als inspringing in de laatste regels.

Een slim contract bouwen

Laten we nu zelf zo'n structuur creëren (het heet BOC - zak met cellen) met behulp van de Fift-taal. Gelukkig hoef je niet zelf een smart contract te schrijven – in de map crypto/block er is een bestand uit het bronarchief new-wallet.fif, waarmee we een nieuwe portemonnee kunnen maken. Laten we het kopiëren naar de map met de samengestelde client (~/liteclient-build, als u de bovenstaande instructies heeft gevolgd). Ik heb de inhoud hierboven aangehaald als voorbeeld van code op Fift.

Voer dit bestand als volgt uit:

./crypto/fift -I"<source-directory>/crypto/fift" new-wallet.fif

Hier <source-directory> moet worden vervangen door het pad naar de uitgepakte bronnen (het symbool “~” kan hier helaas niet worden gebruikt, het volledige pad is nodig). In plaats van een sleutel te gebruiken -I u kunt een omgevingsvariabele definiëren FIFTPATH en plaats dit pad erin.

Sinds we Fift lanceerden met de bestandsnaam new-wallet.fif, het zal het uitvoeren en afsluiten. Als u de bestandsnaam weglaat, kunt u interactief met de tolk spelen.

Na uitvoering zou zoiets als dit in de console moeten worden weergegeven:

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)

Dit betekent dat de portemonnee met het ID -1:4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2 (of, wat is hetzelfde, 0f9PzVILj8yglrVn1zS-NSjtxr7QBfaTCp7JrBqnFPIR8nhZ) succesvol aangemaakt. De bijbehorende code bevindt zich in het bestand new-wallet-query.boc, zijn adres is binnen new-wallet.addren de privésleutel is binnen new-wallet.pk (wees voorzichtig: als u het script opnieuw uitvoert, worden deze bestanden overschreven).

Het TON-netwerk is uiteraard nog niet op de hoogte van deze portemonnee; deze wordt alleen in de vorm van deze bestanden opgeslagen. Nu moet het naar het netwerk worden geüpload. Het probleem is echter dat u, om een ​​slim contract te creëren, een commissie moet betalen en dat uw rekeningsaldo nog steeds nul is.

In de werkmodus wordt dit probleem opgelost door grammen op de beurs te kopen (of over te zetten vanuit een andere portemonnee). Welnu, in de huidige testmodus is er een speciaal slim contract aangemaakt, waaruit je zomaar tot 20 gram kunt vragen.

Een verzoek genereren voor het slimme contract van iemand anders

We doen een verzoek om een ​​slim contract dat grammen links en rechts zo verdeelt. In dezelfde map crypto/block vind bestand 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+ 1+ u, "GIFT" $, b>
<b seqno 32 u, 1 8 u, swap ref, b>
dup ."enveloping message: " <s csr. cr
<b b{1000100} s, wc 8 i, wallet_addr 256 u, 0 Gram, b{00} s,
   swap <s s, b>
dup ."resulting external message: " <s csr. cr
2 boc+>B dup Bx. cr
"wallet-query.boc" B>file

We zullen het ook opslaan in de map met de samengestelde client, maar we zullen de vijfde regel corrigeren - vóór de regel "constant dest_addr". Laten we het vervangen door het adres van de portemonnee die u eerder hebt gemaakt (volledig, niet afgekort). Het is niet nodig om aan het begin “-1:” te schrijven, maar in plaats daarvan “0x” aan het begin.

Je kunt de lijn ook wijzigen 6.666 Gram*/ constant amount — dit is de hoeveelheid in grammen die u aanvraagt ​​(maximaal 20). Zelfs als u een geheel getal opgeeft, laat u de komma staan.

Ten slotte moet u de lijn corrigeren 0x00000011 constant seqno. Het eerste getal hier is het huidige volgnummer, dat is opgeslagen op de rekening die grammen uitgeeft. Waar kan ik het vandaan halen? Zoals hierboven vermeld, start u de client en voert u het volgende uit:

last
getaccount -1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

Helemaal aan het einde zullen de slimme contractgegevens bevatten

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

Het nummer 0000000D (het jouwe zal groter zijn) is het volgnummer dat moet worden vervangen testgiver.fif.

Dat is alles, sla het bestand op en voer het uit (./crypto/fift testgiver.fif). De uitvoer zal een bestand zijn wallet-query.boc. Dit is wat er wordt gevormd bericht naar het slimme contract van iemand anders - een verzoek "zoveel gram overbrengen naar die en die rekening."

Met behulp van de client uploaden we deze naar het netwerk:

> sendfile wallet-query.boc
[ 1][t 1][1558747399.456575155][test-lite-client.cpp:577][!testnode]    sending query from file wallet-query.boc
[ 3][t 2][1558747399.500236034][test-lite-client.cpp:587][!query]   external message status is 1

Als je nu belt last, en dan opnieuw de status opvragen van de rekening waarvan we om grammen hebben gevraagd, dan zouden we moeten zien dat het volgnummer met één is verhoogd - dit betekent dat er geld naar onze rekening is gestuurd.

De laatste stap blijft: download de code van onze portemonnee (het saldo is al aangevuld, maar zonder de slimme contractcode kunnen we deze niet beheren). Wij voeren uit sendfile new-wallet-query.boc - en dat is alles, je hebt je eigen portemonnee in het TON-netwerk (ook al is het voorlopig maar een testversie).

Uitgaande transacties aanmaken

Om geld over te maken van het saldo van de aangemaakte rekening is er een bestand crypto/block/wallet.fif, die ook in de map bij de samengestelde client moet worden geplaatst.

Net als bij de vorige stappen moet u het bedrag dat u overmaakt, het adres van de ontvanger (dest_addr) en het volgnummer van uw portemonnee aanpassen (dit is gelijk aan 1 na het initialiseren van de portemonnee en wordt na elke uitgaande transactie met 1 verhoogd. U kunt bekijk het door de status van uw account op te vragen). Voor tests kunt u bijvoorbeeld mijn portemonnee gebruiken - 0x4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2.

Bij het opstarten (./crypto/fift wallet.fif) haalt het script het adres van uw portemonnee (vanwaar u de overdracht uitvoert) en de privésleutel uit de bestanden new-wallet.addr и new-wallet.pken er wordt naar het ontvangen bericht geschreven new-wallet-query.boc.

Net als voorheen kunt u bellen om de transactie rechtstreeks uit te voeren sendfile new-wallet-query.boc bij de cliënt. Vergeet hierna niet de status van de blockchain bij te werken (last) en controleer of het saldo en volgnummer van onze portemonnee zijn gewijzigd (getaccount <account_id>).

Dat is alles, nu kunnen we slimme contracten maken in TON en verzoeken naar hen sturen. Zoals je kunt zien is de huidige functionaliteit al voldoende om bijvoorbeeld een gebruiksvriendelijkere portemonnee te maken met een grafische interface (de verwachting is echter dat deze al beschikbaar zal komen als onderdeel van de messenger).

Alleen geregistreerde gebruikers kunnen deelnemen aan het onderzoek. Inloggen, Alsjeblieft.

Heb je interesse om de artikelen voort te zetten met analyse van TON, TVM, Fift?

• Ja, ik wacht op de voltooiing van de serie artikelen met een algemeen overzicht van TON

• Ja, het is interessant om meer te lezen over de Fift-taal

• Ja, ik wil meer weten over TON Virtual Machine en de assembler daarvoor

• Nee, dit alles is niet interessant

39 gebruikers hebben gestemd. 12 gebruikers onthielden zich van stemming.

Wat vindt u van de plannen van Telegram om TON te lanceren?

• Ik heb hoge verwachtingen van dit project

• Ik volg de ontwikkeling gewoon met interesse.

• Ik ben sceptisch en betwijfel het succes ervan.

• Ik ben geneigd dit initiatief als een mislukking en onnodig voor de brede massa te beschouwen

47 gebruikers hebben gestemd. 12 gebruikers onthielden zich van stemming.

Bron: www.habr.com