За това как да напишете и публикувате интелигентен договор в TON

За какво е тази статия?

В статията ще говоря за това как участвах в първия (от два) блокчейн конкурс на Telegram, не взех награда и реших да запиша опита си в статия, за да не потъне в забрава и може би да помогне някой.

Тъй като не исках да пиша абстрактен код, а да направя нещо работещо, за статията написах интелигентен договор за незабавна лотария и уебсайт, който показва данни за интелигентен договор директно от TON, без да използва междинно съхранение.

Статията ще бъде полезна за тези, които искат да направят първия си интелигентен договор в TON, но не знаят откъде да започнат.

Използвайки лотарията като пример, ще премина от инсталиране на средата до публикуване на интелигентен договор, взаимодействие с него и писане на уебсайт за получаване и публикуване на данни.

Относно участието в конкурса

Миналия октомври Telegram обяви блокчейн състезание с нови езици Fift и FunC. Беше необходимо да изберете измежду писането на който и да е от петте предложени интелигентни договора. Мислех, че би било хубаво да направя нещо различно, да науча език и да направя нещо, дори и да не ми се налага да пиша нищо друго в бъдеще. Освен това темата е постоянно на устните.

Струва си да кажа, че нямах опит в разработването на интелигентни договори.

Планирах да участвам до последно, докато успея и след това да напиша обзорна статия, но се провалих още при първата. аз написа портфейл с включен мултиподпис FunC и общо взето проработи. Взех го за основа интелигентен договор за Solidity.

По това време си мислех, че това определено е достатъчно, за да заема поне някакво призово място. В резултат около 40 от 60 участници станаха призьори и аз не бях сред тях. Като цяло няма нищо лошо в това, но едно нещо ме притесни. Към момента на обявяване на резултатите прегледът на теста за договора ми не беше направен, попитах участниците в чата има ли още някой да го няма, нямаше.

Очевидно обръщайки внимание на съобщенията ми, два дни по-късно съдиите публикуваха коментар и аз все още не разбирам дали случайно са пропуснали интелигентния ми договор по време на оценяването или просто са помислили, че е толкова лош, че няма нужда от коментар. Зададох въпрос на страницата, но не получих отговор. Въпреки че не е тайна кой е преценил, сметнах за излишно да пиша лични съобщения.

Беше отделено много време за разбиране, така че беше решено да се напише статия. Тъй като все още няма много информация, тази статия ще помогне да спестите време на всички заинтересовани.

Концепцията за интелигентни договори в TON

Преди да напишете нещо, трябва да разберете от коя страна да подходите към това нещо. Затова сега ще ви кажа от какви части се състои системата. По-точно, какви части трябва да знаете, за да напишете поне някакъв вид трудов договор.

Ще се фокусираме върху писането на интелигентен договор и работата с него TON Virtual Machine (TVM), Fift и FunC, така че статията е по-скоро като описание на разработката на обикновена програма. Тук няма да се спираме на това как работи самата платформа.

Като цяло за това как работи TVM и език Fift има добра официална документация. Докато участвах в състезанието и сега, докато пишех настоящия договор, често се обръщах към нея.

Основният език, на който са написани интелигентните договори е FunC. В момента няма документация за него, така че за да напишете нещо, трябва да проучите примери за интелигентни договори от официалното хранилище и имплементацията на самия език там, плюс можете да разгледате примери за интелигентни договори от последните два състезания. Връзки в края на статията.

Да кажем, че вече сме написали интелигентен договор за FunC, след което компилираме кода в Fift асемблер.

Компилираният интелигентен договор остава да бъде публикуван. За да направите това, трябва да напишете функция в Fift, който ще приеме кода на интелигентния договор и някои други параметри като вход, а изходът ще бъде файл с разширение .boc (което означава „торба с клетки“) и, в зависимост от това как го пишем, частен ключ и адрес, който се генерира въз основа на кода на интелигентния договор. Вече можете да изпращате grams на адреса на интелигентен договор, който все още не е публикуван.

