Hur man skriver och publicerar ett smart kontrakt i TON

Vad handlar den här artikeln om?

I den här artikeln kommer jag att berätta om hur jag deltog i den första (av två) Telegram blockchain-tävling, inte vann något pris och bestämde mig för att spela in upplevelsen i en artikel så att den inte skulle sjunka i glömska och kanske hjälpa någon.

Eftersom jag inte ville skriva abstrakt kod, utan för att få något att fungera, skrev jag till artikeln ett smart kontrakt direktlotteri och en hemsida som visar smart kontraktsdata direkt från TON utan att använda mellanlagring.

Artikeln kommer att vara användbar för dem som vill göra sitt första smarta kontrakt i TON, men inte vet var de ska börja.

Med lotteriet som exempel kommer jag att gå från att installera miljön till att publicera ett smart kontrakt, interagera med det och skriva en hemsida för att ta emot och publicera data.

Om deltagande i tävlingen

I oktober förra året utlyste Telegram en blockchain-tävling med nya språk Fift и FunC. Det var nödvändigt att välja att skriva något av de fem föreslagna smarta kontrakten. Jag tänkte att det skulle vara trevligt att göra något annorlunda, lära mig ett språk och göra något, även om jag inte skulle behöva skriva något annat i framtiden. Dessutom är ämnet ständigt på allas läppar.

Det är värt att säga att jag inte hade någon erfarenhet av att utveckla smarta kontrakt.

Jag planerade att delta ända till slutet medan jag kunde och sedan skriva en recensionsartikel, men jag misslyckades direkt vid den första. jag skrev plånbok med multisignatur på FunC och i allmänhet fungerade det. Jag tog det som grund smart kontrakt om soliditet.

I det ögonblicket tänkte jag att detta definitivt räckte för att ta åtminstone någon prisplats. Till sist blev cirka 40 av 60 deltagare pristagare och jag var inte bland dem. I allmänhet är det inget fel med det här, men en sak störde mig. Vid den tidpunkt då beskedet om resultatet av granskningen med testet för mitt kontrakt inte hade gjorts frågade jag deltagarna i chatten om det var någon annan som inte hade det, det fanns inga.

Tydligen, efter att ha lagt märke till mina meddelanden, publicerade domarna en kommentar två dagar senare och jag förstår fortfarande inte om de av misstag missade mitt smarta kontrakt under bedömningen eller helt enkelt tyckte att det var så dåligt att det inte behövde en kommentar. Jag ställde en fråga på sidan men fick inget svar. Även om det inte är någon hemlighet vem som dömde, ansåg jag att det var onödigt att skriva personliga meddelanden.

Det tog mycket tid att förstå, så det beslöts att skriva en artikel. Eftersom det inte finns mycket information ännu, kommer den här artikeln att spara tid för alla intresserade.

Konceptet med smarta kontrakt i TON

Innan du skriver något måste du ta reda på från vilken sida du ska närma dig den här saken. Så nu ska jag berätta vilka delar systemet består av. Mer exakt, vilka delar behöver du veta för att kunna skriva åtminstone något slags arbetskontrakt.

Vi kommer fokusera på att skriva ett smart kontrakt och jobba med TON Virtual Machine (TVM), Fift и FunC, så artikeln är mer som en beskrivning av utvecklingen av ett vanligt program. Vi kommer inte att uppehålla oss vid hur själva plattformen fungerar här.

Generellt om hur det fungerar TVM och språk Fift Det finns bra officiell dokumentation. Under mitt deltagande i tävlingen och nu när jag skrev det nuvarande kontraktet vände jag mig ofta till henne.

Huvudspråket som smarta kontrakt skrivs på är FunC. Det finns för närvarande ingen dokumentation på det, så för att skriva något behöver du studera exempel på smarta kontrakt från det officiella förrådet och implementeringen av själva språket där, plus att du kan titta på exempel på smarta kontrakt från de två senaste tävlingarna. Länkar i slutet av artikeln.

Låt oss säga att vi redan har skrivit ett smart kontrakt på FunC, efter det kompilerar vi koden till Fift assembler.

Det sammanställda smarta kontraktet återstår att publiceras. För att göra detta måste du skriva en funktion i Fift, som kommer att acceptera den smarta kontraktskoden och några andra parametrar som indata, och utdata kommer att vara en fil med tillägget .boc (vilket betyder "påse med celler"), och, beroende på hur vi skriver det, en privat nyckel och en adress som genereras baserat på den smarta kontraktskoden. Du kan redan skicka gram till adressen till ett smart kontrakt som ännu inte har publicerats.

För att publicera ett smart kontrakt i TON mottagits .boc filen kommer att behöva skickas till blockkedjan med en lätt klient (mer om det nedan). Men innan du publicerar måste du överföra gram till den genererade adressen, annars kommer det smarta kontraktet inte att publiceras. När det väl har publicerats kan det interagera med det smarta kontraktet genom att skicka meddelanden till det från utsidan (t.ex. med hjälp av en lätt klient) eller från insidan (t.ex. ett smart kontrakt skickar ett annat meddelande inuti TON).

När vi väl förstår hur kod publiceras blir det lättare. Vi vet ungefär vad vi vill skriva och hur vårt program kommer att fungera. Och medan vi skriver letar vi efter hur detta redan är implementerat i befintliga smarta kontrakt, eller så tittar vi på implementeringskoden Fift и FunC i det officiella arkivet, eller titta i den officiella dokumentationen.

Mycket ofta sökte jag på nyckelord i Telegram-chatten där alla deltagare i tävlingen och Telegram-anställda samlades, det hände sig att under tävlingen samlades alla där och började diskutera Fift och FunC. Länk i slutet av artikeln.

Det är dags att gå från teori till praktik.

Förbereda miljön för att arbeta med TON

Jag gjorde allt som kommer att beskrivas i artikeln om MacOS och dubbelkollade det i en ren version. Ubuntu 18.04 LTS på Docker.

Det första du behöver göra är att ladda ner och installera lite-client med vilken du kan skicka förfrågningar till TON.

Instruktionerna på den officiella webbplatsen beskriver installationsprocessen ganska utförligt och tydligt, med vissa detaljer utelämnade. Här följer vi instruktionerna och installerar eventuella saknade beroenden längs vägen. Jag kompilerade inte varje projekt själv och installerade från det officiella arkivet. Ubuntu (på MacOS jag använde brew).

