Mu mar a sgrìobhas agus a dh’ fhoillsicheas tu cùmhnant snasail ann an TON

Cò mu dheidhinn a tha an artaigil seo?

Anns an artaigil bruidhnidh mi mu mar a ghabh mi pàirt anns a ’chiad (de dhà) co-fharpais blockchain Telegram, nach do ghabh duais, agus cho-dhùin mi m’ eòlas a chlàradh ann an artaigil gus nach tèid e a-steach do dearmad agus, is dòcha, cuideachadh cuideigin.

Leis nach robh mi airson còd eas-chruthach a sgrìobhadh, ach rudeigin a dhèanamh ag obair, airson an artaigil sgrìobh mi cùmhnant snasail airson crannchur sa bhad agus làrach-lìn a sheallas dàta cùmhnant snasail gu dìreach bho TON gun a bhith a’ cleachdadh stòradh eadar-mheadhanach.

Bidh an artaigil feumail dhaibhsan a tha airson a’ chiad chùmhnant snasail aca a dhèanamh ann an TON, ach aig nach eil fios càite an tòisich iad.

A 'cleachdadh a' chrannchuir mar eisimpleir, thèid mi bho bhith a 'stàladh na h-àrainneachd gu bhith a' foillseachadh cùmhnant snasail, ag eadar-obrachadh leis, agus a 'sgrìobhadh làrach-lìn airson dàta fhaighinn agus fhoillseachadh.

Mu dheidhinn com-pàirteachas ann an co-fharpais a

Anns an Dàmhair an-uiridh, dh’ainmich Telegram farpais blockchain le cànanan ùra Fift и FunC. B’ fheudar taghadh bho bhith a’ sgrìobhadh gin de na còig cùmhnantan snasail a chaidh a mholadh. Bha mi a’ smaoineachadh gum biodh e math rudeigin eadar-dhealaichte a dhèanamh, cànan ionnsachadh agus rudeigin a dhèanamh, fiù ’s mura feum mi dad eile a sgrìobhadh san àm ri teachd. A bharrachd air an sin, tha an cuspair an-còmhnaidh air na bilean.

Is fhiach a ràdh nach robh eòlas sam bith agam air cùmhnantan snasail a leasachadh.

Bha mi an dùil pàirt a ghabhail gu deireadh gus an urrainn dhomh agus an uairsin artaigil ath-bhreithneachaidh a sgrìobhadh, ach dh’ fhàilnich mi sa bhad aig a ’chiad fhear. mi sgrìobh sporan le ioma-ainm-sgrìobhte air FunC agus dh'obraich e san fharsaingeachd. Ghabh mi e mar bhunait cùmhnant smart air Solidity.

Aig an àm sin, bha mi a 'smaoineachadh gu robh seo gu cinnteach gu leòr airson àite duais co-dhiù a ghabhail. Mar thoradh air an sin, thàinig timcheall air 40 a-mach à 60 com-pàirtiche gu bhith nan duaisean agus cha robh mi nam measg. San fharsaingeachd, chan eil dad ceàrr air seo, ach chuir aon rud dragh orm. Aig an àm a chaidh na toraidhean ainmeachadh, cha robh an ath-sgrùdadh air an deuchainn airson mo chùmhnant air a dhèanamh, dh 'fhaighnich mi dha na com-pàirtichean anns a' chat an robh duine sam bith eile aig nach robh e, cha robh gin ann.

A rèir choltais a’ toirt aire do na teachdaireachdan agam, dà latha às deidh sin dh’ fhoillsich na britheamhan beachd agus chan eil mi fhathast a’ tuigsinn an do chaill iad gun fhiosta mo chùmhnant snasail rè a’ bhreitheanais no an robh iad dìreach a’ smaoineachadh gu robh e cho dona is nach robh feum air beachd. Chuir mi ceist air an duilleag, ach cha d’ fhuair mi freagairt. Ged nach eil e na dhìomhaireachd cò a bha a’ breithneachadh, bha mi den bheachd nach robh feum air teachdaireachdan pearsanta a sgrìobhadh.

Chaidh tòrr ùine a chosg air tuigse, agus mar sin chaidh co-dhùnadh artaigil a sgrìobhadh. Leis nach eil mòran fiosrachaidh ann fhathast, cuidichidh an artaigil seo le bhith a’ sàbhaladh ùine dha gach neach le ùidh.

Bun-bheachd cùmhnantan snasail ann an TON

Mus sgrìobh thu dad, feumaidh tu faighinn a-mach cò às a bu chòir dhut dèiligeadh ris an rud seo. Mar sin, a-nis innsidh mi dhut dè na pàirtean den t-siostam a th’ ann. Nas mionaidiche, dè na pàirtean a dh'fheumas tu a bhith eòlach gus co-dhiù cuid de chùmhnant obrach a sgrìobhadh.

Cuiridh sinn fòcas air a bhith a’ sgrìobhadh cùmhnant snasail agus ag obair leis TON Virtual Machine (TVM), Fift и FunC, mar sin tha an artaigil nas coltaiche ri tuairisgeul air leasachadh prògram cunbhalach. Cha bhith sinn a’ fuireach air mar a tha an àrd-ùrlar fhèin ag obair an seo.

San fharsaingeachd mu mar a tha e ag obair TVM agus cànan Fift tha deagh sgrìobhainnean oifigeil ann. Fhad 'sa bha mi a' gabhail pàirt anns a 'cho-fharpais agus a-nis fhad' sa bha mi a 'sgrìobhadh a' chùmhnant làithreach, thionndaidh mi thuice gu tric.

Is e am prìomh chànan anns a bheil cùmhnantan snasail air an sgrìobhadh FunC. Chan eil sgrìobhainnean sam bith mu dheidhinn an-dràsta, agus mar sin gus rudeigin a sgrìobhadh feumaidh tu eisimpleirean de chùmhnantan snasail bhon stòr oifigeil agus buileachadh a’ chànain fhèin a sgrùdadh, agus faodaidh tu coimhead air eisimpleirean de chùmhnantan snasail bhon dà àm a dh’ fhalbh. co-fharpaisean. Ceanglaichean aig deireadh an artaigil.

Canaidh sinn gu bheil sinn mu thràth air cùmhnant snasail a sgrìobhadh airson FunC, às deidh sin bidh sinn a’ tional a ’chòd gu Fift assembler.

