Quomodo scribere et edere dolorem contractum in TON

Quid est hic articulus de?

In articulo loquar quomodo in primo (duorum) telegraphi impedimento certaminis interfui, praemium non sumpsit, et experientiam meam in articulo notare decrevi ut in oblivionem non deficiat et fortasse adiuvet. aliquis.

Cum codicem abstractum scribere nolui, sed aliquid operandi facere, articulum scripsi contractum acri momento sortitio et a website quod notitia contractus acri statim ex TON ostendit sine repositione media utendo.

Articulus utilis erit illis qui primum captiosos contractus in TON facere volunt, sed ubi committitur nesciunt.

Ut exemplum sortitio utens, ibo ab institutione ambitus ad edendam gravem contractum, mutuam cum ea, et scribendo website ad recipiendas et edendas notitias.

De participatione competition

Novissimo Octobri, Telegram e stipendio certatum novis linguis denuntiavit Fift и FunC. Necessarium erat eligere e scribendo aliquem ex quinque contractibus captiosis propositis. Putavi pulchrum esse aliquid aliud agere, linguam discere et aliquid facere, etiamsi aliud in posterum scribere non debeam. Plus, locus semper in ore est.

Dignum est dicere me nullam expertus sum contractus captiosos enucleare.

Cogitavi participem usque ad finem usque dum possem et deinde articulum retractationis scribere, sed statim ad primum defecit. ego scripsit peram cum multi-subscriptio in FunC et plerumque laboraverunt. Et tuli ut basis dolor contractus soliditatis.

Illo tempore hoc satis certum esse putabam ut aliquem saltem locum praemii capiam. Quam ob rem participes facti sunt circiter 40 ex 60 praemiis victores et inter eos non eram. Fere nihil mali est, sed unum me vexavit. In tempore nuntiationis eventus, recognitionem contractus mei non esse factam, participes chatis quaesivi si quis alius esset qui non haberet, nullus esset.

Ut videtur animadvertere nuntiis meis, post biduum iudices commentarium ediderunt et adhuc non intellego num forte fallant meum contractum callidum in iudicando vel simpliciter putaverunt tam malum esse ut commento non egeret. Interrogavi in pagina, sed responsum non accepit. Etsi non est occultum qui iudicavit, necesse duxi epistulas personales scribere.

Multum temporis consumptum est intellectui, ut articulum scribere placuit. Cum nondum sit amet informationes, hic articulus adiuvabit tempus nisi pro omnibus, quorum interest.

Notio dolor contractus in TON

Priusquam aliquid scribas, debes instar ex qua parte ad hanc rem accedere. Proinde nunc quibus partibus ratio sit referam. Accuratius, quas partes debes scire ad scribendum aliqua saltem operandi contractus.

Nos focus in scribendo acri contractu et operando cum TON Virtual Machine (TVM), Fift и FunCsic articulus evolutionis regularis programmatis similior est. Non morabimur in quomodo hic suggestus operatur.

In genere quomodo operatur TVM et lingua Fift Bona documenta publica est. Dum in lite communicans et nunc dum contractum hodiernum scribebat, saepe ad eam conversus sum.

Praecipua lingua in qua captiosus contractus scriptum est FunC. Nulla documenta in eo momento, ideo ad aliquid scribendum debes studere exempla calliditatis contractuum ex repositorio officiali et exsequenda ipsius linguae ibi, plus inspicere potes exempla captivorum contractuum ex duobus praeteritis. certationes. Nexus in fine articuli.

Dicamus nos iam scriptum contractus acri for FunCposteaquam codicem in Fift coadunatorem compigimus.

Composuit contractus dolor sit amet nisl. Ad hoc munus scribere debes Fift, qui codicem captiosum contractum capiet et nonnulla alia parametri inputa , et output fasciculus cum extensione erit .boc (quod significat "peram cellularum"), et, secundum quam scribimus, clavis et inscriptio privata, quae ex codice contracto acri generatur. Iam P. mittere potes ad inscriptionem contractus acri nondum divulgato.

