ProHoster > Blag > Riarachán > Faoi conas conradh cliste a scríobh agus a fhoilsiú sa Líonra Oscailte Telegram (TON)

Faoi conas conradh cliste a scríobh agus a fhoilsiú sa Líonra Oscailte Telegram (TON)

Faoi conas conradh cliste a scríobh agus a fhoilsiú in TON

Cad faoi atá an t-alt seo?

San alt beidh mé ag caint faoi conas a ghlac mé páirt sa chéad (de dhá) comórtas blockchain Telegram, ní raibh a ghlacadh duais, agus chinn a thaifeadadh mo thaithí in alt ionas nach ndéanann sé doirteal i oblivion agus, b'fhéidir, cabhrú leat. duine.

Ós rud é nach raibh mé ag iarraidh cód teibí a scríobh, ach rud éigin a dhéanamh ag obair, don alt scríobh mé conradh cliste le haghaidh crannchuir toirt agus láithreán gréasáin a thaispeánann sonraí conartha cliste go díreach ó TON gan úsáid a bhaint as stóráil idirmheánach.

Beidh an t-alt úsáideach dóibh siúd ar mian leo a gcéad chonradh cliste a dhéanamh i TON, ach níl a fhios acu cá háit le tosú.

Ag baint úsáide as an gcrannchur mar shampla, rachaidh mé ó shuiteáil na timpeallachta go dtí conradh cliste a fhoilsiú, idirghníomhú leis, agus suíomh Gréasáin a scríobh chun sonraí a fháil agus a fhoilsiú.

Maidir le rannpháirtíocht sa chomórtas

Deireadh Fómhair seo caite, d'fhógair Telegram comórtas blockchain le teangacha nua Fift и FunC. Bhí sé riachtanach a roghnú as aon cheann de na cúig chonradh cliste molta a scríobh. Shíl mé go mbeadh sé go deas rud éigin difriúil a dhéanamh, teanga a fhoghlaim agus rud éigin a dhéanamh, fiú mura bhfuil orm aon rud eile a scríobh amach anseo. Ina theannta sin, tá an t-ábhar i gcónaí ar na liopaí.

Is fiú a rá nach raibh aon taithí agam ar chonarthaí cliste a fhorbairt.

Bhí sé beartaithe agam páirt a ghlacadh go dtí an deireadh go dtí go bhféadfainn agus ansin alt athbhreithnithe a scríobh, ach theip orm ar an bpointe boise ag an gcéad cheann. mé scríobh sparán le síniú il ar FunC agus d'oibrigh sé go ginearálta. Ghlac mé mar bhunús leis conradh cliste ar Solidity.

Ag an am sin, shíl mé go raibh sé seo cinnte go leor chun duais éigin ar a laghad a ghlacadh. Mar thoradh air sin, bhuaigh thart ar 40 as 60 rannpháirtí duaiseanna agus ní raibh mise ina measc. Go ginearálta, níl aon rud cearr leis seo, ach rud amháin a bheith buartha dom. Nuair a fógraíodh na torthaí, ní raibh an t-athbhreithniú ar an tástáil do mo chonradh déanta, d'iarr mé ar na rannpháirtithe sa chomhrá an raibh aon duine eile nach raibh sé acu, ní raibh aon duine ann.

De réir dealraimh agus aird á tabhairt ar mo theachtaireachtaí, dhá lá ina dhiaidh sin d’fhoilsigh na breithiúna trácht agus ní thuigim fós ar chaill siad mo chonradh cliste trí thimpiste le linn na moltóireachta nó ar shíl siad go raibh sé chomh dona sin nár ghá trácht air. Chuir mé ceist ar an leathanach, ach ní bhfuair mé freagra. Cé nach rún ar bith é cé a rinne breithiúnas, mheas mé nár ghá teachtaireachtaí pearsanta a scríobh.

Caitheadh ​​go leor ama ar thuiscint, mar sin socraíodh alt a scríobh. Ós rud é nach bhfuil mórán faisnéise ann fós, cabhróidh an t-alt seo le ham a shábháil do gach duine a bhfuil suim acu ann.

Coincheap na gconarthaí cliste i TON

Sula scríobhann tú rud ar bith, ní mór duit a dhéanamh amach cén taobh as a rachaidh tú i ngleic leis an rud seo. Mar sin, inseoidh mé duit anois cad iad na codanna atá sa chóras. Níos cruinne, cad iad na codanna is gá duit fios a bheith agat chun conradh oibre de chineál éigin ar a laghad a scríobh.

Díreoimid ar chonradh cliste a scríobh agus oibriú le TON Virtual Machine (TVM), Fift и FunC, mar sin tá an t-alt níos mó cosúil le cur síos ar fhorbairt clár rialta. Ní bhainfimid leas as conas a oibríonn an t-ardán féin anseo.

Go ginearálta faoi conas a oibríonn sé TVM agus язык Fift tá doiciméadú oifigiúil maith ann. Agus mé ag glacadh páirte sa chomórtas agus anois agus mé ag scríobh an chonartha reatha, chas mé chuici go minic.

Is é an príomhtheanga ina scríobhtar conarthaí cliste FunC. Níl aon doiciméadú air faoi láthair, mar sin chun rud éigin a scríobh ní mór duit staidéar a dhéanamh ar shamplaí de chonarthaí cliste ón stór oifigiúil agus cur i bhfeidhm na teanga féin ann, móide is féidir leat breathnú ar shamplaí de chonarthaí cliste ón dá am atá thart. comórtais. Naisc ag deireadh an ailt.

Ligean le rá go bhfuil conradh cliste scríofa againn cheana féin le haghaidh FunC, ina dhiaidh sin déanaimid an cód a thiomsú isteach i gcóimeálaí Cúigear.