apt -y install git 
apt -y install wget 
apt -y install cmake 
apt -y install g++ 
apt -y install zlib1g-dev 
apt -y install libssl-dev 

När alla beroenden är installerade kan du installera lite-client, Fift, FunC.

Låt oss först klona TON-förvaret tillsammans med dess beroenden. För enkelhetens skull gör vi allt i en pärm. ~/TON.

cd ~/TON
git clone https://github.com/ton-blockchain/ton.git
cd ./ton
git submodule update --init --recursive

Förvaret lagrar även implementeringar. Fift и FunC.

Nu är vi redo att montera projektet. Förvarskoden klonas in i mappen ~/TON/ton. I ~/TON skapa en mapp build och vi samlar projektet i den.

mkdir ~/TON/build 
cd ~/TON/build
cmake ../ton

Eftersom vi ska skriva ett smart kontrakt behöver vi inte bara lite-clientMen Fift с FunC, så vi sammanställer allt. Det är ingen snabb process, så vi avvaktar.

cmake --build . --target lite-client
cmake --build . --target fift
cmake --build . --target func

Därefter laddar vi ner konfigurationsfilen, som innehåller data om den nod till vilken lite-client kommer att ansluta.

wget https://test.ton.org/ton-lite-client-test1.config.json

Gör de första förfrågningarna till TON

Låt oss nu starta lite-client.

cd ~/TON/build
./lite-client/lite-client -C ton-lite-client-test1.config.json

Om bygget lyckades kommer du efter lanseringen att se en logg över anslutningen av light-klienten till noden.

[ 1][t 2][1582054822.963129282][lite-client.h:201][!testnode]   conn ready
[ 2][t 2][1582054823.085654020][lite-client.cpp:277][!testnode] server version is 1.1, capabilities 7
[ 3][t 2][1582054823.085725069][lite-client.cpp:286][!testnode] server time is 1582054823 (delta 0)
...

Du kan utföra kommandot help och se vilka kommandon som finns tillgängliga.

help

Låt oss lista kommandona som vi kommer att använda i den här artikeln.

list of available commands:
last    Get last block and state info from server
sendfile <filename> Load a serialized message from <filename> and send it to server
getaccount <addr> [<block-id-ext>]  Loads the most recent state of specified account; <addr> is in [<workchain>:]<hex-or-base64-addr> format
runmethod <addr> [<block-id-ext>] <method-id> <params>...   Runs GET method <method-id> of account <addr> with specified parameters

last получает последний созданный блок с сервера. 

sendfile <filename> отправляет в TON файл с сообщением, именно с помощью этой команды публикуется смарт-контракт и запрсосы к нему. 

getaccount <addr> загружает текущее состояние смарт-контракта с указанным адресом. 

runmethod <addr> [<block-id-ext>] <method-id> <params>  запускает get-методы смартконтракта. 

Nu är vi redo att skriva själva kontraktet.

genomförande

Idé

Som jag skrev ovan är det smarta kontraktet vi skriver ett lotteri.

Dessutom är detta inte ett lotteri där du behöver köpa en biljett och vänta en timme, en dag eller en månad, utan ett ögonblick där användaren överför till kontraktsadressen N gram och får den omedelbart tillbaka 2 * N gram eller tappar. Vi kommer att göra sannolikheten för att vinna cirka 40%. Om det inte finns tillräckligt med gram för betalning, kommer vi att betrakta transaktionen som en påfyllning.

Dessutom är det viktigt att vaden kan ses i realtid och i en bekväm form, så att användaren omedelbart kan förstå om han har vunnit eller förlorat. Därför måste vi göra en webbplats som visar priser och resultat direkt från TON.

Att skriva ett smart kontrakt

För enkelhetens skull gjorde jag en kodmarkering för FunC, pluginet kan hittas och installeras i Visual Studio Code-sökningen, om du plötsligt vill lägga till något så har jag gjort pluginen allmänt tillgänglig. Dessutom har någon tidigare gjort ett plugin för att arbeta med Fift, du kan också installera det och hitta det i VSC.

Låt oss omedelbart skapa ett arkiv där vi kommer att begå mellanliggande resultat.

För att göra livet enklare kommer vi att skriva ett smart kontrakt och testa det lokalt tills det är klart. Först efter det kommer vi att publicera den i TON.

Det smarta kontraktet har två externa metoder som kan anropas. Första, recv_external() Denna funktion exekveras när en förfrågan till kontraktet kommer från omvärlden, det vill säga inte från exempelvis TON, när vi själva genererar ett meddelande och skickar det via lite-klient. Andra, recv_internal() det är när inom TON självt något kontrakt hänvisar till vårt. I båda fallen kan du skicka parametrar till funktionen.

Låt oss börja med ett enkelt exempel som fungerar om det publiceras, men det ger ingen funktionalitet.

() recv_internal(slice in_msg) impure {
    ;; TODO: implementation 
}

() recv_external(slice in_msg) impure {
    ;; TODO: implementation  
}

Här måste vi förklara vad detta är slice. All data som lagras i TON Blockchain är en samling TVM cell eller helt enkelt cell, kan en sådan cell lagra upp till 1023 bitar av data och upp till 4 referenser till andra celler.

TVM cell slice eller slice detta är en del av det befintliga cell används för sin analys, kommer det att bli klart senare. Huvudsaken för oss är att vi kan överföra till ett smart kontrakt slice och beroende på typen av meddelande, bearbeta data in recv_external() eller recv_internal().

impure — ett nyckelord som indikerar att funktionen modifierar smart kontraktsdata.

Låt oss spara kontraktskoden lottery-code.fc och kompilera.

~/TON/build/crypto/func -APSR -o lottery-compiled.fif ~/TON/ton/crypto/smartcont/stdlib.fc ./lottery-code.fc 

Betydelsen av flaggorna kan ses med kommandot

~/TON/build/crypto/func -help

Vi fick in den kompilerade Fift assembler-koden lottery-compiled.fif:

// lottery-compiled.fif

"Asm.fif" include
// automatically generated from `/Users/rajymbekkapisev/TON/ton/crypto/smartcont/stdlib.fc` `./lottery-code.fc` 
PROGRAM{
  DECLPROC recv_internal
  DECLPROC recv_external
  recv_internal PROC:<{
    //  in_msg
    DROP    // 
  }>
  recv_external PROC:<{
    //  in_msg
    DROP    // 
  }>
}END>c

