Solidity Is to Ethereum What Tact Is to TON — Paano Gumawa ng Voting Smart Contract sa TON Gamit ang Tact

Kadalasan, kapag nagsimulang matuto ang mga tao kung paano magsulat ng mga matalinong kontrata, ang unang bagay na maririnig nila ay Solidity at Ethereum. Yun din ang una kong narinig. Ito ang pinagtutuunan ng pansin ng karamihan sa mga tutorial, at sa magandang dahilan. Ang solidity ay naging posible na magsulat ng mga programa na nakatira sa isang blockchain, at ang Ethereum ay naging lugar kung saan nagsimula ang maraming tao.

Ngunit ang Solidity ay hindi lamang ang matalinong wika ng kontrata sa labas. At ang Ethereum ay hindi lamang ang blockchain na sumusuporta sa mga desentralisadong aplikasyon.

Mayroon ding TON , maikli para sa The Open Network . Nilikha ito ng Telegram, ngunit isa na itong pampubliko, chain na hinimok ng komunidad. Ito ay mabilis, magaan, at pinangangasiwaan ang mga bagay na medyo naiiba sa kung ano ang maaaring nakasanayan mo sa Ethereum. Kasama diyan kung paano isinusulat ang mga smart contract. Noong sinimulan kong tuklasin ang dokumentasyon ng TON, nakatagpo ako ng apat na magkakaibang wika para sa pagsusulat ng mga matalinong kontrata: Tact, Tolk, FunC, at Fift . Hindi ako magpapalalim sa apat dito.

Nakatuon ang gabay na ito sa wikang Tact, at makikita natin kung paano ito gamitin upang bumuo ng isang pangunahing kontrata sa pagboto na nagbibigay-daan sa mga user na bumoto at suriin ang mga resulta nang on-chain.

Kung Bakit Ako Nagpasya na Matuto muna ng Tact

Ang TON ecosystem ay aktwal na sumusuporta sa maraming wika, bawat isa ay naghahatid ng iba't ibang mga kaso ng paggamit, antas ng abstraction, at karanasan ng developer. Narito ang isang mabilis na pangkalahatang-ideya ng bawat isa sa kanila:

• Ang FunC ay ang tradisyunal na wika para sa pagsusulat ng mga smart contract ng TON. Ito ay mababa ang antas at nagbibigay sa iyo ng tumpak na kontrol sa kung paano gumagana ang iyong kontrata sa ilalim ng hood. Makapangyarihan ito, ngunit nangangahulugan din ito na kakailanganin mong maunawaan kung paano gumagana ang TON Virtual Machine (TVM), kabilang ang mga konsepto tulad ng pagmamanipula ng stack, layout ng memorya, at deterministikong pagpapatupad. Ang syntax ay medyo katulad ng C, na maaaring hindi pamilyar kung hindi mo pa nagagawa ang istilo ng wikang iyon dati.
• Karaniwang ginagamit ang Fift kasama ng FunC. Ito ay isang stack-based na wika na kadalasang ginagamit para sa direktang pakikipag-ugnayan sa TVM at ginagamit para sa pag-deploy, pag-debug, at pagsasagawa ng on-chain na mga kalkulasyon. Karaniwang hindi ito ang wikang sinisimulan mo para sa pagsusulat ng mga buong smart na kontrata, ngunit mahalaga ito sa pangkalahatang daloy ng trabaho sa pag-unlad sa TON.
• Ang Tolk ay isang mas bagong karagdagan na umuunlad pa rin. Mula sa kung ano ang aking nakalap, ito ay naglalayong pagbutihin ang tooling at pagiging tugma sa mas mataas na antas ng mga wika. Nangangako ito, ngunit hindi pa gaanong pinagtibay o naidokumento.
• Ang Tact ay isang mataas na antas ng wika na partikular na idinisenyo upang gawing mas naa-access at madaling gamitin ang developer ng TON smart contract development. Pinapasimple ng Tact ang maraming mas mababang antas ng pagiging kumplikado at hinahayaan kang tumuon sa pagsulat ng iyong lohika sa isang malinis, nababasang paraan. Ang syntax ay mas malapit sa kung ano ang makikita mo sa TypeScript o Solidity, na ginagawang mas madali upang makapagsimula nang hindi nangangailangan ng malalim na pagsisid sa mga internal ng TVM.

Ang Tact ay nagbibigay at isang mas mabilis na landas para sa pagbuo at pag-deploy ng mga kontrata sa TON blockchain.

Pag-unawa sa Paano Gumagana ang Takte

Bago tayo magsimulang magsulat ng code, mahalagang maunawaan kung paano nakaayos ang mga kontrata ng Tact smart. Kasama sa karaniwang kontrata ng Tact ang ilang pangunahing bahagi:

