Testowy klient TON (Telegram Open Network) oraz nowy język Fift do smart kontraktów

-D , to będzie on umieszczał w nim ostatni blok masterchaina:.\/test-lite-client -C ton-lite-client-test1.config.json -D ~\/ton-db-dir

Teraz możemy przejść do ciekawszych rzeczy — poznać język Fift, spróbować skompilować smart kontrakt (na przykład stworzyć testowy portfel), załadować go do sieci i spróbować przesyłać środki między kontami.

Język Fift

Z dokumentu

można dowiedzieć się, że do tworzenia smart kontraktów zespół Telegramu stworzył nowy język stosowy fiftbase.pdf Fift (prawdopodobnie od liczby fifth , na analogię z Forth — językiem, z którym Fift ma wiele wspólnego).Dokument jest dość obszerny, ma 87 stron, i nie będę szczegółowo opisywał jego treści w ramach tego artykułu (przynajmniej, ponieważ sam go jeszcze nie dokończyłem :). Skupię się na głównych punktach i podam kilka przykładów kodu w tym języku.

Na podstawowym poziomie, składnia Fift jest dość prosta: jego kod składa się z

słów , zazwyczaj oddzielonych spacjami lub nowymi liniami (szczególny przypadek: niektóre słowa nie wymagają separatora po sobie). Każde— to wrażliwa na wielkość liter sekwencja znaków, której odpowiada pewne «replica» (na przykład funkcja snd_ctl_add_slave() została zastąpiona przez snd_ctl_add_replica()), co spowodowało definiowanie definicja (w dużym skrócie, to, co interpreter musi zrobić, gdy napotka to słowo). Jeśli definicji słowa brak, interpreter stara się zinterpretować je jako liczbę i umieścić na stosie. A propos, liczby tutaj — nagle — to 257-bitowe liczby całkowite, a ułamków nie ma wcale — raczej, są one od razu przekształcane w parę całkowitych, tworzących licznik i mianownik ułamka.