Det kan drivas lokalt, för detta kommer vi att förbereda miljön.

Observera att den första raden ansluter Asm.fif, detta är kod skriven i Fift för Fift assembler.

Eftersom vi vill köra och testa det smarta kontraktet lokalt kommer vi att skapa en fil lottery-test-suite.fif och kopiera den kompilerade koden dit, ersätt den sista raden i den, som skriver den smarta kontraktskoden till en konstant code, så att du sedan kan överföra den till den virtuella maskinen:

"TonUtil.fif" include
"Asm.fif" include

PROGRAM{
  DECLPROC recv_internal
  DECLPROC recv_external
  recv_internal PROC:<{
    //  in_msg
    DROP    // 
  }>
  recv_external PROC:<{
    //  in_msg
    DROP    // 
  }>
}END>s constant code

Hittills verkar det klart, låt oss nu lägga till koden som vi kommer att använda för att starta TVM i samma fil.

0 tuple 0x076ef1ea , // magic
0 , 0 , // actions msg_sents
1570998536 , // unix_time
1 , 1 , 3 , // block_lt, trans_lt, rand_seed
0 tuple 100000000000000 , dictnew , , // remaining balance
0 , dictnew , // contract_address, global_config
1 tuple // wrap to another tuple
constant c7

0 constant recv_internal // to run recv_internal() 
-1 constant recv_external // to invoke recv_external()

В c7 vi skriver sammanhanget, det vill säga de data som TVM kommer att lanseras med (eller nätverkstillståndet). Redan under tävlingen visade en av utvecklarna hur den skapas c7 och jag kopierade det. I den här artikeln kan vi behöva ändra rand_seed eftersom genereringen av ett slumptal beror på det och inte kan ändras, kommer samma nummer att returneras varje gång.

recv_internal и recv_external konstanter med värdena 0 och -1 kommer att ansvara för att anropa motsvarande funktioner i det smarta kontraktet.

Nu är vi redo att skapa det första testet för vårt tomma smarta kontrakt. För tydlighetens skull kommer vi för närvarande att lägga till alla tester i samma fil. lottery-test-suite.fif.

Låt oss skapa en variabel storage och skriv en tom i den cell, kommer detta att vara lagringen av det smarta kontraktet.

message Detta är budskapet som vi kommer att överföra till den smarta kontakten utifrån. Vi lämnar det också tomt för tillfället.

variable storage 
<b b> storage ! 

variable message 
<b b> message ! 

Efter att vi har förberett konstanterna och variablerna kör vi TVM med kommandot runvmctx och skicka de skapade parametrarna till ingången.

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx 

I slutändan kommer vi att lyckas så här mellankod på Fift.

Nu kan vi köra den resulterande koden.

export FIFTPATH=~/TON/ton/crypto/fift/lib // выполняем один раз для удобства 
~/TON/build/crypto/fift -s lottery-test-suite.fif 

Programmet bör köras utan fel och vi kommer att se exekveringsloggen i utgången:

execute SETCP 0
execute DICTPUSHCONST 19 (xC_,1)
execute DICTIGETJMPZ
execute DROP
execute implicit RET
[ 3][t 0][1582281699.325381279][vm.cpp:479]     steps: 5 gas: used=304, max=9223372036854775807, limit=9223372036854775807, credit=0

Bra, vi har skrivit den första fungerande versionen av ett smart kontrakt.

Nu måste vi lägga till funktionalitet. Låt oss först ta itu med meddelanden som kommer från omvärlden. recv_external()

Byggherren väljer själv vilket meddelandeformat som kontraktet kan acceptera.

Men vanligtvis,

• För det första vill vi skydda vårt kontrakt från omvärlden och göra det så att endast ägaren av kontraktet kan skicka externa meddelanden till det.
• för det andra, när vi skickar ett giltigt meddelande till TON vill vi att det ska hända exakt en gång, och när vi skickar samma meddelande igen avvisar det smarta kontraktet det.

Så nästan varje kontrakt handlar om dessa två frågor, eftersom vårt kontrakt får externa meddelanden måste vi ta hand om det också.

Vi gör det i omvänd ordning. Låt oss först lösa problemet med upprepning: om kontraktet redan har fått ett sådant meddelande och bearbetat det, kommer det inte att utföras en andra gång. Och då ska vi lösa problemet så att bara en viss krets av människor kan skicka meddelanden till det smarta kontraktet.

Det finns olika sätt att lösa problemet med dubbletter av meddelanden. Så här gör vi. I det smarta kontraktet initierar vi räknaren för mottagna meddelanden med startvärdet 0. I varje meddelande till det smarta kontraktet kommer vi att lägga till det aktuella värdet på räknaren. Om räknarvärdet i meddelandet inte stämmer överens med värdet i det smarta kontraktet så bearbetar vi det inte, om det stämmer överens så bearbetar vi det och ökar räknaren i det smarta kontraktet med 1.

Vi återvänder till lottery-test-suite.fif och vi lägger till det andra testet. Om vi ​​skickar ett ogiltigt nummer bör koden ge ett undantag. Låt oss till exempel säga att kontraktsdata lagrar 166 och vi skickar 165.

<b 166 32 u, b> storage !
<b 165 32 u, b> message !

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx

drop 
exit_code ! 
."Exit code " exit_code @ . cr 
exit_code @ 33 - abort"Test #2 Not passed"

Låt oss starta.

 ~/TON/build/crypto/fift -s lottery-test-suite.fif 

Och vi kommer att se att testet utförs med ett fel.

[ 1][t 0][1582283084.210902214][words.cpp:3046] lottery-test-suite.fif:67: abort": Test #2 Not passed
[ 1][t 0][1582283084.210941076][fift-main.cpp:196]      Error interpreting file `lottery-test-suite.fif`: error interpreting included file `lottery-test-suite.fif` : lottery-test-suite.fif:67: abort": Test #2 Not passed

I detta skede lottery-test-suite.fif ska se ut по ссылке.

Låt oss nu lägga till motlogiken till det smarta kontraktet lottery-code.fc.

() recv_internal(slice in_msg) impure {
    ;; TODO: implementation 
}

() recv_external(slice in_msg) impure {
    if (slice_empty?(in_msg)) {
        return (); 
    }
    int msg_seqno = in_msg~load_uint(32);
    var ds = begin_parse(get_data());
    int stored_seqno = ds~load_uint(32);
    throw_unless(33, msg_seqno == stored_seqno);
}

