Så skriver och publicerar du ett smart kontrakt i TON

Vad handlar denna artikel om?

I artikeln kommer jag att berätta om hur jag deltog i den första (av två) Telegram-tävlingen om blockchain, jag erhöll ingen prisplats och beslutade att dokumentera min erfarenhet i artikeln så att den inte skulle gå förlorad och kanske hjälpa någon.

Eftersom jag inte ville skriva en abstrakt kod utan göra något fungerande, skrev jag för artikeln ett smart kontrakt för en snabblott och en webbplats som visar data från det smarta kontraktet direkt från TON utan att använda mellanlagringslösningar.

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

Med hjälp av lotteriet kommer jag att gå igenom allt från installation av miljön till publicering av det smarta kontraktet, interaktion med det och skriva en webbplats för att hämta och publicera data.

Om deltagande i tävlingen

I oktober förra året tillkännagav Telegram en blockchain-tävling med nya språk Fift och FunC. Man behövde välja och skriva något av de fem föreslagna smarta kontrakten. Jag ansåg att det skulle vara kul att syssla med något ovanligt, lära mig språket och göra något, även om jag inte skulle behöva skriva något mer i framtiden. Dessutom är ämnet ständigt aktuellt.

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

Jag planerade att delta ända tills det inte gick längre och skriva en översiktsartikel efteråt, men jag misslyckades direkt i början. Jag skrev en plånbok med flera signaturer på FunC och den fungerade generellt. Jag tog ett smart kontrakt på Solidity som grund..

Vid den tiden ansåg jag att detta definitivt skulle räcka för att åtminstone få någon prisplats. Slutligen blev cirka 40 av 60 deltagare pristagare och jag var inte bland dem. I allmänhet är det inget att oroa sig för, men en sak gjorde mig nervös. Vid tidpunkten för resultatets tillkännagivande hade ingen granskning med test av mitt kontrakt gjorts, jag frågade deltagarna i chatten om det fanns någon annan som inte hade det, men det fanns det inte.

Tydligen, efter att ha uppmärksammat mina meddelanden, publicerade domarna en kommentar efter två dagar och jag förstod aldrig om de av misstag hade missat mitt smarta kontrakt under bedömningen eller bara tyckte att det var så dåligt att det inte behövde någon kommentar. Jag ställde en fråga på sidan, men fick inget svar. Även om vem som bedömde — är ingen hemlighet, tyckte jag att det var överflödigt att skriva privata meddelanden.

Mycket tid har lagts på förståelsen, så det beslutades att skriva en artikel. Eftersom informationen fortfarande är ganska begränsad, kommer artikeln att hjälpa alla intresserade att spara tid.

Konceptet för smarta kontrakt i TON

Innan man skriver något måste man förstå hur man ska angripa denna sak. Därför kommer jag nu att berätta vilka delar systemet består av. Närmare bestämt vilka delar man behöver veta för att skriva åtminstone ett fungerande kontrakt.

Vi kommer att fokusera på att skriva ett smart kontrakt och arbeta med TON Virtual Machine (TVM), Fift och FunC, så artikeln liknar mer en beskrivning av utvecklingen av ett vanligt program. Vi kommer inte att stanna vid hur själva plattformen fungerar.

Generellt sett finns det en bra officiell dokumentation om hur TVM och språket Fift är utformad. Under deltagandet i tävlingen och nu under skrivandet av det aktuella kontraktet har jag ofta refererat till den.

Det huvudsakliga språket för att skriva smarta kontrakt är FunC. För tillfället finns det ingen dokumentation, så för att skriva något måste man studera exempel på smarta kontrakt från det officiella arkivet och själva implementationen av språket där, plus man kan titta på exempel på smarta kontrakt från de två senaste tävlingarna. Länkar finns i slutet av artikeln.

Anta att vi redan har skrivit ett smart kontrakt i FunC, efter detta kompilerar vi koden till Fift-assembler.

Det kompilerade smarta kontraktet återstår att publicera. För detta behöver man skriva en funktion i Fift, som tar in koden för det smarta kontraktet och några ytterligare parametrar, och som ger ut en fil med tillägget .boc (vilket betyder "bag of cells"), och beroende på hur vi skriver, den privata nyckeln och adressen som genereras baserat på koden för det smarta kontraktet. Till adressen för det smarta kontraktet, som ännu inte har publicerats, kan man redan skicka gram.

För att publicera det smarta kontraktet i TON måste den erhållna .boc filen skickas till blockchainen med hjälp av en lättklient (om detta nedan). Men innan publiceringen måste man överföra gram till den genererade adressen, annars kommer det smarta kontraktet inte att publiceras. Efter publiceringen kan man interagera med det smarta kontraktet genom att skicka meddelanden till det utifrån (till exempel via en lättklient) eller inifrån (till exempel att ett smart kontrakt skickar ett meddelande till ett annat inom TON).

