ກ່ຽວກັບວິທີການຂຽນແລະເຜີຍແຜ່ສັນຍາສະຫມາດໃນ TON

ບົດຄວາມນີ້ກ່ຽວກັບຫຍັງ?

ໃນບົດຄວາມຂ້າພະເຈົ້າຈະສົນທະນາກ່ຽວກັບວິທີທີ່ຂ້າພະເຈົ້າໄດ້ເຂົ້າຮ່ວມໃນຄັ້ງທໍາອິດ (ສອງ) ການແຂ່ງຂັນ Telegram blockchain, ບໍ່ໄດ້ເອົາລາງວັນ, ແລະຕັດສິນໃຈທີ່ຈະບັນທຶກປະສົບການຂອງຂ້າພະເຈົ້າໃນບົດຄວາມເພື່ອບໍ່ໃຫ້ມັນຈົມລົງໃນ oblivion ແລະ, ບາງທີອາດ, ຊ່ວຍ. ຄົນ.

ເນື່ອງຈາກວ່າຂ້ອຍບໍ່ຢາກຂຽນລະຫັດທີ່ບໍ່ມີຕົວຕົນ, ແຕ່ເຮັດບາງສິ່ງບາງຢ່າງທີ່ເຮັດວຽກ, ສໍາລັບບົດຄວາມທີ່ຂ້ອຍຂຽນສັນຍາສະຫມາດສໍາລັບການຈັບສະຫລາກທັນທີແລະເວັບໄຊທ໌ທີ່ສະແດງຂໍ້ມູນສັນຍາສະຫມາດໂດຍກົງຈາກ TON ໂດຍບໍ່ຕ້ອງໃຊ້ການເກັບຮັກສາລະດັບກາງ.

ບົດຄວາມຈະເປັນປະໂຫຍດຕໍ່ຜູ້ທີ່ຕ້ອງການເຮັດສັນຍາສະຫມາດທໍາອິດຂອງພວກເຂົາໃນ TON, ແຕ່ບໍ່ຮູ້ວ່າຈະເລີ່ມຕົ້ນຈາກໃສ.

ການນໍາໃຊ້ lottery ເປັນຕົວຢ່າງ, ຂ້າພະເຈົ້າຈະໄປຈາກການຕິດຕັ້ງສະພາບແວດລ້ອມເພື່ອເຜີຍແຜ່ສັນຍາສະຫມາດ, ພົວພັນກັບມັນ, ແລະຂຽນເວັບໄຊທ໌ສໍາລັບການຮັບແລະເຜີຍແຜ່ຂໍ້ມູນ.

ກ່ຽວກັບການເຂົ້າຮ່ວມການແຂ່ງຂັນ

ເດືອນຕຸລາທີ່ຜ່ານມາ, Telegram ໄດ້ປະກາດການແຂ່ງຂັນ blockchain ດ້ວຍພາສາໃຫມ່ Fift и FunC. ມັນຈໍາເປັນຕ້ອງເລືອກຈາກການຂຽນໃດໆໃນຫ້າສັນຍາສະຫມາດທີ່ສະເຫນີ. ຂ້ອຍຄິດວ່າມັນຈະເປັນການດີທີ່ຈະເຮັດບາງສິ່ງບາງຢ່າງທີ່ແຕກຕ່າງກັນ, ຮຽນຮູ້ພາສາແລະເຮັດບາງສິ່ງບາງຢ່າງ, ເຖິງແມ່ນວ່າຂ້ອຍບໍ່ຈໍາເປັນຕ້ອງຂຽນຫຍັງອີກໃນອະນາຄົດ. ນອກຈາກນັ້ນ, ຫົວຂໍ້ແມ່ນຢູ່ສະເຫມີຢູ່ໃນປາກ.

ມັນເປັນມູນຄ່າທີ່ບອກວ່າຂ້ອຍບໍ່ມີປະສົບການໃນການພັດທະນາສັນຍາສະຫມາດ.

ຂ້າພະເຈົ້າໄດ້ວາງແຜນທີ່ຈະເຂົ້າຮ່ວມຈົນກ່ວາທີ່ສຸດຈົນກ່ວາຂ້າພະເຈົ້າສາມາດແລະຫຼັງຈາກນັ້ນຂຽນບົດທົບທວນຄືນ, ແຕ່ຂ້າພະເຈົ້າລົ້ມເຫລວທັນທີໃນຕອນທໍາອິດ. I ຂຽນກະເປົາເງິນ ມີລາຍເຊັນຫຼາຍອັນ FunC ແລະໂດຍທົ່ວໄປແລ້ວມັນໄດ້ເຮັດວຽກ. ຂ້າພະເຈົ້າໄດ້ເອົາມັນເປັນພື້ນຖານ ສັນຍາສະຫລາດກ່ຽວກັບຄວາມສາມັກຄີ.

ໃນເວລານັ້ນ, ຂ້າພະເຈົ້າຄິດວ່ານີ້ແນ່ນອນພຽງພໍທີ່ຈະເອົາຢ່າງຫນ້ອຍບາງລາງວັນ. ດັ່ງນັ້ນ, ຜູ້ເຂົ້າຮ່ວມປະມານ 40 ໃນ 60 ຄົນໄດ້ກາຍເປັນຜູ້ຊະນະລາງວັນແລະຂ້ອຍບໍ່ໄດ້ຢູ່ໃນນັ້ນ. ໂດຍທົ່ວໄປ, ບໍ່ມີຫຍັງຜິດປົກກະຕິກັບເລື່ອງນີ້, ແຕ່ມີສິ່ງຫນຶ່ງທີ່ລົບກວນຂ້ອຍ. ໃນເວລາທີ່ການປະກາດຜົນ, ການທົບທວນຄືນການທົດສອບສໍາລັບສັນຍາຂອງຂ້າພະເຈົ້າບໍ່ໄດ້ເຮັດ, ຂ້າພະເຈົ້າໄດ້ຖາມຜູ້ເຂົ້າຮ່ວມໃນການສົນທະນາວ່າມີຄົນອື່ນທີ່ບໍ່ມີມັນ, ບໍ່ມີ.

ເບິ່ງຄືວ່າໄດ້ເອົາໃຈໃສ່ກັບຂໍ້ຄວາມຂອງຂ້ອຍ, ສອງມື້ຕໍ່ມາຜູ້ພິພາກສາໄດ້ພິມຄໍາຄິດຄໍາເຫັນແລະຂ້ອຍຍັງບໍ່ເຂົ້າໃຈວ່າພວກເຂົາພາດສັນຍາສະຫມາດຂອງຂ້ອຍໂດຍບັງເອີນໃນລະຫວ່າງການຕັດສິນຫຼືພຽງແຕ່ຄິດວ່າມັນບໍ່ດີຫຼາຍທີ່ມັນບໍ່ຕ້ອງການຄໍາຄິດຄໍາເຫັນ. ຂ້າພະເຈົ້າໄດ້ຖາມຄໍາຖາມຢູ່ໃນຫນ້າ, ແຕ່ບໍ່ໄດ້ຮັບຄໍາຕອບ. ເຖິງ​ແມ່ນ​ວ່າ​ມັນ​ບໍ່​ມີ​ຄວາມ​ລັບ​ທີ່​ຕັດ​ສິນ, ຂ້າ​ພະ​ເຈົ້າ​ຖື​ວ່າ​ມັນ​ບໍ່​ຈໍາ​ເປັນ​ທີ່​ຈະ​ຂຽນ​ຂໍ້​ຄວາມ​ສ່ວນ​ບຸກ​ຄົນ.

ເວລາຫຼາຍແມ່ນໃຊ້ເວລາໃນຄວາມເຂົ້າໃຈ, ດັ່ງນັ້ນຈຶ່ງໄດ້ຕັດສິນໃຈຂຽນບົດຄວາມ. ເນື່ອງຈາກບໍ່ມີຂໍ້ມູນຫຼາຍ, ບົດຄວາມນີ້ຈະຊ່ວຍປະຫຍັດເວລາສໍາລັບທຸກຄົນທີ່ສົນໃຈ.

ແນວຄວາມຄິດຂອງສັນຍາສະຫມາດໃນ TON

ກ່ອນທີ່ທ່ານຈະຂຽນຫຍັງ, ທ່ານຈໍາເປັນຕ້ອງຄິດອອກວ່າຂ້າງໃດທີ່ຈະເຂົ້າຫາເລື່ອງນີ້ຈາກ. ເພາະສະນັ້ນ, ໃນປັດຈຸບັນຂ້າພະເຈົ້າຈະບອກທ່ານວ່າພາກສ່ວນໃດຂອງລະບົບປະກອບດ້ວຍ. ຫຼາຍທີ່ຊັດເຈນ, ພາກສ່ວນໃດທີ່ທ່ານຈໍາເປັນຕ້ອງຮູ້ເພື່ອຂຽນສັນຍາການເຮັດວຽກຢ່າງຫນ້ອຍບາງປະເພດ.

ພວກເຮົາຈະສຸມໃສ່ການຂຽນສັນຍາສະຫມາດແລະເຮັດວຽກກັບ TON Virtual Machine (TVM), Fift и FunC, ດັ່ງນັ້ນບົດຄວາມແມ່ນຄ້າຍຄືກັບຄໍາອະທິບາຍຂອງການພັດທະນາໂຄງການປົກກະຕິ. ພວກ​ເຮົາ​ຈະ​ບໍ່​ຢູ່​ໃນ​ວິ​ທີ​ການ​ຂອງ​ເວ​ທີ​ຕົວ​ມັນ​ເອງ​ເຮັດ​ວຽກ​ຢູ່​ທີ່​ນີ້​.

ໂດຍທົ່ວໄປກ່ຽວກັບວິທີການເຮັດວຽກ TVM ແລະພາສາ Fift ມີເອກະສານທີ່ເປັນທາງການທີ່ດີ. ໃນຂະນະທີ່ເຂົ້າຮ່ວມການແຂ່ງຂັນແລະໃນປັດຈຸບັນໃນຂະນະທີ່ຂຽນສັນຍາໃນປະຈຸບັນ, ຂ້ອຍມັກຈະຫັນໄປຫານາງ.

ພາສາຕົ້ນຕໍທີ່ສັນຍາສະຫມາດແມ່ນຂຽນ FunC. ບໍ່ມີເອກະສານກ່ຽວກັບມັນໃນເວລານີ້, ດັ່ງນັ້ນເພື່ອຂຽນບາງສິ່ງບາງຢ່າງ, ທ່ານຈໍາເປັນຕ້ອງໄດ້ສຶກສາຕົວຢ່າງຂອງສັນຍາສະຫມາດຈາກຄັງເກັບມ້ຽນຢ່າງເປັນທາງການແລະການປະຕິບັດພາສາຂອງມັນເອງຢູ່ທີ່ນັ້ນ, ທ່ານສາມາດເບິ່ງຕົວຢ່າງຂອງສັນຍາສະຫມາດຈາກສອງທີ່ຜ່ານມາ. ການແຂ່ງຂັນ. ການເຊື່ອມຕໍ່ໃນຕອນທ້າຍຂອງບົດຄວາມ.

ໃຫ້ເວົ້າວ່າພວກເຮົາໄດ້ຂຽນແລ້ວສັນຍາສະຫມາດສໍາລັບ FunC, ຫຼັງຈາກນັ້ນພວກເຮົາລວບລວມລະຫັດເຂົ້າໄປໃນ Fift assembler.

ສັນຍາອັດສະລິຍະທີ່ລວບລວມຍັງຄົງຖືກເຜີຍແຜ່. ເພື່ອເຮັດສິ່ງນີ້, ທ່ານຈໍາເປັນຕ້ອງຂຽນຫນ້າທີ່ຢູ່ໃນ Fift, ເຊິ່ງຈະເອົາລະຫັດສັນຍາສະຫມາດແລະບາງຕົວກໍານົດການອື່ນໆເປັນ input, ແລະຜົນໄດ້ຮັບຈະເປັນໄຟລ໌ທີ່ມີນາມສະກຸນ. .boc (ຊຶ່ງຫມາຍຄວາມວ່າ "ຖົງຂອງຈຸລັງ"), ແລະ, ຂຶ້ນກັບວິທີທີ່ພວກເຮົາຂຽນມັນ, ລະຫັດສ່ວນຕົວແລະທີ່ຢູ່, ເຊິ່ງຖືກສ້າງຂຶ້ນໂດຍອີງໃສ່ລະຫັດສັນຍາສະຫມາດ. ເຈົ້າສາມາດສົ່ງກຼາມໄປຫາທີ່ຢູ່ຂອງສັນຍາສະຫມາດທີ່ຍັງບໍ່ໄດ້ເຜີຍແຜ່.