Tá an conradh cliste tiomsaithe fós le foilsiú. Chun seo a dhéanamh ní mór duit feidhm a scríobh i Fift, a ghlacfaidh an cód conartha cliste agus roinnt paraiméadair eile mar ionchur, agus beidh an t-aschur ina chomhad leis an síneadh .boc (a chiallaíonn “mála cealla”), agus, ag brath ar an gcaoi a scríobhaimid é, eochair phríobháideach agus seoladh, a ghintear bunaithe ar chód an chonartha cliste. Is féidir leat gram a sheoladh cheana féin chuig seoladh conartha cliste nach bhfuil foilsithe fós.

Chun conradh cliste a fhoilsiú i TON a fuarthas .boc beidh gá an comhad a sheoladh chuig an blockchain ag baint úsáide as cliant éadrom (níos mó ar sin thíos). Ach roimh fhoilsiú, ní mór duit gram a aistriú chuig an seoladh a ghintear, ar shlí eile ní fhoilseofar an conradh cliste. Tar éis é a fhoilsiú, is féidir leat idirghníomhú leis an gconradh cliste trí theachtaireachtaí ón taobh amuigh a sheoladh (mar shampla, ag baint úsáide as cliant éadrom) nó ón taobh istigh (mar shampla, cuireann conradh cliste amháin teachtaireacht taobh istigh de TON).

Nuair a thuigimid conas a fhoilsítear an cód, éiríonn sé níos éasca. Tá a fhios againn go garbh cad ba mhaith linn a scríobh agus conas a oibreoidh ár gclár. Agus muid ag scríobh, féachaimid ar an gcaoi a gcuirtear é seo i bhfeidhm cheana féin i gconarthaí cliste atá ann cheana féin, nó déanaimid breathnú ar an gcód cur chun feidhme Fift и FunC sa stór oifigiúil, nó féach sa doiciméadú oifigiúil.

Go minic rinne mé cuardach ar eochairfhocail sa chomhrá Telegram inar bhailigh rannpháirtithe uile an chomórtais agus fostaithe Telegram, agus tharla sé sin gur bhailigh gach duine ann le linn an chomórtais agus thosaigh siad ag plé Fift agus FunC. Nasc ag deireadh an ailt.

Tá sé in am bogadh ó theoiric go cleachtas.

An timpeallacht a ullmhú le haghaidh oibriú le TON

Rinne mé gach rud a gcuirfear síos air san alt ar MacOS agus rinne mé seiceáil faoi dhó ar Ubuntu 18.04 LTS glan ar Docker.

Is é an chéad rud is gá duit a dhéanamh ná a íoslódáil agus a shuiteáil lite-client leis ar féidir leat iarratais a sheoladh chuig TON.