• contract block – Dito mo tutukuyin ang pangalan ng iyong kontrata at magdedeklara ng anumang mga variable ng estado.

• init block – Sinisimulan nito ang mga variable ng estado ng iyong kontrata at itinatakda ang mga kondisyon ng pagsisimula ng kontrata. Ang block na ito ay tumatakbo nang isang beses sa oras ng pag-deploy.

• receive ng mga bloke - Ito ay tulad ng mga tagapakinig ng kaganapan. Pinangangasiwaan nila ang mga papasok na mensahe at tinutukoy kung paano tumugon ang iyong kontrata sa kanila.

• Getter functions ( get fun ) – Ito ay mga opsyonal na read-only na function na nagbibigay-daan sa mga user o iba pang kontrata na i-query ang estado ng kontrata nang hindi ito binabago.

  
  

Gumagamit ang Tact ng komunikasyong nakabatay sa mensahe, na kung paano gumagana ang lahat ng pakikipag-ugnayan sa TON. Ang bawat kontrata ay tumatanggap ng mensahe at pinoproseso ito sa sarili nitong receive block. Ang istrukturang ito na nakabatay sa mensahe ay nakakatulong na ayusin ang iyong lohika ng kontrata sa isang modular, mapanatili na paraan.

Ilapat natin ito ngayon sa isang tunay na halimbawa sa pamamagitan ng pagbuo ng isang simpleng kontrata sa pagboto.

Pagbuo ng Iyong Unang Kontrata sa Pagboto gamit ang Tact (Gamit ang TON Web IDE)

Sa seksyong ito, tatalakayin natin kung paano ipatupad ang isang pangunahing sistema ng pagboto gamit ang Tact. Ang kontrata sa pagboto na ito ay magbibigay-daan sa mga user na bumoto para sa mga paunang natukoy na kandidato at subaybayan ang kabuuang bilang ng mga boto na natatanggap ng bawat kandidato.

Gagawin namin ang lahat sa loob ng TON Web IDE, na isang in-browser na tool kung saan maaari mong isulat, buuin, at subukan ang iyong mga kontrata nang walang lokal na pag-install.

Hakbang 1 – Buksan ang TON Web IDE

• Pumunta sa https://ide.ton.org .
• I-click ang Gumawa ng bagong proyekto . Sa popup:
  • Siguraduhin na ang wika ay nasa Tact .
  • Piliin ang Blangkong Kontrata bilang iyong template.
  • Pangalanan ang iyong proyekto tulad ng VotingContract .
  • I-click ang + Lumikha .

Hakbang 2 – Pagsulat ng Kodigo sa Kontrata sa Pagboto

Pagkatapos gawin ang iyong proyekto, buksan ang main.tact file. Makakakita ka ng setup ng boilerplate:

 // Import the Deployable trait so the contract can be deployed easily import "@stdlib/deploy"; contract BlankContract with Deployable { init() { } }

• import "@stdlib/deploy"; ay kinakailangan para gumana ang deployment at hindi dapat alisin sa code.
• BlankContract ay ang pangalan ng placeholder.
• Ang init() block ay tumatakbo nang isang beses lamang kapag ang kontrata ay na-deploy at ginagamit upang simulan ang mga variable ng estado.

Ngayon, imapa natin ang sarili nating code.

Una, tutukuyin natin ang istraktura ng mensahe para sa pagboto:

 // Import the Deployable trait so the contract can be deployed easily import "@stdlib/deploy"; // Define a message structure for voting message Vote { candidate: Int as uint32; // 1 = Alice, 2 = Bob }

Ito ang mensahe ng Bumoto. Kapag may gustong bumoto, magpapadala sila ng mensahe sa kontrata na may kasamang numero:

• 1 para kay Alice
• 2 para kay Bob

Ginagamit ng Tact ang istrukturang ito upang iproseso ang papasok na boto at magpasya kung sinong kandidato ang makakakuha ng punto.