ເພື່ອເຜີຍແຜ່ສັນຍາສະຫມາດໃນ TON ໄດ້ຮັບ .boc ໄຟລ໌ຈະຕ້ອງຖືກສົ່ງໄປຫາ blockchain ໂດຍໃຊ້ລູກຄ້າແສງສະຫວ່າງ (ເພີ່ມເຕີມກ່ຽວກັບວ່າຂ້າງລຸ່ມນີ້). ແຕ່ກ່ອນທີ່ຈະເຜີຍແຜ່, ທ່ານຈໍາເປັນຕ້ອງໂອນກຼາມໄປຫາທີ່ຢູ່ທີ່ສ້າງຂຶ້ນ, ຖ້າບໍ່ດັ່ງນັ້ນສັນຍາສະຫມາດຈະບໍ່ຖືກເຜີຍແຜ່. ຫຼັງຈາກການພິມເຜີຍແຜ່, ທ່ານສາມາດພົວພັນກັບສັນຍາສະຫມາດໂດຍການສົ່ງຂໍ້ຄວາມຈາກພາຍນອກ (ຕົວຢ່າງ, ການນໍາໃຊ້ລູກຄ້າແສງສະຫວ່າງ) ຫຼືຈາກພາຍໃນ (ຕົວຢ່າງ, ສັນຍາສະຫມາດຫນຶ່ງສົ່ງຂໍ້ຄວາມພາຍໃນ TON).

ເມື່ອພວກເຮົາເຂົ້າໃຈວິທີການເຜີຍແຜ່ລະຫັດ, ມັນຈະງ່າຍຂຶ້ນ. ພວກ​ເຮົາ​ປະ​ມານ​ຮູ້​ວ່າ​ສິ່ງ​ທີ່​ພວກ​ເຮົາ​ຕ້ອງ​ການ​ທີ່​ຈະ​ຂຽນ​ແລະ​ວິ​ທີ​ການ​ໂຄງ​ການ​ຂອງ​ພວກ​ເຮົາ​ຈະ​ເຮັດ​ວຽກ​. ແລະໃນຂະນະທີ່ຂຽນ, ພວກເຮົາຊອກຫາວິທີການນີ້ໄດ້ຖືກປະຕິບັດແລ້ວໃນສັນຍາສະຫມາດທີ່ມີຢູ່, ຫຼືພວກເຮົາເບິ່ງເຂົ້າໄປໃນລະຫັດການປະຕິບັດ Fift и FunC ໃນ repository ຢ່າງເປັນທາງການ, ຫຼືເບິ່ງຢູ່ໃນເອກະສານຢ່າງເປັນທາງການ.

ເລື້ອຍໆຂ້ອຍໄດ້ຄົ້ນຫາຄໍາສໍາຄັນໃນການສົນທະນາ Telegram ບ່ອນທີ່ຜູ້ເຂົ້າຮ່ວມການແຂ່ງຂັນແລະພະນັກງານ Telegram ທັງຫມົດໄດ້ລວບລວມ, ແລະມັນກໍ່ເກີດຂື້ນວ່າໃນລະຫວ່າງການແຂ່ງຂັນທຸກໆຄົນໄດ້ເຕົ້າໂຮມກັນຢູ່ທີ່ນັ້ນແລະເລີ່ມສົນທະນາ Fift ແລະ FunC. ເຊື່ອມຕໍ່ໃນຕອນທ້າຍຂອງບົດຄວາມ.

ມັນເປັນເວລາທີ່ຈະຍ້າຍອອກຈາກທິດສະດີໄປສູ່ການປະຕິບັດ.

ການກະກຽມສະພາບແວດລ້ອມສໍາລັບການເຮັດວຽກກັບ TON

ຂ້ອຍໄດ້ເຮັດທຸກຢ່າງທີ່ຈະອະທິບາຍໄວ້ໃນບົດຄວາມໃນ MacOS ແລະກວດສອບມັນສອງເທື່ອໃນສະພາບທີ່ສະອາດ Ubuntu 18.04 LTS ໃນ Docker.

ສິ່ງທໍາອິດທີ່ທ່ານຈໍາເປັນຕ້ອງເຮັດແມ່ນດາວໂຫລດແລະຕິດຕັ້ງ lite-client ທີ່ທ່ານສາມາດສົ່ງຄໍາຮ້ອງຂໍໃຫ້ TON.

ຄຳແນະນຳໃນເວັບໄຊທ໌ທາງການອະທິບາຍຂະບວນການຕິດຕັ້ງຢ່າງລະອຽດ ແລະ ຊັດເຈນ, ໂດຍບໍ່ລະບຸລາຍລະອຽດບາງຢ່າງ. ໃນທີ່ນີ້ພວກເຮົາປະຕິບັດຕາມຄຳແນະນຳ, ຕິດຕັ້ງ dependencies ທີ່ຂາດຫາຍໄປຕາມທາງ. ຂ້ອຍບໍ່ໄດ້ລວບລວມແຕ່ລະໂຄງການດ້ວຍຕົວເອງ ແລະ ຕິດຕັ້ງຈາກບ່ອນເກັບຂໍ້ມູນທາງການ. Ubuntu (ໃນ MacOS ທີ່ຂ້ອຍໃຊ້ brew).

apt -y install git 
apt -y install wget 
apt -y install cmake 
apt -y install g++ 
apt -y install zlib1g-dev 
apt -y install libssl-dev 

ເມື່ອການເພິ່ງພາອາໄສທັງຫມົດຖືກຕິດຕັ້ງ, ທ່ານສາມາດຕິດຕັ້ງໄດ້ lite-client, Fift, FunC.

ທໍາອິດ, ພວກເຮົາ clone repository TON ພ້ອມກັບການເພິ່ງພາອາໄສຂອງມັນ. ເພື່ອຄວາມສະດວກ, ພວກເຮົາຈະເຮັດທຸກຢ່າງໃນໂຟນເດີ ~/TON.

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

ຄັງເກັບມ້ຽນຍັງເກັບຮັກສາການປະຕິບັດ Fift и FunC.

ໃນປັດຈຸບັນພວກເຮົາມີຄວາມພ້ອມທີ່ຈະປະກອບໂຄງການ. ລະຫັດ repository ແມ່ນ cloned ເຂົ້າໄປໃນໂຟນເດີ ~/TON/ton. ການ ~/TON ສ້າງໂຟນເດີ build ແລະເກັບກໍາໂຄງການຢູ່ໃນມັນ.

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

ນັບຕັ້ງແຕ່ພວກເຮົາກໍາລັງຈະຂຽນສັນຍາສະຫມາດ, ພວກເຮົາຕ້ອງການບໍ່ພຽງແຕ່ lite-clientແຕ່ Fift с FunC, ສະນັ້ນໃຫ້ພວກເຮົາລວບລວມທຸກສິ່ງທຸກຢ່າງ. ມັນບໍ່ແມ່ນຂະບວນການທີ່ໄວ, ດັ່ງນັ້ນພວກເຮົາກໍາລັງລໍຖ້າ.

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

ຕໍ່ໄປ, ດາວໂຫລດໄຟລ໌ການຕັ້ງຄ່າທີ່ມີຂໍ້ມູນກ່ຽວກັບ node ທີ່ lite-client ຈະເຊື່ອມຕໍ່.

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

ເຮັດການຮ້ອງຂໍຄັ້ງທໍາອິດກັບ TON

ຕອນນີ້ໃຫ້ເປີດຕົວ lite-client.

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

ຖ້າການກໍ່ສ້າງປະສົບຜົນສໍາເລັດ, ຫຼັງຈາກນັ້ນຫຼັງຈາກການເປີດຕົວທ່ານຈະເຫັນບັນທຶກຂອງການເຊື່ອມຕໍ່ຂອງລູກຄ້າແສງສະຫວ່າງກັບ node.

[ 1][t 2][1582054822.963129282][lite-client.h:201][!testnode]   conn ready
[ 2][t 2][1582054823.085654020][lite-client.cpp:277][!testnode] server version is 1.1, capabilities 7
[ 3][t 2][1582054823.085725069][lite-client.cpp:286][!testnode] server time is 1582054823 (delta 0)
...

ທ່ານສາມາດດໍາເນີນການຄໍາສັ່ງ help ແລະເບິ່ງວ່າຄໍາສັ່ງໃດທີ່ມີຢູ່.

help

ໃຫ້ບອກລາຍຊື່ຄໍາສັ່ງທີ່ພວກເຮົາຈະໃຊ້ໃນບົດຄວາມນີ້.

list of available commands:
last    Get last block and state info from server
sendfile <filename> Load a serialized message from <filename> and send it to server
getaccount <addr> [<block-id-ext>]  Loads the most recent state of specified account; <addr> is in [<workchain>:]<hex-or-base64-addr> format
runmethod <addr> [<block-id-ext>] <method-id> <params>...   Runs GET method <method-id> of account <addr> with specified parameters

last получает последний созданный блок с сервера. 

sendfile <filename> отправляет в TON файл с сообщением, именно с помощью этой команды публикуется смарт-контракт и запрсосы к нему. 

getaccount <addr> загружает текущее состояние смарт-контракта с указанным адресом. 

runmethod <addr> [<block-id-ext>] <method-id> <params>  запускает get-методы смартконтракта. 

ໃນປັດຈຸບັນພວກເຮົາພ້ອມທີ່ຈະຂຽນສັນຍາຕົວມັນເອງ.

Реализация

Idea

ດັ່ງທີ່ຂ້າພະເຈົ້າຂຽນໄວ້ຂ້າງເທິງ, ສັນຍາສະຫມາດທີ່ພວກເຮົາກໍາລັງຂຽນແມ່ນ lottery.

ຍິ່ງໄປກວ່ານັ້ນ, ນີ້ບໍ່ແມ່ນຫວຍທີ່ທ່ານຈໍາເປັນຕ້ອງຊື້ປີ້ແລະລໍຖ້າຫນຶ່ງຊົ່ວໂມງ, ມື້ຫຼືເດືອນ, ແຕ່ທັນທີທີ່ຜູ້ໃຊ້ໂອນໄປຫາທີ່ຢູ່ສັນຍາ. N ກຣາມ, ແລະທັນທີໄດ້ຮັບມັນກັບຄືນມາ 2 * N ກຼາມຫຼືສູນເສຍ. ພວກເຮົາຈະເຮັດໃຫ້ຄວາມເປັນໄປໄດ້ຂອງການຊະນະປະມານ 40%. ຖ້າບໍ່ມີກຼາມພຽງພໍສໍາລັບການຈ່າຍເງິນ, ພວກເຮົາຈະພິຈາລະນາການເຮັດທຸລະກໍາເປັນການຕື່ມເງິນ.

ຍິ່ງໄປກວ່ານັ້ນ, ມັນເປັນສິ່ງສໍາຄັນທີ່ການເດີມພັນສາມາດເຫັນໄດ້ໃນເວລາທີ່ແທ້ຈິງແລະໃນຮູບແບບທີ່ສະດວກສະບາຍ, ເພື່ອໃຫ້ຜູ້ໃຊ້ສາມາດເຂົ້າໃຈໄດ້ທັນທີວ່າລາວຊະນະຫຼືສູນເສຍ. ດັ່ງນັ້ນ, ທ່ານຈໍາເປັນຕ້ອງເຮັດເວັບໄຊທ໌ທີ່ຈະສະແດງການເດີມພັນແລະຜົນໄດ້ຮັບໂດຍກົງຈາກ TON.

ການຂຽນສັນຍາສະຫມາດ

ເພື່ອຄວາມສະດວກສະບາຍ, ຂ້າພະເຈົ້າໄດ້ເນັ້ນໃສ່ລະຫັດສໍາລັບ FunC; plugin ສາມາດຊອກຫາແລະຕິດຕັ້ງຢູ່ໃນ Visual Studio Code ຊອກຫາ; ຖ້າທ່ານຕ້ອງການເພີ່ມບາງສິ່ງບາງຢ່າງ, ຂ້າພະເຈົ້າໄດ້ເຮັດໃຫ້ plugin ເປີດເຜີຍຕໍ່ສາທາລະນະ. ນອກຈາກນີ້, ຜູ້ໃດຜູ້ຫນຶ່ງກ່ອນຫນ້ານີ້ໄດ້ເຮັດ plugin ສໍາລັບການເຮັດວຽກກັບ Fift, ທ່ານຍັງສາມາດຕິດຕັ້ງມັນແລະຊອກຫາມັນຢູ່ໃນ VSC.

ໃຫ້ສ້າງບ່ອນເກັບມ້ຽນໃນທັນທີທີ່ພວກເຮົາຈະປະຕິບັດຜົນໄດ້ຮັບລະດັບປານກາງ.