Słowa zazwyczaj współdziałają z wartościami znajdującymi się na szczycie stosu. Osobny typ słów to prefiksowe — używają nie stosu, a następujących po nich symboli z pliku źródłowego. Na przykład, w ten sposób realizowane są literały ciągów — symbol „cudzysłów” (") jest słowem prefiksowym, które wyszukuje następny (zamykający) cudzysłów i umieszcza ciąg między nimi na stosie. Podobnie zachowują się komentarze jednolinijkowe (//) i wielolinijkowe (/*).

Na tym prawie kończy się wewnętrzna konstrukcja języka. Wszystko inne (w tym struktury kontrolne) definiowane jest jako słowa (albo wewnętrzne, takie jak operacje arytmetyczne i definiowanie nowych słów; albo określone w „standardowej bibliotece” Fift.fif, która leży w folderze crypto/fift w źródłach).

Prosty przykład programu w Fift:

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

W pierwszej linijce definiowane jest nowe słowo setxy (zwróć uwagę na prefiks {, który tworzy blok do zamykającego } i prefiks :, który rzeczywiście definiuje słowo). setxy bierze liczbę ze szczytu stosu, definiuje (lub przedefiniowuje) ją jako globalną stałą x, a kwadrat tej liczby — jako stałą y (biorąc pod uwagę, że wartości stałych można przedefiniować, raczej nazwałbym je zmiennymi, ale podążam za nazewnictwem w języku).

W następnych dwóch linijkach na stos trafia liczba, wywoływana jest setxy, a następnie wartość stałych x, y (do wyświetlenia używa się słowa .), obie stałe umieszczane są na stosie, sumowane, a wynik również jest wyświetlany. W rezultacie zobaczymy:

3 9 12 ok
7 49 56 ok

(Linia „ok” jest wyświetlana przez interpreter, gdy kończy przetwarzanie bieżącej linii w interaktywnym trybie wejścia)

A oto pełny przykład kodu:

"Asm.fif" dołącz

-1 stała wc  
// utwórz portfel w workchain -1 (masterchain)

// Utwórz nowy prosty portfel
<{  SETCP0 DUP IFNOTRET INC 32 THROWIF  
    512 INT LDSLICEX DUP 32 PLDU   
    c4 PUSHCTR CTOS 32 LDU 256 LDU ENDS  
    s1 s2 XCPU            
    EQUAL 33 THROWIFNOT   
    s2 PUSH HASHSU        
    s0 s4 s4 XC2PU        
    CHKSIGNU              
    34 THROWIFNOT         
    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
// kod
<b 0 32 u, newkeypair swap dup constant wallet_pk "new-wallet.pk" b>plik
   B, 
b&gt; // dane
// brak bibliotek
<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>$ typ cr
256 u&gt;B "nowy-portfel.addr" B&gt;plik
<b 0 32 u, b>
dup ."podpisywanie wiadomości: " <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 ."Zewnętrzna wiadomość do inicjalizacji to " <s csr. cr
2 boc+>B dup Bx. cr
"nowy-portfel-zapytanie.boc" tuck B&gt;plik
."(Zapisano do pliku " typ .")" cr

Ten przerażająco wyglądający plik służy do stworzenia smart kontraktu — zostanie umieszczony w pliku new-wallet-query.boc po wykonaniu. Zauważ, że tutaj używany jest także inny język assemblerowy dla TON Virtual Machine (o nim nie będę się szczegółowo rozwodzić), którego instrukcje zostaną umieszczone w blockchainie.

W ten sposób assembler dla TVM został napisany w Fift — źródła tego assemblera znajdują się w pliku crypto/fift/Asm.fif i są dołączane na początku podanego powyżej fragmentu kodu.

Co mogę powiedzieć, wydaje się, że Nikolai Durov po prostu lubi tworzyć nowe języki programowania 🙂

Tworzenie smart contractu i interakcja z TON

Załóżmy, że zbudowaliśmy klienta TON oraz interpreter Fift, jak opisano powyżej, i zapoznaliśmy się z językiem. Jak teraz stworzyć smart contract? O tym mówi plik HOWTO, który dołączono do źródeł.

Konta w TON

Jak opisałem w przeglądzie TON, ta sieć zawiera więcej niż jeden blockchain — jest jeden wspólny, tzw. 'masterchain', oraz dowolna liczba dodatkowych 'workchainów', identyfikowanych 32-bitową liczbą. Masterchain ma identyfikator -1, oprócz niego można również wykorzystać 'bazowy' workchain z identyfikatorem 0. Każdy workchain może mieć swoją konfigurację. Wewnątrz każdy workchain jest podzielony na sharded chains, ale to już szczegół implementacji, który niekoniecznie trzeba mieć na uwadze.

W obrębie jednego workchainu przechowywana jest wiele kont, które mają swoje identyfikatory account_id. Dla masterchainu i zerowego workchainu mają one długość 256 bitów. Tak więc identyfikator konta zapisywany jest, na przykład, w ten sposób:

-1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

To jest 'surowy' format: najpierw identyfikator workchainu, następnie dwukropek, a potem identyfikator konta w zapisie szesnastkowym.

Ponadto istnieje skrócony format — numer workchainu i adres konta są kodowane binarnie, do nich dodawana jest suma kontrolna i wszystko to kodowane jest w Base64:

Ef+BVndbeTJeXWLnQtm5bDC2UVpc0vH2TF2ksZPAPwcODSkb

Znając ten format zapisu, możemy zażądać aktualnego stanu jakiegoś konta za pomocą klienta testowego za pomocą polecenia

getaccount -1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

Otrzymamy mniej więcej taką odpowiedź:

[ 3][t 2][1558746708.815218925][test-lite-client.cpp:631][!testnode]    żądanie stanu konta dla -1:8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D
[ 3][t 2][1558746708.858564138][test-lite-client.cpp:652][!testnode]    otrzymano stan konta dla -1:8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D w odniesieniu do bloków (-1,8000000000000000,72355):F566005749C1B97F18EDE013EBA7A054B9014961BC1AD91F475B9082919A2296:1BD5DE54333164025EE39D389ECE2E93DA2871DA616D488253953E52B50DC03F oraz (-1,8000000000000000,72355):F566005749C1B97F18EDE013EBA7A054B9014961BC1AD91F475B9082919A2296:1BD5DE54333164025EE39D389ECE2E93DA2871DA616D488253953E52B50DC03F
stan konta to (konto
  addr:(addr_std
    anycast:nic nie workchain_id:-1 adres: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)) ostatnio zapłacone:0
    należność:nic)
  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:nic
        special:nic
        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}

Widoczna struktura, która jest przechowywana w DHT wskazanego workchaina. Na przykład w polu storage.balance znajduje się aktualny balans konta, w storage.state.code — kod smart kontraktu, a w storage.state.data — jego aktualne dane. Zwróć uwagę, że przechowalnia danych TON - Cell, komórki - jest drzewiasta, a każda komórka może mieć zarówno swoje dane, jak i komórki podrzędne. To pokazano pod względem wcięć w ostatnich linijkach.

Konstrukcja smart kontraktu