За публикуване на интелигентен договор в TON получен .boc файлът ще трябва да бъде изпратен до блокчейна с помощта на лек клиент (повече за това по-долу). Но преди да публикувате, трябва да прехвърлите grams на генерирания адрес, в противен случай интелигентният договор няма да бъде публикуван. След публикуването можете да взаимодействате с интелигентния договор, като му изпращате съобщения отвън (например, като използвате лек клиент) или отвътре (например, един интелигентен договор изпраща на друг съобщение в TON).

След като разберем как се публикува кодът, става по-лесно. Приблизително знаем какво искаме да напишем и как ще работи програмата ни. И докато пишем, търсим как това вече е имплементирано в съществуващите интелигентни договори или разглеждаме кода за внедряване Fift и FunC в официалното хранилище или погледнете в официалната документация.

Много често търсих ключови думи в чата на Telegram, където се събраха всички участници в състезанието и служители на Telegram, и се случи така, че по време на състезанието всички се събраха там и започнаха да обсъждат Fift и FunC. Линк в края на статията.

Време е да преминем от теория към практика.

Подготовка на средата за работа с TON

Направих всичко, което ще бъде описано в статията за MacOS и го проверих два пъти в чист Ubuntu 18.04 LTS на Docker.

Първото нещо, което трябва да направите, е да изтеглите и инсталирате lite-client с който можете да изпращате заявки до TON.

