Solidity è per Ethereum ciò che Tact è per TON — Come creare uno Smart Contract di voto su TON usando Tact

La maggior parte delle volte, quando le persone iniziano a imparare a scrivere contratti intelligenti, la prima cosa di cui sentono parlare è Solidity ed Ethereum. È stata la prima cosa di cui ho sentito parlare anch'io. È ciò su cui si concentrano la maggior parte dei tutorial, e per una buona ragione. Solidity ha reso possibile scrivere programmi che vivono su una blockchain, ed Ethereum è diventato il luogo in cui molte persone hanno iniziato.

Ma Solidity non è l'unico linguaggio di smart contract in circolazione. E Ethereum non è l'unica blockchain che supporta applicazioni decentralizzate.

C'è anche TON , abbreviazione di The Open Network . È stato creato da Telegram, ma ora è una catena pubblica guidata dalla comunità. È veloce, leggera e gestisce le cose in modo un po' diverso da come potresti essere abituato su Ethereum. Ciò include il modo in cui vengono scritti gli smart contract. Quando ho iniziato a esplorare la documentazione di TON, mi sono imbattuto in quattro linguaggi diversi per scrivere smart contract: Tact, Tolk, FunC e Fift . Non entrerò nei dettagli di tutti e quattro qui.

Questa guida si concentra sul linguaggio Tact e vedremo come utilizzarlo per creare un contratto di voto di base che consente agli utenti di esprimere voti e controllare i risultati on-chain.

Perché ho deciso di imparare prima il tatto

L'ecosistema TON supporta effettivamente più linguaggi, ognuno dei quali serve casi d'uso, livelli di astrazione ed esperienza di sviluppo diversi. Ecco una rapida panoramica di ciascuno di essi:

• FunC è il linguaggio tradizionale per scrivere smart contract TON. È di basso livello e ti dà un controllo preciso su come funziona il tuo contratto sotto il cofano. È potente, ma significa anche che dovrai capire come funziona la TON Virtual Machine (TVM), inclusi concetti come manipolazione dello stack, layout della memoria ed esecuzione deterministica. La sintassi è in qualche modo simile a C, che può sembrare poco familiare se non hai mai lavorato con quello stile di linguaggio prima.
• Fift è in genere utilizzato insieme a FunC. È un linguaggio basato su stack che viene utilizzato principalmente per interagire direttamente con TVM e per distribuire, eseguire il debug ed eseguire calcoli on-chain. Di solito non è il linguaggio con cui si inizia per scrivere contratti intelligenti completi, ma è importante nel flusso di lavoro di sviluppo complessivo su TON.
• Tolk è un'aggiunta più recente che è ancora in evoluzione. Da quanto ho capito, mira a migliorare gli strumenti e la compatibilità con linguaggi di livello superiore. È promettente, ma non è ancora ampiamente adottato o documentato.
• Tact è un linguaggio di alto livello progettato specificamente per rendere lo sviluppo di smart contract TON più accessibile e user-friendly per gli sviluppatori. Tact semplifica molto la complessità di livello inferiore e ti consente di concentrarti sulla scrittura della tua logica in modo pulito e leggibile. La sintassi è più vicina a quella che vedresti in TypeScript o Solidity, il che rende molto più facile iniziare senza dover immergerti nei dettagli interni di TVM.

Tact fornisce un percorso più rapido per creare e distribuire contratti sulla blockchain TON.

Capire come funziona il tatto

Prima di iniziare a scrivere codice, è importante capire come sono strutturati gli smart contract Tact. Un tipico contratto Tact include alcuni componenti principali:

• Blocco contract : qui puoi definire il nome del contratto e dichiarare tutte le variabili di stato.

• init block – Inizializza le variabili di stato del contratto e imposta le condizioni di avvio del contratto. Questo blocco viene eseguito una volta al momento della distribuzione.

• blocchi receive – Sono come degli event listener. Gestiscono i messaggi in arrivo e definiscono come il tuo contratto reagisce a essi.

• Funzioni getter ( get fun ): sono funzioni opzionali di sola lettura che consentono agli utenti o ad altri contratti di interrogare lo stato del contratto senza modificarlo.

  
  

Tact utilizza la comunicazione basata sui messaggi, che è il modo in cui funzionano tutte le interazioni su TON. Ogni contratto riceve un messaggio e lo elabora nel suo blocco receive . Questa struttura basata sui messaggi aiuta a organizzare la logica del contratto in modo modulare e gestibile.

Applichiamo ora questo principio a un esempio concreto, creando un semplice contratto di voto.

Creazione del primo contratto di voto con Tact (utilizzando TON Web IDE)

In questa sezione, spiegheremo come implementare un sistema di voto di base utilizzando Tact. Questo contratto di voto consente agli utenti di votare per candidati predefiniti e tiene traccia del numero totale di voti ricevuti da ciascun candidato.

Faremo tutto all'interno del TON Web IDE, uno strumento integrato nel browser che ti consente di scrivere, creare e testare i tuoi contratti senza dover installare nulla in locale.