Teraz stwórzmy same taką strukturę (nazywaną BOC - bag of cells) za pomocą języka Fift. Na szczęście nie musimy pisać smart kontraktu samodzielnie — w folderze crypto/block z archiwum z kodem źródłowym znajduje się plik new-wallet.fif, który pomoże nam stworzyć nowy portfel. Skopiujmy go do folderu z zbudowanym klientem (~\/liteclient-build, jeśli postępowałeś zgodnie z powyższymi instrukcjami). Jego zawartość przytaczałem powyżej w celu przykładu kodu w Fift.

Wykonujemy ten plik w następujący sposób:

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

Tutaj <source-directory> należy zastąpić ścieżką do rozpakowanych źródeł (niestety symbol „~” nie może być tutaj użyty, potrzebna jest pełna ścieżka). Zamiast używania klucza -I można zdefiniować zmienną środowiskową FIFTPATH i umieścić tę ścieżkę w niej.

Ponieważ uruchomiliśmy Fift z nazwą pliku new-wallet.fif, wykona go i zakończy działanie. Jeśli pominiesz nazwę pliku, możesz bawić się interpretera w trybie interaktywnym.

Po wykonaniu w konsoli powinno się wyświetlić coś takiego:

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

nowy adres portfela = -1 : 4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2 
0f9PzVILj8yglrVn1zS-NSjtxr7QBfaTCp7JrBqnFPIR8nhZ
podpisywanie wiadomości: x{00000000}

Zewnętrzna wiadomość do inicjalizacji to x{89FEE120E20C7E953E31546F64C23CD654002C1AA919ADD24DB12DDF85C6F3B58AE41198A28AD8DAF3B9588E7A629252BA3DB88F030D00BC1016110B2073359EAC3C13823C53245B65D056F2C070B940CDA09789585935C7ABA4D2AD4BED139281CFA1200000001_}
 x{FF0020DDA4F260810200D71820D70B1FED44D0D31FD3FFD15112BAF2A122F901541044F910F2A2F80001D31F3120D74A96D307D402FB00DED1A4C8CB1FCBFFC9ED54}
 x{0000000055375F730EDC2292E8CB15C42E8036EE9C25AA958EE002D2DE48A205E3A3426B}

B5EE9C724104030100000000D60002CF89FEE120E20C7E953E31546F64C23CD654002C1AA919ADD24DB12DDF85C6F3B58AE41198A28AD8DAF3B9588E7A629252BA3DB88F030D00BC1016110B2073359EAC3C13823C53245B65D056F2C070B940CDA09789585935C7ABA4D2AD4BED139281CFA1200000001001020084FF0020DDA4F260810200D71820D70B1FED44D0D31FD3FFD15112BAF2A122F901541044F910F2A2F80001D31F3120D74A96D307D402FB00DED1A4C8CB1FCBFFC9ED5400480000000055375F730EDC2292E8CB15C42E8036EE9C25AA958EE002D2DE48A205E3A3426B6290698B
(Zapisano do pliku new-wallet-query.boc)

Oznacza to, że portfel o identyfikatorze -1:4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2 (lub, co jest tym samym, 0f9PzVILj8yglrVn1zS-NSjtxr7QBfaTCp7JrBqnFPIR8nhZ) został pomyślnie utworzony. Odpowiedni kod znajdzie się w pliku new-wallet-query.boc, jego adres będzie w new-wallet.addr, a klucz prywatny w new-wallet.pk (uważaj — ponowne uruchomienie skryptu nadpisze te pliki).

Oczywiście, sieć TON jeszcze nie zna tego portfela, jest przechowywany tylko w postaci tych plików. Teraz należy załadować go do sieci. Prawda jest taka, że aby utworzyć smart kontrakt, musisz zapłacić prowizję, a saldo na Twoim koncie jest na razie zerowe.

W trybie operacyjnym problem ten rozwiązuje zakup gramów na giełdzie (lub transfer z innego portfela). W obecnym trybie testowym uruchomiono specjalny smart kontrakt, z którego można poprosić o 20 gramów po prostu tak.

Formowanie żądania do cudzej smart kontraktu

Żądanie do smart kontraktu, który rozdaje gramy na lewo i prawo, zrobimy w następujący sposób. W tej samej folderze crypto/block znajdujemy plik 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>
duplikat ."wiadomość otaczająca: " <s csr. cr
<b b{1000100} s, wc 8 i, wallet_addr 256 u, 0 gram, b{00} s,
 swap <s b>
duplikat ."wynikowa wiadomość zewnętrzna: " <s csr. cr
2 boc+>B duplikat Bx. cr
"zapytanie-portfela.boc" B&gt;plik

Zachowamy go również w folderze z zebranym klientem, ale poprawimy piątą linię — przed linią „constant dest_addr„. Zastąpimy ją adresem portfela, który stworzyłeś wcześniej (pełnym, nie skróconym). Nie należy pisać „-1:” na początku, zamiast tego na początku wstaw „0x”.