Инструкциите на официалния уебсайт описват процеса на инсталиране доста подробно и ясно и пропускат някои подробности. Тук следваме инструкциите, като инсталираме липсващите зависимости по пътя. Не компилирах сам всеки проект и не инсталирах от официалното хранилище на Ubuntu (на MacOS, който използвах 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 

След като всички зависимости са инсталирани, можете да инсталирате lite-client, Fift, FunC.

Първо, ние клонираме хранилището на TON заедно с неговите зависимости. За удобство ще направим всичко в папка ~/TON.

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

Хранилището също така съхранява реализации Fift и FunC.

Сега сме готови да сглобим проекта. Кодът на хранилището се клонира в папка ~/TON/ton. В ~/TON създайте папка build и съберете проекта в него.

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

Тъй като ще напишем интелигентен договор, трябва не само lite-clientно Fift с FunC, така че нека компилираме всичко. Това не е бърз процес, така че чакаме.

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

След това изтеглете конфигурационния файл, който съдържа данни за възела, към който lite-client ще се свърже.

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

Извършване на първите заявки към TON

Сега да стартираме lite-client.

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

Ако компилацията е била успешна, след стартирането ще видите дневник на връзката на лекия клиент към възела.

[ 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)
...

Можете да изпълните командата help и вижте какви команди са налични.

help

Нека изброим командите, които ще използваме в тази статия.

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-методы смартконтракта. 

Сега сме готови да напишем самия договор.

Изпълнение

Идея

Както писах по-горе, интелигентният договор, който пишем, е лотария.

Освен това, това не е лотария, в която трябва да закупите билет и да изчакате час, ден или месец, а мигновена, в която потребителят прехвърля на адреса на договора N грама, и веднага си го връща 2 * N грама или губи. Ще направим вероятността да спечелим около 40%. Ако няма достатъчно грамове за плащане, тогава ще считаме транзакцията за допълване.

Освен това е важно залозите да се виждат в реално време и в удобна форма, за да може потребителят веднага да разбере дали е спечелил или загубил. Следователно, трябва да направите уебсайт, който ще показва залози и резултати директно от TON.

Писане на интелигентен договор

За удобство подчертах кода за FunC; плъгинът може да бъде намерен и инсталиран в търсенето на Visual Studio Code; ако изведнъж искате да добавите нещо, направих плъгина публично достъпен. Освен това някой преди това е направил плъгин за работа с Fift, можете също да го инсталирате и да го намерите във VSC.

Нека незабавно създадем хранилище, където ще ангажираме междинните резултати.

За да улесним живота си, ще напишем интелигентен договор и ще го тестваме локално, докато бъде готов. Едва след това ще го публикуваме в ТОН.

Интелигентният договор има два външни метода, които могат да бъдат достъпни. първо, recv_external() тази функция се изпълнява, когато искане към договора идва от външния свят, тоест не от TON, например, когато ние сами генерираме съобщение и го изпращаме чрез lite-клиента. Второ, recv_internal() това е, когато в рамките на самия TON всеки договор се отнася до нашия. И в двата случая можете да подадете параметри към функцията.

Нека започнем с прост пример, който ще работи, ако бъде публикуван, но в него няма функционално натоварване.

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

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

Тук трябва да обясним какво представлява slice. Всички данни, съхранявани в TON Blockchain, са колекция TVM cell или просто cell, в такава клетка можете да съхранявате до 1023 бита данни и до 4 връзки към други клетки.

TVM cell slice или slice това е част от съществуващия cell се използва за анализиране, ще стане ясно по-късно. Основното за нас е, че можем да се трансферираме slice и в зависимост от типа на съобщението, обработва данните в recv_external() или recv_internal().

impure — ключова дума, която показва, че функцията променя данните за интелигентен договор.

Нека запазим кода на договора lottery-code.fc и компилирайте.

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

Значението на флаговете може да се види с помощта на командата

~/TON/build/crypto/func -help

Компилирахме асемблерния код на Fift 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

Може да се стартира локално, за това ще подготвим средата.

Имайте предвид, че първият ред се свързва Asm.fif, това е код, написан на Fift за асемблера Fift.

Тъй като искаме да стартираме и тестваме интелигентния договор локално, ще създадем файл lottery-test-suite.fif и копирайте компилирания код там, като замените последния ред в него, който записва кода на интелигентния договор в константа codeза да го прехвърлите на виртуалната машина:

"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

Дотук изглежда ясно, сега нека добавим към същия файл кода, който ще използваме за стартиране на 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 // to run recv_internal() 
-1 constant recv_external // to invoke recv_external()

В c7 записваме контекста, т.е. данните, с които ще се стартира TVM (или състоянието на мрежата). Още по време на състезанието един от разработчиците показа как се създава c7 и копирах. В тази статия може да се наложи да променим rand_seed тъй като генерирането на произволно число зависи от него и ако не се промени, същото число ще се връща всеки път.

recv_internal и recv_external константи със стойности 0 и -1 ще отговарят за извикването на съответните функции в интелигентния договор.

Сега сме готови да създадем първия тест за нашия празен интелигентен договор. За по-голяма яснота засега ще добавим всички тестове към един и същи файл lottery-test-suite.fif.

Нека създадем променлива storage и напишете празно в него cell, това ще бъде хранилището за интелигентни договори.

message Това е съобщението, което ще предадем на интелигентния контакт отвън. Засега също ще го направим празен.

variable storage 
<b b> storage ! 

variable message 
<b b> message ! 

След като сме подготвили константите и променливите, стартираме TVM с помощта на командата runvmctx и предайте създадените параметри на входа.

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx 

Накрая ще успеем като този междинен код за Fift.

Сега можем да стартираме получения код.

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

Програмата трябва да работи без грешки и в изхода ще видим дневника за изпълнение:

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

Страхотно, написахме първата работеща версия на интелигентния договор.

Сега трябва да добавим функционалност. Първо нека се справим със съобщенията, които идват от външния свят до recv_external()

Самият разработчик избира формата на съобщението, който договорът може да приеме.

Но обикновено

• първо, искаме да защитим нашия договор от външния свят и да го направим така, че само собственикът на договора да може да изпраща външни съобщения до него.
• второ, когато изпратим валидно съобщение до TON, искаме това да се случи точно веднъж и когато изпратим същото съобщение отново, интелигентният договор го отхвърля.

Така че почти всеки договор решава тези два проблема, тъй като нашият договор приема външни съобщения, трябва да се погрижим и за това.

Ще го направим в обратен ред. Първо, нека решим проблема с повторението, ако договорът вече е получил такова съобщение и го е обработил, няма да го изпълни втори път. И тогава ще решим проблема, така че само определен кръг от хора да могат да изпращат съобщения до интелигентния договор.

Има различни начини за решаване на проблема с дублиращи се съобщения. Ето как ще го направим. В интелигентния договор инициализираме брояча на получените съобщения с първоначална стойност 0. Във всяко съобщение към интелигентния договор ще добавим текущата стойност на брояча. Ако стойността на брояча в съобщението не съвпада със стойността в интелигентния договор, тогава ние не я обработваме; ако е така, тогава я обработваме и увеличаваме брояча в интелигентния договор с 1.

Да се ​​върнем към lottery-test-suite.fif и добавете втори тест към него. Ако изпратим неправилен номер, кодът трябва да изведе изключение. Например, оставете данните за договора да съхраняват 166 и ние ще изпратим 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"

Да стартираме.

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

И ще видим, че тестът е изпълнен с грешка.

[ 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

На този етап lottery-test-suite.fif трябва да изглежда като по ссылке.

Сега нека добавим логиката на брояча към интелигентния договор 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 е посланието, което изпращаме.

Първото нещо, което правим, е да проверим дали съобщението съдържа данни, ако не, просто излизаме.

След това анализираме съобщението. in_msg~load_uint(32) зарежда числото 165, 32 бита unsigned int от предаденото съобщение.

След това зареждаме 32 бита от хранилището на интелигентния договор. Проверяваме дали зареденото число съвпада с подаденото; ако не, хвърляме изключение. В нашия случай, тъй като преминаваме несъвпадение, трябва да се хвърли изключение.

Сега нека компилираме.

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

Копирайте получения код в lottery-test-suite.fif, като не забравяте да замените последния ред.

Проверяваме дали тестът преминава:

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

Тук Можете да видите съответния ангажимент с текущите резултати.

Имайте предвид, че е неудобно постоянно да копирате компилирания код на интелигентен договор във файл с тестове, така че ще напишем скрипт, който ще запише кода в константа за нас, и просто ще свържем компилирания код към нашите тестове, използвайки "include".

Създайте файл в папката на проекта build.sh със следното съдържание.

#!/bin/bash

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

Нека го направим изпълним.

chmod +x ./build.sh

Сега просто стартирайте нашия скрипт, за да съставите договора. Но освен това, трябва да го запишем в константа code. Така че ще създадем нов файл lotter-compiled-for-test.fif, които ще включим във файла lottery-test-suite.fif.

Нека добавим skirpt код към sh, който просто ще дублира компилирания файл lotter-compiled-for-test.fif и променете последния ред в него.

# 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

Сега, за да проверим, нека стартираме получения скрипт и ще се генерира файл lottery-compiled-for-test.fif, които ще включим в нашия lottery-test-suite.fif

В lottery-test-suite.fif изтрийте кода на договора и добавете реда "lottery-compiled-for-test.fif" include.

Провеждаме тестове, за да проверим дали преминават.

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

Страхотно, сега, за да автоматизираме стартирането на тестове, нека създадем файл test.sh, който първо ще се изпълни build.shи след това изпълнете тестовете.

touch test.sh
chmod +x test.sh

Пишем вътре

./build.sh 

echo "nCompilation completedn"

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

Хайде да го направим test.sh и го стартирайте, за да се уверите, че тестовете работят.

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

Ние проверяваме дали договорът е съставен и тестовете са изпълнени.

Страхотно, сега при стартиране test.sh Тестовете ще бъдат събрани и стартирани незабавно. Ето връзката към ангажират.

Добре, преди да продължим, нека направим още нещо за удобство.

Нека създадем папка build където ще съхраняваме копирания договор и неговия клонинг, записан в константа lottery-compiled.fif, lottery-compiled-for-test.fif. Нека създадем и папка test къде ще се съхранява тестовият файл? lottery-test-suite.fif и потенциално други поддържащи файлове. Връзка към съответните промени.

Нека продължим да развиваме интелигентния договор.

След това трябва да има тест, който проверява дали съобщението е получено и броячът се актуализира в магазина, когато изпратим правилния номер. Но ще го направим по-късно.

Сега нека помислим каква структура на данните и какви данни трябва да се съхраняват в интелигентния договор.

Ще опиша всичко, което съхраняваме.

`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` переменная типа словарь, хранит последние двадцать ставок. 

След това трябва да напишете две функции. Да се ​​обадим на първия pack_state(), който ще пакетира данните за последващо запазване в хранилището на интелигентния договор. Да извикаме второто unpack_state() ще чете и връща данни от хранилището.

_ 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;
}

Добавяме тези две функции в началото на интелигентния договор. Ще се получи като този междинен резултат.

За да запазите данни, ще трябва да извикате вградената функция set_data() и ще записва данни от pack_state() в хранилището за интелигентни договори.

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

Сега, когато разполагаме с удобни функции за писане и четене на данни, можем да продължим напред.

Трябва да проверим дали входящото съобщение отвън е подписано от собственика на договора (или друг потребител, който има достъп до частния ключ).

Когато публикуваме интелигентен договор, можем да го инициализираме с необходимите ни данни в хранилището, което ще бъде запазено за бъдеща употреба. Ще запишем публичния ключ там, за да можем да проверим дали входящото съобщение е подписано със съответния частен ключ.

Преди да продължим, нека създадем частен ключ и да го запишем test/keys/owner.pk. За да направите това, нека стартираме Fift в интерактивен режим и изпълним четири команди.

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

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

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

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

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

Нека създадем папка keys вътре в папката test и напишете личния ключ там.

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

Виждаме файл в текущата папка owner.pk.

Премахваме публичния ключ от стека и при нужда можем да го вземем от частния.

Сега трябва да напишем проверка на подписа. Да започнем с теста. Първо четем частния ключ от файла с помощта на функцията file>B и го запишете в променлива owner_private_key, след което използвате функцията priv>pub конвертирайте частния ключ в публичен ключ и запишете резултата 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 !

Ще ни трябват и двата ключа.

Инициализираме хранилището на интелигентния договор с произволни данни в същата последователност като във функцията pack_state()и го запишете в променлива 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 !

След това ще съставим подписано съобщение, то ще съдържа само подписа и стойността на брояча.

Първо създаваме данните, които искаме да предадем, след това ги подписваме с частен ключ и накрая генерираме подписано съобщение.

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 !  

В резултат на това съобщението, което ще изпратим към интелигентния договор, се записва в променлива message_to_send, относно функциите hashu, ed25519_sign_uint можеш да четеш в документацията на Fift.

И за провеждане на теста се обаждаме отново.

message_to_send @ 
recv_external 
code 
storage @
c7
runvmctx

Ето го Файлът с тестовете трябва да изглежда така на този етап.

Нека изпълним теста и той ще се провали, така че ще променим интелигентния договор, така че да може да получава съобщения в този формат и да проверява подписа.

Първо преброяваме 512 бита от подписа на съобщението и го записваме в променлива, след това преброяваме 32 бита от променливата на брояча.

Тъй като имаме функция за четене на данни от хранилището на смарт договора, ще я използваме.

Следва проверка на брояча, прехвърлен с хранилището, и проверка на подписа. Ако нещо не съвпада, тогава хвърляме изключение със съответния код.

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));