Tha an cùmhnant smart cruinnichte fhathast ri fhoillseachadh. Gus seo a dhèanamh feumaidh tu gnìomh a sgrìobhadh a-steach Fift, a bheir an còd cùmhnant snasail agus cuid de pharaimearan eile mar chur-a-steach, agus bidh an toradh mar fhaidhle leis an leudachadh .boc (a tha a’ ciallachadh “poca cheallan”), agus, a rèir mar a bhios sinn ga sgrìobhadh, iuchair phrìobhaideach agus seòladh, a thèid a chruthachadh a rèir còd a’ chùmhnaint snasail. Faodaidh tu graman a chuir gu seòladh cùmhnant sgairteil nach deach fhoillseachadh fhathast.

Gus cùmhnant snasail fhoillseachadh ann an TON a fhuaireadh .boc feumar am faidhle a chuir chun blockchain a’ cleachdadh teachdaiche aotrom (barrachd air sin gu h-ìosal). Ach mus tèid fhoillseachadh, feumaidh tu graman a ghluasad chun an t-seòlaidh a chaidh a chruthachadh, air neo cha tèid an cùmhnant snasail fhoillseachadh. Às deidh fhoillseachadh, faodaidh tu eadar-obrachadh leis a ’chùmhnant snasail le bhith a’ cur teachdaireachdan thuige bhon taobh a-muigh (mar eisimpleir, a ’cleachdadh teachdaiche aotrom) no bhon taobh a-staigh (mar eisimpleir, bidh aon chùmhnant snasail a’ cur teachdaireachd eile taobh a-staigh TON).

Cho luath ‘s a thuigeas sinn mar a thèid an còd fhoillseachadh, bidh e nas fhasa. Tha fios againn gu ìre mhòr dè a tha sinn airson a sgrìobhadh agus mar a dh’ obraicheas ar prògram. Agus fhad ‘s a tha sinn a’ sgrìobhadh, bidh sinn a ’coimhead airson mar a tha seo air a chuir an gnìomh ann an cùmhnantan snasail a th’ ann mar-thà, no bidh sinn a ’coimhead a-steach don chòd buileachaidh Fift и FunC anns an ionad-tasgaidh oifigeil, no coimhead anns na sgrìobhainnean oifigeil.

Glè thric bha mi a’ coimhead airson prìomh fhaclan anns a’ chat Telegram far an do chruinnich com-pàirtichean na farpais agus luchd-obrach Telegram, agus mar sin thachair gun do chruinnich a h-uile duine an sin rè a’ cho-fharpais agus thòisich iad a’ bruidhinn air Fift agus FunC. Ceangal aig deireadh an artaigil.

Tha an t-àm ann gluasad bho theòiridh gu cleachdadh.

Ag ullachadh na h-àrainneachd airson a bhith ag obair le TON

Rinn mi a h-uile rud a thèid a mhìneachadh san artaigil air MacOS agus rinn mi sgrùdadh dùbailte air ann an dreach glan. Ubuntu 18.04 LTS air Docker.

Is e a 'chiad rud a dh'fheumas tu a dhèanamh a luchdachadh sìos agus a stàladh lite-client leis an urrainn dhut iarrtasan a chuir gu TON.