В slice in_msg ligger budskapet vi skickar.

Det första vi gör är att kontrollera om det finns data i meddelandet, om inte så avslutar vi bara.

Därefter analyserar vi meddelandet. in_msg~load_uint(32) laddar numret 165, 32-bitars unsigned int från det överförda meddelandet.

Därefter laddar vi 32 bitar från den smarta kontraktslagringen. Vi kontrollerar att det laddade numret matchar det överförda, om inte gör vi ett undantag. I vårt fall, eftersom vi passerar en missmatchning, bör ett undantag göras.

Låt oss nu kompilera.

~/TON/build/crypto/func -APSR -o lottery-compiled.fif ~/TON/ton/crypto/smartcont/stdlib.fc ./lottery-code.fc 

Kopiera den resulterande koden till lottery-test-suite.fif, glöm inte att ersätta den sista raden.

Låt oss kontrollera att testet klarar:

~/TON/build/crypto/fift -s lottery-test-suite.fif

Precis här Du kan se motsvarande commit med de aktuella resultaten.

Observera att det är obekvämt att ständigt kopiera den kompilerade koden för det smarta kontraktet till filen med tester, så vi kommer att skriva ett skript som skriver koden till en konstant för oss, och vi kommer helt enkelt att koppla den kompilerade koden till våra tester med hjälp av "include".

Skapa en fil i projektmappen build.sh med följande innehåll.

#!/bin/bash

~/TON/build/crypto/func -SPA -R -o lottery-compiled.fif ~/TON/ton/crypto/smartcont/stdlib.fc ./lottery-code.fc

Låt oss göra det körbart.

chmod +x ./build.sh

Nu räcker det med att köra vårt skript för att kompilera kontraktet. Men förutom detta måste vi skriva in det i en konstant code. Så vi kommer att skapa en ny fil lotter-compiled-for-test.fif, som vi kommer att inkludera i filen lottery-test-suite.fif.

Låt oss lägga till lite kod till sh-skriptet som helt enkelt kommer att duplicera den kompilerade filen in lotter-compiled-for-test.fif och ändra den sista raden i den.

# copy and change for test 
cp lottery-compiled.fif lottery-compiled-for-test.fif
sed '$d' lottery-compiled-for-test.fif > test.fif
rm lottery-compiled-for-test.fif
mv test.fif lottery-compiled-for-test.fif
echo -n "}END>s constant code" >> lottery-compiled-for-test.fif

Nu, för att kontrollera, låt oss köra det resulterande skriptet och en fil kommer att genereras lottery-compiled-for-test.fif, som vi kommer att ta med i vår lottery-test-suite.fif

В lottery-test-suite.fif radera kontraktskoden och lägg till en rad "lottery-compiled-for-test.fif" include.

Vi kör testerna för att kontrollera att de klarar.

~/TON/build/crypto/fift -s lottery-test-suite.fif

Bra, nu skapar vi en fil för att automatisera körningen av tester test.sh, som först kommer att uppträda build.sh, och kör sedan testerna.

touch test.sh
chmod +x test.sh

Vi skriver inuti

./build.sh 

echo "nCompilation completedn"

export FIFTPATH=~/TON/ton/crypto/fift/lib
~/TON/build/crypto/fift -s lottery-test-suite.fif

Låt oss göra test.sh och kör det för att se till att testerna fungerar.

chmod +x ./test.sh
./test.sh

Vi kontrollerar att kontraktet sammanställs och att testerna körs.

Bra, nu på start test.sh testerna kommer att kompileras och köras omedelbart. Här är länken till begå.

Okej, innan vi fortsätter, låt oss göra en sak till för bekvämlighets skull.

Låt oss skapa en mapp build där vi kommer att lagra det kompilerade kontraktet och dess klon skriven till konstanten lottery-compiled.fif, lottery-compiled-for-test.fif. Vi kommer också att skapa en mapp test där testfilen kommer att lagras lottery-test-suite.fif och eventuellt andra stödfiler. Länk till relevanta ändringar.

Låt oss fortsätta utveckla det smarta kontraktet.

Härnäst ska det vara ett test som kontrollerar att meddelandet tas emot och räknaren är uppdaterad i butiken när vi skickar rätt nummer. Men det gör vi senare.

Låt oss nu fundera på vilken datastruktur och vilken data som behöver lagras i ett smart kontrakt.

Jag kommer att beskriva allt som vi lagrar.

`seqno` 32-х битное целое положительное число счетчик. 

`pubkey` 256-ти битное целое положительное число публичный ключ, с помощью которого, мы будем проверять подпись отправленного извне сообщения, о чем ниже. 

`order_seqno` 32-х битное целое положительное число хранит счетчик количества ставок. 

`number_of_wins` 32-х битное целое положительное число хранит  количество побед. 

`incoming_amount` тип данных Gram (первые 4 бита отвечает за длину), хранит общее количество грамов, которые были отправлены на контртакт. 

`outgoing_amount` общее количество грамов, которое было отправлено победителям. 

`owner_wc` номер воркчейна, 32-х битное (в некоторых местах написано, что 8-ми битное) целое число. В данный момент всего два -1 и 0. 

`owner_account_id` 256-ти битное целое положительное число, адрес контракта в текущем воркчейне. 

`orders` переменная типа словарь, хранит последние двадцать ставок. 

Därefter måste du skriva två funktioner. Vi ringer den första pack_state(), som kommer att paketera data för efterföljande lagring i den smarta kontraktslagringen. Den andra ska vi kalla den unpack_state() kommer att läsa och returnera data från lagring.

_ pack_state(int seqno, int pubkey, int order_seqno, int number_of_wins, int incoming_amount, int outgoing_amount, int owner_wc, int owner_account_id, cell orders) inline_ref {
    return begin_cell()
            .store_uint(seqno, 32)
            .store_uint(pubkey, 256)
            .store_uint(order_seqno, 32)
            .store_uint(number_of_wins, 32)
            .store_grams(incoming_amount)
            .store_grams(outgoing_amount)
            .store_int(owner_wc, 32)
            .store_uint(owner_account_id, 256)
            .store_dict(orders)
            .end_cell();
}