Passaggio 1: aprire TON Web IDE

• Vai su https://ide.ton.org .
• Fai clic su Crea un nuovo progetto . Nel popup:
  • Assicurati che la lingua sia su Tact .
  • Scegli Contratto vuoto come modello.
  • Assegna al tuo progetto un nome simile a VotingContract .
  • Fai clic su + Crea .

Fase 2 – Scrittura del codice del contratto di voto

Dopo aver creato il tuo progetto, apri il file main.tact . Vedrai una configurazione boilerplate:

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

• import "@stdlib/deploy"; è necessario affinché la distribuzione funzioni e non deve essere rimosso dal codice.
• BlankContract è il nome segnaposto.
• Il blocco init() viene eseguito solo una volta quando il contratto viene distribuito e viene utilizzato per inizializzare le variabili di stato.

Ora, tracciamo il nostro codice.

Per prima cosa, definiamo la struttura del messaggio per il voto:

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

Questo è il messaggio Vote. Quando qualcuno vuole votare, invierà un messaggio al contratto che include un numero:

• 1 per Alice
• 2 per Bob

Tact utilizza questa struttura per elaborare il voto in arrivo e decidere quale candidato otterrà il punto.

Successivamente, imposteremo il nostro contratto e aggiungeremo due variabili di stato per tenere traccia dei voti di ciascun candidato:

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

All'interno del contratto abbiamo definito due variabili:

• votesAlice : memorizza il numero di voti ricevuti da Alice.
• votesBob : memorizza il numero di voti ricevuti da Bob.

Ora inizializzeremo quei conteggi dei voti a zero all'interno del blocco init per impostare lo stato iniziale del contratto quando verrà distribuito per la prima volta.

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

Il blocco init viene eseguito una sola volta , proprio quando il contratto viene distribuito, e imposta entrambi i conteggi dei voti a zero.

Ora arriva la logica. Quando viene inviato un voto, vogliamo che il contratto verifichi a chi è destinato il voto e aumenti il conteggio corretto dei voti.

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

Quindi, quando si riceve un voto:

• Se msg.candidate è 1, aggiungiamo +1 a votesAlice
• Se msg.candidate è 2, aggiungiamo +1 a votesBob

Infine, creeremo delle funzioni getter che consentiranno a chiunque di interrogare il conteggio dei voti per ciascun candidato senza modificare lo stato del contratto.

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

Queste due funzioni getter ci permettono di controllare il numero di voti ricevuti da ogni candidato senza modificare nulla nel contratto. È un'operazione di sola lettura.

Di seguito il codice completo del contratto di voto:

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

Fase 4 – Creare e distribuire il contratto

• Nella barra laterale sinistra, fare clic su Build & Deploy

• In Ambiente , assicurati che sia selezionata l'opzione Sandbox .
• Assicurati che main.tact sia selezionato e clicca su Build . Questo compilerà il tuo contratto e verificherà eventuali errori di sintassi o problemi nel tuo codice.
• Quindi, assicurati che VotingContract sia selezionato nel menu a discesa, poiché è il tuo contratto effettivo, non il segnaposto predefinito. Se non lo vedi, premi Ctrl + S per salvare il file in modo che l'IDE possa rilevare il contratto aggiornato.
• Quindi fai clic su ReDeploy . Se tutto funziona correttamente, vedrai un messaggio di conferma nei log che mostra che il tuo contratto è stato distribuito correttamente su Sandbox.

Passaggio 5: interagire con il contratto

Una volta distribuito, scorri verso il basso e vedrai due sezioni:

• Getters: getVotesForAlice , getVotesForBob
• Ricevitori: Vote

Per esprimere un voto: nella sezione Vota , inserisci 1 nel campo di input candidate e clicca su Invia. Hai appena votato per Alice! Puoi ripetere questa operazione per esprimere altri voti.

Per controllare il conteggio dei voti : fare clic su Chiama sotto getVotesForAlice e controllare il pannello dei registri per vedere il conteggio dei voti

• Fai lo stesso per Bob inviando 2 nel campo candidate , quindi controlla getVotesForBob

Nel mio test, ho votato per Alice 9 volte e per Bob 6 volte , e le funzioni getter hanno dimostrato esattamente questo.

💭 Considerazioni finali: continua a costruire, continua a esplorare

🙌 Complimenti se hai letto tutto!

Ora che hai visto come funziona un semplice contratto di voto in Tact, hai mosso il primo passo nello sviluppo di smart contract su TON. Questo contratto potrebbe essere basilare, ma la struttura e i concetti si applicano anche a logiche più complesse.

Se vuoi continuare a sperimentare, prova ad estendere questo contratto o a esplorare altri template predefiniti da https://tact-by-example.org/all . Il TON Web IDE semplifica anche la sperimentazione di diversi casi d'uso e include anche dei template per aiutarti a creare e imparare più velocemente.

Quindi vai avanti, modifica, testa, costruisci qualcosa di meglio.