När vi väl förstod hur koden publiceras blir det enklare. Vi har en ungefärlig idé om vad vi vill skriva och hur vårt program kommer att fungera. Under skrivprocessen söker vi efter hur detta redan har implementerats i befintliga smarta kontrakt, eller kollar i implementationskoden. Fift och FunC i det officiella arkivet, eller ser på den officiella dokumentationen.

Jag har ofta sökt efter nyckelord i Telegram-chatten där alla deltagare i tävlingen och anställda på Telegram var samlade. Det visade sig att under tävlingen samlades alla där för att diskutera Fift och FunC. Länken finns i slutet av artikeln.

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

Förberedelse av miljön för att arbeta med TON.

Allt som beskrivs i artikeln utförde jag på MacOS och verifierade även i en ren Ubuntu 18.04 LTS på Docker.

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

Instruktionen på den officiella webbplatsen beskriver installationsprocessen ganska detaljerat och hoppar över vissa detaljer. Här följer vi instruktionerna samtidigt som vi installerar de saknade beroendena. Jag valde att inte själv kompilera varje projekt utan installerade från det officiella Ubuntu-arkivet (på MacOS använde jag 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 vi installera. lite-client, Fift, FunC.

Först klonar vi TON-arkivet tillsammans med dess beroenden. För smidighetens skull gör vi allt i mappen ~\/TON.

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

I arkivet finns också implementationer. Fift och FunC.

Nu är vi redo att bygga projektet. Koden från arkivet har klonats till mappen ~\/TON\/ton. I ~\/TON vi skapar en mapp build och bygger projektet i den.

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

Eftersom vi planerar att skriva ett smart kontrakt behöver vi inte bara lite-clientoch även Fift med FunC, så vi kompilerar allt. Det är inte en snabb process, så vi väntar.

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

Därefter laddar vi ner konfigurationsfilen som innehåller information om noden som lite-client kommer att kopplas upp.

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

Vi gör våra första förfrågningar till TON.

Nu startar vi. lite-client.

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

Om bygget lyckades kommer du efter att ha startat att se loggen för den lätta klientens anslutning 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 är tillgängliga.

help

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

lista över tillgängliga kommandon:
last    Hämtar senaste blocket och statusinformation från servern
sendfile  Laddar en serialiserad meddelande från  och skickar det till servern
getaccount  [<block-id-ext>]  Laddar det mest aktuella tillståndet av angiven konto;  är i [<workchain>:]<hex-or-base64-addr> format
runmethod  [<block-id-ext>] <method-id> <params>...   Kör GET-metod <method-id> av konto <addr> med angivna parametrar

last hämtar det senaste skapade blocket från servern.

sendfile  skickar en fil med meddelandet till TON, med denna kommandopubliceras smartkontrakt och förfrågningar till det.

getaccount  laddar det aktuella tillståndet av smartkontraktet med den angivna adressen.

runmethod  [<block-id-ext>] <method-id> <params>  kör GET-metoder av smartkontraktet. 

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

Implementering

Tanken

Som jag nämnde tidigare, det smartkontrakt som vi skriver är en lotteri.

Det är inte en lotteri där du måste köpa en biljett och vänta en timme, dag eller månad, utan en omedelbar där användaren skickar gram till kontraktadressen N och får omedelbart tillbaka 2 * N gram eller förlorar. Vi sätter vinstchanserna till omkring 40%. Om det inte finns tillräckligt med gram för utbetalning, kommer vi att betrakta transaktionen som en påfyllning.

Det är viktigt att satsningarna kan ses i realtid och på ett bekvämt sätt så att användaren omedelbart kan förstå om de vunnit eller förlorat. Därför behöver vi skapa en webbplats som visar satsningarna och resultaten direkt från TON.

Skrivande av smartkontrakt

För enkelhetens skull har jag skapat syntaktisk markering för FunC, plugin kan hittas och installeras i Visual Studio Code-sökningen. Om någon vill lägga till något så har jag gjort pluginen tillgänglig offentligt. Tidigare har även någon gjort en plugin för Fift, som också kan hittas och installeras i VSC.

Låt oss genast skapa ett repository dit vi kommer att commita mellanresultaten.

För att underlätta livet kommer vi att skriva smartkontraktet och testa lokalt tills det är klart. Endast efter det publicerar vi det i TON.

Smartkontraktet har två externa metoder som man kan anropa. Första, recv_external() denna funktion utförs när en begäran till kontraktet kommer från den externa världen, alltså inte från TON, till exempel när vi själva formar meddelandet och skickar det genom lite-client. Andra, recv_internal() det är när någon kontrakt inuti TON anropar vårt. I båda fallen kan parametrar skickas till funktionen.

Låt oss börja med ett enkelt exempel som kommer att fungera när det publiceras, men som inte har någon funktionell belastning.

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

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

Det här behöver förklaras vad som är slice. All data som lagras i TON Blockchain är en samling TVM cell eller helt enkelt cell, i en sådan cell kan man lagra upp till 1023 bit data och upp till 4 länkar till andra celler.

TVM cell slice eller slice är en del av en befintlig cell används för att parsa den, och senare kommer det att bli tydligt. Huvudsaken för oss är att vi kan skicka slice och beroende på typ av meddelande hantera data i recv_external() eller recv_internal().

impure – ett nyckelord som anger att funktionen ändrar datan i smartkontraktet.

Vi kommer att spara kontraktskoden i lottery-code.fc och kompilera den.

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

Värdet av flaggorna kan kontrolleras med kommandot

~\/TON\/build\/crypto\/func -help

Vi har fått en kompilerad Fift-assemblerkod i 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

Den kan köras lokalt, så vi förbereder miljön.

Vi noterar att den första raden inkluderar Asm.fif, detta är kod skriven i Fift för Fift-assembler.

Eftersom vi vill köra och testa smartkontraktet lokalt skapar vi en fil lottery-test-suite.fif och kopierar dit den kompilerade koden, och byter ut sista raden som skriver smartkontraktkoden till en konstant code, för att senare skicka 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

Det verkar klart hittills, nu lägger vi till kod i samma fil som vi ska använda för att köra TVM.

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 \/\/ för att köra recv_internal() 
-1 constant recv_external \/\/ för att anropa recv_external()

I c7 vi skriver ner kontexten, det vill säga data som TVM kommer att köras med (eller nätverksstatus). Redan under tävlingen visade en av utvecklarna hur man skapar c7 och jag kopierade det. I denna artikel kan vi behöva ändra på rand_seed eftersom det påverkar genereringen av ett slumpmässigt tal och inte ska ändras, så kommer samma tal alltid att returneras.

recv_internal och recv_external konstanter med värdena 0 och -1 kommer att svara för anropet av motsvarande funktioner i smartkontraktet.

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

Skapa en variabel lagring och skriv ett tomt värde i den. cell, detta kommer att vara lagringsutrymmet för smartkontraktet.

meddelande detta är meddelandet som vi kommer att skicka till smartkontraktet utifrån. Vi kommer också att göra det tomt för tillfället.

variabel lagring 
<b b> lagring ! 

variabel meddelande 
<b b> meddelande ! 

Efter att vi har förberett konstanterna och variablerna startar vi TVM med kommandot runvmctx och överför de skapade parametrarna som indata.

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx 

Resultatet blir en sådan här intermediär kod på Fift.

Nu kan vi köra den resulterande koden.

export FIFTPATH=~\/TON\/ton\/crypto\/fift\/lib \/\/ körs en gång för bekvämlighet 
~\/TON\/build\/crypto\/fift -s lottery-test-suite.fif 

Programmet ska fungera utan fel och i utskriften ser vi exekveringsloggen:

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

Utmärkt, vi har skrivit den första fungerande versionen av smartkontraktet.

Nu måste vi lägga till funktionalitet. Först ska vi hantera meddelandena som kommer från den externa världen till recv_external()

Utvecklaren väljer själv meddelandeformatet som kontraktet kan ta emot.

Men vanligtvis,

• För det första vill vi skydda vårt kontrakt från den externa världen och se till att endast kontraktets ägare kan skicka externa meddelanden till det.
• För det andra, när vi skickar ett giltigt meddelande till TON vill vi att detta inträffar exakt en gång och att smartkontraktet avvisar samma meddelande om det skickas igen.

Därför hanteras nästan alltid dessa två problem i varje kontrakt; eftersom vårt kontrakt tar emot externa meddelanden, måste vi också ta hand om detta.

Vi ska göra det i omvänd ordning. Först löser vi problemet med upprepning: om kontraktet redan har mottagit ett sådant meddelande och behandlat det, kommer det inte att utföra det en andra gång. Och därefter löser vi problemet med att endast en viss krets personer kan skicka meddelanden till smartkontraktet.

Det finns olika sätt att lösa problemet med återkommande meddelanden. Vi gör så här. I smartkontraktet initierar vi en räknare för mottagna meddelanden med ett ursprungligt värde på 0. I varje meddelande lägger vi till det aktuella värdet på räknaren i smartkontraktet. Om värdet på räknaren i meddelandet inte stämmer överens med värdet i smartkontraktet kommer vi inte att bearbeta det, om det stämmer överens kommer vi att bearbeta det och öka räknaren i smartkontraktet med 1.

Vi återvänder till lottery-test-suite.fif och lägger till ett andra test. Vi skickar ett felaktigt nummer, koden ska kasta ett undantag. Låt oss säga att kontraktsdata lagrar 166, men vi skickar 165.

<b 166 32 u, b> lagring !
<b 165 32 u, b> meddelande !

meddelande @ 
recv_external 
kod 
lagring @ 
c7 
runvmctx

tappa 
exit_code ! 
."Utgångskod " exit_code @ . cr 
exit_code @ 33 - abort"Test #2 Godkänd"

Vi kör.

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

Och vi ser att testet körs med ett fel.

[ 1][t 0][1582283084.210902214][words.cpp:3046] lottery-test-suite.fif:67: abort": Test #2 Inte passerat
[ 1][t 0][1582283084.210941076][fift-main.cpp:196]      Fel vid tolkning av fil `lottery-test-suite.fif`: fel vid tolkning av inkluderad fil `lottery-test-suite.fif` : lottery-test-suite.fif:67: abort": Test #2 Inte passerat

I detta skede lottery-test-suite.fif borde se ut som via länken.

Nu låt oss lägga till logiken för räknaren i smartkontraktet i 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);
}

