Stiffness is that ethereum be what tact is TON – how to build a smart contract to vote on TO

Most of the time, when people begin to learn how to write smart contracts, the first thing they hear about is hardness and ethereum. This was the first thing I heard about it too. This is what most educational programs focus on, for a good reason. It made hardening it is possible to write programs that live on Blockchain, and Etherum became the place where many people began.

But hardness is not the only smart contract language there. Ethereum is not the only Blockchain that supports decentralized applications.

There too TonShort to Open network. It was created by Telegram, but it is now a general series driven by society. It is fast and lightweight and deals with things a little differently from what you may use in Ethereum. This includes how to write smart contracts. When I started exploring TON documents, four different languages ​​were encountered to write smart contracts: Lick, Tulk, Fonk, and Dark. I will not deepen the four here.

This guide focuses on the language of tact, and we will see how it is used to create a basic voting contract that allows users to make votes and check the results on the chain.

Why did you decide to learn to tackle first

The ecosystem of the ton actually supports multiple languages, as it serves all different use cases, levels of abstraction, and developer experience. Here is a quick overview of each of them:

• FUNC It is the traditional language for writing smart contracts ton. It is a low level and gives you careful control of how your contract works under the cap. It is strong, but it also means that you will need to understand how the ton -ton (TVM) work, including concepts such as stack treatment, memory planning and inevitable implementation. The sentence construction is somewhat similar to C, which can feel uncommon if you have not worked with this style of language before.
• Eighth It is usually used along with Funk. It is a body -based language that is mostly used to interact with TVM directly and is used to spread and correct errors and perform accounts on the chain. It is usually the language that you start to write full smart contracts, but it is important in the functioning of comprehensive development on TON.
• Tulk It is a newer addition that is still developing. From what you collected, it aims to improve tools and compliance with languages ​​with a higher level. It is promising, but not yet with adopting or widely documented.
• cleverness It is a high -level language designed specifically to make smart contracts to develop more and friendly for developers. Simplify the dress a lot of complexity of the lowest level and allows you to focus on writing your logic in a clean and readable way. The sentence building is closer to what you see in Tyscript or hardness, which makes it easier to start without the need to dive into the depths of TVM.

It provides TACK and a faster pathway to build and publish contracts on Ton Blockchain.

Understand how the tact works

Before we start writing code, it is important to understand how smart contracts are organized. The typical tact contract includes some basic components:

• contract Block – This is where you specify your contract name and announce any state variables.

• init Block – prepares the contract status variables and determines the conditions for the start of the contract. This mass operates once at the time of publication.

• receive Blocs – these are similar to events listeners. They deal with received messages and determine how your contract interacts with them.

• Getter jobs (get fun-These are optional reading functions only that allow users or other contracts to inquire about the condition of the contract without changing it.

The dress -based dress is used, which is how all reactions work on a ton. Each contract receives a message and addresses it alone receive roadblock. This message -based structure helps regulate the logic of the contract in a standard manner that can be maintained.

Let’s now apply this in a real example by building a simple voting contract.

Building the first voting contract with TCT (using TON Web IDE)

In this section, we will roam how to implement a basic voting system using a tact. This voting contract will allow users to vote for pre -specified candidates and tracks the total number of votes that each candidate receives.

We’ll do everything inside TON Web IDE, which is a tool in the browser where you can write, build and test your contracts without installing anything locally.

Step 1 – Open TON Web IDE

• Go to https://ide.ton.org.
• Click Create a new project. In the popup:
  • Ensure that the language is running cleverness.
  • He chooses Empty contract As your template.
  • The name of your project is like VotingContract.
  • Click + Create.

Step 2 – Writing the voting contract code

After creating your project, open main.tact file. You will see a boileplate preparation:

// Import the Deployable trait so the contract can be deployed easily
import "@stdlib/deploy";

contract BlankContract with Deployable {
    init() {
        
    }
}

• import "@stdlib/deploy"; Required to work for work and should not be removed from the code.
• BlankContract It is the name of the deputy element.
• the init() Block is running only once when the contract is published and is used to create the status variables.

Now, let’s draw our own code.

First, we will determine the messaging structure for voting:

// 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
}

This is the voting message. When someone wants to vote, he will send a message to the contract that includes a number:

The dress uses this structure to address the incoming vote and determine the filter that gets this point.

After that, we will prepare our contract and add two variables to the state to track the votes of each candidate:

...
contract VotingContract with Deployable {

    // State variables to track votes
    votesAlice: Int as uint32;
    votesBob: Int as uint32;

Inside the contract, we identified two variables:

• votesAliceIt stores the number of votes that Alice receives.
• votesBobIt stores the number of sounds that Bob gets.

We will now create the charges of voting to zero inside init Set the status of the contract when it is first published.

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

the init Lump operation Only onceDirectly when the contract is published and each of the charges determines the voices to zero.

Now logic comes. When sending the vote, we want the contract to verify the vote and increase the correct number of votes.

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

So when receiving the vote:

• if msg.candidate It is 1, we add +1 to votesAlice
• if msg.candidate It is 2, add +1 to votesBob

Finally, we will create a Getter jobs to allow anyone to inquire about the number of votes for each candidate without changing the condition of the contract.

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

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

These two Jetter functions let’s check the number of votes received by each candidate without adjusting anything in the contract. It is a process of reading only.

Below is the full voting contract code:

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

Step 4 – Building and publishing the contract

• On the left sidebar, click Building and publishing

• under environmentCheck Sand box It was chosen.
• make sure Main.tract It was identified and click Build. This will assemble your contract and verify any errors or problems to build a sentence in your code.
• After that, make sure Voting It was identified in the drop -down menu because this is the actual contract, not the virtual deputy element. If you don’t see it, click Ctrl + S To save your file so that IDE can discover the updated contract.
• Then click Re -post. If everything is working properly, you will see a confirmation message in the records that show that your contract has been successfully published on Sandbox.

Step 5 – Interacting with the contract

Once it is published, scroll down and you will see two parts:

• Getters: getVotesForAliceand getVotesForBob
• Receptions: Vote

To vote: in vote Section, enter 1 in candidate Input field and click Send. I just voted for Alice! You can repeat this to make more sounds.

To check the number of votes: Click Call under getVotesForAlice And verify Records A committee to see the number of votes

• Do the same for a pop by sending 2 in candidate The field, then check getVotesForBob

In my test race, I voted for Alice 9 times Bob 6 timesAnd the functions of Getter showed exactly.

Final ideas: Continue construction, continue to explore

Congratulations if you read all the way!

Now that you saw how the simple voting contract works brilliantly, you took your first step in developing smart contracts on TON. This nodes may be essential, but the structure and concepts apply to a more complex logic as well.

If you want to continue experimenting, try to expand this nodes or explore other molds suitable from https://tact-By-example.org/all. TON Web Ide also makes it easy to try different use situations, and it also comes with molds to help you build and learn faster.

So go ahead, select, test, and build something better.