Съответен ангажимент тук.

Нека да проведем тестовете и да видим, че вторият тест е неуспешен. Поради две причини няма достатъчно битове в съобщението и няма достатъчно битове в хранилището, така че кодът се срива при анализиране. Трябва да добавим подпис към съобщението, което изпращаме, и да копираме хранилището от последния тест.

Във втория тест ще добавим подпис на съобщение и ще променим хранилището на интелигентния договор. Ето го файлът с тестовете изглежда така в момента.

Нека напишем четвърти тест, в който ще изпратим съобщение, подписано с чужд частен ключ. Нека създадем друг частен ключ и да го запазим във файл not-owner.pk. Ние ще подпишем съобщението с този частен ключ. Нека да проведем тестовете и да се уверим, че всички тестове са преминали. Ангажирайте се в този момент.

Сега най-накрая можем да преминем към внедряване на логиката на интелигентния договор.
В recv_external() ще приемем два вида съобщения.

Тъй като нашият договор ще акумулира загубите на играчите, тези пари трябва да бъдат преведени на създателя на лотарията. Адресът на портфейла на създателя на лотарията се записва в хранилището при създаването на договора.

За всеки случай се нуждаем от възможност за смяна на адреса, на който изпращаме грамове от губещите. Трябва също така да можем да изпращаме грамове от лотарията до адреса на собственика.