_ unpack_state() inline_ref {
    var ds = begin_parse(get_data());
    var unpacked = (ds~load_uint(32), ds~load_uint(256), ds~load_uint(32), ds~load_uint(32), ds~load_grams(), ds~load_grams(), ds~load_int(32), ds~load_uint(256), ds~load_dict());
    ds.end_parse();
    return unpacked;
}

Vi lägger till dessa två funktioner i början av det smarta kontraktet. Det kommer att lösa sig så här mellanresultat.

För att spara data måste du anropa den inbyggda funktionen set_data() och det kommer att spela in data från pack_state() i den smarta kontraktslagringen.

cell packed_state = pack_state(arg_1, .., arg_n); 
set_data(packed_state);

Nu när vi har bekväma funktioner för att skriva och läsa data kan vi gå vidare.

Vi måste kontrollera att det inkommande meddelandet utifrån är undertecknat av kontraktets ägare (eller annan användare som har tillgång till den privata nyckeln).

När vi publicerar ett smart kontrakt kan vi initialisera det med den data vi behöver i lagringen, som kommer att sparas för framtida bruk. Vi kommer att skriva den publika nyckeln där så att vi kan verifiera att signaturen för det inkommande meddelandet gjordes med motsvarande privata nyckel.

Innan vi fortsätter, låt oss skapa en privat nyckel och skriva ner den test/keys/owner.pk. För att göra detta, låt oss köra Fift i interaktivt läge och köra fyra kommandon.

`newkeypair` генерация публичного и приватного ключа и запись их в стек. 

`drop` удаления из стека верхнего элемента (в данном случае публичный ключ)  

`.s` просто посмотреть что лежит в стеке в данный момент 

`"owner.pk" B>file` запись приватного ключа в файл с именем `owner.pk`. 

`bye` завершает работу с Fift. 

Låt oss skapa en mapp keys inuti mappen test och vi skriver den privata nyckeln där.

mkdir test/keys
cd test/keys
~/TON/build/crypto/fift -i 
newkeypair
 ok
.s 
BYTES:128DB222CEB6CF5722021C3F21D4DF391CE6D5F70C874097E28D06FCE9FD6917 BYTES:DD0A81AAF5C07AAAA0C7772BB274E494E93BB0123AA1B29ECE7D42AE45184128 
drop 
 ok
"owner.pk" B>file
 ok
bye

Vi ser filen i den aktuella mappen owner.pk.

Vi tar bort den publika nyckeln från stacken och kan hämta den från den privata vid behov.

Nu måste vi skriva en signaturkontroll. Låt oss börja med testet. Först läser vi den privata nyckeln från filen med hjälp av funktionen file>B och skriv det i en variabel owner_private_keyoch sedan använda funktionen priv>pub konvertera den privata nyckeln till en offentlig nyckel och skriv resultatet till owner_public_key.

variable owner_private_key
variable owner_public_key 

"./keys/owner.pk" file>B owner_private_key !
owner_private_key @ priv>pub owner_public_key !

Vi kommer att behöva båda nycklarna.

Initiera den smarta kontraktslagringen med godtyckliga data i samma sekvens som i funktionen pack_state()och skriv det i en variabel storage.

variable owner_private_key
variable owner_public_key 
variable orders
variable owner_wc
variable owner_account_id

"./keys/owner.pk" file>B owner_private_key !
owner_private_key @ priv>pub owner_public_key !
dictnew orders !
0 owner_wc !
0 owner_account_id !

<b 0 32 u, owner_public_key @ B, 0 32 u, 0 32 u, 0 Gram, 0 Gram, owner_wc @ 32 i, owner_account_id @ 256 u,  orders @ dict, b> storage !

Därefter kommer vi att komponera ett signerat meddelande, det kommer bara att innehålla signaturen och räknarvärdet.

Först skapar vi den data vi vill överföra, sedan signerar vi den med en privat nyckel och slutligen bildar vi ett signerat meddelande.

variable message_to_sign
variable message_to_send
variable signature
<b 0 32 u, b> message_to_sign !
message_to_sign @ hashu owner_private_key @ ed25519_sign_uint signature !
<b signature @ B, 0 32 u, b> <s  message_to_send !  

Som ett resultat skrivs meddelandet som vi skickar till det smarta kontraktet in i en variabel message_to_send, om funktioner hashu, ed25519_sign_uint du kan läsa i Fift-dokumentationen.

Och för att köra testet kallar vi det igen.

message_to_send @ 
recv_external 
code 
storage @
c7
runvmctx

Här så testfilen ska se ut så här i detta skede.

Låt oss köra testet och det kommer att misslyckas, så låt oss ändra det smarta kontraktet så att det kan ta emot meddelanden i detta format och kontrollera signaturen.

Först läser vi 512 bitar av signaturen från meddelandet och skriver dem till en variabel, sedan läser vi 32 bitar av räknarvariabeln.

Eftersom vi har en funktion för att läsa data från den smarta kontraktslagringen kommer vi att använda den.

Kontrollera sedan räknaren som överförts med lagringen och kontrollera signaturen. Om något inte matchar, slänger vi ett undantag med motsvarande kod.

var signature = in_msg~load_bits(512);
var message = in_msg;
int msg_seqno = message~load_uint(32);
(int stored_seqno, int pubkey, int order_seqno, int number_of_wins, int incoming_amount, int outgoing_amount, int owner_wc, int owner_account_id, cell orders) = unpack_state();
throw_unless(33, msg_seqno == stored_seqno);
throw_unless(34, check_signature(slice_hash(in_msg), signature, pubkey));

Motsvarande åtagande just här.

Låt oss köra testerna och se att det andra testet misslyckas. Av två skäl, inte tillräckligt med bitar i meddelandet och inte tillräckligt med bitar i lagringen, så koden kraschar vid analys. Vi måste lägga till en signatur i meddelandet vi skickar och kopiera lagringen från det senaste testet.

I det andra testet kommer vi att lägga till en meddelandesignatur och ändra den smarta kontraktslagringen. Här så så här ser testfilen ut för tillfället.

Låt oss skriva ett fjärde test där vi skickar ett meddelande signerat med någon annans privata nyckel. Låt oss skapa en annan privat nyckel och spara den i en fil not-owner.pk. Vi kommer att signera meddelandet med denna privata nyckel. Låt oss köra testerna och se till att alla tester klarar. Begå just nu.

Nu kan vi äntligen gå vidare till att implementera den smarta kontraktslogiken.
В recv_external() Vi accepterar två typer av meddelanden.