Dolor contractus in TON evulgare accepit .boc tabella necesse erit ad impedimentum mittendum uti clienti levi (more in illo infra). Sed ante edendum, debes P. ad inscriptionem generatam transferre, alioquin dolor contractus publici iuris fieri non potest. Post publicationem, cum callide contractus potes, nuntios ab extra mittendo (exempli gratia, levi cliente utens) vel ab intus (exempli gratia, unus contractus dolor alium nuntium intus TON mittit).

Intelleximus quomodo codicem editum sit facilior. Durius scimus quid scribere velimus et quomodo programmata nostra operabuntur. Et dum scribemus, quaerimus quomodo hoc iam impleatur in contractibus captiosis existentibus, vel in codice exsequendo inspicimus? Fift и FunC in repositorio publico, seu in documentis officialibus.

Saepius quaesivi keywords in chat Telegram ubi omnes participes certationis et telegraphi operarii convenerunt, et factum est ut inter certantes omnes ibi convenerunt et de Fift et FunC disputabant. Link in fine articuli.

Tempus est a ratione ad usum movere.

Praeparans elit ad opus cum TON

Omnia feci quae in articulo de MacOS describentur et in mundis Ubuntu 18.04 LTS in Docker duplex repressit.

Primum quod debes facere est download et install lite-client quacum mittere potes postulare TON.