Można także zmienić linię 6.666 Gram* / stała ilość — to jest ilość w gramach, którą żądasz (nie więcej niż 20). Nawet jeśli podasz liczbę całkowitą, pozostaw kropkę dziesiętną.

Na koniec musisz poprawić linijkę 0x00000011 stały seqno. Pierwsza liczba tutaj to obecny numer sekwencyjny, który jest przechowywany w koncie wydającym gramy. Skąd go wziąć? Jak wspomniano wcześniej, uruchom klienta i wykonaj:

last
getaccount -1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

Na samym końcu w danych smart kontraktu będzie

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

Liczba 0000000D (u Ciebie będzie większa) to numer sekwencyjny, który należy podstawić do testgiver.fif.

Wszystko, zapisujemy plik i uruchamiamy (./crypto/fift testgiver.fif). W wyniku otrzymamy plik wallet-query.boc. To jest utworzone wiadomość do obcego smart kontraktu — prośba „przelej tyle gramów na takie konto”.

Za pomocą klienta ładujemy go do sieci:

> sendfile wallet-query.boc
[ 1][t 1][1558747399.456575155][test-lite-client.cpp:577][!testnode] wysyłanie zapytania z pliku wallet-query.boc
[ 3][t 2][1558747399.500236034][test-lite-client.cpp:587][!query] status wiadomości zewnętrznej to 1

Jeśli teraz wywołasz last, a następnie ponownie zapytasz o status konta, na które poprosiliśmy o gramy, powinieneś zobaczyć, że jego numer sekwencyjny zwiększył się o jeden — to oznacza, że wysłał pieniądze na nasze konto.

Pozostał ostatni krok — ładujemy kod naszego portfela (jego saldo zostało już zasilone, ale bez kodu smart kontraktu nie będziemy mogli nim zarządzać). Wykonujemy sendfile new-wallet-query.boc — i to wszystko, masz własny portfel w sieci TON (choć na razie tylko testowy).

Tworzenie wychodzących transakcji

Aby przekazywać pieniądze z salda utworzonego konta, istnieje plik crypto/block/wallet.fif, który również należy umieścić w folderze ze zbudowanym klientem.

Analogicznie do poprzednich kroków, musisz poprawić kwotę, którą przekażesz, adres odbiorcy (dest_addr) i seqno swojego portfela (wynosi 1 po inicjalizacji portfela i zwiększa się o 1 po każdej wychodzącej transakcji — będziesz mógł go zobaczyć, pytając o stan swojego konta). Na testy możesz użyć, na przykład, mojego portfela — 0x4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2.

Podczas uruchamiania (./crypto/fift wallet.fif) skrypt weźmie adres Twojego portfela (z którego przesyłasz) i jego klucz prywatny z plików new-wallet.addr i new-wallet.pk, a otrzymaną wiadomość zapisze w new-wallet-query.boc.

Jak wcześniej, aby bezpośrednio wykonać transakcję, wywołujemy sendfile new-wallet-query.boc w kliencie. Następnie pamiętajmy, aby zaktualizować stan blockchaina (last) i sprawdzamy, że saldo i seqno naszego portfela się zmieniły (getaccount).

I to wszystko, teraz potrafimy tworzyć smart kontrakty w TON i wysyłać do nich zapytania. Jak widzimy, obecna funkcjonalność jest już wystarczająca, aby na przykład stworzyć bardziej przyjazny portfel z graficznym interfejsem (chociaż oczekuje się, że będzie on dostępny jako część komunikatora).

Tylko zarejestrowani użytkownicy mogą brać udział w ankiecie. Zaloguj się, proszę.

Czy jesteś zainteresowany kontynuacją artykułów dotyczących TON, TVM, Fift?

• Tak, czekam na zakończenie cyklu artykułów z ogólnym przeglądem TON.

• Tak, ciekawi mnie poczytać więcej o języku Fift.

• Tak, chcę dowiedzieć się więcej o TON Virtual Machine i assemblerze dla niego.

• Nie, nie interesuje mnie nic z tego.

Głosowało 39 użytkowników. Wstrzymało się 12 użytkowników.

Co myślisz o planach Telegramu dotyczących uruchomienia TON?

• Pokładam duże nadzieje w tym projekcie.

• Po prostu z zainteresowaniem śledzę jego rozwój.

• Jestem sceptycznie nastawiony, wątpię w jego sukces.

• Skłonny uważam, że ta inicjatywa jest nieudana, niepotrzebna szerokim masom.

Głosowało 47 użytkowników. Wstrzymało się 12 użytkowników.

Źródło: habr.com