ເພື່ອເຮັດໃຫ້ຊີວິດຂອງພວກເຮົາງ່າຍຂຶ້ນ, ພວກເຮົາຈະຂຽນສັນຍາສະຫມາດແລະທົດສອບມັນຢູ່ໃນທ້ອງຖິ່ນຈົນກວ່າມັນຈະກຽມພ້ອມ. ພຽງແຕ່ຫຼັງຈາກນັ້ນພວກເຮົາຈະເຜີຍແຜ່ໃນ TON.

ສັນຍາສະຫມາດມີສອງວິທີການພາຍນອກທີ່ສາມາດເຂົ້າເຖິງໄດ້. ຫນ້າທໍາອິດ, recv_external() ຟັງຊັນນີ້ຖືກປະຕິບັດໃນເວລາທີ່ຄໍາຮ້ອງຂໍຕໍ່ສັນຍາມາຈາກໂລກພາຍນອກ, ນັ້ນແມ່ນ, ບໍ່ແມ່ນມາຈາກ TON, ຕົວຢ່າງ, ເມື່ອພວກເຮົາສ້າງຂໍ້ຄວາມແລະສົ່ງຜ່ານລູກຄ້າ lite. ອັນທີສອງ, recv_internal() ນີ້ແມ່ນເວລາທີ່, ພາຍໃນ TON ຕົວຂອງມັນເອງ, ສັນຍາໃດໆຫມາຍເຖິງພວກເຮົາ. ໃນທັງສອງກໍລະນີ, ທ່ານສາມາດຜ່ານພາລາມິເຕີໄປຫາຫນ້າທີ່.

ໃຫ້ເລີ່ມຕົ້ນດ້ວຍຕົວຢ່າງທີ່ງ່າຍດາຍທີ່ຈະເຮັດວຽກຖ້າຈັດພີມມາ, ແຕ່ບໍ່ມີການໂຫຼດທີ່ເປັນປະໂຫຍດໃນມັນ.

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

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

ໃນທີ່ນີ້ພວກເຮົາຈໍາເປັນຕ້ອງໄດ້ອະທິບາຍວ່າມັນແມ່ນຫຍັງ slice. ຂໍ້ມູນທັງຫມົດທີ່ເກັບໄວ້ໃນ TON Blockchain ແມ່ນການລວບລວມ TVM cell ຫຼື​ພຽງ​ແຕ່ cell, ໃນເຊລດັ່ງກ່າວທ່ານສາມາດເກັບຮັກສາຂໍ້ມູນໄດ້ເຖິງ 1023 bits ແລະສູງເຖິງ 4 ເຊື່ອມຕໍ່ໄປຫາເຊລອື່ນ.

TVM cell slice ຫຼື slice ນີ້ແມ່ນສ່ວນຫນຶ່ງຂອງທີ່ມີຢູ່ແລ້ວ cell ຖືກນໍາໃຊ້ເພື່ອວິເຄາະມັນ, ມັນຈະກາຍເປັນທີ່ຈະແຈ້ງຕໍ່ມາ. ສິ່ງທີ່ສໍາຄັນສໍາລັບພວກເຮົາແມ່ນວ່າພວກເຮົາສາມາດໂອນ slice ແລະຂຶ້ນກັບປະເພດຂອງຂໍ້ຄວາມ, ປະມວນຜົນຂໍ້ມູນໃນ recv_external() ຫຼື recv_internal().

impure — ຄໍາສໍາຄັນທີ່ຊີ້ບອກວ່າຫນ້າທີ່ດັດແປງຂໍ້ມູນສັນຍາສະຫມາດ.

ໃຫ້ບັນທຶກລະຫັດສັນຍາໃນ lottery-code.fc ແລະລວບລວມ.

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

ຄວາມຫມາຍຂອງທຸງສາມາດເບິ່ງໄດ້ໂດຍໃຊ້ຄໍາສັ່ງ

~/TON/build/crypto/func -help

ພວກເຮົາໄດ້ລວບລວມລະຫັດ Fift assembler ໃນ lottery-compiled.fif:

// lottery-compiled.fif

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

ມັນສາມາດເປີດຕົວຢູ່ໃນທ້ອງຖິ່ນ, ສໍາລັບການນີ້ພວກເຮົາຈະກະກຽມສະພາບແວດລ້ອມ.

ໃຫ້ສັງເກດວ່າສາຍທໍາອິດເຊື່ອມຕໍ່ Asm.fif, ນີ້ແມ່ນລະຫັດທີ່ຂຽນໃນ Fift ສໍາລັບ Fift assembler.

ເນື່ອງຈາກພວກເຮົາຕ້ອງການດໍາເນີນການແລະທົດສອບສັນຍາສະຫມາດຢູ່ໃນທ້ອງຖິ່ນ, ພວກເຮົາຈະສ້າງໄຟລ໌ lottery-test-suite.fif ແລະຄັດລອກລະຫັດທີ່ລວບລວມຢູ່ທີ່ນັ້ນ, ແທນທີ່ແຖວສຸດທ້າຍໃນມັນ, ເຊິ່ງຂຽນລະຫັດສັນຍາສະຫມາດເປັນຄ່າຄົງທີ່. codeຈາກນັ້ນໂອນມັນໄປໃສ່ເຄື່ອງ virtual:

"TonUtil.fif" include
"Asm.fif" include

PROGRAM{
  DECLPROC recv_internal
  DECLPROC recv_external
  recv_internal PROC:<{
    //  in_msg
    DROP    // 
  }>
  recv_external PROC:<{
    //  in_msg
    DROP    // 
  }>
}END>s constant code

ມາຮອດປະຈຸມັນເບິ່ງຄືວ່າຈະແຈ້ງ, ຕອນນີ້ໃຫ້ເພີ່ມລະຫັດດຽວກັນກັບໄຟລ໌ທີ່ພວກເຮົາຈະໃຊ້ເພື່ອເປີດຕົວ TVM.

0 tuple 0x076ef1ea , // magic
0 , 0 , // actions msg_sents
1570998536 , // unix_time
1 , 1 , 3 , // block_lt, trans_lt, rand_seed
0 tuple 100000000000000 , dictnew , , // remaining balance
0 , dictnew , // contract_address, global_config
1 tuple // wrap to another tuple
constant c7

0 constant recv_internal // to run recv_internal() 
-1 constant recv_external // to invoke recv_external()

В c7 ພວກເຮົາບັນທຶກສະພາບການ, ນັ້ນແມ່ນ, ຂໍ້ມູນທີ່ TVM (ຫຼືສະຖານະເຄືອຂ່າຍ) ຈະຖືກເປີດຕົວ. ເຖິງແມ່ນວ່າໃນລະຫວ່າງການແຂ່ງຂັນ, ຫນຶ່ງໃນນັກພັດທະນາໄດ້ສະແດງໃຫ້ເຫັນວິທີການສ້າງ c7 ແລະຂ້າພະເຈົ້າໄດ້ຄັດລອກ. ໃນບົດຄວາມນີ້ພວກເຮົາອາດຈະຕ້ອງມີການປ່ຽນແປງ rand_seed ນັບຕັ້ງແຕ່ການສ້າງຕົວເລກແບບສຸ່ມແມ່ນຂຶ້ນກັບມັນແລະຖ້າບໍ່ປ່ຽນແປງ, ຕົວເລກດຽວກັນຈະຖືກສົ່ງຄືນທຸກໆຄັ້ງ.

recv_internal и recv_external constants ທີ່ມີຄ່າ 0 ແລະ -1 ຈະຮັບຜິດຊອບສໍາລັບການໂທຫາຫນ້າທີ່ສອດຄ້ອງກັນໃນສັນຍາສະຫມາດ.

ໃນປັດຈຸບັນພວກເຮົາພ້ອມທີ່ຈະສ້າງການທົດສອບຄັ້ງທໍາອິດສໍາລັບສັນຍາສະຫມາດທີ່ຫວ່າງເປົ່າຂອງພວກເຮົາ. ເພື່ອຄວາມຊັດເຈນ, ສໍາລັບຕອນນີ້ພວກເຮົາຈະເພີ່ມການທົດສອບທັງຫມົດເຂົ້າໃນໄຟລ໌ດຽວກັນ lottery-test-suite.fif.

ມາສ້າງຕົວແປ storage ແລະຂຽນອັນເປົ່າໃສ່ໃນມັນ cell, ນີ້ຈະເປັນການເກັບຮັກສາສັນຍາສະຫມາດ.

message ນີ້ແມ່ນຂໍ້ຄວາມທີ່ພວກເຮົາຈະສົ່ງໄປຫາຜູ້ຕິດຕໍ່ smart ຈາກພາຍນອກ. ພວກເຮົາຍັງຈະເຮັດໃຫ້ມັນຫວ່າງເປົ່າສໍາລັບໃນປັດຈຸບັນ.

variable storage 
<b b> storage ! 

variable message 
<b b> message ! 

ຫຼັງຈາກທີ່ພວກເຮົາໄດ້ກະກຽມຄ່າຄົງທີ່ແລະຕົວແປ, ພວກເຮົາເປີດຕົວ TVM ໂດຍໃຊ້ຄໍາສັ່ງ runvmctx ແລະຜ່ານພາລາມິເຕີທີ່ສ້າງຂື້ນໄປຫາວັດສະດຸປ້ອນ.

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx 

ໃນທີ່ສຸດພວກເຮົາຈະປະສົບຜົນສໍາເລັດ ແບບນີ້ ລະ​ຫັດ​ລະ​ດັບ​ປານ​ກາງ​ສໍາ​ລັບ​ການ​ Fift.

ໃນປັດຈຸບັນພວກເຮົາສາມາດດໍາເນີນການລະຫັດຜົນໄດ້ຮັບ.

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

ໂປລແກລມຄວນຈະດໍາເນີນການໂດຍບໍ່ມີຂໍ້ຜິດພາດແລະໃນຜົນໄດ້ຮັບພວກເຮົາຈະເຫັນບັນທຶກການປະຕິບັດ:

execute SETCP 0
execute DICTPUSHCONST 19 (xC_,1)
execute DICTIGETJMPZ
execute DROP
execute implicit RET
[ 3][t 0][1582281699.325381279][vm.cpp:479]     steps: 5 gas: used=304, max=9223372036854775807, limit=9223372036854775807, credit=0

ຍິ່ງໃຫຍ່, ພວກເຮົາໄດ້ຂຽນສະບັບທໍາອິດທີ່ເຮັດວຽກຂອງສັນຍາສະຫມາດ.

ໃນປັດຈຸບັນພວກເຮົາຈໍາເປັນຕ້ອງໄດ້ເພີ່ມການເຮັດວຽກ. ທໍາອິດໃຫ້ຈັດການກັບຂໍ້ຄວາມທີ່ມາຈາກໂລກພາຍນອກເພື່ອ recv_external()

ນັກພັດທະນາຕົວເອງເລືອກຮູບແບບຂໍ້ຄວາມທີ່ສັນຍາສາມາດຍອມຮັບໄດ້.

ແຕ່ປົກກະຕິແລ້ວ

• ກ່ອນອື່ນ ໝົດ, ພວກເຮົາຕ້ອງການປົກປ້ອງສັນຍາຂອງພວກເຮົາຈາກໂລກພາຍນອກແລະເຮັດໃຫ້ມັນມີພຽງແຕ່ເຈົ້າຂອງສັນຍາເທົ່ານັ້ນທີ່ສາມາດສົ່ງຂໍ້ຄວາມພາຍນອກໄປຫາມັນ.
• ອັນທີສອງ, ເມື່ອພວກເຮົາສົ່ງຂໍ້ຄວາມທີ່ຖືກຕ້ອງໄປຫາ TON, ພວກເຮົາຕ້ອງການໃຫ້ສິ່ງນີ້ເກີດຂຶ້ນຢ່າງແນ່ນອນແລະເມື່ອພວກເຮົາສົ່ງຂໍ້ຄວາມດຽວກັນອີກເທື່ອຫນຶ່ງ, ສັນຍາສະຫມາດປະຕິເສດມັນ.

ດັ່ງນັ້ນເກືອບທຸກໆສັນຍາແກ້ໄຂບັນຫາທັງສອງຢ່າງນີ້, ນັບຕັ້ງແຕ່ສັນຍາຂອງພວກເຮົາຍອມຮັບຂໍ້ຄວາມພາຍນອກ, ພວກເຮົາຈໍາເປັນຕ້ອງໄດ້ດູແລເຊັ່ນກັນ.