Susunod, ise-set up namin ang aming kontrata at magdagdag ng dalawang variable ng estado upang masubaybayan ang mga boto ng bawat kandidato:

 ... contract VotingContract with Deployable { // State variables to track votes votesAlice: Int as uint32; votesBob: Int as uint32;

Sa loob ng kontrata, tinukoy namin ang dalawang variable:

• votesAlice : iniimbak ang bilang ng mga boto na natatanggap ni Alice.
• votesBob : iniimbak ang bilang ng mga boto na natatanggap ni Bob.

Sisimulan na namin ngayon ang mga bilang ng boto sa zero sa loob ng init block upang itakda ang panimulang estado ng kontrata kapag ito ay unang na-deploy.

 init() { self.votesAlice = 0; self.votesBob = 0; }

Isang beses lang tatakbo ang init block , kapag na-deploy na ang kontrata at itinatakda nito ang parehong bilang ng boto sa zero.

Ngayon ay dumating ang lohika. Kapag nagpadala ng boto, gusto naming suriin ng kontrata kung para kanino ang boto at dagdagan ang tamang bilang ng boto.

 // Handle vote messages receive(msg: Vote) { if (msg.candidate == 1) { self.votesAlice += 1; } else if (msg.candidate == 2) { self.votesBob += 1; } }

Kaya kapag natanggap ang isang boto:

• Kung 1 ang msg.candidate , nagdaragdag kami ng +1 sa votesAlice
• Kung 2 ang msg.candidate , nagdaragdag kami ng +1 sa votesBob

Panghuli, gagawa kami ng mga function ng getter upang hayaan ang sinuman na magtanong sa bilang ng boto para sa bawat kandidato nang hindi binabago ang estado ng kontrata.

 // Getter for Alice's votes get fun getVotesForAlice(): Int { return self.votesAlice; } // Getter for Bob's votes get fun getVotesForBob(): Int { return self.votesBob; } }

Ang dalawang getter function na ito ay hayaan nating suriin ang bilang ng mga boto na natanggap ng bawat kandidato nang hindi binabago ang anuman sa kontrata. Isa itong read-only na operasyon.

Nasa ibaba ang buong code ng kontrata sa pagboto:

 import "@stdlib/deploy"; // Define a message structure for voting message Vote { candidate: Int as uint32; // 1 = Alice, 2 = Bob } contract VotingContract with Deployable { // State variables to track votes votesAlice: Int as uint32; votesBob: Int as uint32; init() { self.votesAlice = 0; self.votesBob = 0; } // Handle vote messages receive(msg: Vote) { if (msg.candidate == 1) { self.votesAlice += 1; } else if (msg.candidate == 2) { self.votesBob += 1; } } // Getter for Alice's votes get fun getVotesForAlice(): Int { return self.votesAlice; } // Getter for Bob's votes get fun getVotesForBob(): Int { return self.votesBob; } }

Hakbang 4 – Buuin at I-deploy ang Kontrata

• Sa kaliwang sidebar, mag-click sa Build & Deploy

• Sa ilalim ng Environment , tiyaking napili ang Sandbox .
• Tiyaking napili ang main.tact at i-click ang Build . Isasama nito ang iyong kontrata at titingnan kung may mga error o isyu sa syntax sa iyong code.
• Susunod, tiyaking napili ang VotingContract sa dropdown dahil iyon ang iyong aktwal na kontrata, hindi ang default na placeholder. Kung hindi mo ito nakikita, pindutin ang Ctrl + S upang i-save ang iyong file upang matukoy ng IDE ang na-update na kontrata.
• Pagkatapos ay i-click ang ReDeploy . Kung gumagana nang tama ang lahat, makakakita ka ng mensahe ng kumpirmasyon sa mga log na nagpapakita na matagumpay na na-deploy ang iyong kontrata sa Sandbox.

Hakbang 5 – Makipag-ugnayan sa Kontrata

Kapag na-deploy na, mag-scroll pababa at makakakita ka ng dalawang seksyon:

• Getters: getVotesForAlice , getVotesForBob
• Mga Receiver: Vote

Para bumoto: Sa seksyong Bumoto , ilagay 1 sa field ng input candidate at i-click ang Ipadala. Binoto mo lang si Alice! Maaari mong ulitin ito para bumoto pa.

Upang suriin ang bilang ng boto : I-click ang Tumawag sa ilalim ng getVotesForAlice at tingnan ang panel ng mga log upang makita ang bilang ng boto

• Gawin ang parehong para kay Bob sa pamamagitan ng pagpapadala 2 sa field candidate , pagkatapos ay suriin getVotesForBob

Sa aking test run, bumoto ako para kay Alice ng 9 na beses at Bob 6 na beses , at ang mga function ng getter ay eksaktong ipinakita iyon.

💭 Mga Pangwakas na Kaisipan: Ipagpatuloy ang Pagbuo, Ipagpatuloy ang Paggalugad

🙌 Congrats kung nabasa mo ng todo!

Ngayong nakita mo na kung paano gumagana ang isang simpleng kontrata sa pagboto sa Tact, ginawa mo na ang iyong unang hakbang sa pagbuo ng matalinong kontrata sa TON. Maaaring basic ang kontratang ito, ngunit nalalapat din ang istruktura at mga konsepto sa mas kumplikadong lohika.

Kung gusto mong patuloy na mag-eksperimento, subukang palawigin ang kontratang ito o i-explore ang iba pang mga prebuilt na template mula sa https://tact-by-example.org/all . Pinapadali din ng TON Web IDE na subukan ang iba't ibang kaso ng paggamit at mayroon din itong mga template upang matulungan kang bumuo at matuto nang mas mabilis.

Kaya sige, sabunutan, subukan, bumuo ng mas mahusay.