Да започнем с първия. Нека първо напишем тест, който ще провери дали след изпращане на съобщението интелигентният договор е запазил новия адрес в хранилището. Имайте предвид, че в съобщението, освен гишето и новия адрес, ние също предаваме action 7-битово цяло неотрицателно число, в зависимост от него ще изберем как да обработим съобщението в интелигентния договор.

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

В теста можете да видите как се десериализира съхранението на интелигентни договори storage във Фифт. Десериализацията на променливи е описана в документацията на Fift.

Връзка за ангажиране с добавено тесто.

Нека да проведем теста и да се уверим, че е неуспешен. Сега нека добавим логика за промяна на адреса на собственика на лотарията.

В интелигентния договор продължаваме да анализираме message, прочетете в action. Напомняме, че ще имаме две action: сменете адреса и изпратете грам.

След това прочитаме новия адрес на собственика на договора и го запазваме в хранилището.
Провеждаме тестовете и виждаме, че третият тест е неуспешен. Той се срива поради факта, че сега договорът допълнително анализира 7 бита от съобщението, които липсват в теста. Добавете несъществуващ към съобщението action. Нека да направим тестовете и да видим, че всичко ще мине. Тук ангажирайте се с промени. Страхотен.

Сега нека напишем логиката за изпращане на посочения брой грамове към предварително записания адрес.