ພວກເຮົາຈະເຮັດມັນໃນລໍາດັບປີ້ນກັບກັນ. ທໍາອິດ, ໃຫ້ແກ້ໄຂບັນຫາດ້ວຍການຊໍ້າຊ້ອນ; ຖ້າສັນຍາໄດ້ຮັບຂໍ້ຄວາມດັ່ງກ່າວແລ້ວແລະດໍາເນີນການມັນ, ມັນຈະບໍ່ປະຕິບັດເປັນຄັ້ງທີສອງ. ແລະຫຼັງຈາກນັ້ນພວກເຮົາຈະແກ້ໄຂບັນຫາເພື່ອໃຫ້ພຽງແຕ່ວົງການສະເພາະໃດຫນຶ່ງຂອງປະຊາຊົນສາມາດສົ່ງຂໍ້ຄວາມໄປຫາສັນຍາສະຫມາດ.

ມີວິທີທີ່ແຕກຕ່າງກັນເພື່ອແກ້ໄຂບັນຫາທີ່ມີຂໍ້ຄວາມທີ່ຊ້ໍາກັນ. ນີ້ແມ່ນວິທີທີ່ພວກເຮົາຈະເຮັດມັນ. ໃນສັນຍາສະຫມາດ, ພວກເຮົາເລີ່ມຕົ້ນຕົວນັບຂອງຂໍ້ຄວາມທີ່ໄດ້ຮັບດ້ວຍມູນຄ່າເບື້ອງຕົ້ນ 0. ໃນແຕ່ລະຂໍ້ຄວາມໄປຫາສັນຍາສະຫມາດ, ພວກເຮົາຈະເພີ່ມມູນຄ່າ counter ໃນປັດຈຸບັນ. ຖ້າມູນຄ່າ counter ໃນຂໍ້ຄວາມບໍ່ກົງກັບມູນຄ່າໃນສັນຍາສະຫມາດ, ພວກເຮົາບໍ່ໄດ້ປະມວນຜົນມັນ; ຖ້າມັນເຮັດ, ພວກເຮົາປຸງແຕ່ງມັນແລະເພີ່ມຕົວນັບໃນສັນຍາສະຫມາດໂດຍ 1.

ໃຫ້ກັບຄືນໄປຫາ lottery-test-suite.fif ແລະເພີ່ມການທົດສອບທີສອງໃສ່ມັນ. ຖ້າພວກເຮົາສົ່ງຕົວເລກທີ່ບໍ່ຖືກຕ້ອງ, ລະຫັດຄວນຈະເປັນການຍົກເວັ້ນ. ຕົວຢ່າງ, ໃຫ້ຂໍ້ມູນສັນຍາເກັບ 166, ແລະພວກເຮົາຈະສົ່ງ 165.

<b 166 32 u, b> storage !
<b 165 32 u, b> message !

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx

drop 
exit_code ! 
."Exit code " exit_code @ . cr 
exit_code @ 33 - abort"Test #2 Not passed"

ເປີດຕົວ.

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

ແລະພວກເຮົາຈະເຫັນວ່າການທົດສອບຖືກປະຕິບັດດ້ວຍຄວາມຜິດພາດ.

[ 1][t 0][1582283084.210902214][words.cpp:3046] lottery-test-suite.fif:67: abort": Test #2 Not passed
[ 1][t 0][1582283084.210941076][fift-main.cpp:196]      Error interpreting file `lottery-test-suite.fif`: error interpreting included file `lottery-test-suite.fif` : lottery-test-suite.fif:67: abort": Test #2 Not passed

ໃນຂັ້ນຕອນນີ້ lottery-test-suite.fif ຄວນເບິ່ງຄື ການເຊື່ອມຕໍ່.

ຕອນນີ້ໃຫ້ເຮົາຕື່ມເຫດຜົນໂຕ້ແຍ້ງກັບສັນຍາສະຫມາດໃນ lottery-code.fc.

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

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

В slice in_msg ຕົວະຂໍ້ຄວາມທີ່ພວກເຮົາສົ່ງ.

ສິ່ງທໍາອິດທີ່ພວກເຮົາເຮັດແມ່ນກວດເບິ່ງວ່າຂໍ້ຄວາມມີຂໍ້ມູນ, ຖ້າບໍ່ແມ່ນ, ພວກເຮົາພຽງແຕ່ອອກຈາກ.

ຕໍ່ໄປ, ພວກເຮົາແຍກຂໍ້ຄວາມ. in_msg~load_uint(32) ໂຫຼດຈໍານວນ 165, 32-bit unsigned int ຈາກ​ຂໍ້​ຄວາມ​ທີ່​ສົ່ງ​ອອກ​.

ຕໍ່ໄປ, ພວກເຮົາໂຫລດ 32 bits ຈາກການເກັບຮັກສາສັນຍາສະຫມາດ. ພວກເຮົາກວດເບິ່ງວ່າຕົວເລກທີ່ໂຫລດກົງກັບເລກທີ່ຜ່ານ; ຖ້າບໍ່ແມ່ນ, ພວກເຮົາຍົກຂໍ້ຍົກເວັ້ນ. ໃນກໍລະນີຂອງພວກເຮົາ, ເນື່ອງຈາກວ່າພວກເຮົາກໍາລັງຜ່ານການແຂ່ງຂັນທີ່ບໍ່ແມ່ນການແຂ່ງຂັນ, ການຍົກເວັ້ນຄວນຈະຖືກຖິ້ມ.

ໃນປັດຈຸບັນໃຫ້ເຮົາລວບລວມ.

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

ສຳເນົາລະຫັດຜົນໄດ້ຮັບໄປໃສ່ lottery-test-suite.fif, ຢ່າລືມປ່ຽນເສັ້ນສຸດທ້າຍ.

ພວກເຮົາກວດເບິ່ງວ່າການທົດສອບຜ່ານ:

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

ຢູ່​ທີ່​ນີ້ ທ່ານສາມາດເບິ່ງຄໍາຫມັ້ນສັນຍາທີ່ສອດຄ້ອງກັນກັບຜົນໄດ້ຮັບໃນປະຈຸບັນ.

ໃຫ້ສັງເກດວ່າມັນບໍ່ສະດວກທີ່ຈະຄັດລອກລະຫັດທີ່ລວບລວມຂອງສັນຍາສະຫມາດເຂົ້າໄປໃນໄຟລ໌ທີ່ມີການທົດສອບຢ່າງຕໍ່ເນື່ອງ, ດັ່ງນັ້ນໃຫ້ພວກເຮົາຂຽນ script ທີ່ຈະຂຽນລະຫັດເປັນຄົງທີ່ສໍາລັບພວກເຮົາ, ແລະພວກເຮົາຈະເຊື່ອມຕໍ່ລະຫັດທີ່ລວບລວມກັບການທົດສອບຂອງພວກເຮົາໂດຍໃຊ້ "include".

ສ້າງໄຟລ໌ໃນໂຟນເດີໂຄງການ build.sh ດ້ວຍເນື້ອໃນຕໍ່ໄປນີ້.

#!/bin/bash

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

ຂໍໃຫ້ມັນປະຕິບັດໄດ້.

chmod +x ./build.sh

ໃນປັດຈຸບັນ, ພຽງແຕ່ດໍາເນີນການ script ຂອງພວກເຮົາເພື່ອລວບລວມສັນຍາ. ແຕ່ນອກຈາກນີ້, ພວກເຮົາຈໍາເປັນຕ້ອງຂຽນມັນເຂົ້າໄປໃນຄົງທີ່ code. ດັ່ງນັ້ນພວກເຮົາຈະສ້າງໄຟລ໌ໃຫມ່ lotter-compiled-for-test.fif, ທີ່ພວກເຮົາຈະລວມຢູ່ໃນໄຟລ໌ lottery-test-suite.fif.

ໃຫ້ເພີ່ມລະຫັດ skirt ກັບ sh, ເຊິ່ງພຽງແຕ່ຈະ duplicate ໄຟລ໌ລວບລວມໃນ lotter-compiled-for-test.fif ແລະປ່ຽນເສັ້ນສຸດທ້າຍໃນມັນ.

# copy and change for test 
cp lottery-compiled.fif lottery-compiled-for-test.fif
sed '$d' lottery-compiled-for-test.fif > test.fif
rm lottery-compiled-for-test.fif
mv test.fif lottery-compiled-for-test.fif
echo -n "}END>s constant code" >> lottery-compiled-for-test.fif

ດຽວນີ້, ເພື່ອກວດເບິ່ງ, ໃຫ້ແລ່ນສະຄິບທີ່ໄດ້ຮັບຜົນແລະໄຟລ໌ຈະຖືກສ້າງຂື້ນ lottery-compiled-for-test.fif, ທີ່ພວກເຮົາຈະປະກອບຢູ່ໃນຂອງພວກເຮົາ lottery-test-suite.fif

В lottery-test-suite.fif ລຶບລະຫັດສັນຍາແລະເພີ່ມສາຍ "lottery-compiled-for-test.fif" include.

ພວກເຮົາດໍາເນີນການທົດສອບເພື່ອກວດເບິ່ງວ່າພວກເຂົາຜ່ານ.

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

ດີຫຼາຍ, ຕອນນີ້ເພື່ອອັດຕະໂນມັດການເປີດຕົວການທົດສອບ, ໃຫ້ເຮົາສ້າງໄຟລ໌ test.sh, ເຊິ່ງທໍາອິດຈະປະຕິບັດ build.sh, ແລະ​ຫຼັງ​ຈາກ​ນັ້ນ​ດໍາ​ເນີນ​ການ​ທົດ​ສອບ​.

touch test.sh
chmod +x test.sh

ພວກເຮົາຂຽນພາຍໃນ

./build.sh 

echo "nCompilation completedn"

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

ໃຫ້ເຮັດມັນ test.sh ແລະດໍາເນີນການເພື່ອໃຫ້ແນ່ໃຈວ່າການທົດສອບເຮັດວຽກ.

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

ພວກເຮົາກວດເບິ່ງວ່າສັນຍາລວບລວມແລະການທົດສອບຖືກປະຕິບັດ.

ດີຫຼາຍ, ຕອນນີ້ເລີ່ມຕົ້ນ test.sh ການທົດສອບຈະຖືກລວບລວມແລະດໍາເນີນການທັນທີ. ນີ້ແມ່ນການເຊື່ອມຕໍ່ກັບ ຄໍາຫມັ້ນສັນຍາ.

ຕົກລົງ, ກ່ອນທີ່ພວກເຮົາຈະສືບຕໍ່, ໃຫ້ເຮັດສິ່ງຫນຶ່ງອີກເພື່ອຄວາມສະດວກ.

ມາສ້າງໂຟນເດີ build ບ່ອນ​ທີ່​ພວກ​ເຮົາ​ຈະ​ເກັບ​ຮັກ​ສາ​ສັນ​ຍາ​ສໍາ​ເນົາ​ແລະ clone ຂອງ​ຕົນ​ຂຽນ​ເປັນ​ຄົງ​ທີ່​ lottery-compiled.fif, lottery-compiled-for-test.fif. ມາສ້າງໂຟນເດີນຳ test ໄຟລ໌ທົດສອບຈະຖືກເກັບໄວ້ຢູ່ໃສ? lottery-test-suite.fif ແລະອາດມີໄຟລ໌ສະຫນັບສະຫນູນອື່ນໆ. ເຊື່ອມຕໍ່ກັບການປ່ຽນແປງທີ່ກ່ຽວຂ້ອງ.

ໃຫ້ສືບຕໍ່ພັດທະນາສັນຍາສະຫມາດ.

ຕໍ່ໄປຄວນຈະມີການທົດສອບທີ່ກວດເບິ່ງວ່າຂໍ້ຄວາມໄດ້ຮັບແລະເຄົາເຕີຖືກປັບປຸງຢູ່ໃນຮ້ານເມື່ອພວກເຮົາສົ່ງຕົວເລກທີ່ຖືກຕ້ອງ. ແຕ່ພວກເຮົາຈະເຮັດແນວນັ້ນຕໍ່ມາ.

ຕອນນີ້ໃຫ້ພວກເຮົາຄິດກ່ຽວກັບໂຄງສ້າງຂໍ້ມູນໃດແລະຂໍ້ມູນໃດທີ່ຕ້ອງໄດ້ຮັບການເກັບຮັກສາໄວ້ໃນສັນຍາສະຫມາດ.

ຂ້ອຍຈະອະທິບາຍທຸກຢ່າງທີ່ພວກເຮົາເກັບ.

`seqno` 32-х битное целое положительное число счетчик. 

`pubkey` 256-ти битное целое положительное число публичный ключ, с помощью которого, мы будем проверять подпись отправленного извне сообщения, о чем ниже. 

`order_seqno` 32-х битное целое положительное число хранит счетчик количества ставок. 

`number_of_wins` 32-х битное целое положительное число хранит  количество побед. 