I slice in_msg innehåller meddelandet som vi skickar.

Det första vi gör är att kontrollera om det finns data i meddelandet; om inte, går vi helt enkelt ut.

Därefter parser vi meddelandet. in_msg~load_uint(32) laddar talet 165, 32-bitars unsigned int från det mottagna meddelandet.

Därefter laddar vi 32 bitar från smartkontraktets lagring. Vi kontrollerar att det laddade talet stämmer överens med det skickade; om inte kastar vi ett undantag. I vårt fall, eftersom vi skickar något som inte stämmer, ska ett undantag kastas.

Nu kompilera vi.

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

Vi kopierar den resulterande koden till lottery-test-suite.fif, utan att glömma att ersätta sista raden.

Kontrollera att testet går igenom:

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

Här kan du se den aktuella commit med resultaten.

Vi noterar att det är besvärligt att ständigt kopiera den kompilerade koden för smartkontraktet till testfilen, så låt oss skriva ett skript som automatiskt skriver koden till en konstant för oss, och vi kopplar enkelt in den kompilerade koden i våra tester med hjälp av "include".

I projektmappen skapar vi filen 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

Vi gör den körbar.

chmod +x .\/build.sh

Nu behöver vi bara köra vårt skript för att kompilera kontraktet. Men bortsett från det måste vi spara det i en konstant. code. Därför kommer vi att skapa en ny fil. lotter-compiled-for-test.fif, som vi kommer att inkludera i filen. lottery-test-suite.fif.