Първо, нека напишем тест. Ще напишем два теста, единият, когато няма достатъчно баланс, вторият, когато всичко трябва да премине успешно. Тестовете могат да се видят в този ангажимент.

Сега нека добавим кода. Първо, нека напишем два помощни метода. Първият метод за получаване е да разберете текущия баланс на интелигентен договор.

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

А вторият е за изпращане на грамове към друг интелигентен договор. Напълно копирах този метод от друг интелигентен договор.

() 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
}

Нека добавим тези два метода към интелигентния договор и да напишем логиката. Първо анализираме броя на грамовете от съобщението. След това проверяваме баланса, ако не е достатъчен, хвърляме изключение. Ако всичко е наред, изпращаме грамовете на запаметения адрес и актуализираме брояча.

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));

Ето го изглежда като интелигентния договор в момента. Нека да проведем тестовете и да се уверим, че ще преминат.

Между другото, комисионна се приспада от интелигентния договор всеки път за обработено съобщение. За да могат съобщенията на интелигентния договор да изпълнят заявката, след основни проверки трябва да се обадите accept_message().

Сега да преминем към вътрешните съобщения. Всъщност ние приемаме само грамове и ще изпращаме обратно двойна сума на играча, ако той спечели, и една трета на собственика, ако загуби.

Първо, нека напишем прост тест. За да направим това, имаме нужда от тестов адрес на интелигентния договор, от който уж изпращаме грамове към интелигентния договор.

Адресът на интелигентния договор се състои от две числа, 32-битово цяло число, отговарящо за работната верига, и 256-битово неотрицателно цяло число, уникален номер на акаунт в тази работна верига. Например -1 и 12345, това е адресът, който ще запишем във файл.

Копирах функцията за запазване на адреса от 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

Нека да разгледаме как работи функцията, това ще ни даде представа как работи Fift. Стартирайте Fift в интерактивен режим.

~/TON/build/crypto/fift -i 

Първо избутваме -1, 12345 и името на бъдещия файл "sender.addr" в стека:

-1 12345 "sender.addr" 

Следващата стъпка е да изпълните функцията -rot, който измества стека по такъв начин, че в горната част на стека има уникален номер на интелигентен договор:

"sender.addr" -1 12345

256 u>B преобразува 256-битово неотрицателно цяло число в байтове.

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap разменя горните два елемента на стека.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B преобразува 32-битово цяло число в байтове.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 BYTES:FFFFFFFF