`incoming_amount` тип данных Gram (первые 4 бита отвечает за длину), хранит общее количество грамов, которые были отправлены на контртакт. 

`outgoing_amount` общее количество грамов, которое было отправлено победителям. 

`owner_wc` номер воркчейна, 32-х битное (в некоторых местах написано, что 8-ми битное) целое число. В данный момент всего два -1 и 0. 

`owner_account_id` 256-ти битное целое положительное число, адрес контракта в текущем воркчейне. 

`orders` переменная типа словарь, хранит последние двадцать ставок. 

ຕໍ່ໄປ, ທ່ານຈໍາເປັນຕ້ອງຂຽນສອງຫນ້າທີ່. ໃຫ້ໂທຫາທໍາອິດ pack_state(), ເຊິ່ງຈະບັນຈຸຂໍ້ມູນສໍາລັບການປະຫຍັດຕໍ່ມາໃນການເກັບຮັກສາສັນຍາສະຫມາດ. ໃຫ້ໂທຫາທີສອງ unpack_state() ຈະອ່ານແລະສົ່ງຄືນຂໍ້ມູນຈາກການເກັບຮັກສາ.

_ pack_state(int seqno, int pubkey, int order_seqno, int number_of_wins, int incoming_amount, int outgoing_amount, int owner_wc, int owner_account_id, cell orders) inline_ref {
    return begin_cell()
            .store_uint(seqno, 32)
            .store_uint(pubkey, 256)
            .store_uint(order_seqno, 32)
            .store_uint(number_of_wins, 32)
            .store_grams(incoming_amount)
            .store_grams(outgoing_amount)
            .store_int(owner_wc, 32)
            .store_uint(owner_account_id, 256)
            .store_dict(orders)
            .end_cell();
}

_ unpack_state() inline_ref {
    var ds = begin_parse(get_data());
    var unpacked = (ds~load_uint(32), ds~load_uint(256), ds~load_uint(32), ds~load_uint(32), ds~load_grams(), ds~load_grams(), ds~load_int(32), ds~load_uint(256), ds~load_dict());
    ds.end_parse();
    return unpacked;
}

ພວກເຮົາເພີ່ມສອງຫນ້າທີ່ນີ້ໄປສູ່ການເລີ່ມຕົ້ນຂອງສັນຍາສະຫມາດ. ມັນຈະເຮັດວຽກອອກ ແບບນີ້ ຜົນໄດ້ຮັບລະດັບປານກາງ.

ເພື່ອບັນທຶກຂໍ້ມູນ, ທ່ານຈະຕ້ອງໂທຫາຫນ້າທີ່ສ້າງໃນຕົວ set_data() ແລະມັນຈະຂຽນຂໍ້ມູນຈາກ pack_state() ໃນການເກັບຮັກສາສັນຍາສະຫມາດ.

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

ໃນປັດຈຸບັນພວກເຮົາມີຫນ້າທີ່ສະດວກສໍາລັບການຂຽນແລະການອ່ານຂໍ້ມູນ, ພວກເຮົາສາມາດກ້າວຕໍ່ໄປ.

ພວກເຮົາຈໍາເປັນຕ້ອງໄດ້ກວດເບິ່ງວ່າຂໍ້ຄວາມທີ່ເຂົ້າມາຈາກພາຍນອກໄດ້ຖືກເຊັນໂດຍເຈົ້າຂອງສັນຍາ (ຫຼືຜູ້ໃຊ້ອື່ນທີ່ມີການເຂົ້າເຖິງກະແຈສ່ວນຕົວ).

ເມື່ອພວກເຮົາເຜີຍແຜ່ສັນຍາສະຫມາດ, ພວກເຮົາສາມາດເລີ່ມຕົ້ນມັນດ້ວຍຂໍ້ມູນທີ່ພວກເຮົາຕ້ອງການໃນການເກັບຮັກສາ, ເຊິ່ງຈະຖືກບັນທຶກໄວ້ສໍາລັບການນໍາໃຊ້ໃນອະນາຄົດ. ພວກເຮົາຈະບັນທຶກກະແຈສາທາລະນະຢູ່ທີ່ນັ້ນເພື່ອໃຫ້ພວກເຮົາສາມາດກວດສອບໄດ້ວ່າຂໍ້ຄວາມທີ່ເຂົ້າມາໄດ້ຖືກເຊັນດ້ວຍລະຫັດສ່ວນຕົວທີ່ສອດຄ້ອງກັນ.

ກ່ອນທີ່ຈະສືບຕໍ່, ໃຫ້ສ້າງລະຫັດສ່ວນຕົວແລະຂຽນມັນໃສ່ test/keys/owner.pk. ເພື່ອເຮັດສິ່ງນີ້, ໃຫ້ເປີດ Fift ໃນໂຫມດໂຕ້ຕອບແລະປະຕິບັດສີ່ຄໍາສັ່ງ.

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

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

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

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

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

ມາສ້າງໂຟນເດີ keys ພາຍໃນໂຟນເດີ test ແລະຂຽນລະຫັດສ່ວນຕົວຢູ່ທີ່ນັ້ນ.

mkdir test/keys
cd test/keys
~/TON/build/crypto/fift -i 
newkeypair
 ok
.s 
BYTES:128DB222CEB6CF5722021C3F21D4DF391CE6D5F70C874097E28D06FCE9FD6917 BYTES:DD0A81AAF5C07AAAA0C7772BB274E494E93BB0123AA1B29ECE7D42AE45184128 
drop 
 ok
"owner.pk" B>file
 ok
bye

ພວກເຮົາເຫັນໄຟລ໌ຢູ່ໃນໂຟນເດີປະຈຸບັນ owner.pk.

ພວກເຮົາເອົາກະແຈສາທາລະນະອອກຈາກ stack ແລະໃນເວລາທີ່ຈໍາເປັນ, ພວກເຮົາສາມາດເອົາມັນຈາກເອກະຊົນໄດ້.

ໃນປັດຈຸບັນພວກເຮົາຈໍາເປັນຕ້ອງຂຽນການຢັ້ງຢືນລາຍເຊັນ. ໃຫ້ເລີ່ມຕົ້ນດ້ວຍການທົດສອບ. ທໍາອິດພວກເຮົາອ່ານລະຫັດສ່ວນຕົວຈາກໄຟລ໌ໂດຍໃຊ້ຟັງຊັນ file>B ແລະຂຽນມັນໃສ່ຕົວແປ owner_private_key, ຫຼັງຈາກນັ້ນການນໍາໃຊ້ຫນ້າທີ່ priv>pub ປ່ຽນລະຫັດສ່ວນຕົວເປັນລະຫັດສາທາລະນະແລະຂຽນຜົນໄດ້ຮັບໃນ owner_public_key.

variable owner_private_key
variable owner_public_key 

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

ພວກເຮົາຈະຕ້ອງການຄີທັງສອງ.

ພວກເຮົາເລີ່ມຕົ້ນການເກັບຮັກສາສັນຍາສະຫມາດທີ່ມີຂໍ້ມູນ arbitrary ໃນລໍາດັບດຽວກັນກັບຫນ້າທີ່ pack_state()ແລະຂຽນມັນເຂົ້າໄປໃນຕົວແປ storage.

variable owner_private_key
variable owner_public_key 
variable orders
variable owner_wc
variable owner_account_id

"./keys/owner.pk" file>B owner_private_key !
owner_private_key @ priv>pub owner_public_key !
dictnew orders !
0 owner_wc !
0 owner_account_id !

<b 0 32 u, owner_public_key @ B, 0 32 u, 0 32 u, 0 Gram, 0 Gram, owner_wc @ 32 i, owner_account_id @ 256 u,  orders @ dict, b> storage !

ຕໍ່ໄປ, ພວກເຮົາຈະຂຽນຂໍ້ຄວາມທີ່ມີລາຍເຊັນ, ມັນຈະມີພຽງແຕ່ລາຍເຊັນແລະມູນຄ່າ counter.

ທໍາອິດ, ພວກເຮົາສ້າງຂໍ້ມູນທີ່ພວກເຮົາຕ້ອງການສົ່ງ, ຫຼັງຈາກນັ້ນພວກເຮົາເຊັນມັນດ້ວຍລະຫັດສ່ວນຕົວແລະສຸດທ້າຍພວກເຮົາສ້າງຂໍ້ຄວາມທີ່ລົງນາມ.

variable message_to_sign
variable message_to_send
variable signature
<b 0 32 u, b> message_to_sign !
message_to_sign @ hashu owner_private_key @ ed25519_sign_uint signature !
<b signature @ B, 0 32 u, b> <s  message_to_send !  

ດັ່ງນັ້ນ, ຂໍ້ຄວາມທີ່ພວກເຮົາຈະສົ່ງກັບສັນຍາສະຫມາດໄດ້ຖືກບັນທຶກໄວ້ໃນຕົວແປ message_to_send, ກ່ຽວກັບຫນ້າທີ່ hashu, ed25519_sign_uint ເຈົ້າສາມາດອ່ານໄດ້ ໃນເອກະສານ Fift.

ແລະເພື່ອດໍາເນີນການທົດສອບພວກເຮົາໂທຫາອີກເທື່ອຫນຶ່ງ.

message_to_send @ 
recv_external 
code 
storage @
c7
runvmctx

ນີ້ຄືດັ່ງນັ້ນ ໄຟລ໌ທີ່ມີການທົດສອບຄວນຈະເປັນແບບນີ້ໃນຂັ້ນຕອນນີ້.

ໃຫ້ດໍາເນີນການທົດສອບແລະມັນຈະລົ້ມເຫລວ, ດັ່ງນັ້ນພວກເຮົາຈະປ່ຽນສັນຍາສະຫມາດເພື່ອໃຫ້ມັນສາມາດໄດ້ຮັບຂໍ້ຄວາມຂອງຮູບແບບນີ້ແລະຢືນຢັນລາຍເຊັນ.

ທໍາອິດ, ພວກເຮົານັບ 512 bits ຂອງລາຍເຊັນຈາກຂໍ້ຄວາມແລະຂຽນມັນກັບຕົວແປ, ຫຼັງຈາກນັ້ນພວກເຮົານັບ 32 bits ຂອງຕົວປ່ຽນແປງ counter.

ເນື່ອງຈາກພວກເຮົາມີຫນ້າທີ່ສໍາລັບການອ່ານຂໍ້ມູນຈາກການເກັບຮັກສາສັນຍາສະຫມາດ, ພວກເຮົາຈະໃຊ້ມັນ.

ຕໍ່ໄປແມ່ນການກວດສອບເຄົາເຕີທີ່ໂອນກັບບ່ອນເກັບມ້ຽນແລະກວດເບິ່ງລາຍເຊັນ. ຖ້າບາງສິ່ງບາງຢ່າງບໍ່ກົງກັນ, ຫຼັງຈາກນັ້ນພວກເຮົາຖິ້ມຂໍ້ຍົກເວັ້ນທີ່ມີລະຫັດທີ່ເຫມາະສົມ.

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

ຄໍາຫມັ້ນສັນຍາທີ່ກ່ຽວຂ້ອງ right here.

ໃຫ້ດໍາເນີນການທົດສອບແລະເບິ່ງວ່າການທົດສອບທີສອງລົ້ມເຫລວ. ສໍາລັບສອງເຫດຜົນ, ບໍ່ມີ bits ພຽງພໍໃນຂໍ້ຄວາມແລະບໍ່ມີ bits ພຽງພໍໃນການເກັບຮັກສາ, ສະນັ້ນລະຫັດ crash ໃນເວລາ parsing. ພວກເຮົາຈໍາເປັນຕ້ອງເພີ່ມລາຍເຊັນໃຫ້ກັບຂໍ້ຄວາມທີ່ພວກເຮົາກໍາລັງສົ່ງແລະຄັດລອກບ່ອນເກັບຂໍ້ມູນຈາກການທົດສອບຄັ້ງສຸດທ້າຍ.

ໃນການທົດສອບຄັ້ງທີສອງ, ພວກເຮົາຈະເພີ່ມລາຍເຊັນຂໍ້ຄວາມແລະປ່ຽນການເກັບຮັກສາສັນຍາສະຫມາດ. ນີ້ຄືດັ່ງນັ້ນ ໄຟລ໌ທີ່ມີການທົດສອບເບິ່ງຄືວ່າໃນປັດຈຸບັນ.