Eftersom vårt kontrakt kommer att ackumulera spelarnas förluster måste dessa pengar överföras till skaparen av lotteriet. Lotteriskaparens plånboksadress skrivs in i förrådet när kontraktet skapas.

För säkerhets skull behöver vi möjligheten att ändra adressen som vi ska skicka förlorarnas gram till. Vi ska även kunna skicka lottogram till ägarens adress.

Låt oss börja med den första. Låt oss först skriva ett test som kontrollerar att det smarta kontraktet efter att ha skickat ett meddelande har sparat den nya adressen i lagringen. Observera att vi förutom disken och den nya adressen även sänder i meddelandet action 7-bitars icke-negativt heltal, beroende på det kommer vi att välja hur vi ska behandla meddelandet i det smarta kontraktet.

<b 0 32 u, 1 @ 7 u, new_owner_wc @  32 i, new_owner_account_id @ 256 u, b> message_to_sign !

I testet kan du se hur deserialiseringen av den smarta kontraktslagringen sker storage i femte. Deserialisering av variabler beskrivs i Fift-dokumentationen.

Länk för att begå med tillsats av deg.

Låt oss köra testet och se till att det misslyckas. Låt oss nu lägga till logik för att ändra lotteriägarens adress.

I det smarta kontraktet fortsätter vi att analysera message, läser vi in action. Låt oss påminna dig om att vi kommer att ha två action: adressändring och skicka gram.

Sedan läser vi den nya adressen till kontraktsägaren och sparar den i förrådet.
Vi kör testerna och ser att det tredje testet misslyckas. Det kraschar eftersom kontraktet nu dessutom analyserar 7 bitar från meddelandet, som saknas i testet. Låt oss lägga till en icke-existerande i meddelandet action. Låt oss köra testerna och se att de alla klarar sig. Här åta sig förändringar. Stor.

Låt oss nu skriva logiken för att skicka det angivna antalet gram till den tidigare sparade adressen.

Låt oss skriva ett test först. Vi kommer att skriva två test, ett när balansen inte räcker till, det andra när allt ska gå bra. Testerna kan ses i detta åtagande.

Låt oss nu skriva klart koden. Låt oss först skriva två hjälpmetoder. Den första get-metoden är att ta reda på det aktuella saldot för ett smart kontrakt.

int balance() inline_ref method_id {
    return get_balance().pair_first();
}

Och den andra är för att skicka gram till ett annat smart kontrakt. Jag kopierade den här metoden helt från ett annat smart kontrakt.

() send_grams(int wc, int addr, int grams) impure {
    ;; int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool src:MsgAddress -> 011000
    cell msg = begin_cell()
    ;;  .store_uint(0, 1) ;; 0 <= format indicator int_msg_info$0 
    ;;  .store_uint(1, 1) ;; 1 <= ihr disabled
    ;;  .store_uint(1, 1) ;; 1 <= bounce = true
    ;;  .store_uint(0, 1) ;; 0 <= bounced = false
    ;;  .store_uint(4, 5)  ;; 00100 <= address flags, anycast = false, 8-bit workchain
        .store_uint (196, 9)
        .store_int(wc, 8)
        .store_uint(addr, 256)
        .store_grams(grams)
        .store_uint(0, 107) ;; 106 zeroes +  0 as an indicator that there is no cell with the data.
        .end_cell(); 
    send_raw_message(msg, 3); ;; mode, 2 for ignoring errors, 1 for sender pays fees, 64 for returning inbound message value
}

Låt oss lägga till dessa två metoder till det smarta kontraktet och skriva logiken. Först analyserar vi antalet gram från meddelandet. Därefter kontrollerar vi saldot, om det inte finns tillräckligt gör vi ett undantag. Om allt är bra skickar vi grammen till den sparade adressen och uppdaterar räknaren.

int amount_to_send = message~load_grams();
throw_if(36, amount_to_send + 500000000 > balance());
accept_message();
send_grams(owner_wc, owner_account_id, amount_to_send);
set_data(pack_state(stored_seqno + 1, pubkey, order_seqno, number_of_wins, incoming_amount, outgoing_amount, owner_wc, owner_account_id, orders));

Här så hur ett smart kontrakt ser ut för tillfället. Låt oss köra testerna och se till att de blir godkända.

Förresten, en provision debiteras det smarta kontraktet varje gång ett meddelande behandlas. För att det smarta kontraktet ska uppfylla begäran måste du efter grundläggande kontroller ringa accept_message().

Låt oss nu gå vidare till interna meddelanden. Faktum är att vi bara accepterar gram och skickar tillbaka dubbla beloppet till spelaren om han vinner och en tredjedel till ägaren om han förlorar.

Låt oss först skriva ett enkelt test. För att göra detta behöver vi en testadress för det smarta kontraktet från vilket vi skickar gram till det smarta kontraktet.

Den smarta kontraktsadressen består av två siffror, ett 32-bitars heltal som ansvarar för arbetskedjan och ett 256-bitars icke-negativt heltals unikt kontonummer i denna arbetskedja. Till exempel, -1 och 12345, kommer vi att spara denna adress i en fil.

Jag kopierade funktionen för att spara adressen från TonUtil.fif.

// ( wc addr fname -- )  Save address to file in 36-byte format
{ -rot 256 u>B swap 32 i>B B+ swap B>file } : save-address

Låt oss ta en titt på hur funktionen fungerar, detta kommer att ge oss en förståelse för hur Fift fungerar. Låt oss starta Fift i interaktivt läge.

~/TON/build/crypto/fift -i 

Först lägger vi -1, 12345 och namnet på den framtida filen "sender.addr" i stacken:

-1 12345 "sender.addr" 

Nästa steg är att utföra funktionen -rot, som skiftar stacken så att det unika smarta kontraktsnumret är överst i stacken:

"sender.addr" -1 12345

256 u>B Konverterar ett 256-bitars icke-negativt heltal till byte.

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap byter ut de två översta elementen i stacken.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B Konverterar ett 32-bitars heltal till byte.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 BYTES:FFFFFFFF

B+ sammanfogar två sekvenser av byte.

 "sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF

igen swap.

BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF "sender.addr" 

Och slutligen skrivs byten till filen. B>file. Efter detta är vår stack tom. Vi slutar Fift. En fil har skapats i den aktuella mappen. sender.addr. Låt oss flytta filen till den skapade mappen test/addresses/.