B+ свързва две последователности от байтове.

 "sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF

Отново swap.

BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF "sender.addr" 

И накрая байтовете се записват във файла B>file. След това нашият стек е празен. Спираме Fift. В текущата папка е създаден файл sender.addr. Нека преместим файла в създадената папка test/addresses/.

Нека напишем прост тест, който ще изпрати грамове към интелигентен договор. Ето ангажимента.

Сега нека да разгледаме логиката на лотарията.

Първото нещо, което правим, е да проверим съобщението bounced или не ако bounced, тогава го игнорираме. bounced означава, че договорът ще върне грамове, ако възникне някаква грешка. Няма да върнем грамове, ако внезапно възникне грешка.

Проверяваме, ако балансът е по-малък от половин грам, тогава просто приемаме съобщението и го игнорираме.

След това анализираме адреса на интелигентния договор, от който идва съобщението.

Ние четем данните от хранилището и след това изтриваме старите залози от историята, ако има повече от двадесет. За удобство написах три допълнителни функции pack_order(), unpack_order(), remove_old_orders().

След това гледаме дали балансът не е достатъчен за плащането, тогава считаме, че това не е залог, а попълване и запазваме попълването в orders.

И накрая същността на интелигентния договор.

Първо, ако играчът загуби, ние го запазваме в историята на залаганията и ако количеството е повече от 3 грама, изпращаме 1/3 на собственика на интелигентния договор.

Ако играчът спечели, ние изпращаме двойна сума на адреса на играча и след това запазваме информацията за залога в историята.

() 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));
}

Това е всичко. Съответен ангажимент.

Сега всичко, което остава, е просто, нека създадем get-methods, така че да можем да получим информация за състоянието на договора от външния свят (всъщност да прочетем данните от тяхното хранилище за интелигентни договори).

Нека добавим get методи. По-долу ще напишем как да получите информация за интелигентен договор.

Също така забравих да добавя кода, който ще обработи първата заявка, която възниква при публикуване на интелигентен договор. Съответен ангажимент. И по-нататък поправено бъг с изпращане на 1/3 от сумата към сметката на собственика.

Следващата стъпка е да публикувате интелигентния договор. Нека създадем папка requests.

За основа взех кода на публикацията simple-wallet-code.fc който може да намери в официалното хранилище.

Нещо, на което си струва да се обърне внимание. Ние генерираме хранилище за интелигентни договори и входно съобщение. След това се генерира адресът на интелигентния договор, т.е. адресът е известен още преди публикуването в TON. След това трябва да изпратите няколко грама на този адрес и едва след това трябва да изпратите файл със самия интелигентен договор, тъй като мрежата взема комисионна за съхранение на интелигентния договор и операциите в него (валидатори, които съхраняват и изпълняват интелигентни договори ). Кодът може да видите тук.

След това изпълняваме кода за публикуване и получаваме lottery-query.boc файл и адрес на интелигентен договор.

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

Не забравяйте да запазите генерираните файлове: lottery-query.boc, lottery.addr, lottery.pk.

Освен всичко друго, ще видим адреса на интелигентния договор в регистрационните файлове за изпълнение.

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

Само за забавление, нека отправим заявка към TON

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

И ще видим, че акаунтът с този адрес е празен.

account state is empty

Изпращаме до адрес 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd 2 Gram и след няколко секунди изпълняваме същата команда. За изпращане на грамове използвам официален портфейл, а можете да помолите някой от чата за тестови грамове, за които ще говоря в края на статията.

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

Изглежда като неинициализирано (state:account_uninit) интелигентен договор със същия адрес и баланс от 1 000 000 000 нанограма.

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

Сега нека публикуваме интелигентния договор. Нека стартираме lite-клиент и изпълним.

> 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 

Нека проверим дали договорът е публикуван.

> last
> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

Освен всичко друго, което получаваме.

  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

Виждаме това account_active.

Съответен ангажимент с промени тук.

Сега нека създадем заявки за взаимодействие с интелигентния договор.