ຂໍໃຫ້ຂຽນການທົດສອບຄັ້ງທີສີ່, ໃນທີ່ພວກເຮົາຈະສົ່ງຂໍ້ຄວາມທີ່ເຊັນດ້ວຍລະຫັດສ່ວນຕົວຂອງຄົນອື່ນ. ມາສ້າງກະແຈສ່ວນຕົວອື່ນ ແລະບັນທຶກມັນໃສ່ໄຟລ໌ not-owner.pk. ພວກເຮົາຈະເຊັນຂໍ້ຄວາມດ້ວຍກະແຈສ່ວນຕົວນີ້. ຂໍໃຫ້ດໍາເນີນການທົດສອບແລະໃຫ້ແນ່ໃຈວ່າການທົດສອບທັງຫມົດຜ່ານ. ຄໍາຫມັ້ນສັນຍາ ໃນເວລານີ້.

ດຽວນີ້ພວກເຮົາສາມາດກ້າວໄປສູ່ການຈັດຕັ້ງປະຕິບັດຕາມເຫດຜົນສັນຍາສະຫຼາດ.
В recv_external() ພວກເຮົາຈະຍອມຮັບຂໍ້ຄວາມສອງປະເພດ.

ເນື່ອງຈາກສັນຍາຂອງພວກເຮົາຈະສະສົມການສູນເສຍຂອງຜູ້ນ, ເງິນນີ້ຕ້ອງໄດ້ຮັບການໂອນໃຫ້ກັບຜູ້ສ້າງ lottery ໄດ້. ທີ່ຢູ່ກະເປົາເງິນຂອງຜູ້ສ້າງຫວຍຖືກບັນທຶກໄວ້ໃນບ່ອນເກັບມ້ຽນເມື່ອສັນຍາຖືກສ້າງຂຶ້ນ.

ພຽງແຕ່ໃນກໍລະນີ, ພວກເຮົາຕ້ອງການຄວາມສາມາດໃນການປ່ຽນທີ່ຢູ່ທີ່ພວກເຮົາສົ່ງກຼາມຂອງຜູ້ສູນເສຍ. ພວກເຮົາຄວນຈະສາມາດສົ່ງແກມຈາກຫວຍໄປຫາທີ່ຢູ່ຂອງເຈົ້າຂອງ.

ໃຫ້ເລີ່ມຕົ້ນດ້ວຍອັນທໍາອິດ. ທໍາອິດໃຫ້ຂຽນການທົດສອບທີ່ຈະກວດເບິ່ງວ່າຫຼັງຈາກສົ່ງຂໍ້ຄວາມ, ສັນຍາສະຫມາດໄດ້ບັນທຶກທີ່ຢູ່ໃຫມ່ໃນບ່ອນເກັບມ້ຽນ. ກະລຸນາສັງເກດວ່າໃນຂໍ້ຄວາມ, ນອກຈາກ counter ແລະທີ່ຢູ່ໃຫມ່, ພວກເຮົາຍັງສົ່ງ action ຈຳນວນເຕັມ 7-bit ທີ່ບໍ່ແມ່ນເລກລົບ, ຂຶ້ນກັບມັນ, ພວກເຮົາຈະເລືອກວິທີການປະມວນຜົນຂໍ້ຄວາມໃນສັນຍາສະຫມາດ.

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

ໃນການທົດສອບທ່ານສາມາດເບິ່ງວິທີການເກັບຮັກສາ smartcontract ແມ່ນ deserialized storage ໃນ Fift. Deserialization ຂອງຕົວແປແມ່ນໄດ້ອະທິບາຍໄວ້ໃນເອກະສານ Fift.

ການເຊື່ອມຕໍ່ຄໍາຫມັ້ນສັນຍາ ມີ dough ເພີ່ມ.

ໃຫ້ດໍາເນີນການທົດສອບແລະໃຫ້ແນ່ໃຈວ່າມັນລົ້ມເຫລວ. ຕອນນີ້ໃຫ້ເພີ່ມເຫດຜົນເພື່ອປ່ຽນທີ່ຢູ່ຂອງເຈົ້າຂອງຫວຍ.

ໃນສັນຍາສະຫມາດພວກເຮົາສືບຕໍ່ວິເຄາະ message, ອ່ານໃນ action. ໃຫ້ພວກເຮົາເຕືອນທ່ານວ່າພວກເຮົາຈະມີສອງ action: ປ່ຽນທີ່ຢູ່ແລະສົ່ງກຼາມ.

ຫຼັງຈາກນັ້ນ, ພວກເຮົາອ່ານທີ່ຢູ່ໃຫມ່ຂອງເຈົ້າຂອງສັນຍາແລະບັນທຶກມັນໄວ້ໃນບ່ອນເກັບມ້ຽນ.
ພວກເຮົາດໍາເນີນການທົດສອບແລະເຫັນວ່າການທົດສອບທີສາມລົ້ມເຫລວ. ມັນ crashed ເນື່ອງຈາກຄວາມຈິງທີ່ວ່າສັນຍາໃນປັດຈຸບັນເພີ່ມເຕີມ parses 7 bits ຈາກຂໍ້ຄວາມ, ທີ່ຂາດຫາຍໄປໃນການທົດສອບ. ເພີ່ມອັນທີ່ບໍ່ມີຢູ່ແລ້ວໃສ່ຂໍ້ຄວາມ action. ໃຫ້ດໍາເນີນການທົດສອບແລະເບິ່ງວ່າທຸກສິ່ງທຸກຢ່າງຜ່ານ. ທີ່ນີ້ ຫມັ້ນສັນຍາກັບການປ່ຽນແປງ. ຍິ່ງໃຫຍ່.

ຕອນນີ້ໃຫ້ພວກເຮົາຂຽນເຫດຜົນສໍາລັບການສົ່ງຈໍານວນກຼາມທີ່ກໍານົດໄວ້ໄປຫາທີ່ຢູ່ທີ່ບັນທຶກໄວ້ກ່ອນຫນ້ານີ້.

ກ່ອນອື່ນ, ໃຫ້ຂຽນແບບທົດສອບ. ພວກເຮົາຈະຂຽນສອງການທົດສອບ, ຫນຶ່ງໃນເວລາທີ່ບໍ່ມີຄວາມສົມດຸນພຽງພໍ, ທີສອງໃນເວລາທີ່ທຸກສິ່ງທຸກຢ່າງຄວນຈະຜ່ານສົບຜົນສໍາເລັດ. ການທົດສອບສາມາດເບິ່ງໄດ້ ໃນຄໍາຫມັ້ນສັນຍານີ້.

ຕອນນີ້ໃຫ້ເພີ່ມລະຫັດ. ທໍາອິດ, ໃຫ້ຂຽນສອງວິທີການຊ່ວຍເຫຼືອ. ວິທີການທໍາອິດທີ່ໄດ້ຮັບແມ່ນເພື່ອຊອກຫາຍອດເງິນໃນປະຈຸບັນຂອງສັນຍາສະຫມາດ.

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

ແລະອັນທີສອງແມ່ນສໍາລັບການສົ່ງກຼາມໄປຫາສັນຍາສະຫມາດອື່ນ. ຂ້າພະເຈົ້າໄດ້ຄັດລອກວິທີການນີ້ຢ່າງສົມບູນຈາກສັນຍາສະຫມາດອື່ນ.

() send_grams(int wc, int addr, int grams) impure {
    ;; int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool src:MsgAddress -> 011000
    cell msg = begin_cell()
    ;;  .store_uint(0, 1) ;; 0 <= format indicator int_msg_info$0 
    ;;  .store_uint(1, 1) ;; 1 <= ihr disabled
    ;;  .store_uint(1, 1) ;; 1 <= bounce = true
    ;;  .store_uint(0, 1) ;; 0 <= bounced = false
    ;;  .store_uint(4, 5)  ;; 00100 <= address flags, anycast = false, 8-bit workchain
        .store_uint (196, 9)
        .store_int(wc, 8)
        .store_uint(addr, 256)
        .store_grams(grams)
        .store_uint(0, 107) ;; 106 zeroes +  0 as an indicator that there is no cell with the data.
        .end_cell(); 
    send_raw_message(msg, 3); ;; mode, 2 for ignoring errors, 1 for sender pays fees, 64 for returning inbound message value
}

ໃຫ້ເພີ່ມສອງວິທີນີ້ໃສ່ສັນຍາສະຫມາດແລະຂຽນເຫດຜົນ. ທໍາອິດ, ພວກເຮົາວິເຄາະຈໍານວນຂອງກຼາມຈາກຂໍ້ຄວາມ. ຕໍ່ໄປພວກເຮົາກວດເບິ່ງຍອດເງິນ, ຖ້າມັນບໍ່ພຽງພໍ, ພວກເຮົາຖິ້ມຂໍ້ຍົກເວັ້ນ. ຖ້າທຸກສິ່ງທຸກຢ່າງດີ, ຫຼັງຈາກນັ້ນພວກເຮົາສົ່ງກຼາມໄປຫາທີ່ຢູ່ທີ່ບັນທຶກໄວ້ແລະປັບປຸງເຄົາເຕີ.

int amount_to_send = message~load_grams();
throw_if(36, amount_to_send + 500000000 > balance());
accept_message();
send_grams(owner_wc, owner_account_id, amount_to_send);
set_data(pack_state(stored_seqno + 1, pubkey, order_seqno, number_of_wins, incoming_amount, outgoing_amount, owner_wc, owner_account_id, orders));

ນີ້ຄືດັ່ງນັ້ນ ເບິ່ງຄືວ່າສັນຍາສະຫມາດໃນຂະນະນີ້. ໃຫ້ດໍາເນີນການທົດສອບແລະໃຫ້ແນ່ໃຈວ່າພວກເຂົາຜ່ານ.

ໂດຍວິທີທາງການ, ຄະນະກໍາມະການຖືກຫັກອອກຈາກສັນຍາສະຫມາດທຸກໆຄັ້ງສໍາລັບຂໍ້ຄວາມທີ່ຖືກປຸງແຕ່ງ. ເພື່ອໃຫ້ຂໍ້ຄວາມສັນຍາສະຫມາດປະຕິບັດການຮ້ອງຂໍ, ຫຼັງຈາກການກວດສອບພື້ນຖານທ່ານຈໍາເປັນຕ້ອງໂທຫາ accept_message().

ຕອນນີ້ໃຫ້ເຮົາກ້າວໄປສູ່ຂໍ້ຄວາມພາຍໃນ. ໃນຄວາມເປັນຈິງ, ພວກເຮົາຈະຍອມຮັບພຽງແຕ່ກຼາມແລະສົ່ງຄືນຈໍານວນສອງເທົ່າໃຫ້ກັບຜູ້ຫຼິ້ນຖ້າລາວຊະນະແລະຫນຶ່ງໃນສາມໃຫ້ກັບເຈົ້າຂອງຖ້າລາວສູນເສຍ.

ກ່ອນອື່ນ, ໃຫ້ຂຽນແບບທົດສອບງ່າຍໆ. ເພື່ອເຮັດສິ່ງນີ້, ພວກເຮົາຕ້ອງການທີ່ຢູ່ທົດສອບຂອງສັນຍາສະຫມາດທີ່ພວກເຮົາສົມມຸດວ່າສົ່ງກຼາມໄປຫາສັນຍາສະຫມາດ.

ທີ່ຢູ່ສັນຍາສະຫມາດປະກອບດ້ວຍສອງຕົວເລກ, ຈໍານວນ 32-bit ທີ່ຮັບຜິດຊອບສໍາລັບ workchain ແລະ 256-bit ຕົວເລກບັນຊີທີ່ບໍ່ຊ້ໍາກັນ integer integer ນີ້. ຕົວຢ່າງ, -1 ແລະ 12345, ນີ້ແມ່ນທີ່ຢູ່ທີ່ພວກເຮົາຈະບັນທຶກໃສ່ໄຟລ໌.

ຂ້າ​ພະ​ເຈົ້າ​ໄດ້​ຄັດ​ລອກ​ຫນ້າ​ທີ່​ສໍາ​ລັບ​ການ​ປະ​ຢັດ​ທີ່​ຢູ່​ຈາກ​ TonUtil.fif.

// ( wc addr fname -- )  Save address to file in 36-byte format
{ -rot 256 u>B swap 32 i>B B+ swap B>file } : save-address

ໃຫ້ເບິ່ງວິທີການເຮັດວຽກ, ນີ້ຈະໃຫ້ຄວາມເຂົ້າໃຈກ່ຽວກັບວິທີການ Fift ເຮັດວຽກ. ເປີດຕົວ Fift ໃນໂໝດໂຕ້ຕອບ.

~/TON/build/crypto/fift -i 

ທໍາອິດພວກເຮົາຍູ້ -1, 12345 ແລະຊື່ຂອງໄຟລ໌ໃນອະນາຄົດ "sender.addr" ໃສ່ stack ໄດ້:

-1 12345 "sender.addr" 