Tha an stiùireadh air an làrach-lìn oifigeil a’ toirt cunntas mionaideach agus soilleir air a’ phròiseas stàlaidh, gun mòran fiosrachaidh fhàgail a-mach. An seo, bidh sinn a’ leantainn an stiùiridh, a’ stàladh eisimeileachdan sam bith a tha a dhìth air an t-slighe. Cha do chuir mi gach pròiseact ri chèile mi-fhìn agus stàlaich mi e bhon stòr-dàta oifigeil. Ubuntu (air MacOS a chleachd mi 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 

Aon uair ‘s gu bheil a h-uile eisimeileachd air a chuir a-steach faodaidh tu a stàladh lite-client, Fift, FunC.

An toiseach, bidh sinn a’ clonadh an stòr TON còmhla ris na h-eisimeileachdan aige. Airson goireasachd, nì sinn a h-uile càil ann am pasgan ~/TON.

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

Bidh an stòr cuideachd a’ stòradh buileachadh Fift и FunC.

A-nis tha sinn deiseil airson am pròiseact a chruinneachadh. Tha an còd tasgaidh air a chlonadh ann am pasgan ~/TON/ton. Tha a ' ~/TON cruthaich pasgan build agus cruinnich am pròiseact innte.

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

Leis gu bheil sinn a 'dol a sgrìobhadh cùmhnant snasail, chan fheum sinn a-mhàin lite-clientach Fift с FunC, mar sin leig leinn a h-uile càil a chruinneachadh. Chan e pròiseas luath a th’ ann, agus mar sin tha sinn a’ feitheamh.

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

An uairsin, luchdaich sìos am faidhle rèiteachaidh anns a bheil dàta mun nód dha bheil lite-client ceangailidh.

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

A’ dèanamh a’ chiad iarrtasan gu TON

A-nis leig leinn a chuir air bhog lite-client.

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

Ma bha an togail soirbheachail, an uairsin às deidh dhut a chuir air bhog chì thu log de cheangal an neach-dèiligidh solais ris an nód.

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

Faodaidh tu an àithne a ruith help agus faic dè na h-òrdughan a tha rim faighinn.

help

Dèanamaid liosta de na h-òrdughan a chleachdas sinn san artaigil seo.

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

A-nis tha sinn deiseil airson an cùmhnant fhèin a sgrìobhadh.

Реализация

Idea

Mar a sgrìobh mi gu h-àrd, is e crannchur a th 'anns a' chùmhnant snasail a tha sinn a 'sgrìobhadh.

A bharrachd air an sin, chan e crannchur a tha seo anns am feum thu tiogaid a cheannach agus feitheamh uair, latha no mìos, ach fear sa bhad anns am bi an neach-cleachdaidh a’ gluasad gu seòladh a’ chùmhnant. N gram, agus sa bhad gheibh e air ais e 2 * N gram no caill. Nì sinn an coltachd buannachadh mu 40%. Mura h-eil gram gu leòr ann airson pàigheadh, beachdaichidh sinn air a’ ghnothach mar rud a bharrachd.

A bharrachd air an sin, tha e cudromach gum faicear geall ann an àm fìor agus ann an cruth goireasach, gus an tuig an neach-cleachdaidh sa bhad a bheil e air buannachadh no air chall. Mar sin, feumaidh tu làrach-lìn a dhèanamh a sheallas geall agus toraidhean gu dìreach bho TON.

A 'sgrìobhadh cùmhnant smart

Airson goireasachd, tha mi air an còd airson FunC a shoilleireachadh; faodar am plugan a lorg agus a chuir a-steach ann an sgrùdadh Còd Visual Studio; ma tha thu gu h-obann airson rudeigin a chuir ris, tha mi air am plugan fhoillseachadh gu poblach. Cuideachd, rinn cuideigin plugan roimhe seo airson a bhith ag obair le Fift, faodaidh tu cuideachd a stàladh agus a lorg ann an VSC.

Cruthaichidh sinn sa bhad stòr far an toir sinn seachad na toraidhean eadar-mheadhanach.

Gus ar beatha a dhèanamh nas fhasa, sgrìobhaidh sinn cùmhnant snasail agus deuchainn gu h-ionadail gus am bi e deiseil. Is ann dìreach às deidh sin a dh’ fhoillsicheas sinn e ann an TON.

Tha dà dhòigh taobh a-muigh aig a’ chùmhnant snasail a gheibhear thuige. A’ chiad, recv_external() tha an gnìomh seo air a chuir gu bàs nuair a thig iarrtas chun chùmhnant bhon t-saoghal a-muigh, is e sin, chan ann bho TON, mar eisimpleir, nuair a bhios sinn fhìn a’ gineadh teachdaireachd agus ga chuir tron ​​​​chliant lite. An dàrna, recv_internal() seo nuair, taobh a-staigh TON fhèin, tha cùmhnant sam bith a’ toirt iomradh air an fheadhainn againne. Anns an dà chùis, faodaidh tu crìochan a thoirt don ghnìomh.

Feuch an tòisich sinn le eisimpleir shìmplidh a dh'obraicheas ma thèid fhoillseachadh, ach chan eil eallach gnìomhach ann.

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

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

An seo feumaidh sinn mìneachadh dè a th’ ann slice. Tha a h-uile dàta a tha air a stòradh ann an TON Blockchain na chruinneachadh TVM cell no dìreach cell, ann an cealla mar sin faodaidh tu suas ri 1023 pìosan dàta a stòradh agus suas ri 4 ceanglaichean gu ceallan eile.

TVM cell slice no slice tha seo na phàirt den fhear a th’ ann mar-thà cell air a chleachdadh airson a pharsadh, bidh e soilleir nas fhaide air adhart. Is e am prìomh rud dhuinne gun urrainn dhuinn gluasad slice agus a rèir an t-seòrsa teachdaireachd, pròiseas an dàta a-steach recv_external() no recv_internal().

impure - prìomh fhacal a tha a’ nochdadh gu bheil an gnìomh ag atharrachadh dàta cùmhnant snasail.

Sàbhail sinn an còd cùmhnant a-steach lottery-code.fc agus a chur ri chèile.

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

Faodar brìgh nam brataichean fhaicinn a’ cleachdadh an àithne

~/TON/build/crypto/func -help

Tha sinn air còd assembler Fift a chuir ri chèile a-steach 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

Faodar a chuir air bhog gu h-ionadail, airson seo ullaichidh sinn an àrainneachd.

Thoir an aire gu bheil a 'chiad loidhne a' ceangal Asm.fif, is e seo còd sgrìobhte ann am Fift for the Fift assembler.

Leis gu bheil sinn airson an cùmhnant snasail a ruith agus fheuchainn gu h-ionadail, cruthaichidh sinn faidhle lottery-test-suite.fif agus dèan lethbhreac den chòd cruinnichte an sin, a’ dol an àite na loidhne mu dheireadh ann, a bhios a’ sgrìobhadh a’ chòd cùmhnant snasail gu seasmhach codegus an uairsin a ghluasad chun inneal brìgheil:

"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

Gu ruige seo tha e coltach gu bheil e soilleir, a-nis cuiridh sinn ris an aon fhaidhle an còd a chleachdas sinn gus TVM a chuir air bhog.

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 bidh sinn a’ clàradh a’ cho-theacsa, is e sin, an dàta leis an tèid an TVM (no stàit an lìonraidh) a chur air bhog. Fiù 's rè a' cho-fharpais, sheall aon de na leasaichean mar a chruthaicheas iad c7 agus rinn mi lethbhreac. San artaigil seo is dòcha gum feum sinn atharrachadh rand_seed leis gu bheil gineadh àireamh air thuaiream an urra ris agus mura tèid atharrachadh, thèid an aon àireamh a thilleadh a h-uile turas.

recv_internal и recv_external bidh uallach air rèiteachaidhean le luachan 0 agus -1 airson na gnìomhan co-fhreagarrach a ghairm sa chùmhnant snasail.

A-nis tha sinn deiseil airson a’ chiad deuchainn a chruthachadh airson ar cùmhnant smart falamh. Airson soilleireachd, airson a-nis cuiridh sinn a h-uile deuchainn ris an aon fhaidhle lottery-test-suite.fif.

Cruthaichidh sinn caochladair storage agus sgrìobh ann aon falamh ann cell, bidh seo a 'smart' stòradh cùmhnant.

message Is e seo an teachdaireachd a bheir sinn chun neach-conaltraidh snasail bhon taobh a-muigh. Bidh sinn cuideachd ga dhèanamh falamh airson a-nis.

variable storage 
<b b> storage ! 

variable message 
<b b> message ! 

Às deidh dhuinn na seasmhach agus na caochladairean ullachadh, bidh sinn a ’cur TVM air bhog a’ cleachdadh an àithne runvmctx agus cuir seachad na crìochan cruthaichte chun an cuir a-steach.

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx 

Aig a’ cheann thall bidh sinn a’ soirbheachadh Mar seo Còd airson eadar-mheadhanach a Fift.

A-nis is urrainn dhuinn an còd a thig às a ruith.

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

Bu chòir don phrògram ruith gun mhearachdan agus anns an toradh chì sinn an loga cur gu bàs:

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

Sgoinneil, tha sinn air a’ chiad dreach obrach den chùmhnant snasail a sgrìobhadh.

A-nis feumaidh sinn comas-gnìomh a chuir ris. An toiseach leig dhuinn dèiligeadh ri teachdaireachdan a thig bhon t-saoghal a-muigh gu recv_external()

Bidh an leasaiche fhèin a’ taghadh an cruth teachdaireachd ris am faod an cùmhnant gabhail ris.

Ach mar as trice

• an toiseach, tha sinn airson ar cùmhnant a dhìon bhon t-saoghal a-muigh agus a dhèanamh gus nach urrainn ach sealbhadair a’ chùmhnant teachdaireachdan bhon taobh a-muigh a chuir thuige.
• san dàrna àite, nuair a chuireas sinn teachdaireachd dhligheach gu TON, tha sinn airson gun tachair seo dìreach aon turas agus nuair a chuireas sinn an aon teachdaireachd a-rithist, tha an cùmhnant snasail ga dhiùltadh.

Mar sin bidh cha mhòr a h-uile cùmhnant a’ fuasgladh an dà dhuilgheadas sin, leis gu bheil ar cùmhnant a’ gabhail ri teachdaireachdan bhon taobh a-muigh, feumaidh sinn aire a thoirt dha sin cuideachd.

Bidh sinn ga dhèanamh ann an òrdugh cùil. An toiseach, leig dhuinn fuasgladh fhaighinn air an duilgheadas le ath-aithris; ma tha an cùmhnant mar-thà air a leithid de theachdaireachd fhaighinn agus air a phròiseasadh, cha chuir e an gnìomh e an dàrna turas. Agus an uairsin fuasglaidh sinn an duilgheadas gus nach urrainn ach cearcall sònraichte de dhaoine teachdaireachdan a chuir chun chùmhnant snasail.

Tha diofar dhòighean ann air an duilgheadas fhuasgladh le teachdaireachdan dùblaichte. Seo mar a nì sinn e. Anns a 'chùmhnant snasail, bidh sinn a' tòiseachadh a 'chunntair de theachdaireachdan a fhuaireadh leis a' chiad luach 0. Anns gach teachdaireachd ris a 'chùmhnant snasail, cuiridh sinn ris a' chunntair làithreach. Mura h-eil an luach cuntair san teachdaireachd a rèir luach a’ chùmhnant snasail, cha bhith sinn ga phròiseasadh; ma nì e, bidh sinn ga phròiseasadh agus ag àrdachadh a’ chunntair sa chùmhnant snasail le 1.

Tillidh sinn gu lottery-test-suite.fif agus cuir dara deuchainn ris. Ma chuireas sinn àireamh ceàrr, bu chòir don chòd eisgeachd a thilgeil. Mar eisimpleir, leig le stòr dàta cùmhnant 166, agus cuiridh sinn 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"

Cuir air bhog sinn.

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

Agus chì sinn gu bheil an deuchainn air a chur gu bàs le mearachd.

[ 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

Aig an ìre seo lottery-test-suite.fif bu chòir coimhead coltach Ceangal.

A-nis leig leinn loidsig a’ chunntair a chuir ris a’ chùmhnant snasail a-steach 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 is breug an teachdaireachd a chuireas sinn.

Is e a’ chiad rud a nì sinn sgrùdadh a bheil dàta anns an teachdaireachd, mura h-eil, bidh sinn dìreach a’ falbh.

An uairsin bidh sinn a 'roinn an teachdaireachd. in_msg~load_uint(32) Luchdaich an àireamh 165, 32-bit unsigned int bhon teachdaireachd a chaidh a chraoladh.

An uairsin bidh sinn a’ luchdachadh 32 pìosan bhon stòradh cùmhnant smart. Bidh sinn a’ dèanamh cinnteach gu bheil an àireamh luchdaichte a’ freagairt ris an fhear a chaidh seachad; mura h-eil, bidh sinn a’ tilgeil eisgeachd. Anns a 'chùis againn, leis gu bheil sinn a' dol seachad air neo-ghèam, bu chòir eisgeachd a thilgeil.

A-nis leig dhuinn a chur ri chèile.

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

Dèan lethbhreac den chòd a thig às gu lottery-test-suite.fif, gun a bhith a’ dìochuimhneachadh an loidhne mu dheireadh a chuir na àite.

Nì sinn cinnteach gu bheil an deuchainn seachad:

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

Dìreach an seo Chì thu an gealltanas co-fhreagarrach leis na toraidhean làithreach.

Thoir an aire gu bheil e mì-ghoireasach an còd cruinn de chùmhnant snasail a chopaigeadh gu faidhle le deuchainnean, agus mar sin sgrìobhaidh sinn sgriobt a sgrìobhas an còd gu cunbhalach dhuinn, agus bidh sinn dìreach a’ ceangal a’ chòd cruinnichte ris na deuchainnean againn a’ cleachdadh "include".

Cruthaich faidhle ann am pasgan a’ phròiseict build.sh leis an t-susbaint a leanas.

#!/bin/bash

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

Dèanamaid e so-ghnìomhaichte.

chmod +x ./build.sh

A-nis, dìreach ruith an sgriobt againn gus an cùmhnant a chuir ri chèile. Ach a bharrachd air an seo, feumaidh sinn a sgrìobhadh gu seasmhach code. Mar sin cruthaichidh sinn faidhle ùr lotter-compiled-for-test.fif, a bheir sinn a-steach don fhaidhle lottery-test-suite.fif.

Nach cuir sinn còd skirpt ri sh, a nì dìreach dùblachadh air an fhaidhle cruinnichte a-steach lotter-compiled-for-test.fif agus atharraich an loidhne mu dheireadh innte.

# 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

A-nis, airson sgrùdadh, ruithidh sinn an sgriobt a thig às agus thèid faidhle a chruthachadh lottery-compiled-for-test.fif, a bheir sinn a steach 'nar n- lottery-test-suite.fif

В lottery-test-suite.fif sguab às an còd cùmhnant agus cuir ris an loidhne "lottery-compiled-for-test.fif" include.

Bidh sinn a’ ruith deuchainnean gus dèanamh cinnteach gu bheil iad seachad.

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

Sgoinneil, a-nis gus foillseachadh deuchainnean a chuir air bhog gu fèin-ghluasadach, cruthaichidh sinn faidhle test.sh, a chuireas an gnìomh an toiseach build.sh, agus an uairsin ruith na deuchainnean.

touch test.sh
chmod +x test.sh

Bidh sinn a’ sgrìobhadh a-staigh

./build.sh 

echo "nCompilation completedn"

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

Dèanamaid e test.sh agus ruith e gus dèanamh cinnteach gu bheil na deuchainnean ag obair.

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

Bidh sinn a’ dèanamh cinnteach gu bheil an cùmhnant air a chruinneachadh agus gu bheil na deuchainnean air an coileanadh.

Sgoinneil, a-nis air tòiseachadh test.sh Thèid na deuchainnean a chuir ri chèile agus ruith iad sa bhad. Seo an ceangal gu tiomnadh.

Ceart gu leòr, mus lean sinn oirnn, dèanamaid aon rud eile airson goireasachd.

Cruthaichidh sinn pasgan build far an glèidh sinn an cùmhnant a chaidh a lethbhreacadh agus a chlò air a sgrìobhadh gu seasmhach lottery-compiled.fif, lottery-compiled-for-test.fif. Cruthaichidh sinn pasgan cuideachd test càite am bi am faidhle deuchainn air a stòradh? lottery-test-suite.fif agus faidhlichean taic eile a dh’ fhaodadh a bhith ann. Ceangal gu atharrachaidhean buntainneach.

Leanaidh sinn oirnn a’ leasachadh a’ chùmhnant smart.

An uairsin bu chòir deuchainn a bhith ann a nì cinnteach gu bheil an teachdaireachd air fhaighinn agus gu bheil an cuntair air ùrachadh anns a’ bhùth nuair a chuireas sinn an àireamh cheart. Ach nì sinn sin nas fhaide air adhart.

A-nis smaoinichidh sinn air dè an structar dàta agus dè an dàta a dh’ fheumar a stòradh sa chùmhnant snasail.

Bheir mi cunntas air a h-uile dad a bhios sinn a’ stòradh.

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

An uairsin feumaidh tu dà ghnìomh a sgrìobhadh. Canaidh sinn a’ chiad fhear pack_state(), a bhios a’ pacadh an dàta airson a shàbhaladh às deidh sin ann an stòradh cùmhnant smart. Canaidh sinn an dàrna fear unpack_state() leughaidh agus tillidh e dàta bhon stòradh.

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

Bidh sinn a’ cur an dà ghnìomh seo ri toiseach a’ chùmhnant snasail. Obraichidh e a-mach Mar seo toradh eadar-mheadhanach.

Gus dàta a shàbhaladh feumaidh tu an gnìomh togte a ghairm set_data() agus sgrìobhaidh e dàta bho pack_state() ann an stòradh cùmhnant smart.

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

A-nis gu bheil gnìomhan goireasach againn airson sgrìobhadh agus leughadh dàta, is urrainn dhuinn gluasad air adhart.

Feumaidh sinn dèanamh cinnteach gu bheil an teachdaireachd a thig a-steach bhon taobh a-muigh air a shoidhnigeadh le sealbhadair a’ chùmhnaint (no neach-cleachdaidh eile aig a bheil cothrom air an iuchair phrìobhaideach).

Nuair a dh’ fhoillsicheas sinn cùmhnant snasail, is urrainn dhuinn a thòiseachadh leis an dàta a tha a dhìth oirnn ann an stòradh, a thèid a shàbhaladh airson a chleachdadh san àm ri teachd. Clàraidh sinn an iuchair phoblach an sin gus an urrainn dhuinn dearbhadh gun deach an teachdaireachd a thàinig a-steach a shoidhnigeadh leis an iuchair phrìobhaideach iomchaidh.

Mus lean sinn air adhart, cruthaichidh sinn iuchair phrìobhaideach agus sgrìobh e thuige test/keys/owner.pk. Gus seo a dhèanamh, leig dhuinn Fift a chuir air bhog ann am modh eadar-ghnìomhach agus cuir an gnìomh ceithir òrdughan.

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

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

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

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

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

Cruthaichidh sinn pasgan keys taobh a-staigh a 'phasgan test agus sgrìobh an iuchair phrìobhaideach an sin.

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

Chì sinn faidhle sa phasgan làithreach owner.pk.

Bheir sinn air falbh an iuchair phoblach bhon stac agus nuair a bhios feum air gheibh sinn bhon fhear phrìobhaideach i.

A-nis feumaidh sinn dearbhadh ainm-sgrìobhte a sgrìobhadh. Feuch an tòisich sinn leis an deuchainn. An toiseach leugh sinn an iuchair phrìobhaideach bhon fhaidhle a’ cleachdadh a’ ghnìomh file>B agus sgrìobh e gu caochladair owner_private_key, an uairsin a 'cleachdadh a' ghnìomh priv>pub tionndaidh an iuchair phrìobhaideach gu iuchair phoblach agus sgrìobh an toradh a-steach 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 !

Feumaidh sinn an dà iuchair.

Bidh sinn a’ tòiseachadh stòradh cùmhnant snasail le dàta neo-riaghailteach san aon sreath ris a’ ghnìomh pack_state()agus sgrìobh e ann an caochladair 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 !

An ath rud, cruthaichidh sinn teachdaireachd soidhnichte, cha bhi ann ach an t-ainm-sgrìobhte agus an luach cuntair.

An toiseach, cruthaichidh sinn an dàta a tha sinn airson a chuir a-mach, an uairsin bidh sinn ga shoidhnigeadh le iuchair phrìobhaideach agus mu dheireadh bidh sinn a’ gineadh teachdaireachd le ainm sgrìobhte.

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 !  

Mar thoradh air an sin, tha an teachdaireachd a chuireas sinn chun chùmhnant snasail air a chlàradh ann an caochladair message_to_send, mu ghnìomhan hashu, ed25519_sign_uint faodaidh tu leughadh ann an sgrìobhainnean Fift.

Agus airson an deuchainn a ruith tha sinn a 'gairm a-rithist.

message_to_send @ 
recv_external 
code 
storage @
c7
runvmctx

An seo Bu chòir gum biodh am faidhle le deuchainnean coltach ri seo aig an ìre seo.

Feuch an ruith sinn an deuchainn agus fàillidh e, agus mar sin atharraichidh sinn an cùmhnant snasail gus am faigh e teachdaireachdan den chruth seo agus dearbhadh an ainm-sgrìobhte.

An toiseach, bidh sinn a’ cunntadh 512 pìosan den ainm-sgrìobhte bhon teachdaireachd agus ga sgrìobhadh gu caochladair, an uairsin bidh sinn a’ cunntadh 32 pìosan den chunntair caochlaideach.

Leis gu bheil gnìomh againn airson dàta a leughadh bhon stòradh cùmhnant smart, cleachdaidh sinn e.

An ath rud tha sgrùdadh air a’ chunntair a chaidh a ghluasad leis an stòradh agus sùil a thoirt air an ainm-sgrìobhte. Mura h-eil rudeigin a 'freagairt, bidh sinn a' tilgeil eisgeachd leis a 'chòd iomchaidh.

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

Gealltanas iomchaidh dhan taobh dheas.

Rachamaid na deuchainnean agus chì sinn gu bheil an dàrna deuchainn a 'fàilligeadh. Airson dà adhbhar, chan eil pìosan gu leòr anns an teachdaireachd agus chan eil pìosan gu leòr anns an stòradh, agus mar sin bidh an còd a’ tuiteam nuair a thathar a’ parsadh. Feumaidh sinn ainm-sgrìobhte a chuir ris an teachdaireachd a tha sinn a’ cur agus lethbhreac a dhèanamh den stòradh bhon deuchainn mu dheireadh.

Anns an dàrna deuchainn, cuiridh sinn ainm-sgrìobhte teachdaireachd ris agus atharraichidh sinn an stòradh cùmhnant smart. An seo tha am faidhle le deuchainnean coltach ris an-dràsta.

Sgrìobhamaid ceathramh deuchainn, anns an cuir sinn teachdaireachd air a shoidhnigeadh le iuchair phrìobhaideach cuideigin eile. Cruthaichidh sinn iuchair phrìobhaideach eile agus sàbhail sinn gu faidhle not-owner.pk. Cuiridh sinn ainm ris an teachdaireachd leis an iuchair phrìobhaideach seo. Rachamaid na deuchainnean agus dèan cinnteach gun tèid a h-uile deuchainn seachad. Geall aig an àm seo.

A-nis is urrainn dhuinn gluasad air adhart gu bhith a’ buileachadh loidsig cùmhnant snasail.
В recv_external() gabhaidh sinn ri dà sheòrsa teachdaireachd.

Leis gun cruinnich ar cùmhnant call nan cluicheadairean, feumar an t-airgead seo a ghluasad gu neach-cruthachaidh a’ chrannchuir. Tha seòladh wallet neach-cruthachaidh a’ chrannchuir air a chlàradh anns an stòradh nuair a thèid an cùmhnant a chruthachadh.

Dìreach air eagal, feumaidh sinn an comas an seòladh chun an cuir sinn graman de luchd-call atharrachadh. Bu chòir dhuinn cuideachd a bhith comasach air graman a chuir bhon chrannchur gu seòladh an neach-seilbh.

Feuch an tòisich sinn leis a 'chiad fhear. Sgrìobh sinn an toiseach deuchainn a nì cinnteach às deidh dhuinn an teachdaireachd a chuir, gun do shàbhail an cùmhnant snasail an seòladh ùr anns an stòradh. Thoir an aire, anns an teachdaireachd, a bharrachd air a’ chunntair agus an seòladh ùr, gum bi sinn cuideachd a’ sgaoileadh action Àireamh iomlan neo-àicheil 7-bit, a rèir e, taghaidh sinn mar a làimhsicheas sinn an teachdaireachd sa chùmhnant snasail.

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

Anns an deuchainn chì thu mar a tha stòradh cùmhnant smart air a dhì-shreathachadh storage ann am Fift. Tha mion-sgrùdadh air caochladairean air a mhìneachadh ann an sgrìobhainnean Fift.

Ceangal a ghealltainn le taois a bharrachd.

Rachamaid an deuchainn agus dèan cinnteach gu bheil e a 'fàilligeadh. A-nis leig dhuinn loidsig a chuir ris gus seòladh sealbhadair a’ chrannchuir atharrachadh.

Anns a’ chùmhnant snasail tha sinn a’ leantainn air adhart a’ parsadh message, leugh a-steach action. Cuimhnichidh sinn gum bi dithis againn action: atharraich seòladh agus cuir graman.

An uairsin bidh sinn a 'leughadh seòladh ùr sealbhadair a' chùmhnant agus ga shàbhaladh ann an stòradh.
Bidh sinn a’ ruith nan deuchainnean agus chì sinn gu bheil an treas deuchainn a’ fàiligeadh. Bidh e a ’tuiteam air sgàth gu bheil an cùmhnant a-nis a’ parsadh 7 pìosan bhon teachdaireachd, a tha a dhìth san deuchainn. Cuir fear nach eil ann ris an teachdaireachd action. Rachamaid na deuchainnean agus chì sinn gu bheil a h-uile càil a 'dol seachad. an seo gealltainn atharrachaidhean. Sgoinneil.

A-nis sgrìobhamaid an reusanachadh airson an àireamh shònraichte de ghramaichean a chuir chun t-seòladh a chaidh a shàbhaladh roimhe.

An toiseach, sgrìobhamaid deuchainn. Sgrìobhaidh sinn dà dheuchainn, aon nuair nach eil cothromachadh gu leòr ann, an dàrna fear nuair a bu chòir a h-uile càil a dhol seachad gu soirbheachail. Faodar coimhead air deuchainnean anns a' ghealladh so.

A-nis leig dhuinn an còd a chur ris. An toiseach, sgrìobhamaid dà dhòigh cuideachaidh. Is e a’ chiad dòigh faighinn a-mach an cothromachadh gnàthach de chùmhnant snasail.

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

Agus tha an dàrna fear airson graman a chuir gu cùmhnant snasail eile. Rinn mi leth-bhreac gu tur den dòigh seo bho chùmhnant snasail eile.

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

Nach cuir sinn an dà dhòigh seo ris a’ chùmhnant snasail agus sgrìobh sinn an loidsig. An toiseach, bidh sinn a’ parsadh an àireamh ghramaichean bhon teachdaireachd. An uairsin nì sinn sgrùdadh air a ’chothromachadh, mura h-eil e gu leòr bidh sinn a’ tilgeil eisgeachd. Ma tha a h-uile càil ceart gu leòr, an uairsin cuiridh sinn na graman chun t-seòladh a chaidh a shàbhaladh agus ùraich sinn a’ chunntair.

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

An seo a’ coimhead coltach ris a’ chùmhnant snasail an-dràsta. Feuch an ruith sinn na deuchainnean agus dèan cinnteach gun tèid iad seachad.

Co-dhiù, thèid coimisean a thoirt a-mach às a ’chùmhnant smart a h-uile uair airson teachdaireachd giullachd. Gus am bi na teachdaireachdan cùmhnant smart an t-iarrtas a chuir an gnìomh, às deidh sgrùdaidhean bunaiteach feumaidh tu fònadh accept_message().

A-nis gluaisidh sinn air adhart gu teachdaireachdan a-staigh. Gu dearbh, cha ghabh sinn ach ri graman agus cuiridh sinn air ais dà uiread an t-suim chun a 'chluicheadair ma bhuannaicheas e agus an treas cuid chun an t-sealbhadair ma chailleas e.

An toiseach, sgrìobhamaid deuchainn shìmplidh. Gus seo a dhèanamh, feumaidh sinn seòladh deuchainn den chùmhnant snasail às am bi sinn a’ cur graman chun chùmhnant snasail.

Tha dà àireamh anns an t-seòladh cùmhnant snasail, àireamh 32-bit le uallach airson an t-sreath-obrach agus àireamh cunntais sònraichte 256-bit neo-àicheil san t-sreath obrach seo. Mar eisimpleir, -1 agus 12345, is e seo an seòladh a shàbhaileas sinn gu faidhle.

Rinn mi leth-bhreac den ghnìomh airson an seòladh a shàbhaladh bho 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

Bheir sinn sùil air mar a tha an gnìomh ag obair, bheir seo tuigse air mar a tha Fift ag obair. Cuir air bhog Fift ann am modh eadar-ghnìomhach.

~/TON/build/crypto/fift -i 

An toiseach bidh sinn a’ putadh -1, 12345 agus ainm an fhaidhle san àm ri teachd “sender.addr” air a’ chruach:

-1 12345 "sender.addr" 

Is e an ath cheum an gnìomh a choileanadh -rot, a ghluaiseas a’ chruach ann an dòigh is gu bheil àireamh cùmhnant snasail sònraichte aig mullach na stac:

"sender.addr" -1 12345

256 u>B ag atharrachadh àireamh iomlan 256-bit neo-àicheil gu bytes.

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap ag atharrachadh an dà eileamaid as àirde den chruach.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B ag atharrachadh slán-àireamh 32-bit gu bytes.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 BYTES:FFFFFFFF

B+ a’ ceangal dà shreath de bytes.

 "sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF

A-rithist swap.

BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF "sender.addr" 

Agus mu dheireadh tha na bytes air an sgrìobhadh chun fhaidhle B>file. Às deidh seo tha ar stac falamh. Stad sinn Fift. Chaidh faidhle a chruthachadh sa phasgan làithreach sender.addr. Gluaisidh sinn am faidhle chun phasgan a chaidh a chruthachadh test/addresses/.

Sgrìobhamaid deuchainn shìmplidh a chuireas graman gu cùmhnant sgairteil. Seo an gealladh.

A-nis leig dhuinn sùil a thoirt air loidsig a 'chrannchuir.

Is e a’ chiad rud a nì sinn sgrùdadh air an teachdaireachd bounced no ma tha bounced, an uairsin bidh sinn ga dearmad. bounced ciallachadh gun till an cùmhnant graman ma thachras mearachd air choireigin. Cha till sinn graman ma thachras mearachd gu h-obann.

Bidh sinn a’ sgrùdadh, ma tha an cothromachadh nas lugha na leth ghram, bidh sinn dìreach a ’gabhail ris an teachdaireachd agus ga leigeil seachad.

An ath rud, bidh sinn a’ parsadh seòladh a’ chùmhnant snasail às an tàinig an teachdaireachd.

Leugh sinn an dàta bhon stòradh agus an uairsin cuir às do sheann gheall bhon eachdraidh ma tha còrr air fichead dhiubh ann. Airson goireasachd, sgrìobh mi trì gnìomhan a bharrachd pack_order(), unpack_order(), remove_old_orders().

An ath rud, bidh sinn a 'coimhead mura h-eil an cothromachadh gu leòr airson a' phàighidh, tha sinn den bheachd nach e geall a tha seo, ach ath-lìonadh agus sàbhail an ath-lìonadh ann an orders.

An uairsin mu dheireadh brìgh a ’chùmhnant smart.

An toiseach, ma chailleas an cluicheadair, bidh sinn ga shàbhaladh san eachdraidh geall agus ma tha an t-suim nas motha na 3 gram, bidh sinn a’ cur 1/3 gu sealbhadair a’ chùmhnant snasail.

Ma bhuannaicheas an cluicheadair, an uairsin bidh sinn a’ cur a dhà uiread gu seòladh a’ chluicheadair agus an uairsin a’ sàbhaladh am fiosrachadh mun gheall ann an eachdraidh.

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

Tha sin uile. Gealltanas co-fhreagarrach.

A-nis tha a h-uile càil a tha air fhàgail sìmplidh, cruthaichidh sinn dòighean faighinn gus am faigh sinn fiosrachadh mu staid a’ chùmhnant bhon t-saoghal a-muigh (gu dearbh, leugh an dàta bhon stòradh cùmhnant smart aca).

Leig leinn dòighean fhaighinn. Bidh sinn a 'sgrìobhadh gu h-ìosal mu mar a gheibh thu fiosrachadh mu smart cùmhnant.

Dhìochuimhnich mi cuideachd an còd a chuir ris a làimhsicheas a’ chiad iarrtas a thachras nuair a bhios mi a’ foillseachadh cùmhnant snasail. Gealltanas co-fhreagarrach. Agus nas fhaide ceartachadh bug le bhith a’ cur 1/3 den t-suim gu cunntas an neach-seilbh.

Is e an ath cheum an cùmhnant smart fhoillseachadh. Cruthaichidh sinn pasgan requests.

Ghabh mi an còd foillseachaidh mar bhunait simple-wallet-code.fc dè lorg anns an ionad-tasgaidh oifigeil.

Rud as fhiach aire a thoirt dha. Bidh sinn a’ gineadh stòradh cùmhnant snasail agus teachdaireachd cuir a-steach. Às deidh seo, thèid seòladh a ’chùmhnant smart a chruthachadh, is e sin, tha fios air an t-seòladh eadhon mus tèid fhoillseachadh ann an TON. An ath rud, feumaidh tu grunn ghramaichean a chuir chun t-seòladh seo, agus dìreach às deidh sin feumaidh tu faidhle a chuir leis a’ chùmhnant snasail fhèin, leis gu bheil an lìonra a ’gabhail coimisean airson a’ chùmhnant snasail agus gnìomhachd a stòradh ann (luchd-dearbhaidh a bhios a ’stòradh agus a’ coileanadh smart. cùmhnantan). Faodar an còd fhaicinn an seo.

An uairsin cuiridh sinn an còd foillseachaidh an gnìomh agus gheibh sinn lottery-query.boc faidhle cùmhnant smart agus seòladh.

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

Na dìochuimhnich na faidhlichean a chaidh a chruthachadh a shàbhaladh: lottery-query.boc, lottery.addr, lottery.pk.

Am measg rudan eile, chì sinn seòladh a’ chùmhnant snasail anns na logaichean cur gu bàs.

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

Dìreach airson spòrs, dèanamaid iarrtas gu TON

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

Agus chì sinn gu bheil an cunntas leis an t-seòladh seo falamh.

account state is empty

Bidh sinn a 'cur chun an t-seòlaidh 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd 2 Gram agus an ceann beagan dhiog bidh sinn a’ cur an gnìomh an aon àithne. Airson graman a chuir mi a’ cleachdadh wallet oifigeil, agus faodaidh tu faighneachd dha cuideigin bhon chat airson graman deuchainn, air am bi mi a’ bruidhinn aig deireadh an artaigil.

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

Tha e coltach ri neo-aithnichte (state:account_uninit) cùmhnant snasail leis an aon sheòladh agus cothromachadh de 1 nanogram.

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

A-nis leig dhuinn an cùmhnant smart fhoillseachadh. Nach cuir sinn air bhog lite-client agus cuiridh sinn an gnìomh.

> 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 

Feuch an dèan sinn cinnteach gu bheil an cùmhnant air fhoillseachadh.

> last
> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

Am measg rudan eile gheibh sinn.

  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

Chì sinn sin account_active.

Gealltanas co-fhreagarrach le atharrachaidhean dhan taobh dheas.

A-nis cruthaichidh sinn iarrtasan airson eadar-obrachadh leis a’ chùmhnant snasail.

Nas mionaidiche, fàgaidh sinn a 'chiad fhear airson an seòladh atharrachadh mar obair neo-eisimeileach, agus nì sinn an dàrna fear airson graman a chuir gu seòladh an neach-seilbh. Gu dearbh, feumaidh sinn an aon rud a dhèanamh ris an deuchainn airson graman a chuir.

Is e seo an teachdaireachd a chuireas sinn chun chùmhnant smart, far a bheil msg_seqno 165, action 2 agus 9.5 gram airson a chuir.

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

Na dìochuimhnich ainm a chuir ris an teachdaireachd leis an iuchair phrìobhaideach agad lottery.pk, a chaidh a chruthachadh na bu thràithe nuair a chaidh a’ chùmhnant snasail a chruthachadh. Seo an gealladh co-fhreagarrach.

A 'faighinn fiosrachadh bho smart cùmhnant a' cleachdadh dòighean fhaighinn

A-nis leig dhuinn sùil a thoirt air mar a ruith smart cùmhnantan faighinn dòighean.

Cur air bhog lite-client agus ruith na dòighean faighinn a sgrìobh sinn.

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

В result a’ toirt a-steach an luach a tha an gnìomh a’ tilleadh balance() bhon chùmhnant smart againn.
Nì sinn an aon rud airson grunn dhòighean eile.

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

Iarraidh sinn an eachdraidh geall agad.

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

Cleachdaidh sinn lite-client agus gheibh sinn dòighean gus fiosrachadh mun chùmhnant snasail a thaisbeanadh air an làrach.

A’ taisbeanadh dàta cùmhnant smart air an làrach-lìn

Sgrìobh mi làrach-lìn sìmplidh ann am Python gus an dàta bhon chùmhnant snasail a thaisbeanadh ann an dòigh iomchaidh. An seo cha bhith mi a 'fuireach air gu mionaideach agus foillsichidh mi an làrach ann an aon ghealladh.

Tha iarrtasan gu TON air an dèanamh bho Python le cuideachadh lite-client. Airson goireasachd, tha an làrach air a phacaigeadh ann an Docker agus air fhoillseachadh air Google Cloud. Ceangal.

Feuch sinn

A-nis feuchaidh sinn ri graman a chuir an sin airson ath-lìonadh bho sporan. Cuiridh sinn 40 gram. Agus dèanamaid geall no dhà airson soilleireachd. Chì sinn gu bheil an làrach a 'sealltainn eachdraidh gheall, an àireamh sa cheud a bhuannaich an-dràsta agus fiosrachadh feumail eile.

Chì sinngun do bhuannaich sinn a’ chiad, gun do chaill sinn an dàrna fear.

Post-d gu caraid

Thionndaidh an artaigil a-mach gu bhith fada nas fhaide na bha mi an dùil, is dòcha gum faodadh e a bhith nas giorra, no is dòcha dìreach airson neach aig nach eil eòlas sam bith mu TON agus a tha airson cùmhnant snasail nach eil cho sìmplidh a sgrìobhadh agus fhoillseachadh leis a ’chomas eadar-obrachadh leis. e. Is dòcha gum faodadh cuid de rudan a bhith air am mìneachadh nas sìmplidh.

Is dòcha gum faodadh cuid de thaobhan den bhuileachadh a bhith air a dhèanamh nas èifeachdaiche agus nas eireachdail, ach an uairsin bhiodh e air eadhon barrachd ùine a thoirt airson an artaigil ullachadh. Tha e comasach cuideachd gun do rinn mi mearachd an àiteigin no nach do thuig mi rudeigin, mar sin ma tha thu a ’dèanamh rudeigin dona, feumaidh tu a bhith an urra ris na sgrìobhainnean oifigeil no an stòr oifigeil leis a’ chòd TON.

Bu chòir a thoirt fa-near, leis gu bheil TON fhèin fhathast aig ìre leasachaidh gnìomhach, gum faodadh atharrachaidhean tachairt a bhriseas gin de na ceumannan san artaigil seo (a thachair fhad ‘s a bha mi a’ sgrìobhadh, chaidh a cheartachadh mar-thà), ach is e an dòigh-obrach coitcheann. eu-coltach ri atharrachadh.

Cha bhith mi a’ bruidhinn mu àm ri teachd TON. Is dòcha gum fàs an àrd-ùrlar rudeigin mòr agus bu chòir dhuinn ùine a chaitheamh ga sgrùdadh agus àite sònraichte a lìonadh leis na toraidhean againn a-nis.

Tha Libra ann cuideachd bho Facebook, aig a bheil comas luchd-cleachdaidh nas motha na TON. Cha mhòr nach eil fios agam mu Libra, a’ breithneachadh leis an fhòram gu bheil tòrr a bharrachd gnìomhachd an sin na ann an coimhearsnachd TON. Ged a tha an luchd-leasachaidh agus coimhearsnachd TON nas coltaiche ri fon talamh, a tha cuideachd fionnar.

iomraidhean

1. Sgrìobhainnean oifigeil TON: https://test.ton.org
2. Stòr-tasgaidh oifigeil TON: https://github.com/ton-blockchain/ton
3. Wallet oifigeil airson diofar àrd-ùrlaran: https://wallet.ton.org
4. Stòr cùmhnant smart bhon artaigil seo: https://github.com/raiym/astonished
5. Ceangal gu làrach-lìn cùmhnant smart: https://ton-lottery.appspot.com
6. Stòr airson an leudachadh airson Visual Studio Code airson FunC: https://github.com/raiym/func-visual-studio-plugin
7. Bruidhinn mu dheidhinn TON ann an Telegram, a chuidich gu mòr le bhith ga thuigsinn aig a 'chiad ìre. Tha mi a’ smaoineachadh nach e mearachd a bhios ann ma chanas mi gu bheil a h-uile duine a sgrìobh rudeigin airson TON ann. Faodaidh tu cuideachd graman deuchainn iarraidh an sin. https://t.me/tondev_ru
8. Còmhradh eile mu TON anns an do lorg mi fiosrachadh feumail: https://t.me/TONgramDev
9. A’ chiad ìre den fharpais: https://contest.com/blockchain
10. An dàrna ìre den cho-fharpais: https://contest.com/blockchain-2

Source: www.habr.com