Lägg till kod i sh-skriptet som helt enkelt duplicerar den kompilerade filen i lotter-compiled-for-test.fif och ändrar 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, kör vi det resulterande skriptet och en fil kommer att genereras för oss. lottery-compiled-for-test.fif, som vi kommer att inkludera i vår lottery-test-suite.fif

I lottery-test-suite.fif tar bort kontraktskoden och lägger till raden "lottery-compiled-for-test.fif" include.

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

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

Utmärkt, nu för att automatisera körningen av testerna skapar vi filen test.sh, som först kommer att köra build.sh, och sedan starta testerna.

touch test.sh
chmod +x test.sh

Inuti skriver vi

.\/build.sh 

echo "nKompileringen avslutadn"

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öra för att säkerställa att testerna fungerar.

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

Vi kontrollerar att kontraktet kompileras och att testerna körs.

Utmärkt, nu kommer kompilering och körning av tester att ske direkt. test.sh Här är länken till commit.

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

Vi skapar en mapp build där vi kommer att lagra det kompilerade kontraktet och dess klon sparad i en konstant. lottery-compiled.fif, lottery-compiled-for-test.fif. Vi skapar också en mapp test där filen med testerna kommer att lagras lottery-test-suite.fif och potentiellt andra hjälpfiler. Länk till relevanta ändringar.

Vi fortsätter utvecklingen av smartkontraktet.

Nästa steg bör vara ett test som kontrollerar att meddelandet tas emot och att räknaren uppdateras i lagret när vi skickar rätt nummer. Men vi gör det senare.

Nu tänker vi på vilken databasstruktur och vilka data som behöver sparas i smartkontraktet.

Jag kommer att beskriva allt vi sparar.

`seqno` 32-bit heltal som räknare. 

`pubkey` 256-bit heltal, den offentliga nyckeln vi kommer att använda för att verifiera signaturen av det externa meddelandet, som nämns nedan. 

`order_seqno` 32-bit heltal som lagrar räknaren för antalet bud. 

`number_of_wins` 32-bit heltal som lagrar antalet vinster. 

`incoming_amount` datatyp Gram (de första 4 biterna representerar längden), lagrar det totala antalet gram som har skickats till kontraktet. 

`outgoing_amount` det totala antalet gram som har skickats till vinnarna. 

`owner_wc` nummer för arbetskedjan, 32-bit (i vissa fall anges det som 8-bit) heltal. För närvarande finns det bara två -1 och 0. 

`owner_account_id` 256-bit heltal, adressen för kontraktet i den aktuella arbetskedjan. 

`orders` variabel av typ ordbok, lagrar de senaste tjugo buden. 

Nästa steg är att skriva två funktioner. Den första kommer vi att kalla pack_state(), som kommer att paketera data för senare lagring i smartkontraktet. Den andra, vi kommer att kalla unpack_state() kommer att läsa och returnera data från lagringen.

_ 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 smartkontraktet. Resultatet blir en sådan här ett mellanresultat.