ຂັ້ນຕອນຕໍ່ໄປແມ່ນເພື່ອປະຕິບັດຫນ້າທີ່ -rot, ເຊິ່ງປ່ຽນ stack ໃນລັກສະນະທີ່ຢູ່ເທິງສຸດຂອງ stack ມີຕົວເລກສັນຍາສະຫມາດທີ່ເປັນເອກະລັກ:

"sender.addr" -1 12345

256 u>B ປ່ຽນຈຳນວນເຕັມທີ່ບໍ່ແມ່ນລົບ 256-bit ເປັນ bytes.

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap ແລກປ່ຽນສອງອົງປະກອບເທິງສຸດຂອງ stack.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B ປ່ຽນຈຳນວນເຕັມ 32-bit ເປັນ bytes.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 BYTES:FFFFFFFF

B+ ເຊື່ອມຕໍ່ສອງລໍາດັບຂອງ bytes.

 "sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF

ອີກເທື່ອ ໜຶ່ງ swap.

BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF "sender.addr" 

ແລະສຸດທ້າຍ bytes ຖືກຂຽນໃສ່ໄຟລ໌ B>file. ຫຼັງຈາກນີ້ stack ຂອງພວກເຮົາແມ່ນຫວ່າງເປົ່າ. ພວກເຮົາຢຸດເຊົາ Fift. ໄຟລ໌ໄດ້ຖືກສ້າງຢູ່ໃນໂຟນເດີປະຈຸບັນ sender.addr. ໃຫ້ຍ້າຍໄຟລ໌ໄປຫາໂຟນເດີທີ່ສ້າງຂຶ້ນ test/addresses/.

ໃຫ້ຂຽນແບບທົດສອບງ່າຍໆທີ່ຈະສົ່ງກຼາມໄປຫາສັນຍາສະຫມາດ. ນີ້ແມ່ນຄຳໝັ້ນສັນຍາ.

ບັດນີ້ເຮົາມາເບິ່ງເຫດຜົນຂອງຫວຍ.

ສິ່ງທໍາອິດທີ່ພວກເຮົາເຮັດແມ່ນກວດເບິ່ງຂໍ້ຄວາມ bounced ຫຼືບໍ່ຖ້າ bounced, ຫຼັງຈາກນັ້ນພວກເຮົາບໍ່ສົນໃຈມັນ. bounced ຫມາຍຄວາມວ່າສັນຍາຈະສົ່ງຄືນກຼາມຖ້າມີຂໍ້ຜິດພາດເກີດຂື້ນ. ພວກ​ເຮົາ​ຈະ​ບໍ່​ສົ່ງ​ຄືນ​ກຼາມ​ຖ້າ​ຫາກ​ວ່າ​ຄວາມ​ຜິດ​ພາດ​ເກີດ​ຂຶ້ນ​ຢ່າງ​ກະ​ທັນ​ຫັນ​.

ພວກເຮົາກວດເບິ່ງ, ຖ້າຍອດເງິນແມ່ນຫນ້ອຍກວ່າເຄິ່ງຫນຶ່ງກຼາມ, ຫຼັງຈາກນັ້ນພວກເຮົາພຽງແຕ່ຍອມຮັບຂໍ້ຄວາມແລະບໍ່ສົນໃຈມັນ.

ຕໍ່ໄປ, ພວກເຮົາວິເຄາະທີ່ຢູ່ຂອງສັນຍາສະຫມາດທີ່ຂໍ້ຄວາມມາ.

ພວກເຮົາອ່ານຂໍ້ມູນຈາກການເກັບຮັກສາແລະຫຼັງຈາກນັ້ນລຶບເດີມພັນເກົ່າອອກຈາກປະຫວັດສາດຖ້າມີຫຼາຍກວ່າຊາວຂອງພວກເຂົາ. ເພື່ອຄວາມສະດວກ, ຂ້າພະເຈົ້າໄດ້ຂຽນສາມຫນ້າທີ່ເພີ່ມເຕີມ pack_order(), unpack_order(), remove_old_orders().

ຕໍ່ໄປ, ພວກເຮົາເບິ່ງວ່າຍອດເງິນບໍ່ພຽງພໍສໍາລັບການຈ່າຍເງິນ, ຫຼັງຈາກນັ້ນພວກເຮົາພິຈາລະນາວ່ານີ້ບໍ່ແມ່ນການເດີມພັນ, ແຕ່ເປັນການເຕີມເຕັມແລະປະຫຍັດການຕື່ມໃນ. orders.

ຫຼັງຈາກນັ້ນ, ສຸດທ້າຍແມ່ນເນື້ອໃນຂອງສັນຍາສະຫມາດ.

ທໍາອິດ, ຖ້າຜູ້ນສູນເສຍ, ພວກເຮົາບັນທຶກມັນໄວ້ໃນປະຫວັດການເດີມພັນແລະຖ້າຈໍານວນຫຼາຍກ່ວາ 3 ກຼາມ, ພວກເຮົາສົ່ງ 1/3 ກັບເຈົ້າຂອງສັນຍາສະຫມາດ.

ຖ້າຜູ້ນຊະນະ, ພວກເຮົາສົ່ງຈໍານວນສອງເທົ່າໄປຫາທີ່ຢູ່ຂອງຜູ້ນແລະຫຼັງຈາກນັ້ນບັນທຶກຂໍ້ມູນກ່ຽວກັບການເດີມພັນໃນປະຫວັດສາດ.

() recv_internal(int order_amount, cell in_msg_cell, slice in_msg) impure {
    var cs = in_msg_cell.begin_parse();
    int flags = cs~load_uint(4);  ;; int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool
    if (flags & 1) { ;; ignore bounced
        return ();
    }
    if (order_amount < 500000000) { ;; just receive grams without changing state 
        return ();
    }
    slice src_addr_slice = cs~load_msg_addr();
    (int src_wc, int src_addr) = parse_std_addr(src_addr_slice);
    (int stored_seqno, int pubkey, int order_seqno, int number_of_wins, int incoming_amount, int outgoing_amount, int owner_wc, int owner_account_id, cell orders) = unpack_state();
    orders = remove_old_orders(orders, order_seqno);
    if (balance() < 2 * order_amount + 500000000) { ;; not enough grams to pay the bet back, so this is re-fill
        builder order = pack_order(order_seqno, 1, now(), order_amount, src_wc, src_addr);
        orders~udict_set_builder(32, order_seqno, order);
        set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins, incoming_amount + order_amount, outgoing_amount, owner_wc, owner_account_id, orders));
        return ();
    }
    if (rand(10) >= 4) {
        builder order = pack_order(order_seqno, 3, now(), order_amount, src_wc, src_addr);
        orders~udict_set_builder(32, order_seqno, order);
        set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins, incoming_amount + order_amount, outgoing_amount, owner_wc, owner_account_id, orders));
        if (order_amount > 3000000000) {
            send_grams(owner_wc, owner_account_id, order_amount / 3);
        }
        return ();
    }
    send_grams(src_wc, src_addr, 2 * order_amount);
    builder order = pack_order(order_seqno, 2, now(), order_amount, src_wc, src_addr);
    orders~udict_set_builder(32, order_seqno, order);
    set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins + 1, incoming_amount, outgoing_amount + 2 * order_amount, owner_wc, owner_account_id, orders));
}

ນັ້ນແມ່ນທັງຫມົດ. ຄໍາຫມັ້ນສັນຍາທີ່ສອດຄ້ອງກັນ.

ດຽວນີ້ສິ່ງທີ່ຍັງເຫຼືອແມ່ນງ່າຍດາຍ, ໃຫ້ສ້າງວິທີການຮັບເພື່ອໃຫ້ພວກເຮົາສາມາດໄດ້ຮັບຂໍ້ມູນກ່ຽວກັບສະຖານະຂອງສັນຍາຈາກໂລກພາຍນອກ (ໃນຄວາມເປັນຈິງ, ອ່ານຂໍ້ມູນຈາກການເກັບຮັກສາສັນຍາສະຫມາດຂອງພວກເຂົາ).

ມາເພີ່ມວິທີການ. ພວກເຮົາຈະຂຽນຂ້າງລຸ່ມນີ້ກ່ຽວກັບວິທີການຮັບຂໍ້ມູນກ່ຽວກັບສັນຍາສະຫມາດ.

ຂ້ອຍຍັງລືມເພີ່ມລະຫັດທີ່ຈະດໍາເນີນການຄໍາຮ້ອງຂໍທໍາອິດທີ່ເກີດຂື້ນໃນເວລາທີ່ເຜີຍແຜ່ສັນຍາສະຫມາດ. ຄໍາຫມັ້ນສັນຍາທີ່ສອດຄ້ອງກັນ. ແລະຕໍ່ໄປ ແກ້ໄຂ bug ກັບການສົ່ງ 1/3 ຂອງຈໍານວນເງິນໄປຍັງບັນຊີຂອງເຈົ້າຂອງ.

ຂັ້ນຕອນຕໍ່ໄປແມ່ນການເຜີຍແຜ່ສັນຍາສະຫມາດ. ມາສ້າງໂຟນເດີ requests.

ຂ້ອຍເອົາລະຫັດສິ່ງພິມເປັນພື້ນຖານ simple-wallet-code.fc ທີ່ ສາມາດຊອກຫາ ໃນ repository ຢ່າງເປັນທາງການ.

ບາງສິ່ງບາງຢ່າງທີ່ຄວນເອົາໃຈໃສ່. ພວກເຮົາສ້າງບ່ອນເກັບຂໍ້ມູນສັນຍາອັດສະລິຍະ ແລະຂໍ້ຄວາມປ້ອນຂໍ້ມູນ. ຫຼັງຈາກນີ້, ທີ່ຢູ່ຂອງສັນຍາສະຫມາດແມ່ນຖືກສ້າງຂຶ້ນ, ນັ້ນແມ່ນ, ທີ່ຢູ່ແມ່ນເປັນທີ່ຮູ້ຈັກເຖິງແມ່ນວ່າກ່ອນທີ່ຈະພິມເຜີຍແຜ່ໃນ TON. ຕໍ່ໄປ, ທ່ານຈໍາເປັນຕ້ອງສົ່ງຫຼາຍກຼາມໄປຫາທີ່ຢູ່ນີ້, ແລະພຽງແຕ່ຫຼັງຈາກນັ້ນທ່ານຈໍາເປັນຕ້ອງສົ່ງໄຟລ໌ທີ່ມີສັນຍາສະຫມາດຂອງມັນເອງ, ນັບຕັ້ງແຕ່ເຄືອຂ່າຍໃຊ້ເວລາຄະນະກໍາມະການສໍາລັບການເກັບຮັກສາສັນຍາສະຫມາດແລະການດໍາເນີນງານຢູ່ໃນມັນ (ຜູ້ກວດສອບທີ່ເກັບຮັກສາແລະປະຕິບັດ smart. ສັນຍາ). ລະຫັດສາມາດເບິ່ງໄດ້ທີ່ນີ້.

ຕໍ່ໄປພວກເຮົາດໍາເນີນການລະຫັດການເຜີຍແຜ່ແລະໄດ້ຮັບ lottery-query.boc ເອກະສານສັນຍາອັດສະລິຍະ ແລະທີ່ຢູ່.

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

ຢ່າລືມບັນທຶກໄຟລ໌ທີ່ສ້າງຂຶ້ນ: lottery-query.boc, lottery.addr, lottery.pk.

ໃນບັນດາສິ່ງອື່ນໆ, ພວກເຮົາຈະເຫັນທີ່ຢູ່ຂອງສັນຍາສະຫມາດໃນບັນທຶກການປະຕິບັດ.

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

ເພື່ອຄວາມມ່ວນ, ຂໍຮ້ອງກັບ TON

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

ແລະພວກເຮົາຈະເຫັນວ່າບັນຊີທີ່ມີທີ່ຢູ່ນີ້ແມ່ນຫວ່າງເປົ່າ.

account state is empty

ພວກເຮົາສົ່ງໄປຫາທີ່ຢູ່ 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd 2 Gram ແລະຫຼັງຈາກສອງສາມວິນາທີພວກເຮົາປະຕິບັດຄໍາສັ່ງດຽວກັນ. ເພື່ອສົ່ງກຼາມຂ້ອຍໃຊ້ ກະເປົາເງິນຢ່າງເປັນທາງການ, ແລະທ່ານສາມາດຮ້ອງຂໍໃຫ້ຜູ້ໃດຜູ້ຫນຶ່ງຈາກການສົນທະນາສໍາລັບການທົດສອບ g, ທີ່ຂ້າພະເຈົ້າຈະເວົ້າກ່ຽວກັບໃນຕອນທ້າຍຂອງບົດຄວາມ.

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

ເບິ່ງ​ຄື​ວ່າ​ບໍ່​ໄດ້​ເລີ່ມ​ຕົ້ນ (state:account_uninit) ສັນຍາສະຫມາດທີ່ມີທີ່ຢູ່ດຽວກັນແລະຍອດເງິນຂອງ 1 nanograms.

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