Instructiones in loco officiali processus institutionem plane et distincte describant ac singula quaedam omittunt. Hic instructiones sequimur, clientelas absentium per viam insertas. Unumquodque consilium non feci et constitui ex repositorio officiali Ubuntu (in MacOS usus sum 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

Cum omnes clientelae installed potes install lite-client, Fift, FunC.

Primum repositorium TON cum suis clientelis claudimus. Pro commodo, omnia in folder faciemus ~/TON.

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

Reconditorium etiam addit implementations Fift и FunC.

Nunc parati sumus ad consilium convenire. Reconditorium est cloned in folder ~/TON/ton. Quod ~/TON partum a folder build et exstent in ea.

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

Cum scribemus contractum acri, non solum nobis opus est lite-clientAutem Fift с FunCSic omnia componamus. Processus velox non est, ergo exspectamus.

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

Deinde, lima configurationem, quae notitia de nodi contineat cui lite-client coniungam.

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

Primas petitiones TON

Nunc Lorem lite-client.

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

Si aedificatum valuit, tunc post launch videbis truncum nexus clientis luminis ad nodi.

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

Potes currere imperium help et vide quid praesto sint mandata.

help

Mandata indicemus quibus in hoc articulo utemur.

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

Nunc parati sumus contractum ipsum scribere.

Реализация

idea

Sicut supra scripsi, dolor contractus quod scribimus est sortitio.

Haec autem non est sors in qua tesseram emere debes et horam, diem vel mensem expectare, sed momentum illud in quo utens ad electronicam contractus transit. N P. * et statim recipiat eam 2 * N P. vel amittit. Probabiliter nos fere 40% conciliandi faciamus. P. Si non sufficiunt ad solutionem, tunc deliberabimus rem tamquam a summo usque.

Praeterea interest sponsiones in tempore reali et forma convenienti videri potest, ut statim usor intelligat utrum lucratus sit an amiserit. Ergo debes facere website quod sponsionibus ostendet et consequitur directe ex TON.

Scribens dolor contractus

Pro commodo, codicem pro FunC illustravi, plugin in inquisitione Visuali Codicis inveni et institui potest: si subito aliquid addere vis, plugin publice praesto feci. Etiam aliquis ante plugin operando cum Fift fecit, eam etiam instituere potes et in VSC invenire.

Confestim repositorium faciamus ubi eventus medios committemus.

Ad vitam nostram faciliorem faciendam, scribemus contractum acri et probabimus localiter donec paratus est. Id solum post TON edemus.

Dolor contractus duos modos externos habet qui accessed possunt. Primis, recv_external() Hoc munus fit cum petitio contractus ab extra venit, id est, non ab TON, verbi gratia, cum ipsi nuntium generamus et per clientem mittimus. Secundo; recv_internal() hoc est, cum intra ipsum TON, contractus aliquis ad nostrum spectat. Utrisque ad munus parametri transire potes.

Si sit amet nisl, sed eget turpis in nulla.

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

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

Hic explicandum quid sit slice. Omnia data in TON Blockchain condita est collectio TVM cell or simply cell, in tali cellula quam ad 1023 referta notitiarum congerere potes et usque ad 4 nexus cum aliis cellulis.

TVM cell slice aut slice hoc est pars existentis cell parse adhibetur, postea patebit. Summa nobis est quod transferre possumus slice et secundum genus nuntium, aliquid in notitia in recv_external() aut recv_internal().

impure - a keyword quod munus indicat quod notitia contractus captiosus modificat.

Sit nisi contractus in codice lottery-code.fc et compilare.

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

Sensus vexilla considerari potest utens imperio

~/TON/build/crypto/func -help

Fift CONGREGATOR codicem compilavit in 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

localiter excussum esse potest, ad hoc ambitum parabimus.

Nota quod prima linea connectit Asm.fifscriptum est in Fift pro Fift coadunatoris.

Cum volumus currere et probare localiter contractum callidum, fasciculum creabimus lottery-test-suite.fif et codicem ibi exaratum exscribere, ultimam lineam in eo reponens, qui codicem callidum contractus constanti scribit codedeinde transferre ad machinam virtualem;

"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

Hactenus clarum videtur, nunc eundem fasciculi codicem addamus, quo TVM deducendi utemur.

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 contextum commemoramus, id est, notitia quacum TVM (vel res publica retis) deducetur. Etiam in elit, tincidunt quis creare c7 et exscripsi. In hoc articulo mutare necesse est rand_seed quia ex eo dependet generatio incerti numeri, et si non mutatur, tot idem reddetur omni tempore.

recv_internal и recv_external constantes cum valoribus 0 et -1 responsabiles erunt vocandi functiones correspondentes in contractu acri.

Nunc parati sumus primum experimentum creare contractus inanis dolor noster. Ad claritatem, nunc enim omnes probationes ad eandem limam addemus lottery-test-suite.fif.

Faciamus variabilis storage et scribe inanem in eam cell, hic erit dolor contrahendi.

message Haec est nuntius quem extra contactum acri trademus. Vacuam etiam nunc dabimus.

variable storage 
<b b> storage ! 

variable message 
<b b> message !

Postquam constantes et variabiles paravimus, TVM imperio utentes deducimus runvmctx et parametri creatum ad input transi.

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx

In fine erimus hic est medium codice for Fift.

Nunc codicem consequens currere possumus.

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

Progressio currere sine erroribus et in output videbimus exsecutionem:

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

Magnum opus scripsimus primum versio dolor contractus.

Nunc opus est ut functionality addere. Primum agamus de nuntiis quae ab extra mundum veniunt recv_external()

Ipse elit nuntium format quod contractum accipere potest.

Sed plerumque

Uno modo, velimus contractum nostrum ab exterioribus tueri et facere, ut solus dominus contractus possit mittere nuntios externos ad ipsum.
deinde, cum validum nuntium ad TON mittimus, id semel prorsus evenire volumus et cum idem nuntium iterum mittimus, dolor contractus illud respuit.

Ita fere omnis contractus has duas difficultates solvit, cum contractus noster nuntios externas recipiat, necesse est etiam illius curam habere.

Faciamus nos inverso ordine. Primum quaestionem cum repetitione solvamus: si contractus iam talem nuntium accepit et processit, iterum non faciet. Problema deinde solvemus ut tantum circulus quidam hominum nuntios ad contractum callidum mittere possit.

Diversi modi sunt ut problema duplicata nuntiis eveniant. Ecce quomodo hoc faciamus. In captioso contractu initiali occurro nuntiis acceptis cum valore initiali 0. In unaquaque relatum ad captiosus contractus, hodiernam contra valorem addemus. Si valorem dictionum in nuntio non congruit quantitati captiosus contractus, tunc non processum est, si facit, tunc processimus et contra amussim in contractu augemus per 1 .

Redeamus lottery-test-suite.fif et alterum experimentum appone. Si numerus inordinatus mittimus, codice exceptionem mittat. Verbi gratia, contractus notitia copia CLXVI et CLXV mittemus.

<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"

Lorem scriptor.

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

Et videbimus quod probatio fit errore.

[ 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

In hoc gradu, lottery-test-suite.fif ut tamquam Link.

Nunc addamus logicam contra rationem dolori contractus in 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 iacet nuntius mittimus.

Primum quod agimus est perceptum si nuntius inest notitia, si non, tunc simpliciter exit.

Deinde nuntium parse. in_msg~load_uint(32) numerum onerat 165, 32-bit unsigned int a nuntius traductus.

Deinde 32 frenos oneratis e captiuitatis captiuitatis repositione. Compermus quod onustus numerus unus praeteritus aequet: sin minus, exceptionem objicimus. In nobis, quoniam non pares imus, excipi debet.

Nunc compilare videamus.

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

Ita ut effingo codice lottery-test-suite.fifnon inmemores ultimam versus reponere.

Reprehendo quod probatio transit:

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

Ius hic Potes videre correspondentes committere cum eventibus currentibus.

Nota quod inconveniens est ut codicem acri contractum in lima cum probatis constanter effingo, ita scribemus scripturam quae codicem nobis constantem scribet et simpliciter codici compilatum cum probationibus nostris adhibebimus. "include".

Creare lima in project folder build.sh cum sequenti content.

#!/bin/bash

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

faciamus exsecutabile.

chmod +x ./build.sh

Nunc, sicut currite scriptionem nostram ad componendum contractum. Sed praeter haec, necesse est ut eam scribamus in constantem code. Ita novum documentum creabimus lotter-compiled-for-test.fif, quam in tabella includemus lottery-test-suite.fif.

Addamus codicem oram sh, quod fasciculi compilationem simpliciter duplicant in lotter-compiled-for-test.fif et ultimam lineam in ea mutent.

# 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

Nunc, ut inspicias, scriptum inde curramus et lima generabitur lottery-compiled-for-test.fifquas includimus in nostro lottery-test-suite.fif

В lottery-test-suite.fif dele contractum signum et adde lineam "lottery-compiled-for-test.fif" include.

Probat curritur ad reprehendo quod transeunt.

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

Magna, nunc ad launch probationum automate, fasciculum crearemus test.shquae prius faciet build.shac deinde probat.

touch test.sh
chmod +x test.sh

Scribimus intus

./build.sh 

echo "nCompilation completedn"

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

faciam test.sh et discurre fac quod probat opus.

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

Reprimimus quod contractus compilaet et probationes exsecutioni mandant.

Magna, nunc startup test.sh Probat scribentur et statim currunt. Hic est nexus cum committere.

Bene, antequam pergamus, unum pro commoditate faciamus.

Sit scriptor folder creare build ubi contractum transcriptum et eius clone scriptum in constantem servabimus lottery-compiled.fif, lottery-compiled-for-test.fif. Sit scriptor folder etiam creare test ubi test file recondi? lottery-test-suite.fif et in potentia alia lima subsidia. Link to pertinet mutationes.

Dolor contractus developing pergamus.

Proxima probatio habeatur quae cohibet nuntium acceptum et occurro renovatum in copia cum numerum rectam mittimus. Sed id postea faciamus.

Nunc cogitemus de quibus data structura et quae notitia in contractu acri condi debet.

Narrabo omnia quae condimus.

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

Deinde duo munera scribere debes. Vocemus primum pack_state(), quae notitias sequentes in repositione captiuitatis compinget. Vocemus secundo unpack_state() leget et reditus notitia ex repono.

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

Has duas functiones addimus ad principium doloris contractus. Hoc erit elaborare hic est medium exitum.

Data servare debes vocare in munere constructum set_data() et scribet ex notitia pack_state() in dolor contractus repono.

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

Nunc munera apta scribendi ac legendi nobis data, movere possumus.

Inhibere nos oportet nuntium ab extra advenientem signatum esse a domino contractu (vel alio usore qui aditum ad clavem privatam habet).

Cum dolorem contractum evulgamus, initialificare possumus cum notitia reposita quae in futuro usui servabitur. Clavem publicam ibi memorabimus ut cognoscere possimus nuntium advenientem esse signatum cum clavis privatis correspondentibus.

Priusquam pergamus, clavem privatam faciamus et eam scribemus test/keys/owner.pk. Ad hoc Fift in modum interactive deducamus et quattuor mandata faciamus.

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

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

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

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

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

Sit scriptor folder creare keys intra folder test et scribe ibi clavis privata.

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

Videmus lima in current folder owner.pk.

Clavem publicam e acervo removemus et, cum opus fuerit, a privato accipere possumus.

Nunc verificationis signature opus est scribere. Incipiamus cum tentatione. Primum clavem privatam e tabella utens munere legimus file>B et scribere ad variabilis owner_private_keyErgo utens munus priv>pub convertat clavis privatam ad clavem publicam et scribe exitum in 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 !

Utraque clavium indigebimus.

Nos initialize dolor contractus repono notitia arbitraria in eodem ordine ac in officio pack_state()et scribe in variabili 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 !

Deinceps nuntium signatum componemus, tantum subscriptionem et valorem contrarius continebit.

Primum notitias quas transmittere velimus creamus, deinde eam cum clavis privata signamus ac demum nuntium signatum generamus.

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 !

Quam ob rem nuntius quem mittemus ad captiosam contractum in variabili memoratur message_to_send, de muneribus hashu, ed25519_sign_uint potes legere in quinto documenta.

Et iterum tentationem currere vocamus.

message_to_send @ 
recv_external 
code 
storage @
c7
runvmctx

Sicut hoc Tabella cum probationibus ut hac in re spectare debet.

Experimentum curramus et deficiet, sic callidum contractum mutabimus ut epistulas huius formae recipere possit ac subscriptionem comprobare.

Primum numerum 512 subscriptionis computamus ac eam in variabilem scribimus, deinde 32 bitas dictionum variabiles numeramus.

Cum munus habemus ad legendi notitias ex repositione captioso contractus, ea utemur.

Proximum inhibito calculo translatum est cum repositione et subscriptione iniecta. Si aliquid non congruit, exceptionem in codice apto mittemus.

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

Pertinet committere hic.

Ad probationes curremus, et videamus ne secunda probatio deficiat. Duabus de causis in nuntio satis frena non sunt et satis frena non sunt in repositione, itaque signum inruerit cum parsing. Necesse est nobis subscriptionem addere nuntio mittimus et repositio ex ultimis experimentis effingo.

In secundo experimento, nuntium subscriptio adiciamus et captiosam contractus repono mutamus. Sicut hoc tabella cum probat similis in tempore.

Quartum testimonium scribamus, in quo mittemus nuntium cum alterius clavis privatis signatum. Aliam clavem privatam faciamus et eam ad limam serves not-owner.pk. Epistulam cum hac clavis privata signabimus. Probat curramus et fac ut omnes probationes transeant. Committere et in hoc tempore.

Nunc tandem progredi possumus ad logicam contractus acri exsequendam.
В recv_external() duo genera epistularum accepturi sumus.

Cum contractus noster damna scaenicorum accumulabit, haec pecunia ad sortis creatorem transferri debet. Inscriptio pera sortitionis creatoris scripta est in repositione cum contractus creatur.

Modo in casu, facultate indigemus inscriptionis mutandae ad quam P. victos mittimus. P. etiam ex sortitio ad electronicam domini mittere poterimus.

Cum primum sit amet. Primum scribe experimentum quod reprehendo, praemisso nuntio, captiosus contractus novam inscriptionem in repositione servavit. Nota quaeso quod in nuntio, praeterquam occurro et inscriptionem novam, nos etiam transmittimus action Numerus 7-bit integer non-negativus, eo fretus, eligemus quomodo nuntius processurus in contractu acri.

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

In experimento videre potes quomodo repono contractus est deserialized storage in Fift. Deserialization variabilium in Fif documentis describitur.

Committere link cum addita farina.

Experimentum curramus, et deficio fac. Nunc logicam addamus, ut sortis possessorem mutet oratio.

In dolor contractus pergimus ad parse message, lege in action. te admoneamus nos duos habebimus action: muta oratio et P. mitte.

Deinde inscriptionem novam contractus possessoris legimus et in reposita servamus.
Experimenta currimus, et tertia probatio deficit. Inruerit ex eo quod contractus nunc additis 7 particulis ex nuntio, quae desunt in test. Addere non-esse nuntium action. Experimenta curremus, et videamus omnia praeterire. hic vices committere. Magna.

Nunc logicam scribamus ut certum numerum P. ad inscriptionem antea servatam mittendam.

Primum experimentum scribere. Duo experimenta scribemus, unum cum non satis statera, alterum cum omnia feliciter eveniunt. Probat videri potest hoc committere.

Nunc codicem addamus. Primum duos adiutores modi scribamus. Primus modus nanciscendam est invenire hodiernam libram acri contractus.

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

et secundus est pro mittendo P. ad alium contractum callidum. Hanc methodum prorsus exscripsi ex alio contracto callido.

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

Hos duos modos ad captiosos contractus et logicam scribendos addamus. Primo, numerum P. ex verbo. Deinde stateram refutamus, si non satis excipimus. Si omnia bona sunt, P. mittimus ad inscriptionem servatam et contra renovationem.

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

Sicut hoc similis dolor contractus tempore. Testimonia curramus et fac ut transeant.

Obiter mandatum detrahitur ex contractu acri omni tempore pro processu nuntius. Ut nuntiis contractus captiosis ad petitionem exsequendam, post postulata fundamentalia vocare debes accept_message().

Nunc ad nuntios internas transeamus. In facto tantum P. acceptabimus et remittimus duplum lusori si vincit, et tertiam domino si amiserit.

Primum simplex test scribere. Ad hoc opus est oratio probationis contractus ophthalmiae e quo velut P. ad contractum captiosum mittemus.

Inscriptio contractus sollers in duobus numeris consistit, 32 frenum integer erga ergastulum author et 256 frenum integer non-negativus numerus singularis in hoc workcha. Eg -1 et 12345, haec est oratio limam servabimus.

Exscripsi munus servandi inscriptionis e 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

Intueamur quomodo opus sit munus, hoc dabit intellegentiam quam Fift opera. Launch Fift in modus interactive.

~/TON/build/crypto/fift -i

Primo impellimus -1, 12345 et nomen futuri fasciculi "sender.addr" in acervum;

-1 12345 "sender.addr"

Proximum est munus exequi -rotACERVUS ita ut in summa ACERVUS sit singularis callidi numerus;

"sender.addr" -1 12345

256 u>B converts ad CCLVI frenum non-integrum negativum ad bytes.

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap swaps the top two elements of the ACERVUS.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B convertat XXXII frenum integer ad bytes.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 BYTES:FFFFFFFF

B+ duo sequentia bytes connectit.

 "sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF

rursus swap.

BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF "sender.addr"

Postremo bytes in tabella scripti sunt B>file. Post hunc acervus noster vacuus est. Nos prohibere Fift. File creata in current folder sender.addr. Sit scriptor creatum in tabella movere folder test/addresses/.

Scribere simplex experimentum quod P. ad acri contractu mittet. Hic est committere.

Nunc rationem sortiendi videamus.

Primum est reprehendo verbo facimus bounced aut non if bouncedergo negligimus. bounced significat contractum rediturum P. si aliquis error inciderit. P. Non revertemur, si subito incidit error.

Reprehendimus, si statera minor est quam dimidium gram, simpliciter nuntium accipimus et eum negligimus.

Deinde parse inscriptione contractus captiosus unde nuntius venit.

Legimus notitias e repositione et tunc vetera sponsionibus ex historia delere si plures quam viginti sunt. Pro commodo, tria munera additamenta scripsi pack_order(), unpack_order(), remove_old_orders().

Deinde quaerimus si statera non sufficit ad solutionem, tunc consideramus quod hoc non est bet, sed a repletione et conservatio in. orders.

Tunc demum essentia dolor contractus.

Primum, si lusor amittit, eam in historia sponsionis servamus et si moles plus quam 3 P. III, 1/3 ad dominum contractus callidi mittimus.

Si ludio ludius vincit, duplicem quantitatem in inscriptione lusoris mittimus et tunc informationes de sponsio in historia serva.

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

Quod suus omnes. correspondentes committere.

Nunc omnia quae restant simplicia sunt, methodos creare faciamus ut informationem habere possimus de statu contractus ab extra (re vera, notitias legere e repositione captiuitatis suae).

Sit scriptor addere modi possidebit. Infra scribemus quomodo informationes accipias de contractu acri.

Oblitus sum etiam codicem addere qui processura est in ipsa petitione prima quae occurrit cum libellorum captiosi contractus. correspondentes committere... Et ulterius correctum bug mittens 1/3 de quantitate ad rationem domini.

Proximum est edendi contractus callidi. Sit scriptor folder creare requests.

Accepi editionem codice pro fundamento simple-wallet-code.fc quod inveniri potest in repositio officialis.

Operae pretium est aliquid. Nos repositionis contractus dolor gignimus et nuntium initus. Post haec, oratio de contractu dolorum gignitur, hoc est, oratio etiam ante publicationem in TON nota est. Deinde plures P. ad hanc inscriptionem mittere debes, et tantum postea fasciculum cum ipso contractu calloso mittere debes, cum retiacula mandata sumit ut contractus captiosus et operationes in ea (validatores qui reponunt et captiosam exercent. pactiones). Codex hic considerari potest.

Deinde exequimur codicem edendi et adepto lottery-query.boc dolor contractus lima et oratio.

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

Noli oblivisci nisi generatae files: lottery-query.boc, lottery.addr, lottery.pk.

Inter alia inscriptionem contractam acerbissimam in exsecutione tigna videbimus.

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

Iustus pro fun, rogamus ut TON

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

Et videbimus rationem cum hac inscriptione vacua esse.

account state is empty

Mittimus ad electronica 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd 2 Gram, et post brevi tempore idem praeceptum exequimur. P. Ut utar officialis peraet petere potes aliquem a chat pro testi P., de quo in fine articuli loquar.

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

Similis uninitialized (state:account_uninit) contractus acri cum eadem inscriptione et libra 1 nanogramorum.

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

Nunc accumsan dolor sit amet nisl. Lorem lite-clientem faciamus et faciamus.

> 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

Sit scriptor reprehendo quod contractus publici iuris factus est.

> last
> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

Inter alia fuat.

  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

Quod videmus account_active.

Correspondentes mutationes hic.

Nunc petamus ut penitus cum dolore contractus crearemus.

Accuratius primum relinquemus in inscriptione mutanda tamquam operis sui iuris, et alterum faciemus pro P. mittendi inscriptione domini. In facto, idem nos facere debebimus ac in test P. mitto.

Hoc nuntium mittemus ad captiosam pactionem, ubi msg_seqno 165, action P. 2 et 9.5 ad mittam.

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

Noli oblivisci subscribere verbo cum privatis clavis lottery.pkquae generata prius cum callidis contractibus. Hic est correspondentes committere.

Accepto notitia ex captiosus contractus utendi modi

Nunc inspiciamus quo pacto contractus callidior currendi methodos possideat.

Launch lite-client et percurre modos quos scripsimus.

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

В result habet valorem quod munus redit balance() a nostro dolor contractus.
Idem pluribus pluribus modis faciemus.

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

Quaeramus pro bet historia.

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

Utemur lite-clientis et methodos adhibebimus ad informationem ostentandam de acri contractu in situ.

Ostendens captiosus notitia contractus in website

Simplicem locum in Pythone scripsi ut notitias ex acri contractu convenienti modo ostenderet. Hic ego in eo non moror singillatim et evulgabo locum in uno committere.

Petitiones ad TON fiunt ex Python propter lite-client. Pro commodo, situs in Docker packaged et editus in Google Cloud. Link.

Conatus

Nunc experiamur P. ibi mittere pro repletione e sacculus. P. 40 mittemus. Et duos sponsiones ad claritatem faciamus. Videmus situm esse historiam sponsionum, hodiernam conciliationem recipis et alia utilia indicia.

videmusquod prima vicimus, secunda perdimus.

afterword

Articulus evasit multo longior quam exspectavi, fortasse brevius esse potuit, vel fortasse iustus pro eo qui nihil de TON scit et scribere vult et evulgare non-sic-simplex dolor contractus cum facultate mutuae cum illud. Fortassis aliqua simplicius explicari potuerunt.

Fortassis aliquae rationes exsecutionis efficacius et elegantius fieri potuissent, sed tunc temporis etiam tempus praeparandi articulum cepisset. Fieri etiam potest ut alicubi erraverim vel non intellexi aliquid, si quid gravius agis, opus est documentis publicis niti vel repositorio officiali cum codice TON.

Animadvertendum est, cum ipsa TON adhuc in evolutionis stadio activo, mutationes in hoc articulo (quod factum est cum scriberem, jam correctum sit) occurrere possit, ut in hoc articulo aliqua frangatur. inconveniens mutare.

De futuro TON non loqui. Fortassis suggestus aliquid magnum fiet et nos illud tempus vacare studeamus et angulum cum productis nostris nunc impleamus.

Est etiam Libra a Facebook, quae potentialem audientiam users maiorem quam TON habet. De Libra nihil fere novi, in foro iudicans multo plus ibi esse quam in communitate TON. Quamquam tincidunt et communitas TON similiores sunt sub terra, quae etiam frigus est.

References

Documenta officialis TON: https://test.ton.org
Repositorium officialis TON: https://github.com/ton-blockchain/ton
Officialis pera pro diversis suggestis; https://wallet.ton.org
Captio contractus repositorium ex hoc articulo: https://github.com/raiym/astonished
Ad dolor contractus website: https://ton-lottery.appspot.com
Repositorium extensionis pro Visual Studio Code pro FunC: https://github.com/raiym/func-visual-studio-plugin
Loqui de TON in Telegram, quod vere adiuvatur ut eam in ineunte scaena viderit. Puto non erraturum esse si dixero omnes qui aliquid scripserunt pro TON ibi esse. P. Ibi probare etiam potes. https://t.me/tondev_ru
Alius chat de TON in quo informationes utiles inveni: https://t.me/TONgramDev
Primo stadio certationis: https://contest.com/blockchain
Secundus gradus certationis: https://contest.com/blockchain-2

Source: www.habr.com

Quomodo scribere et edicere acri contractu in Network Telegram Open (TON)