För att spara data behöver vi anropa den inbyggda funktionen set_data() och den kommer att spara data från pack_state() till lagringen av smartkontraktet.

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 behöver kontrollera att det inkommande externa meddelandet är signerat av kontraktets ägare (eller en annan användare som har tillgång till den privata nyckeln).

När vi publicerar ett smart kontrakt kan vi initiera det med de data vi behöver i lagringen, som kommer att sparas för framtida användning. Vi kommer att skriva dit den offentliga nyckeln så att vi kan verifiera att signaturen av det inkommande meddelandet skapades av den motsvarande privata nyckeln.

Innan vi fortsätter skapar vi en privat nyckel och skriver den i test/keys/owner.pk. För detta startar vi Fift i interaktivt läge och utför fyra kommandon.

`newkeypair` genererar en offentlig och privat nyckel och skriver dem i stacken. 

`drop` tar bort det översta elementet från stacken (i detta fall den offentliga nyckeln)  

`.s` visar bara vad som ligger i stacken för tillfället 

`"owner.pk" B>file` skriver den privata nyckeln till en fil med namnet `owner.pk`. 

`bye` avslutar arbetet med Fift. 

Vi skapar en mapp nycklar inuti mappen test och dit skriver vi den privata nyckeln.

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 i den aktuella mappen en fil owner.pk.

Vi tar bort den offentliga nyckeln från stacken, när vi behöver kan vi hämta den från den privata.

Nu behöver vi skriva en signaturkontroll. Vi börjar med ett test. Först läser vi in den privata nyckeln från filen med hjälp av funktionen file>B och skriver den till variabeln owner_private_key, sedan med hjälp av funktionen priv>pub konverterar vi den privata nyckeln till en offentlig och skriver resultatet i owner_public_key.

variabel owner_private_key
variabel owner_public_key 

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

Båda nycklarna behövs.

Vi initierar lagringen av det smarta kontraktet med godtyckliga data i samma sekvens som i funktionen pack_state()och skriver till variabeln lagring.

variabel ägare_privata_nyckel
variabel ägare_offentliga_nyckel
variabel beställningar
variabel ägare_wc
variabel ägare_konto_id

"./nycklar/ägare.pk" fil>B ägare_privata_nyckel !
ägare_privata_nyckel @ priv>pub ägare_offentliga_nyckel !
dictnew beställningar !
0 ägare_wc !
0 ägare_konto_id !

<b 0 32 u, owner_public_key @ b, gram, owner_wc i, owner_account_id 256 orders dict, b> lagring !

Därefter kommer vi att skapa ett signerat meddelande som bara kommer att innehålla signaturen och värdet av räknaren.

Först skapar vi datan som vi vill överföra, sedan signerar vi dem med den privata nyckeln och slutligen formulerar vi det signerade meddelandet.

variabel meddelande_att_signera
variabel meddelande_att_skicka
variabel signatur
<b 0 32 u, b> meddelande_att_signera !
meddelande_att_signera @ hashägare_privata_nyckel @ ed25519_signera_uint signatur !
<b signature @ b, 0 32 u, b> &lt;s !  

Resultatet, meddelandet som vi kommer att skicka till det smarta kontraktet, är skrivet i variabeln message_to_send, angående funktionerna hashu, ed25519_sign_uint kan läsas i dokumentationen för Fift.

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

message_to_send @ 
recv_external 
code 
storage @
c7
runvmctx

Så här bör filen med tester se ut vid detta stadium.

Vi kommer att köra testet och det kommer att misslyckas, så vi ändrar det smarta kontraktet så att det kan ta emot meddelanden av detta format och verifiera signaturen.

Först läser vi 512 bitar av signaturen från meddelandet och skriver det i en variabel, därefter läser vi 32 bitar av räknarvariabeln.

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

Vidare verifierar vi räknaren som skickas med lagringen och kontrollerar signaturen. Om något inte stämmer, kastar 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 commit här.

Vi kör testerna och ser att det andra testet misslyckas. Av två anledningar: brist på bitar i meddelandet och brist på bitar i lagringen, så koden misslyckas vid parsing. Vi måste lägga till signaturen av meddelandet som vi skickar och kopiera lagringen från den senaste testen.

I den andra testen lägger vi till signaturen av meddelandet och ändrar smartkontraktets lagring. Så här så här ser testfilen ut just nu.

Låt oss skriva det fjärde testet, där vi skickar ett meddelande som är signerat med en annan persons privata nyckel. Vi skapar ytterligare en privat nyckel och sparar den i en fil not-owner.pk. Vi signerar meddelandet med denna privata nyckel. Vi kör testerna och ser till att alla tester passerar. Commit just nu.

Nu kan vi äntligen gå vidare till implementeringen av smartkontraktets logik.
I recv_external() Vi kommer att ta emot två typer av meddelanden.

Eftersom vårt kontrakt kommer att ackumulera spelarens förluster, måste dessa pengar överföras till skaparen av lotteriet. Adressen till skaparen av lotteriet skrivs in i lagringen när kontraktet skapas.