Låt oss skriva ett enkelt test som skickar gram till ett smart kontrakt. Här är engagemanget.

Låt oss nu gå ner till lotteriets logik.

Det första vi gör är att kontrollera meddelandet bounced eller inte, om bounced, då ignorerar vi det. bounced innebär att kontraktet kommer att returnera gram om något fel uppstår. Vi returnerar inte gram om ett fel uppstår.

Vi kontrollerar, om saldot är mindre än ett halvt gram, accepterar vi helt enkelt meddelandet och ignorerar det.

Därefter analyserar vi adressen till det smarta kontraktet som meddelandet kom från.

Vi läser data från lagringen och raderar sedan gamla insatser från historiken om det finns fler än tjugo av dem. För enkelhetens skull skrev jag ytterligare tre funktioner pack_order(), unpack_order(), remove_old_orders().

Därefter tittar vi, om saldot inte räcker för betalningen, anser vi att detta inte är en satsning, utan en påfyllning och vi sparar påfyllningen i orders.

Nu, äntligen, kärnan i ett smart kontrakt.

Först, om spelaren förlorar, sparar vi det i spelhistoriken och om beloppet är mer än 3 gram skickar vi 1/3 till ägaren av det smarta kontraktet.

Om spelaren vinner skickar vi det dubbla beloppet till spelarens adress och sparar sedan insatsinformationen i historiken.

() recv_internal(int order_amount, cell in_msg_cell, slice in_msg) impure {
    var cs = in_msg_cell.begin_parse();
    int flags = cs~load_uint(4);  ;; int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool
    if (flags & 1) { ;; ignore bounced
        return ();
    }
    if (order_amount < 500000000) { ;; just receive grams without changing state 
        return ();
    }
    slice src_addr_slice = cs~load_msg_addr();
    (int src_wc, int src_addr) = parse_std_addr(src_addr_slice);
    (int stored_seqno, int pubkey, int order_seqno, int number_of_wins, int incoming_amount, int outgoing_amount, int owner_wc, int owner_account_id, cell orders) = unpack_state();
    orders = remove_old_orders(orders, order_seqno);
    if (balance() < 2 * order_amount + 500000000) { ;; not enough grams to pay the bet back, so this is re-fill
        builder order = pack_order(order_seqno, 1, now(), order_amount, src_wc, src_addr);
        orders~udict_set_builder(32, order_seqno, order);
        set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins, incoming_amount + order_amount, outgoing_amount, owner_wc, owner_account_id, orders));
        return ();
    }
    if (rand(10) >= 4) {
        builder order = pack_order(order_seqno, 3, now(), order_amount, src_wc, src_addr);
        orders~udict_set_builder(32, order_seqno, order);
        set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins, incoming_amount + order_amount, outgoing_amount, owner_wc, owner_account_id, orders));
        if (order_amount > 3000000000) {
            send_grams(owner_wc, owner_account_id, order_amount / 3);
        }
        return ();
    }
    send_grams(src_wc, src_addr, 2 * order_amount);
    builder order = pack_order(order_seqno, 2, now(), order_amount, src_wc, src_addr);
    orders~udict_set_builder(32, order_seqno, order);
    set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins + 1, incoming_amount, outgoing_amount + 2 * order_amount, owner_wc, owner_account_id, orders));
}

Det var allt. Motsvarande åtagande.

Nu är det enkelt: låt oss skapa get-metoder så att vi kan få information om kontraktets tillstånd från omvärlden (läs faktiskt data från den smarta kontraktslagringen).

Låt oss lägga till get-metoder. Vi kommer att skriva nedan om hur du får information om ett smart kontrakt.

Jag glömde också lägga till koden som ska hantera den allra första förfrågan som uppstår när det smarta kontraktet publiceras. Motsvarande åtagande. Och en sak till rättad bugg med att skicka 1/3 av beloppet till ägarens konto.

Allt som återstår är att publicera det smarta kontraktet. Låt oss skapa en mapp requests.

Jag tog publiceringskoden som grund simple-wallet-code.fc который kan hittas i det officiella arkivet.

Här är några saker värda att uppmärksamma. Vi bildar en smart avtalslagring och ett ingångsmeddelande. Efter detta genereras den smarta kontraktsadressen, det vill säga adressen är känd redan innan publicering i TON. Därefter måste du skicka några gram till den här adressen och först efter det behöver du skicka filen med själva det smarta kontraktet, eftersom nätverket tar en provision för att lagra det smarta kontraktet och operationer i det (validatorer som lagrar och utför smarta kontrakt). Koden kan ses här.

Därefter kör vi publiceringskoden och hämtar lottery-query.boc fil och adress för det smarta kontraktet.

~/TON/build/crypto/fift -s requests/new-lottery.fif 0

Glöm inte att spara de genererade filerna: lottery-query.boc, lottery.addr, lottery.pk.

Vi kommer bland annat att se den smarta kontraktsadressen i exekveringsloggarna.

new wallet address = 0:044910149dbeaf8eadbb2b28722e7d6a2dc6e264ec2f1d9bebd6fb209079bc2a 
(Saving address to file lottery.addr)
Non-bounceable address (for init): 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd
Bounceable address (for later access): kQAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8KpFY

Låt oss för skojs skull göra en förfrågan till TON

$ ./lite-client/lite-client -C ton-lite-client-test1.config.json 
getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

Och vi kommer att se att kontot med den här adressen är tomt.

account state is empty

Vi skickar till adressen 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd 2 gram och efter några sekunder kör vi samma kommando. För att skicka gram använder jag officiell plånbok, och du kan be om testgram från någon från chatten, vilket jag kommer att prata om i slutet av artikeln.

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

Ser ut som en oinitierad ( har dykt upp på nätverketstate:account_uninit) ett smart kontrakt med en sådan adress och ett saldo på 1 000 000 000 nanogram.

account state is (account
  addr:(addr_std
    anycast:nothing workchain_id:0 address:x044910149DBEAF8EADBB2B28722E7D6A2DC6E264EC2F1D9BEBD6FB209079BC2A)
  storage_stat:(storage_info
    used:(storage_used
      cells:(var_uint len:1 value:1)
      bits:(var_uint len:1 value:103)
      public_cells:(var_uint len:0 value:0)) last_paid:1583257959
    due_payment:nothing)
  storage:(account_storage last_trans_lt:3825478000002
    balance:(currencies
      grams:(nanograms
        amount:(var_uint len:4 value:2000000000))
      other:(extra_currencies
        dict:hme_empty))
    state:account_uninit))