ຕອນນີ້ໃຫ້ພວກເຮົາເຜີຍແຜ່ສັນຍາສະຫມາດ. ເປີດຕົວລູກຄ້າ lite ແລະດໍາເນີນການ.

> sendfile lottery-query.boc
[ 1][t 2][1583008371.631410122][lite-client.cpp:966][!testnode] sending query from file lottery-query.boc
[ 3][t 1][1583008371.828550100][lite-client.cpp:976][!query]    external message status is 1 

ໃຫ້ກວດເບິ່ງວ່າສັນຍາໄດ້ຖືກຈັດພີມມາ.

> last
> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

ໃນບັນດາສິ່ງອື່ນໆທີ່ພວກເຮົາໄດ້ຮັບ.

  storage:(account_storage last_trans_lt:3825499000002
    balance:(currencies
      grams:(nanograms
        amount:(var_uint len:4 value:1987150999))
      other:(extra_currencies
        dict:hme_empty))
    state:(account_active

ພວກເຮົາເຫັນວ່າ account_active.

ຄໍາຫມັ້ນສັນຍາທີ່ສອດຄ້ອງກັນກັບການປ່ຽນແປງ right here.

ຕອນນີ້ໃຫ້ສ້າງການຮ້ອງຂໍເພື່ອພົວພັນກັບສັນຍາສະຫມາດ.

ຫຼາຍທີ່ຊັດເຈນ, ພວກເຮົາຈະອອກຈາກອັນທໍາອິດສໍາລັບການປ່ຽນທີ່ຢູ່ເປັນວຽກເອກະລາດ, ແລະພວກເຮົາຈະເຮັດອັນທີສອງສໍາລັບການສົ່ງກຼາມໄປຫາທີ່ຢູ່ຂອງເຈົ້າຂອງ. ໃນ​ຄວາມ​ເປັນ​ຈິງ, we will need to do the same as in the test for sending grams .

ນີ້ແມ່ນຂໍ້ຄວາມທີ່ພວກເຮົາຈະສົ່ງໄປຫາສັນຍາສະຫມາດ, ບ່ອນທີ່ msg_seqno 165, action 2 ແລະ 9.5 ກຼາມສໍາລັບການສົ່ງ.

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

ຢ່າລືມເຊັນຂໍ້ຄວາມດ້ວຍກະແຈສ່ວນຕົວຂອງເຈົ້າ lottery.pk, ເຊິ່ງໄດ້ຖືກສ້າງຂື້ນກ່ອນຫນ້ານີ້ໃນເວລາສ້າງສັນຍາສະຫມາດ. ນີ້ແມ່ນຄໍາຫມັ້ນສັນຍາທີ່ສອດຄ້ອງກັນ.

ການ​ຮັບ​ຂໍ້​ມູນ​ຈາກ​ສັນ​ຍາ smart ໂດຍ​ໃຊ້​ວິ​ທີ​ການ​ໄດ້​ຮັບ​

ຕອນນີ້ໃຫ້ເບິ່ງວິທີການດໍາເນີນການສັນຍາ smart ໄດ້ຮັບວິທີການ.

ເປີດຕົວ lite-client ແລະດໍາເນີນການຮັບວິທີການທີ່ພວກເຮົາຂຽນ.

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

В result ປະກອບມີຄ່າທີ່ຟັງຊັນສົ່ງຄືນ balance() ຈາກສັນຍາສະຫມາດຂອງພວກເຮົາ.
ພວກເຮົາຈະເຮັດເຊັ່ນດຽວກັນສໍາລັບວິທີການຫຼາຍ.

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

ຂໍໃຫ້ປະຫວັດການເດີມພັນຂອງທ່ານ.

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

ພວກເຮົາຈະນໍາໃຊ້ lite-client ແລະໄດ້ຮັບວິທີການເພື່ອສະແດງຂໍ້ມູນກ່ຽວກັບສັນຍາສະຫມາດຢູ່ໃນເວັບໄຊທ໌.

ສະແດງຂໍ້ມູນສັນຍາສະຫມາດຢູ່ໃນເວັບໄຊທ໌

ຂ້ອຍຂຽນເວັບໄຊທ໌ງ່າຍໆໃນ Python ເພື່ອສະແດງຂໍ້ມູນຈາກສັນຍາສະຫມາດໃນວິທີທີ່ສະດວກ. ໃນທີ່ນີ້ຂ້າພະເຈົ້າຈະບໍ່ໄດ້ອາໄສຢູ່ກັບມັນໃນລາຍລະອຽດແລະຈະເຜີຍແຜ່ເວັບໄຊທ໌ ໃນຫນຶ່ງຄໍາຫມັ້ນສັນຍາ.

ການຮ້ອງຂໍໃຫ້ TON ແມ່ນມາຈາກ Python ໂດຍການຊ່ວຍເຫຼືອ lite-client. ເພື່ອຄວາມສະດວກ, ເວັບໄຊທ໌ໄດ້ຖືກບັນຈຸຢູ່ໃນ Docker ແລະເຜີຍແຜ່ໃນ Google Cloud. ເຊື່ອມຕໍ່.

ໃຫ້ພະຍາຍາມ

ຕອນນີ້ໃຫ້ພະຍາຍາມສົ່ງກຼາມຢູ່ທີ່ນັ້ນເພື່ອການຕື່ມຂໍ້ມູນຈາກ ກະເປົາເງິນ. ພວກເຮົາຈະສົ່ງ 40 ກຣາມ. ແລະໃຫ້ພວກເຮົາວາງເດີມພັນສອງສາມຢ່າງເພື່ອຄວາມຊັດເຈນ. ພວກເຮົາເຫັນວ່າເວັບໄຊທ໌ສະແດງໃຫ້ເຫັນປະຫວັດການເດີມພັນ, ອັດຕາສ່ວນຊະນະໃນປະຈຸບັນແລະຂໍ້ມູນທີ່ເປັນປະໂຫຍດອື່ນໆ.

ພວກເຮົາເບິ່ງວ່າພວກເຮົາຊະນະຄັ້ງທໍາອິດ, ເສຍທີສອງ.

Afterword

ບົດຄວາມໄດ້ກາຍມາເປັນຍາວກວ່າທີ່ຂ້ອຍຄາດໄວ້, ບາງທີມັນອາດຈະສັ້ນກວ່າ, ຫຼືອາດຈະເປັນພຽງແຕ່ຜູ້ທີ່ບໍ່ຮູ້ຫຍັງກ່ຽວກັບ TON ແລະຕ້ອງການຂຽນແລະເຜີຍແຜ່ສັນຍາສະຫມາດທີ່ບໍ່ງ່າຍດາຍທີ່ມີຄວາມສາມາດໃນການພົວພັນກັບ. ມັນ. ບາງທີບາງສິ່ງທີ່ສາມາດອະທິບາຍໄດ້ງ່າຍຂຶ້ນ.

ບາງ​ທີ​ບາງ​ດ້ານ​ຂອງ​ການ​ປະ​ຕິ​ບັດ​ສາ​ມາດ​ເຮັດ​ໄດ້​ຢ່າງ​ມີ​ປະ​ສິດ​ທິ​ພາບ​ແລະ​ສະ​ຫງ່າ​ງາມ​, ແຕ່​ຫຼັງ​ຈາກ​ນັ້ນ​ມັນ​ຈະ​ໃຊ້​ເວ​ລາ​ຫຼາຍ​ກວ່າ​ທີ່​ຈະ​ກະ​ກຽມ​ບົດ​ຄວາມ​. ມັນເປັນໄປໄດ້ວ່າຂ້ອຍເຮັດຜິດພາດຢູ່ບ່ອນໃດບ່ອນຫນຶ່ງຫຼືບໍ່ເຂົ້າໃຈບາງສິ່ງບາງຢ່າງ, ດັ່ງນັ້ນ, ຖ້າທ່ານກໍາລັງເຮັດສິ່ງທີ່ຮ້າຍແຮງ, ທ່ານຈໍາເປັນຕ້ອງອີງໃສ່ເອກະສານທາງການຫຼືບ່ອນເກັບມ້ຽນຢ່າງເປັນທາງການທີ່ມີລະຫັດ TON.

ມັນຄວນຈະສັງເກດວ່ານັບຕັ້ງແຕ່ TON ຕົວຂອງມັນເອງຍັງຢູ່ໃນຂັ້ນຕອນຂອງການພັດທະນາຢ່າງຫ້າວຫັນ, ການປ່ຽນແປງອາດຈະເກີດຂື້ນທີ່ຈະທໍາລາຍຂັ້ນຕອນໃດໆໃນບົດຄວາມນີ້ (ທີ່ເກີດຂຶ້ນໃນຂະນະທີ່ຂ້ອຍຂຽນ, ມັນໄດ້ຖືກແກ້ໄຂແລ້ວ), ແຕ່ວິທີການທົ່ວໄປແມ່ນ. ຄົງຈະບໍ່ປ່ຽນແປງ.

ຂ້ອຍຈະບໍ່ເວົ້າກ່ຽວກັບອະນາຄົດຂອງ TON. ບາງທີເວທີຈະກາຍເປັນສິ່ງທີ່ໃຫຍ່ແລະພວກເຮົາຄວນໃຊ້ເວລາສຶກສາມັນແລະຕື່ມຂໍ້ມູນໃສ່ກັບຜະລິດຕະພັນຂອງພວກເຮົາໃນປັດຈຸບັນ.

ຍັງມີ Libra ຈາກເຟສບຸກ, ເຊິ່ງມີຜູ້ຊົມທີ່ມີທ່າແຮງຂອງຜູ້ໃຊ້ຂະຫນາດໃຫຍ່ກວ່າ TON. ຂ້າພະເຈົ້າຮູ້ເກືອບບໍ່ມີຫຍັງກ່ຽວກັບ Libra, ການຕັດສິນໂດຍກອງປະຊຸມມີກິດຈະກໍາຫຼາຍກ່ວາຢູ່ໃນຊຸມຊົນ TON. ເຖິງແມ່ນວ່າຜູ້ພັດທະນາແລະຊຸມຊົນຂອງ TON ແມ່ນຄ້າຍຄືຢູ່ໃຕ້ດິນ, ເຊິ່ງຍັງເຢັນ.

ເອກະສານ

1. ເອກະສານ TON ຢ່າງເປັນທາງການ: https://test.ton.org
2. TON repository ຢ່າງ​ເປັນ​ທາງ​ການ​: https://github.com/ton-blockchain/ton
3. ກະເປົາເງິນຢ່າງເປັນທາງການສໍາລັບເວທີທີ່ແຕກຕ່າງກັນ: https://wallet.ton.org
4. ຄັງສັນຍາອັດສະລິຍະຈາກບົດຄວາມນີ້: https://github.com/raiym/astonished
5. ເຊື່ອມຕໍ່ກັບເວັບໄຊທ໌ສັນຍາສະຫມາດ: https://ton-lottery.appspot.com
6. Repository ສໍາລັບສ່ວນຂະຫຍາຍສໍາລັບ Visual Studio Code ສໍາລັບ FunC: https://github.com/raiym/func-visual-studio-plugin
7. ສົນທະນາກ່ຽວກັບ TON ໃນ Telegram, ເຊິ່ງກໍ່ຊ່ວຍຄິດໄລ່ມັນຢູ່ໃນຂັ້ນຕອນເບື້ອງຕົ້ນ. ຂ້າພະເຈົ້າຄິດວ່າມັນຈະບໍ່ມີຄວາມຜິດພາດຖ້າຂ້ອຍເວົ້າວ່າທຸກຄົນທີ່ຂຽນບາງສິ່ງບາງຢ່າງສໍາລັບ TON ແມ່ນຢູ່ທີ່ນັ້ນ. ນອກນັ້ນທ່ານຍັງສາມາດຮ້ອງຂໍໃຫ້ມີກຼາມທົດສອບຢູ່ທີ່ນັ້ນ. https://t.me/tondev_ru
8. ການສົນທະນາອື່ນກ່ຽວກັບ TON ທີ່ຂ້ອຍພົບຂໍ້ມູນທີ່ເປັນປະໂຫຍດ: https://t.me/TONgramDev
9. ຂັ້ນ​ຕອນ​ທໍາ​ອິດ​ຂອງ​ການ​ແຂ່ງ​ຂັນ​: https://contest.com/blockchain
10. ຂັ້ນ​ຕອນ​ທີ​ສອງ​ຂອງ​ການ​ແຂ່ງ​ຂັນ​: https://contest.com/blockchain-2

ແຫຼ່ງຂໍ້ມູນ: www.habr.com