För säkerhets skull behöver vi möjligheten att ändra adressen dit vi ska skicka förlorade gram. Vi måste också ha möjlighet att skicka gram från lotteriet till ägarens adress.

Låt oss börja med den första. Vi skriver först ett test som kontrollerar att efter att meddelandet skickats har smartkontraktet sparat den nya adressen i lagringen. Vi noterar att vi förutom räknaren och den nya adressen också skickar åtgärd ett 7-bitars heltal som är icke-negativt, beroende på det kommer vi att välja hur vi bearbetar meddelandet i smartkontraktet.

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

I testet kan vi se hur deserialisering av smartkontraktets lagring går till. lagring I Fift. Deserialisering av variabler beskrivs i dokumentationen för Fift.

Länk till commit med en ny test.

Vi kör testet och ser till att det misslyckas. Nu lägger vi till logik för att ändra ägarens adress till lotteriet.

I smartkontraktet fortsätter vi att parsa meddelande, läser in åtgärd. Låt oss påminna om att vi kommer att ha två åtgärd: ändring av adress och överföring av gram.

Sedan läser vi in den nya ägarens adress och sparar i lagringen.
Vi kör testerna och ser att det tredje testet misslyckas. Det misslyckas eftersom kontraktet nu också parserar 7 bitar från meddelandet som saknas i testet. Låt oss lägga till ett icke-existerande åtgärd. Vi kör testerna och ser att alla går igenom. Här commit för ändringar. Utmärkt.

Nu skriver vi logik för att skicka det angivna antalet gram till den tidigare sparade adressen.

Först skriver vi ett test. Vi kommer att skriva två tester, ett när saldot är otillräckligt och ett när allt ska gå igenom. Tester kan ses i denna commit.

Nu skriver vi klart koden. Först ska vi skriva två hjälpfunktioner. Den första är en get-funktion för att få veta det aktuella saldot av smartkontraktet.

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

Och den andra för att skicka gram till ett annat smartkontrakt. Den här metoden har jag helt kopierat från ett annat smartkontrakt.

() 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 <= formatindikator int_msg_info$0 
    ;;  .store_uint(1, 1) ;; 1 <= ihr avstängd
    ;;  .store_uint(1, 1) ;; 1 <= studs = true
    ;;  .store_uint(0, 1) ;; 0 <= studs = false
    ;;  .store_uint(4, 5)  ;; 00100 <= adressflaggor, anycast = false, 8-bit arbetskedja
        .store_uint (196, 9)
        .store_int(wc, 8)
        .store_uint(addr, 256)
        .store_grams(grams)
        .store_uint(0, 107) ;; 106 nollor +  0 som en indikator på att det inte finns någon cell med data.
        .end_cell(); 
    send_raw_message(msg, 3); ;; läge, 2 för att ignorera fel, 1 för att avsändaren betalar avgifter, 64 för att returnera värdet av inkommande meddelande
}

Vi lägger till dessa två metoder i smartkontraktet och skriver logiken. Först parserar vi antalet gram från meddelandet. Sedan kontrollerar vi saldot, om det inte räcker kastar vi ett undantag. Om allt går bra, skickar vi gram 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));

Så här ser smartkontraktet ut vid denna tidpunkt. Vi kör testerna och kontrollerar att de går igenom.

För övrigt debiteras en avgift för varje bearbetat meddelande av smartkontraktet. För att meddelanden ska kunna utföra begäran i smartkontraktet måste man efter de grundläggande kontrollerna kalla på accept_message().

Nu ska vi hantera interna meddelanden. Faktum är att vi bara kommer att ta emot gram och skicka tillbaka dubbel summa till spelaren vid vinst och en tredjedel till ägaren vid förlust.

Låt oss börja med att skriva ett enkelt test. För detta behöver vi en testadress för smartkontraktet från vilket vi skickar gram till smartkontraktet.

Adressen till smartkontraktet består av två nummer, ett 32-bitars heltal som representerar workchain och ett unikt 256-bitars positivt heltal som är kontonumret i denna workchain. Till exempel, -1 och 12345, den här adressen sparar vi 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 gå igenom hur funktionen fungerar, detta kommer att ge en förståelse för hur Fift fungerar. Vi kör 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 köra funktionen -rot, som skiftar stacken så att det unika numret för smartkontraktet hamnar högst upp i stacken:

"sender.addr" -1 12345

256 u>B konverterar det 256-bitars positiva heltalet till bytes.

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap byter plats på de två översta elementen i stacken.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B konverterar det 32-bitars heltalet till bytes.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 BYTES:FFFFFFFF

B+ kombinerar två sekvenser av bytes.

 "sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF

Återigen swap.

BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF "sender.addr" 

Och slutligen skrivs bytes till filen B>file. Efter detta är vår stack tom. Vi stoppar Fift. En fil har skapats i den aktuella mappen sender.addr. Vi flyttar filen till den skapade mappen test\/addresses\/.