x{C00044910149DBEAF8EADBB2B28722E7D6A2DC6E264EC2F1D9BEBD6FB209079BC2A20259C2F2F4CB3800000DEAC10776091DCD650004_}
last transaction lt = 3825478000001 hash = B043616AE016682699477FFF01E6E903878CDFD6846042BA1BFC64775E7AC6C4
account balance is 2000000000ng

Låt oss nu publicera det smarta kontraktet. Låt oss starta lite-klient och köra den.

> sendfile lottery-query.boc
[ 1][t 2][1583008371.631410122][lite-client.cpp:966][!testnode] sending query from file lottery-query.boc
[ 3][t 1][1583008371.828550100][lite-client.cpp:976][!query]    external message status is 1 

Låt oss kontrollera att kontraktet är publicerat.

> last
> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

Vi ska bland annat ta emot.

  storage:(account_storage last_trans_lt:3825499000002
    balance:(currencies
      grams:(nanograms
        amount:(var_uint len:4 value:1987150999))
      other:(extra_currencies
        dict:hme_empty))
    state:(account_active

Vi ser det account_active.

Motsvarande åtagande med ändringar just här.

Låt oss nu skapa förfrågningar för att interagera med det smarta kontraktet.

Närmare bestämt kommer vi att lämna den första för att ändra adressen som ett oberoende verk, och vi kommer att göra den andra för att skicka gram till ägarens adress. Faktum är att vi måste göra samma sak som i testet för att skicka gram.

Detta är meddelandet vi kommer att skicka till det smarta kontraktet, där msg_seqno 165 action 2 och 9.5 gram för frakt.

<b 165 32 u, 2 7 u, 9500000000 Gram, b>

Glöm inte att signera meddelandet med en privat nyckel lottery.pk, som genererades tidigare när det smarta kontraktet skapades. Här är motsvarande kommitté.

Få information från ett smart kontrakt med get-metoder

Låt oss nu titta på hur man kör smarta kontrakt få metoder.

Vi lanserar lite-client och kör get-metoderna vi skrev.

$ ./lite-client/lite-client -C ton-lite-client-test1.config.json
> runmethod 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd balance
arguments:  [ 104128 ] 
result:  [ 64633878952 ] 
...

В result innehåller värdet som funktionen returnerar balance() från vårt smarta kontrakt.
Vi kommer att göra detsamma för flera fler metoder.

> runmethod 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd get_seqno
...
arguments:  [ 77871 ] 
result:  [ 1 ] 

Låt oss begära vadslagningshistoriken.

> runmethod 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd get_orders
...
arguments:  [ 67442 ] 
result:  [ ([0 1 1583258284 10000000000 0 74649920601963823558742197308127565167945016780694342660493511643532213172308] [1 3 1583258347 4000000000 0 74649920601963823558742197308127565167945016780694342660493511643532213172308] [2 1 1583259901 50000000000 0 74649920601963823558742197308127565167945016780694342660493511643532213172308]) ] 

Vi kommer att använda lite-klient och get-metoder för att visa information om det smarta kontraktet på sajten.

Visar smart kontraktsdata på webbplatsen

Jag skrev en enkel Python-webbplats för att visa smarta kontraktsdata på ett bekvämt sätt. Jag kommer inte att gå in i detalj om det här och kommer att publicera sidan i ett åtagande.

Förfrågningar till TON görs från Python via lite-client. För enkelhetens skull är webbplatsen förpackad i Docker och publicerad på Google Cloud. Länk.

Låt oss försöka

Låt oss nu försöka skicka gram dit att fylla på från handväska. Vi skickar 40 gram. Och låt oss göra ett par satsningar för tydlighetens skull. Vi ser att sidan visar historiken för vad, den aktuella vinstprocenten och annan användbar information.

Vi ser, att vi vann den första och förlorade den andra.

efterordet

Artikeln visade sig vara mycket längre än jag förväntade mig, kanske kunde den ha varit kortare, eller så kanske den är helt rätt för en person som inte vet något om TON och vill skriva och publicera ett inte så enkelt smart kontrakt med möjligheten att interagera med det. Vissa saker kunde kanske ha förklarats enklare.

Kanske kunde vissa aspekter av implementeringen ha gjorts mer effektivt och elegant, men då hade det tagit ännu mer tid att förbereda artikeln. Det är också möjligt att jag gjorde ett misstag någonstans eller inte förstod något, så om du gör något allvarligt måste du lita på den officiella dokumentationen eller det officiella förrådet med TON-koden.

Det bör noteras att eftersom TON själv fortfarande är i det aktiva utvecklingsstadiet kan förändringar inträffa som kommer att bryta något av stegen i den här artikeln (vilket är vad som hände medan jag skrev, jag har redan korrigerat det), men det generella tillvägagångssättet kommer sannolikt inte att förändras.

Jag kommer inte att prata om framtiden för TON. Kanske kommer plattformen att bli något större och vi borde lägga tid på att studera den och ockupera nischen med våra produkter nu.

Det finns också Libra från Facebook, som har en potentiell publik av användare större än TON. Jag vet nästan ingenting om Vågen, av forumet att döma är det mycket mer aktivitet där än i TON-communityt. Även om utvecklarna och TON-communityt är mer som underground, vilket också är coolt.

referenser

1. Officiell TON-dokumentation: https://test.ton.org
2. Officiellt TON-förråd: https://github.com/ton-blockchain/ton
3. Officiell plånbok för olika plattformar: https://wallet.ton.org
4. Smart kontraktsförråd från denna artikel: https://github.com/raiym/astonished
5. Länk till webbplatsen för smart kontrakt: https://ton-lottery.appspot.com
6. Visual Studio Code tilläggsförråd för FunC: https://github.com/raiym/func-visual-studio-plugin
7. En chatt om TON i Telegram, som verkligen hjälpte mig att ta reda på det i det inledande skedet. Jag tror att det inte kommer att vara ett misstag om jag säger att alla som skrivit något för TON är där. Du kan också be om provgram där. https://t.me/tondev_ru
8. En annan chatt om TON där jag hittade användbar information: https://t.me/TONgramDev
9. Första etappen av tävlingen: https://contest.com/blockchain
10. Andra etappen av tävlingen: https://contest.com/blockchain-2

Källa: will.com