По-точно първото ще оставим за смяна на адреса като самостоятелна работа, а второто ще направим за изпращане на грамове до адреса на собственика. Всъщност ще трябва да направим същото като в теста за изпращане на грамове.

Това е съобщението, което ще изпратим на интелигентния договор, където msg_seqno 165, action 2 и 9.5 грама за изпращане.

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

Не забравяйте да подпишете съобщението с личния си ключ lottery.pk, който беше генериран по-рано при създаването на интелигентния договор. Ето съответния ангажимент.

Получаване на информация от интелигентен договор чрез get методи

Сега нека да разгледаме как да стартираме методите за получаване на интелигентен договор.

Стартиране lite-client и стартирайте методите за получаване, които написахме.

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

В result съдържа стойността, която функцията връща balance() от нашия интелигентен договор.
Ще направим същото за още няколко метода.

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

Нека поискаме вашата история на залагания.

> 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]) ] 

Ще използваме lite-client и ще получим методи за показване на информация за интелигентния договор на сайта.

Показване на данни за интелигентен договор на уебсайта

Написах прост уебсайт в Python за показване на данните от интелигентния договор по удобен начин. Тук няма да се спирам подробно на него и ще публикувам сайта в един ангажимент.

Заявките към TON се правят от Python през lite-client. За удобство сайтът е пакетиран в Docker и публикуван в Google Cloud. Връзка.

Опитвайки

Сега нека се опитаме да изпратим грамове там за попълване от портмоне. Ще изпратим 40гр. И нека направим няколко залога за яснота. Виждаме, че сайтът показва историята на залозите, текущия процент на печалба и друга полезна информация.

Виждамече спечелихме първото, загубихме второто.

послеслов

Статията се оказа много по-дълга, отколкото очаквах, може би можеше да е по-кратка или може би просто за човек, който не знае нищо за TON и иска да напише и публикува не толкова прост интелигентен договор с възможност за взаимодействие с то. Може би някои неща можеха да се обяснят по-просто.

Може би някои аспекти на внедряването биха могли да бъдат направени по-ефективно и елегантно, но тогава подготовката на статията щеше да отнеме още повече време. Възможно е също да съм сгрешил някъде или да не съм разбрал нещо, така че ако правите нещо сериозно, трябва да разчитате на официалната документация или на официалното хранилище с TON кода.

Трябва да се отбележи, че тъй като самият TON все още е в активен етап на разработка, може да настъпят промени, които ще нарушат някоя от стъпките в тази статия (което се случи, докато писах, вече е коригирано), но общият подход е малко вероятно е да се промени.

Няма да говоря за бъдещето на TON. Може би платформата ще стане нещо голямо и трябва да отделим време за изучаването й и да запълним ниша с нашите продукти сега.

Има и Libra от Facebook, която има потенциална аудитория от потребители, по-голяма от TON. Не знам почти нищо за Libra, съдейки по форума там има много повече активност, отколкото в общността на TON. Въпреки че разработчиците и общността на TON са по-скоро ъндърграунд, което също е страхотно.

Позоваването

1. Официална документация на TON: https://test.ton.org
2. Официално хранилище на TON: https://github.com/ton-blockchain/ton
3. Официален портфейл за различни платформи: https://wallet.ton.org
4. Хранилище за интелигентни договори от тази статия: https://github.com/raiym/astonished
5. Връзка към уебсайта на интелигентния договор: https://ton-lottery.appspot.com
6. Хранилище за разширение за Visual Studio Code за FunC: https://github.com/raiym/func-visual-studio-plugin
7. Чат за TON в Telegram, което наистина помогна да го разберем в началния етап. Мисля, че няма да сгреша, ако кажа, че всеки, който е написал нещо за TON, е там. Там можете да поискате и тестови грамове. https://t.me/tondev_ru
8. Друг чат за TON, в който намерих полезна информация: https://t.me/TONgramDev
9. Първи етап на състезанието: https://contest.com/blockchain
10. Втори етап на състезанието: https://contest.com/blockchain-2

Източник: www.habr.com