Vi skriver ett enkelt test som ska skicka gram till smartkontraktet. Här är committen.

Nu ska vi fokusera på logiken för lotteriet.

Det första vi gör är att kontrollera meddelandet bounced eller inte, om bounced, så ignorerar vi det. bounced Det betyder att kontraktet kommer att returnera gram om det uppstår något fel. Vi kommer inte att återvända gram ifall ett fel skulle uppstå.

Vi kontrollerar balansen; om den är mindre än ett halvt gram accepterar vi helt enkelt meddelandet och ignorerar det.

Vi parser adressen för smartkontraktet från vilket meddelandet kom.

Vi läser in data från lagringen och tar bort gamla insatser från historiken om det finns mer än tjugo. För att underlätta har jag skrivit tre ytterligare funktioner. pack_order(), unpack_order(), remove_old_orders().

Sedan kontrollerar vi om saldot inte räcker till för utbetalningen, då betraktar vi det som en insättning och sparar insättningen i orders.

Därefter, äntligen själva essensen av smartkontraktet.

Först, om spelaren förlorar sparar vi dem i historiken för insatser och om beloppet är större än 3 gram skickar vi 1/3 till ägaren av smartkontraktet.

Om spelaren vinner skickar vi det dubbla beloppet till spelarens adress och sparar sedan informationen om insatsen 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) { ;; ignorera studsad
        return ();
    }
    if (order_amount < 500000000) { ;; bara ta emot gram utan att ändra tillstånd 
        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() = 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. Den motsvarande commit.

Nu återstår det enkla, vi skapar get-metoder så att vi kan få information om tillståndet för kontraktet från den externa världen (i praktiken läsa data från deras lagring i smartkontraktet).

Låt oss lägga till get-metoder. Hur man får information om smartkontraktet kommer vi att skriva om nedan.

Jag glömde också att lägga till koden som kommer att hantera den allra första begäran som görs vid publiceringen av smarta kontrakt. Den motsvarande commit. Och dessutom åtgärdat felet med att skicka 1/3 av summan till ägarens konto.

För att gå vidare behöver vi publicera det smarta kontraktet. Låt oss skapa en mapp requests.

Jag baserade koden för publiceringen på simple-wallet-code.fc som går det att hitta finns i det officiella arkivet.

Det är viktigt att notera att vi formar lagringen för det smarta kontraktet och meddelandet till ingången. Efter det genereras adressen för det smarta kontraktet, vilket innebär att adressen är känd redan innan publiceringen i TON. Därefter måste vi skicka några gram till denna adress och först efter det skicka filen med det smarta kontraktet, eftersom nätverket tar en avgift för lagring och operationer i det smarta kontraktet (validatorer som lagrar och utför smarta kontrakt). Koden kan ses här.

Sedan kör vi publiceringskoden och får lottery-query.boc filen och adressen till 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.

Bland annat i körningsloggarna ser vi adressen till det smarta kontraktet.

new wallet address = 0:044910149dbeaf8eadbb2b28722e7d6a2dc6e264ec2f1d9bebd6fb209079bc2a 
(Sparar adress till fil lottery.addr)
Icke-bounceable adress (för init): 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd
Bounceable adress (för senare åtkomst): kQAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8KpFY

Av intresse kommer vi att göra en begäran till TON

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

Och vi ser att kontot med denna adress är tomt.

konto innehåll är tomt

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 den officiella plånboken, och testgram kan man be om från någon i chatten, som jag kommer att nämna i slutet av artikeln.

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

ser att det finns ett icke-initierat (state:account_uninit) smartkontrakt med denna adress och en balans på 1 000 000 000 nanogram.

kontostatus är (konto
  addr:(addr_std
    anycast:ingenting workchain_id:0 address:x044910149DBEAF8EADBB2B28722E7D6A2DC6E264EC2F1D9BEBD6FB209079BC2A)
  lagringsstatistik:(storage_info
    använt:(storage_used
      celler:(var_uint len:1 value:1)
      bitar:(var_uint len:1 value:103)
      offentliga_celler:(var_uint len:0 value:0)) senast_betald:1583257959
    förfallen_betalning:ingenting)
  lagring:(account_storage last_trans_lt:3825478000002
    balans:(valutor
      gram:(nanogram
        belopp:(var_uint len:4 value:2000000000))
      annat:(extra_currencies
        dict:hme_empty))
    status:account_uninit))
x{C00044910149DBEAF8EADBB2B28722E7D6A2DC6E264EC2F1D9BEBD6FB209079BC2A20259C2F2F4CB3800000DEAC10776091DCD650004_}
senaste transaktion lt = 3825478000001 hash = B043616AE016682699477FFF01E6E903878CDFD6846042BA1BFC64775E7AC6C4
konto balans är 2000000000ng

Nu publicerar vi smartkontraktet. Vi kör igång lite-klienten och utför.

> sendfile lottery-query.boc
[ 1][t 2][1583008371.631410122][lite-client.cpp:966][!testnode] skickar förfrågan från fil lottery-query.boc
[ 3][t 1][1583008371.828550100][lite-client.cpp:976][!query]    extern meddelandestatus är 1 

Vi kontrollerar att kontraktet är publicerat.

> last
> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

Bland annat får vi.

  lagring:(account_storage last_trans_lt:3825499000002
    balans:(valutor
      gram:(nanogram
        belopp:(var_uint len:4 value:1987150999))
      annat:(extra_currencies
        dict:hme_empty))
    status:(account_active

Vi ser att account_active.

Den motsvarande commit med ändringar här.

Nu skapar vi förfrågningar för att interagera med smartkontraktet.

Mer specifikt, den första för att ändra adressen lämnar vi som självständigt arbete, och den andra för att skicka gram till ägarens adress gör vi. I praktiken behöver vi göra samma sak som i testet för att skicka gram.

Så här meddelande kommer vi att skicka till smartkontraktet, där msg_seqno 165, åtgärd 2 och 9.5 gram att skicka.

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

Kom ihåg att underteckna meddelandet med den privata nyckeln lottery.pk, som genererades tidigare vid skapandet av smartkontraktet. Här är den motsvarande commit.

Vi får information från smartkontraktet med hjälp av get-metoder

Nu ska vi se hur man kör get-metoder i smartkontraktet.

Starta lite-client och vi kör get-metoderna som vi har skrivit.

$ .\/lite-client\/lite-client -C ton-lite-client-test1.config.json
> runmethod 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd balans
argument:  [ 104128 ] 
resultat:  [ 64633878952 ] 
...

I result innehåller värdet som funktionen balance() från vårt smartkontrakt.
Samma sak kommer vi utföra för ytterligare några metoder.

> runmethod 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd get_seqno
...
argument:  [ 77871 ] 
resultat:  [ 1 ] 

Vi begär historik över satsningar.

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

Vi kommer att använda lite-client och get-metoder för att visa information om smartkontraktet på webbplatsen.

Vi visar data från smartkontraktet på webbplatsen.

Jag har skrivit en enkel webbplats i Python för att visa data från smartkontraktet på ett användarvänligt sätt. Här kommer jag inte att gå in på detaljer och publicera webbplatsen. med en commit..

Förfrågningar till TON görs från Python med hjälp av lite-client. För bekvämlighetens skull packas webbplatsen i Docker och publiceras på Google Cloud. Länk till webbplatsen.

Vi testar

Nu ska vi försöka skicka gram för påfyllning från plånboken.Vi kommer att skicka 40 gram. Och göra några insatser för tydlighetens skull. Vi ser att webbplatsen visar insatshistorik, aktuell vinstprocent och annan nyttig information.

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

Epilog

Artikeln blev mycket längre än jag hade förväntat mig, kanske kunde den ha varit kortare, eller så är den just right för någon som inte vet något om TON och vill skriva och publicera ett inte så enkelt smartkontrakt med möjlighet att interagera med det. Kanske vissa saker kunde ha förklarats enklare.

Det är möjligt att vissa aspekter av implementeringen kunde ha gjorts mer effektivt och elegant, men då skulle förberedelsen av artikeln ha tagit ännu mer tid. Dessutom kan det hända att jag har gjort något fel eller missförstått något, så om du gör något seriöst bör du förlita dig på den officiella dokumentationen eller det officiella kodarkivet för TON.

Det är värt att notera att eftersom TON fortfarande är under aktiv utveckling kan förändringar inträffa som bryter någon av stegen i denna artikel (vilket redan har hänt medan jag skrev, och jag har redan åtgärdat det), men den övergripande metoden kommer sannolikt inte att förändras.

Jag kommer inte att spekulera om TON:s framtid. Kanske blir plattformen något större och det är värt att investera tid i att studera den och ta en nisch med våra produkter redan nu.

Det finns också Libra från Facebook, som har en potentiell användarpublik större än TON. Jag vet nästan inget om Libra, men enligt forumet är aktiviteten där mycket större än i TON-gemenskapen. Även om utvecklarna och TON-gemenskapen mer liknar underground, vilket också är coolt.

Länkar

1. Officiell dokumentation om TON: https://test.ton.org
2. Officiellt arkiv för TON: https://github.com/ton-blockchain/ton
3. Officiell plånbok för olika plattformar: https://wallet.ton.org
4. Arkiv för smartkontraktet från denna artikel: https://github.com/raiym/astonished
5. Länk till webbplatsen för smartkontraktet: https://ton-lottery.appspot.com
6. Arkiv för extension för Visual Studio Code för FunC: https://github.com/raiym/func-visual-studio-plugin
7. En chat om TON på Telegram som har hjälpt mig mycket i början. Jag tror inte det är fel att säga att alla som har skrivit något för TON finns där. Där kan man också be om testgram. https://t.me/tondev_ru
8. En annan chat om TON där jag har hittat nyttig 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: habr.com