Déanann na treoracha ar an láithreán gréasáin oifigiúil cur síos ar an bpróiseas suiteála go mion agus go soiléir agus fágtar roinnt sonraí ar lár. Anseo leanaimid na treoracha, ag suiteáil na spleáchais atá ar iarraidh feadh na slí. Níor thiomsaigh mé gach tionscadal mé féin agus suiteáil mé ó stór oifigiúil Ubuntu (ar MacOS a d'úsáid mé 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

Tar éis gach spleáchas a shuiteáil is féidir leat a shuiteáil lite-client, Fift, FunC.

Ar dtús, déanaimid clónáil ar an stór TON mar aon lena spleáchais. Ar mhaithe le caoithiúlacht, déanfaimid gach rud i bhfillteán ~/TON.

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

Stórálann an stór feidhmiúcháin freisin Fift и FunC.

Anois táimid réidh leis an tionscadal a chur le chéile. Clónáiltear an cód stórtha i bhfillteán ~/TON/ton. I ~/TON cruthaigh fillteán build agus an tionscadal a bhailiú ann. 

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

Ós rud é go bhfuil muid chun conradh cliste a scríobh, ní mór dúinn ní hamháin lite-clientAch Fift с FunC, mar sin déanaimis gach rud a thiomsú. Ní próiseas tapa é, mar sin táimid ag fanacht. 

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

Ansin, íoslódáil an comhad cumraíochta ina bhfuil sonraí faoin nód lena mbaineann lite-client nascfaidh. 

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

Na chéad iarratais a dhéanamh chuig TON

Anois, a ligean ar seoladh lite-client. 

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

Má d'éirigh leis an tógáil, ansin tar éis an tseolta feicfidh tú logáil de nasc an chliaint solais leis 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)
...

Is féidir leat an t-ordú a rith help agus féach cad iad na horduithe atá ar fáil. 

help

Déanaimis liosta de na horduithe a úsáidfimid san Airteagal 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-методы смартконтракта.

Anois táimid réidh chun an conradh féin a scríobh.

Cur i bhFeidhm

Idea

Mar a scríobh mé thuas, is crannchur é an conradh cliste atá á scríobh againn.

Thairis sin, ní crannchur é seo ina gcaithfidh tú ticéad a cheannach agus fanacht uair an chloig, lá nó mí, ach ceann láithreach ina n-aistríonn an t-úsáideoir chuig seoladh an chonartha N gram, agus láithreach faigheann sé ar ais 2 * N gram nó caillfidh. Déanfaimid an dóchúlacht a bhuachan thart ar 40%. Mura bhfuil go leor gram le híocaíocht, ansin déanfaimid an t-idirbheart a mheas mar bhreisiú.

Thairis sin, tá sé tábhachtach go bhfeicfear geallta i bhfíor-am agus i bhfoirm áisiúil, ionas gur féidir leis an úsáideoir a thuiscint láithreach cé acu a bhuaigh nó a chaill sé. Mar sin, ní mór duit suíomh gréasáin a dhéanamh a thaispeánfaidh geallta agus torthaí go díreach ó TON.

Conradh cliste a scríobh

Ar mhaithe le caoithiúlacht, tá an cód le haghaidh FunC aibhsithe agam; is féidir an breiseán a aimsiú agus a shuiteáil i gcuardach an Chóid Amharc-Stiúideo; más mian leat go tobann rud éigin a chur leis, chuir mé an breiseán ar fáil go poiblí. Chomh maith leis sin, rinne duine éigin breiseán roimhe seo chun oibriú le Fift, is féidir leat é a shuiteáil agus é a fháil i VSC.

Cruthaímid láithreach stór ina gcuirfimid na torthaí idirmheánacha.

Chun ár saol a dhéanamh níos éasca, scríobhfaimid conradh cliste agus déanfaimid é a thástáil go háitiúil go dtí go mbeidh sé réidh. Ach amháin ina dhiaidh sin foilseoimid é in TON.

Tá dhá mhodh sheachtracha ag an gconradh cliste ar féidir teacht air. Ar dtús, recv_external() déantar an fheidhm seo nuair a thagann iarratas ar an gconradh ón domhan lasmuigh, is é sin, ní ó TON, mar shampla, nuair a ghinimid féin teachtaireacht agus é a sheoladh tríd an gcliant lite. Dara, recv_internal() is é seo an uair, laistigh de TON féin, a thagraíonn aon chonradh dár gceann féin. Sa dá chás, is féidir leat paraiméadair a chur ar aghaidh chuig an bhfeidhm.

Tosaímid le sampla simplí a oibreoidh má fhoilsítear é, ach níl aon ualach feidhmiúil ann. 

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

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

Anseo ní mór dúinn a mhíniú cad é slice. Is bailiúchán é na sonraí go léir atá stóráilte i TON Blockchain TVM cell nó go simplí cell, i gcill den sórt sin is féidir leat suas le 1023 giotán sonraí a stóráil agus suas le 4 nasc le cealla eile.

TVM cell slice nó slice tá sé seo mar chuid den cheann atá ann cheana féin cell a úsáidtear chun é a pharsáil, beidh sé soiléir níos déanaí. Is é an rud is mó dúinn gur féidir linn aistriú slice agus ag brath ar an gcineál teachtaireachta, na sonraí a phróiseáil i recv_external() nó recv_internal().

impure — eochairfhocal a thugann le fios go modhnaítear sonraí conartha cliste san fheidhm.

A ligean ar a shábháil ar an cód conartha i lottery-code.fc agus a thiomsú. 

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

Is féidir brí na mbratach a fheiceáil leis an ordú 

~/TON/build/crypto/func -help

Táimid tar éis cód cóimeála Fift a thiomsú i lottery-compiled.fif: 

// lottery-compiled.fif

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

Is féidir é a sheoladh go háitiúil, chuige seo ullmhóimid an timpeallacht.

Tabhair faoi deara go nascann an chéad líne Asm.fif, tá an cód seo scríofa in Fift for the Fift cóimeálaí.

Ós rud é go dteastaíonn uainn an conradh cliste a reáchtáil agus a thástáil go háitiúil, cruthóimid comhad lottery-test-suite.fif agus cóipeáil an cód tiomsaithe ansin, ag cur in ionad na líne deiridh ann, a scríobhann an cód conartha cliste go tairiseach codeansin é a aistriú chuig an meaisín fíorúil: 

"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

Go dtí seo is cosúil go bhfuil sé soiléir, anois cuirimis leis an gcomhad céanna an cód a úsáidfimid chun TVM a sheoladh. 

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 déanaimid taifead ar an gcomhthéacs, is é sin, na sonraí lena seolfar an TVM (nó an stát líonra). Fiú le linn an chomórtais, léirigh ceann de na forbróirí conas a chruthú c7 agus chóipeáil mé. San Airteagal seo b'fhéidir go gcaithfimid athrú rand_seed ós rud é go mbraitheann giniúint uimhir randamach air agus mura n-athraítear é, cuirfear an uimhir chéanna ar ais gach uair.

recv_internal и recv_external beidh tairisigh le luachanna 0 agus -1 freagrach as na feidhmeanna comhfhreagracha sa chonradh cliste a ghlaoch.

Anois táimid réidh chun an chéad tástáil a chruthú dár gconradh cliste folamh. Ar mhaithe le soiléireacht, cuirfimid gach tástáil leis an gcomhad céanna faoi láthair lottery-test-suite.fif.

A ligean ar a chruthú athróg storage agus scríobh ceann folamh isteach ann cell, is é seo an stóráil chonartha cliste.

message Is é seo an teachtaireacht a chuirfimid chuig an teagmháil chliste ón taobh amuigh. Déanfaimid folamh é go ceann tamaill freisin. 

variable storage 
<b b> storage ! 

variable message 
<b b> message !

Tar éis dúinn na tairisigh agus na hathróga a ullmhú, seolann muid TVM ag baint úsáide as an ordú runvmctx agus na paraiméadair chruthaithe a chur ar aghaidh chuig an ionchur. 

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx

Sa deireadh éireoidh linn mar seo Cóid idirmheánach le haghaidh Fift.

Anois is féidir linn an cód mar thoradh air a rith. 

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

Ba cheart go rithfidh an clár gan earráidí agus san aschur feicfimid an loga forghníomhaithe: 

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

Go hiontach, tá an chéad leagan oibre den chonradh cliste scríofa againn.

Anois ní mór dúinn feidhmiúlacht a chur leis. Ar dtús déanaimis déileáil le teachtaireachtaí a thagann ón domhan lasmuigh chuig recv_external()

Roghnaíonn an forbróir é féin an fhormáid teachtaireachta is féidir leis an gconradh a ghlacadh.

Ach de ghnáth

  • ar an gcéad dul síos, ba mhaith linn ár gconradh a chosaint ón domhan lasmuigh agus é a dhéanamh ionas nach féidir ach le húinéir an chonartha teachtaireachtaí seachtracha a sheoladh chuige.
  • ar an dara dul síos, nuair a sheolaimid teachtaireacht bhailí chuig TON, ba mhaith linn go dtarlódh sé seo go díreach uair amháin agus nuair a sheolaimid an teachtaireacht chéanna arís, diúltaíonn an conradh cliste é.

Mar sin réitíonn beagnach gach conradh an dá fhadhb seo, ós rud é go nglacann ár gconradh le teachtaireachtaí seachtracha, ní mór dúinn aire a thabhairt dó sin freisin.

Déanfaimid é in ord droim ar ais. Ar dtús, déanaimis an fhadhb a réiteach arís agus arís eile; má tá teachtaireacht den sórt sin faighte ag an gconradh cheana féin agus é a phróiseáil, ní dhéanfaidh sé an dara huair é a fhorghníomhú. Agus ansin déanfaimid an fhadhb a réiteach ionas nach féidir ach ciorcal áirithe daoine teachtaireachtaí a sheoladh chuig an gconradh cliste.

Tá bealaí éagsúla ann chun an fhadhb a réiteach le teachtaireachtaí dúblacha. Seo é mar a dhéanfaimid é. Sa chonradh cliste, cuirimid tús le cuntar na dteachtaireachtaí a fuarthas leis an luach tosaigh 0. I ngach teachtaireacht leis an gconradh cliste, cuirfimid an luach reatha gcuntar. Mura bhfuil an luach gcuntar sa teachtaireacht ag teacht leis an luach sa chonradh cliste, ansin ní dhéanaimid é a phróiseáil; má dhéanann sé, ansin déanaimid é a phróiseáil agus an gcuntar sa chonradh cliste a mhéadú faoi 1.

Fillfimid ar lottery-test-suite.fif agus cuir an dara triail leis. Má sheolaimid uimhir mícheart, ba cheart go gcaithfeadh an cód eisceacht. Mar shampla, lig an stór sonraí conartha 166, agus cuirfimid 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"

A ligean ar a sheoladh. 

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

Agus feicfimid go ndéantar an tástáil a fhorghníomhú le earráid. 

[ 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

Ag an gcéim seo lottery-test-suite.fif chóir cuma mhaith по ссылке.

Anois cuirimis loighic an chuntair leis an gconradh cliste i lottery-code.fc. 

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

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

В slice in_msg luíonn an teachtaireacht a sheolaimid.

Is é an chéad rud a dhéanaimid ná a sheiceáil an bhfuil sonraí sa teachtaireacht, mura bhfuil, ansin fágfaimid go simplí.

Ansin pharsáilimid an teachtaireacht. in_msg~load_uint(32) luchtú an uimhir 165, 32-giotán unsigned int ón teachtaireacht tarchurtha.

Ansin déanaimid 32 giotán a luchtú ón stóráil chonartha cliste. Déanaimid seiceáil go bhfuil an uimhir luchtaithe ag teacht leis an uimhir a ritheadh; mura bhfuil, caithfimid eisceacht. Is é ár gcás, ós rud é go bhfuil muid ag dul thar neamh-mheaitseáil, ba cheart eisceacht a chaitheamh.

Anois, déanaimis a thiomsú. 

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

Cóipeáil an cód mar thoradh air chuig lottery-test-suite.fif, gan dearmad a dhéanamh ar an líne dheireanach a athsholáthar.

Déanaimid seiceáil go n-éiríonn leis an tástáil: 

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

Anseo Is féidir leat an gealltanas comhfhreagrach leis na torthaí reatha a fheiceáil.

Tabhair faoi deara go bhfuil sé deacair an cód tiomsaithe de chonradh cliste a chóipeáil i gcónaí i gcomhad le tástálacha, agus mar sin scríobhfaimid script a scríobhfaidh an cód isteach i tairiseach dúinn, agus déanfaimid an cód tiomsaithe a nascadh go simplí lenár dtástálacha ag baint úsáide as. "include".

Cruthaigh comhad san fhillteán tionscadail build.sh leis an ábhar seo a leanas. 

#!/bin/bash

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

Déanaimis é inrite. 

chmod +x ./build.sh

Anois, níl le déanamh ach ár script a reáchtáil chun an conradh a thiomsú. Ach ina theannta sin, ní mór dúinn a scríobh isteach i tairiseach code. Mar sin cruthóimid comhad nua lotter-compiled-for-test.fif, a chuirfimid san áireamh sa chomhad lottery-test-suite.fif.

Cuirimis cód skirpt le sh, rud a dhéanfaidh dúbailt ar an gcomhad tiomsaithe i lotter-compiled-for-test.fif agus athraigh an líne dheireanach ann. 

# 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

Anois, le seiceáil, rithfimid an script mar thoradh air agus ginfear comhad lottery-compiled-for-test.fif, a chuirfimid san áireamh inár lottery-test-suite.fif

В lottery-test-suite.fif scrios an cód conartha agus cuir an líne leis "lottery-compiled-for-test.fif" include.

Reáchtálaimid tástálacha chun a chinntiú go n-éiríonn leo. 

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

Go hiontach, anois chun seoladh tástálacha a uathoibriú, déanaimis comhad a chruthú test.sh, a fhorghníomhóidh ar dtús build.sh, agus ansin na tástálacha a reáchtáil. 

touch test.sh
chmod +x test.sh

Scríobhaimid taobh istigh

./build.sh 

echo "nCompilation completedn"

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

Lig dúinn é a dhéanamh test.sh agus é a reáchtáil chun a chinntiú go n-oibríonn na tástálacha. 

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

Déanaimid seiceáil go gcuirtear an conradh le chéile agus go ndéantar na tástálacha.

Go hiontach, anois ar tosaithe test.sh Déanfar na tástálacha a thiomsú agus a reáchtáil láithreach. Seo é an nasc chuig gealltanas.

Ceart go leor, sula leanaimid ar aghaidh, déanaimis rud amháin eile ar mhaithe le caoithiúlacht.

Cruthaímid fillteán build áit a stórálfaimid an conradh cóipeáilte agus a chlón scríofa i dtariseach lottery-compiled.fif, lottery-compiled-for-test.fif. A ligean ar a chruthú freisin fillteán test cá stórálfar an comhad tástála? lottery-test-suite.fif agus comhaid tacaíochta eile a d'fhéadfadh a bheith ann. Nasc le hathruithe ábhartha.

Leanfaimid orainn ag forbairt an chonartha cliste.

Ansin ba chóir go mbeadh tástáil ann a sheiceálann go bhfuarthas an teachtaireacht agus go ndéantar an cuntar a nuashonrú sa siopa nuair a sheolaimid an uimhir cheart. Ach déanfaimid é sin níos déanaí.

Anois déanaimis smaoineamh ar an struchtúr sonraí agus na sonraí is gá a stóráil sa chonradh cliste.

Déanfaidh mé cur síos ar gach rud atá á stóráil againn. 

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

Ansin ní mór duit dhá fheidhm a scríobh. A ligean ar glaoch ar an gcéad dul síos pack_state(), a phacáil na sonraí lena shábháil ina dhiaidh sin sa stóráil chonartha cliste. A ligean ar glaoch ar an dara unpack_state() léifidh agus seolfaidh sé sonraí ón stóráil. 

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

Cuirimid an dá fheidhm seo le tús an chonartha cliste. Oibreoidh sé amach mar seo toradh idirmheánach.

Chun sonraí a shábháil beidh ort an fheidhm ionsuite a ghlaoch set_data() agus scríobhfaidh sé sonraí ó pack_state() sa stóráil chonartha cliste. 

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

Anois go bhfuil feidhmeanna áisiúla againn chun sonraí a scríobh agus a léamh, is féidir linn dul ar aghaidh.

Ní mór dúinn a sheiceáil go bhfuil an teachtaireacht a thagann isteach ón taobh amuigh sínithe ag úinéir an chonartha (nó úsáideoir eile a bhfuil rochtain aige ar an eochair phríobháideach).

Nuair a fhoilsímid conradh cliste, is féidir linn é a thúsú leis na sonraí a theastaíonn uainn i stóráil, a shábháilfear lena n-úsáid amach anseo. Déanfaimid taifead ar an eochair phoiblí ansin ionas gur féidir linn a fhíorú gur síníodh an teachtaireacht isteach leis an eochair phríobháideach chomhfhreagrach.

Sula leanaimid ar aghaidh, cruthaimis eochair phríobháideach agus scríobhfaimid chuici test/keys/owner.pk. Chun seo a dhéanamh, a ligean ar sheoladh Fift i mód idirghníomhach agus a fhorghníomhú ceithre orduithe.

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

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

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

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

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

Cruthaímid fillteán keys taobh istigh den fhillteán test agus scríobh an eochair phríobháideach ann. 

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

Feicimid comhad san fhillteán reatha owner.pk.

Bainimid an eochair phoiblí den chruach agus nuair is gá is féidir linn é a fháil ón gceann príobháideach.

Anois ní mór dúinn fíorú sínithe a scríobh. Let tús leis an tástáil. Ar dtús léigh muid an eochair phríobháideach ón gcomhad ag baint úsáide as an bhfeidhm file>B agus scríobh chuig athróg é owner_private_key, ansin ag baint úsáide as an fheidhm priv>pub tiontaigh an eochair phríobháideach go eochair phoiblí agus scríobh an toradh isteach 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 !

Beidh an dá eochair ag teastáil uainn.

Cuirimid tús leis an stóráil chonartha cliste le sonraí treallach san ord céanna agus atá san fheidhm pack_state()agus scríobh isteach in athróg é 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 !

Ansin, déanfaimid teachtaireacht sínithe a chumadh, ní bheidh ann ach an síniú agus an luach cuntair.

Ar dtús, cruthaímid na sonraí a theastaíonn uainn a tharchur, ansin sínímid é le heochair phríobháideach agus ar deireadh ginimid teachtaireacht sínithe. 

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 sin, déantar an teachtaireacht a chuirfimid chuig an gconradh cliste a thaifeadadh in athróg message_to_send, faoi fheidhmeanna hashu, ed25519_sign_uint is féidir leat léamh i gcáipéisíocht Fift.

Agus chun an tástáil a rith glaoimid arís. 

message_to_send @ 
recv_external 
code 
storage @
c7
runvmctx

Anseo mar sin Ba cheart go mbeadh cuma mar seo ar an gcomhad le tástálacha ag an gcéim seo.

Déanaimis an tástáil a reáchtáil agus teipfidh sé, mar sin déanfaimid an conradh cliste a athrú ionas gur féidir leis teachtaireachtaí den fhormáid seo a fháil agus an síniú a fhíorú.

Ar dtús, déanaimid 512 giotán den síniú ón teachtaireacht a chomhaireamh agus é a scríobh chuig athróg, ansin déanaimid 32 giotán den athróg chuntar a chomhaireamh.

Ós rud é go bhfuil feidhm againn chun sonraí a léamh ón stóráil chonartha cliste, úsáidfimid é.

Is é Next seiceáil an gcuntar aistrithe leis an stóráil agus seiceáil an síniú. Mura n-oireann rud éigin, caithimid eisceacht leis an gcód cuí. 

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

Tiomantas ábhartha anseo.

A ligean ar a reáchtáil na tástálacha agus a fheiceáil go mainneoidh an dara tástáil. Ar dhá chúis, níl go leor giotán sa teachtaireacht agus níl go leor giotán sa stóráil, mar sin tuairteanna an cód nuair a parsáil. Ní mór dúinn síniú a chur leis an teachtaireacht atá á seoladh againn agus an stóráil a chóipeáil ón tástáil dheireanach.

Sa dara tástáil, cuirfimid síniú teachtaireachta agus athróimid an stóráil conartha cliste. Anseo mar sin tá cuma ar an gcomhad le tástálacha faoi láthair.

Scríobhaimis an ceathrú tástáil, ina seolfaimid teachtaireacht sínithe le heochair phríobháideach duine eile. Déanaimis eochair phríobháideach eile a chruthú agus é a shábháil i gcomhad not-owner.pk. Déanfaimid an teachtaireacht a shíniú leis an eochair phríobháideach seo. Déanaimis na tástálacha a reáchtáil agus cinntigh go n-éireoidh le gach tástáil. Geall faoi ​​láthair.

Anois is féidir linn bogadh ar aghaidh ar deireadh chuig loighic an chonartha chliste a chur i bhfeidhm.
В recv_external() glacfaimid le dhá chineál teachtaireachtaí.

Ós rud é go carnóidh ár gconradh caillteanais na n-imreoirí, ní mór an t-airgead seo a aistriú chuig cruthaitheoir an chrannchuir. Taifeadtar seoladh sparán cruthaitheoir an chrannchuir sa stóráil nuair a chruthaítear an conradh.

Ar eagla na heagla, ní mór dúinn an cumas an seoladh a sheolaimid gram de na cailliúnaithe a athrú. Ba cheart go mbeimis in ann gram a sheoladh ón gcrannchur chuig seoladh an úinéara freisin.

Let tús leis an gcéad cheann. Scríobhfaimid an chéad tástáil a sheiceálfaidh, tar éis an teachtaireacht a sheoladh, gur shábháil an conradh cliste an seoladh nua sa stóráil. Tabhair faoi deara go bhfuil sa teachtaireacht, chomh maith leis an gcuntar agus an seoladh nua, a tharchur againn freisin action Uimhir neamh-dhiúltach slánuimhir 7-giotán, ag brath air, roghnóimid conas an teachtaireacht a phróiseáil sa chonradh cliste. 

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

Sa tástáil is féidir leat a fheiceáil conas a dhéantar stóráil conartha cliste a dhíshraithiú storage i gCúigiú. Déantar cur síos ar dhíshraithiú athróg i gcáipéisíocht Fift.

Geall nasc le taos breise.

Déanaimis an tástáil a reáchtáil agus cinntigh go dteipeann uirthi. Anois cuirimis an loighic chun seoladh úinéir an chrannchuir a athrú.

Sa chonradh cliste leanaimid ar aghaidh ag parsáil message, léigh i action. Cuir i gcuimhne duit go mbeidh dhá cheann againn action: athraigh seoladh agus seol gram.

Ansin léigh muid seoladh nua úinéir an chonartha agus é a shábháil i stóráil.
Reáchtálaimid na tástálacha agus feicimid go dteipeann ar an tríú tástáil. Tuairteanna sé mar gheall ar an bhfíric go bhfuil an conradh anois parsáil chomh maith 7 giotán ón teachtaireacht, atá in easnamh sa tástáil. Cuir ceann nach bhfuil ann leis an teachtaireacht action. A ligean ar a reáchtáil na tástálacha agus a fheiceáil go n-éiríonn gach rud. Anseo gealltanas a thabhairt d'athruithe. Go hiontach.

Anois scríobhaimis an loighic chun an líon sonraithe gram a sheoladh chuig an seoladh a sábháladh roimhe seo.

Ar dtús, scríobhaimis tástáil. Scríobhfaimid dhá thástáil, ceann amháin nuair nach bhfuil go leor cothromaíocht ann, an dara ceann nuair ba chóir go n-éireodh le gach rud. Is féidir tástálacha a fheiceáil sa ghealltanas seo.

Anois cuirimis an cód leis. Gcéad dul síos, a ligean ar scríobh dhá mhodh cúntóir. Is é an chéad mhodh a fháil ná cothromaíocht reatha conradh cliste a fháil amach. 

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

Agus tá an dara ceann le haghaidh gram a sheoladh chuig conradh cliste eile. Chóipeáil mé an modh seo go hiomlán ó chonradh cliste 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
}

Cuirfimid an dá mhodh seo leis an gconradh cliste agus scríobhfaimid an loighic. Ar dtús, déanaimid parsáil ar líon na ngraim ón teachtaireacht. Ansin seiceáilimid an t-iarmhéid, mura leor é caithfimid eisceacht. Má tá gach rud ceart go leor, ansin cuirimid na gram chuig an seoladh sábháilte agus nuashonraigh an gcuntar. 

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

Anseo mar sin cuma an conradh cliste faoi láthair. Déanaimis na tástálacha a reáchtáil agus cinntigh go n-éireoidh leo.

Dála an scéil, déantar coimisiún a bhaint as an gconradh cliste gach uair le haghaidh teachtaireacht phróiseáilte. Ionas go bhféadfaidh na teachtaireachtaí conartha cliste an t-iarratas a fhorghníomhú, tar éis seiceálacha bunúsacha is gá duit glaoch accept_message().

Anois, a ligean ar bogadh ar aghaidh go dtí teachtaireachtaí inmheánacha. Go deimhin, ní ghlacfaimid ach le gram agus seolfaimid ar ais dhá oiread an méid chuig an imreoir má bhuann sé agus an tríú cuid chuig an úinéir má chailleann sé.

Ar dtús, scríobhaimis tástáil shimplí. Chun seo a dhéanamh, ní mór dúinn seoladh tástála an chonartha cliste óna gcuirimid gram chuig an gconradh cliste.

Tá dhá uimhir sa seoladh conartha cliste, slánuimhir 32-giotán atá freagrach as an slabhra oibre agus uimhir chuntais uathúla slánuimhir neamh-dhiúltach 256-giotán sa slabhra oibre seo. Mar shampla, -1 agus 12345, is é seo an seoladh a shábhálfaimid chuig comhad.

Chóipeáil mé an fheidhm chun an seoladh a shábháil ó 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

Breathnaímid ar conas a oibríonn an fheidhm, tabharfaidh sé seo tuiscint ar conas a oibríonn Fift. Seoladh Fift i mód idirghníomhach. 

~/TON/build/crypto/fift -i

Ar dtús brúigh muid -1, 12345 agus ainm an chomhaid todhchaí "sender.addr" ar an gcruach:

-1 12345 "sender.addr"

Is é an chéad chéim eile an fheidhm a fhorghníomhú -rot, a aistríonn an chruach sa chaoi is go bhfuil uimhir chonartha chliste uathúil ag barr an chruach: 

"sender.addr" -1 12345

256 u>B athraíonn slánuimhir neamhdhiúltach 256-giotán go beart. 

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap malartaíonn sé an dá ghné is airde den chruach. 

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B athraíonn slánuimhir 32-giotán go bearta. 

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 BYTES:FFFFFFFF

B+ nascann sé dhá sheicheamh beart.

 "sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF

Arís swap. 

BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF "sender.addr"

Agus ar deireadh scríobhtar na bearta chuig an gcomhad B>file. Ina dhiaidh seo tá ár cruach folamh. A ligean ar stop Fift. Cruthaíodh comhad san fhillteán reatha sender.addr. Bogfaimid an comhad chuig an bhfillteán cruthaithe test/addresses/.

Scríobhfaimid tástáil shimplí a sheolfaidh gram ar chonradh cliste. Seo an gealltanas.

Anois féachaimis ar loighic an chrannchuir.

Is é an chéad rud a dhéanaimid ná an teachtaireacht a sheiceáil bounced nó ní má bounced, ansin déanaimid neamhaird de. bounced ciallaíonn sé go dtabharfaidh an conradh gram ar ais má tharlaíonn earráid éigin. Ní thabharfaimid gram ar ais má tharlaíonn earráid go tobann.

Déanaimid seiceáil, má tá an t-iarmhéid níos lú ná leath ghram, ansin glacaimid leis an teachtaireacht agus neamhaird a dhéanamh air.

Ansin, déanaimid parsáil ar sheoladh an chonartha cliste as ar tháinig an teachtaireacht.

Léimid na sonraí ón stóráil agus ansin scriosann muid sean-geallta ón stair má tá níos mó ná fiche acu. Ar mhaithe le caoithiúlacht, scríobh mé trí fheidhm bhreise pack_order(), unpack_order(), remove_old_orders().

Ansin, féachaimid mura leor an t-iarmhéid don íocaíocht, ansin measaimid nach geall é seo, ach athsholáthar agus sábháil an t-athlánú i orders.

Ansin ar deireadh an croílár an chonartha cliste.

Ar dtús, má chailleann an t-imreoir, déanaimid é a shábháil sa stair gealltóireachta agus má tá an méid níos mó ná 3 gram, cuirimid 1/3 chuig úinéir an chonartha cliste.

Má bhuann an t-imreoir, seolaimid dhá oiread an méid chuig seoladh an imreora agus ansin sábhálfaimid an fhaisnéis faoin ngeall sa stair. 

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

Sin é. Gealltanas comhfhreagrach.

Anois tá gach atá fágtha simplí, cruthaímid modhanna teachta ionas gur féidir linn faisnéis a fháil ón domhan lasmuigh faoi staid an chonartha (go deimhin, léigh na sonraí óna stóráil chonartha cliste).

A ligean ar a chur modhanna a fháil. Scríobhfaimid thíos faoi conas faisnéis a fháil faoi chonradh cliste.

Rinne mé dearmad freisin an cód a chur leis a phróiseálfaidh an chéad iarratas a tharlaíonn nuair a bhíonn conradh cliste á fhoilsiú. Gealltanas comhfhreagrach. Agus a thuilleadh ceartaithe fabht le 1/3 den mhéid a sheoladh chuig cuntas an úinéara.

Is é an chéad chéim eile ná an conradh cliste a fhoilsiú. Cruthaímid fillteán requests.

Ghlac mé an cód foilsitheoireachta mar bhonn simple-wallet-code.fc a is féidir a aimsiú sa stór oifigiúil.

Rud ar fiú aird a thabhairt air. Gineann muid stór conartha cliste agus teachtaireacht ionchuir. Tar éis seo, gintear seoladh an chonartha cliste, is é sin, tá an seoladh ar eolas fiú roimh fhoilsiú i TON. Ansin, ní mór duit roinnt gram a sheoladh chuig an seoladh seo, agus ach amháin ina dhiaidh sin ní mór duit comhad a sheoladh leis an gconradh cliste féin, ós rud é go nglacann an líonra coimisiún chun an conradh cliste agus na hoibríochtaí atá ann a stóráil (bailitheoirí a stórálann agus a fhorghníomhaíonn cliste. conarthaí). Is féidir an cód a fheiceáil anseo.

Ansin déanaimid an cód foilsitheoireachta a fhorghníomhú agus a fháil lottery-query.boc comhad conartha cliste agus seoladh. 

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

Ná déan dearmad na comhaid ginte a shábháil: lottery-query.boc, lottery.addr, lottery.pk.

I measc rudaí eile, feicfimid seoladh an chonartha cliste sna logaí forghníomhaithe. 

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

Le haghaidh spraoi, déanaimis iarratas chuig TON 

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

Agus feicfimid go bhfuil an cuntas leis an seoladh seo folamh. 

account state is empty

Seolaimid chuig an seoladh 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd 2 Gram agus tar éis cúpla soicind déanaimid an t-ordú céanna a fhorghníomhú. Chun gram a sheoladh a úsáidim sparán oifigiúil, agus is féidir leat gram tástála a iarraidh ar dhuine éigin ón gcomhrá, a labhróidh mé faoi ag deireadh an ailt. 

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

Is cosúil le neamhthosaithe (state:account_uninit) conradh cliste leis an seoladh céanna agus cothromaíocht 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

Anois, déanaimis an conradh cliste a fhoilsiú. A ligean ar sheoladh lite-client agus a fhorghní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

Déanaimis seiceáil go bhfuil an conradh foilsithe. 

> last
> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

I measc rudaí eile a fhaighimid. 

  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

Feicimid é sin account_active.

Tiomantas comhfhreagrach le hathruithe anseo.

Anois, déanaimis iarratais a chruthú chun idirghníomhú leis an gconradh cliste.

Níos cruinne, fágfaimid an chéad cheann chun an seoladh a athrú mar obair neamhspleách, agus déanfaimid an dara ceann chun gram a sheoladh chuig seoladh an úinéara. Go deimhin, beidh orainn an rud céanna a dhéanamh agus atá sa tástáil le haghaidh seolta gram.

Is é seo an teachtaireacht a chuirfimid chuig an gconradh cliste, i gcás ina msg_seqno 165, action 2 agus 9.5 gram le haghaidh a sheoladh. 

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

Ná déan dearmad an teachtaireacht a shíniú le d'eochair phríobháideach lottery.pk, a gineadh níos luaithe agus an conradh cliste á chruthú. Seo é an gealltanas comhfhreagrach.

Faisnéis a fháil ó chonradh cliste ag baint úsáide as modhanna a fháil

Anois, déanaimis féachaint ar conas modhanna conartha cliste a reáchtáil.

Seoladh lite-client agus na modhanna a fháil a scríobh muid a reáchtáil. 

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

В result ina bhfuil an luach a thugann an fheidhm ar ais balance() ónár gconradh cliste.
Déanfaimid an rud céanna le haghaidh roinnt modhanna eile. 

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

Iarraimis do stair geall. 

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

Bainfimid úsáid as lite-client agus faighfimid modhanna chun faisnéis faoin gconradh cliste a thaispeáint ar an suíomh.

Sonraí conarthaí cliste a thaispeáint ar an suíomh Gréasáin

Scríobh mé suíomh Gréasáin simplí i Python chun na sonraí ón gconradh cliste a thaispeáint ar bhealach áisiúil. Anseo ní bheidh mé ag fanacht air go mion agus foilseoidh mé an suíomh in aon tiomantas.

Déantar iarratais ar TON ó Python leis an gcabhair lite-client. Ar mhaithe le caoithiúlacht, tá an suíomh pacáistithe i Docker agus foilsithe ar Google Cloud. Nasc.

Déanaimis iarracht

Anois déanaimis iarracht gram a sheoladh ann le hathlíonadh ó sparán. Seolfaimid 40 gram. Agus déanaimis cúpla geall ar mhaithe le soiléireacht. Feicimid go léiríonn an suíomh stair na geallta, an céatadán buaite reatha agus faisnéis úsáideach eile.

Feicimidgur bhuaigh muid an chéad, chaill muid an dara.

Afterword

An t-alt iompaigh amach a bheith i bhfad níos faide ná mar a bhí súil agam, b'fhéidir go bhféadfadh sé a bheith níos giorra, nó b'fhéidir díreach do dhuine a bhfuil a fhios rud ar bith faoi TON agus ba mhaith leis a scríobh agus a fhoilsiú conradh cliste nach bhfuil chomh simplí leis an gcumas chun idirghníomhú leis. é. B'fhéidir go bhféadfaí roinnt rudaí a mhíniú ar bhealach níos simplí.

B’fhéidir go bhféadfaí gnéithe áirithe den chur i bhfeidhm a dhéanamh ar bhealach níos éifeachtaí agus níos galánta, ach ansin thógfadh sé níos mó ama fós an t-alt a ullmhú. Is féidir freisin go ndearna mé botún áit éigin nó nár thuig mé rud éigin, mar sin má tá rud éigin tromchúiseach á dhéanamh agat, ní mór duit brath ar an doiciméadú oifigiúil nó ar an stór oifigiúil leis an gcód TON.

Ba chóir a thabhairt faoi deara, ós rud é go bhfuil TON féin fós sa chéim ghníomhach forbartha, go bhféadfadh athruithe tarlú a bhriseann aon cheann de na céimeanna san Airteagal seo (a tharla agus mé ag scríobh, tá sé ceartaithe cheana féin), ach is é an cur chuige ginearálta nach dócha a athrú.

Ní bheidh mé ag caint faoi thodhchaí TON. B'fhéidir go n-éireoidh an t-ardán rud éigin mór agus ba cheart dúinn am a chaitheamh ag déanamh staidéir air agus nideoige a líonadh lenár dtáirgí anois.

Tá Libra ó Facebook freisin, a bhfuil lucht féachana ionchasach úsáideoirí níos mó ná TON. Níl a fhios agam beagnach rud ar bith faoi Libra, a mheas ag an bhfóram go bhfuil i bhfad níos mó gníomhaíochta ann ná sa phobal TON. Cé go bhfuil níos mó cosúil le forbróirí agus pobail TON faoi thalamh, rud atá fionnuar freisin.

tagairtí

  1. Doiciméadúchán oifigiúil TON: https://test.ton.org
  2. Stór oifigiúil TON: https://github.com/ton-blockchain/ton
  3. Sparán oifigiúil le haghaidh ardáin éagsúla: https://wallet.ton.org
  4. Stór conartha cliste ón alt seo: https://github.com/raiym/astonished
  5. Nasc chuig suíomh Gréasáin an chonartha chliste: https://ton-lottery.appspot.com
  6. Stór le haghaidh an síneadh le haghaidh Visual Studio Code for FunC: https://github.com/raiym/func-visual-studio-plugin
  7. Comhrá faoi TON i Telegram, rud a chabhraigh i ndáiríre chun é a dhéanamh amach ag an gcéad chéim. Is dóigh liom nach botún a bheidh ann má deirim go bhfuil gach duine a scríobh rud éigin do TON ann. Is féidir leat gram tástála a iarraidh ansin freisin. https://t.me/tondev_ru
  8. Comhrá eile faoi TON ina bhfuair mé eolas úsáideach: https://t.me/TONgramDev
  9. An chéad chéim den chomórtas: https://contest.com/blockchain
  10. An dara céim den chomórtas: https://contest.com/blockchain-2

Foinse: will.com

Add a comment