Résumé : Sur la plateforme de blockchain TON (The Open Network), les contrats intelligents jouent un rôle crucial. Cet article va permettre aux lecteurs de comprendre les fonctionnalités de dict (dictionnaire) et list (liste) dans la langue FunC, ainsi que de savoir comment réaliser des élections de validateur efficaces dans des situations réelles.
1. Introduction
Les contrats intelligents sur la plateforme de blockchain TON sont écrits en FunC, une langue qui offre une riche gamme de structures de données, telles que dict et list, pour le stockage et le traitement des données. Dans cet article, nous allons analyser un morceau de code de contrat intelligent de TON pour explorer les usages de dict et list.
2. Usages de dict (dictionnaire)
2.1 Définition et initialisation de dict
Dans la langue FunC, le dict est une structure de données associative utilisée pour le stockage et la recherche des données. Voici comment on peut définir et initialiser un dict :
var sdict = new_dict();
Ici, nous créons un dict vide nommé sdict.
2.2 Opérations sur dict
(1) Ajouter des éléments
Pour ajouter des éléments dans un dict, on peut utiliser :
sdict~dict_set_builder(128 + 32 + 256, key, begin_cell()
.store_uint(min(max_factor, max_stake_factor), 32)
.store_uint(addr, 256)
.store_uint(adnl_addr, 256));
Ici, nous utilisons la méthode dict_set_builder pour ajouter un couple clé-valeur au dict. La clé est composée de données de 128 bits, 32 bits et 256 bits, tandis que la valeur est une tuple contenant des données de 32 bits, 256 bits et 256 bits.
(2) Supprimer un élément et obtenir la clé la plus petite
Le code suivant montre comment supprimer l’élément de clé la plus petite d’un dict et obtenir sa valeur :
var (key, cs, f) = sdict~dict::delete_get_min(128 + 32 + 256);
Ici, nous utilisons la méthode delete_get_min pour supprimer l’élément de clé la plus petite du dict et retourner la clé et sa valeur correspondante.
3. Usages de list (liste)
3.1 Définition et initialisation de list
Dans la langue FunC, la liste est utilisée pour stocker une série d’éléments. Voici comment on peut définir et initialiser une liste :
var l = nil;
Ici, nous créons une liste vide nommée l.
3.2 Opérations sur list
(1) Ajouter des éléments
Pour ajouter des éléments dans une liste, on peut utiliser :
l = cons([stake, max_f, pubkey, adnl_addr], l);
Ici, nous utilisons la fonction cons pour ajouter une tuple en tête de la liste.
(2) Parcourir une liste
Le code suivant montre comment parcourir une liste et obtenir ses éléments :
var [stake, max_f, pubkey, adnl_addr] = l~list_next();
Ici, nous utilisons la méthode list_next pour obtenir l’élément suivant de la liste.
4. Application pratique : élection de validateur
Après avoir analysé les usages de dict et list, nous allons explorer comment réaliser une élection de validateur efficace dans une situation réelle. Le code suivant montre comment sélectionner des validateurs satisfaisant aux conditions grâce à dict et list :
// ... Code partiel omis
repeat (m - 1) {
l1 = cdr(l1);
}
var m_stake = car(l1).at(0); // Capital de mise minimal
// ... Code partiel omis
do {
var [stake, max_f, pubkey, adnl_addr] = l~list_next();
// ... Code partiel omis
if (i < m) {
// ... Code partiel omis
vset~udict_set_builder(16, i, vinfo);
}
// ... Code partiel omis
} until (l.null?());
// ... Code partiel omis
5. Conclusion
En analysant ce morceau de code de contrat intelligent de TON, nous avons appris les usages de dict et list dans la langue FunC, ainsi que comment réaliser une élection de validateur efficace dans des situations réelles. La compréhension de ces structures de données est essentielle pour la création de contrats intelligents TON efficaces. J’espère que cet article puisse offrir une référence utile aux lecteurs sur leur chemin de programmation en langage FunC.
6. Usages avancés de dict et list
6.1 Utilisation imbriquée de dict
Dans les applications réelles, nous rencontrons souvent des situations où nous devons stocker des structures complexes dans un dict. Dans ce cas, nous pouvons utiliser l’imbrication de dict.
var nested_dict = new_dict();
nested_dict~dict_set(256, pubkey, new_dict()
.dict_set(128, "stake", stake)
.dict_set(32, "time", time));
Dans ce code, nous créons un dict imbriqué nested_dict, où chaque clé pubkey correspond à un dict contenant les informations du capital de mise stake et de l’heure de dépôt time.
6.2 Tri et recherche dans list
Dans les contrats intelligents de TON, la liste peut être utilisée non seulement pour stocker des données, mais aussi pour effectuer des opérations de tri et de recherche.
l = sort(l, func(a, b) { return a.at(0) > b.at(0); });
Ici, nous utilisons la fonction sort pour trier la liste l en fonction de l’élément de la première position de chaque tuple.
La recherche peut être effectuée en parcourant la liste :
var found = false;
var result = nil;
foreach (item in l) {
if (item.at(0) == target) {
found = true;
result = item;
break;
}
}
Dans ce code, nous parcourons la liste l et recherchons le premier élément qui est égal à target.
7. Analyse de cas : système de vote basé sur dict et list
7.1 Analyse des besoins
Supposons que nous voulons implémenter un système de vote simple dans un contrat intelligent de TON, permettant aux utilisateurs de voter pour les candidats. Nous devons stocker les informations des candidats, des votants et des résultats du vote.
7.2 Conception de structure de données
Nous pouvons utiliser les structures de données suivantes pour stocker les informations du système de vote :
- Dict des candidats (candidates_dict) : la clé est l’ID du candidat, et la valeur est les informations du candidat (nom, nombre de voix, etc.).
- Dict des votants (voters_dict) : la clé est l’adresse du votant, et la valeur est les informations du votant (ID du candidat voté, heure du vote, etc.).
7.3 Implémentation du code
Voici une partie de l’implémentation du système de vote :
var candidates_dict = new_dict();
var voters_dict = new_dict();
// Ajouter un candidat
function add_candidate(candidate_id, name) {
candidates_dict~dict_set(256, candidate_id, new_dict()
.dict_set(256, "name", name)
.dict_set(64, "votes", 0));
}
// Voter
function vote(voter_addr, candidate_id) {
// Vérifier si le votant a déjà voté
var voted = voters_dict~dict_get?(256, voter_addr);
if (voted) {
throw(1); // Voté déjà, lance une exception
}
// Mettre à jour le nombre de voix du candidat
var candidate_info = candidates_dict~dict_get(256, candidate_id);
candidate_info~dict_set(64, "votes", candidate_info~dict_get(64, "votes") + 1);
// Enregistrer les informations du votant
voters_dict~dict_set(256, voter_addr, new_dict()
.dict_set(256, "candidate_id", candidate_id)
.dict_set(32, "time", now()));
}
// Obtenir les résultats du vote
function get_results() {
var results_list = new_list();
foreach (candidate_id, candidate_info in candidates_dict) {
results_list = cons([candidate_info~dict_get(256, "name"), candidate_info~dict_get(64, "votes")], results_list);
}
return sort(results_list, func(a, b) { return a.at(1) > b.at(1); });
}
7.4 Analyse et conclusion
Dans ce cas d’application, nous avons utilisé dict pour stocker les informations des candidats et des votants, et list pour stocker les résultats du vote. Grâce à l’utilisation de l’imbrication de dict, nous avons réussi à construire une structure de données complexe. En même temps, en utilisant les fonctionnalités de tri de list, nous pouvons facilement obtenir une liste de candidats triée par nombre de voix.
8. Optimisation et extension
Dans les applications réelles, nous pourrions avoir besoin d’optimiser et d’étendre l’utilisation de dict et list pour améliorer les performances et les fonctionnalités du contrat intelligent.
8.1 Optimisation de l’espace de stockage de dict
Lors du stockage de données importantes, l’espace de stockage de dict peut devenir une contrainte. Nous pouvons optimiser en utilisant :
- Des structures de données plus compactes, telles que les champs de bits.
- Suppression de champs inutiles pour réduire l’espace de stockage.
8.2 Extension des fonctionnalités de list
La langue FunC fournit des fonctions intégrées riches, nous pouvons étendre les fonctionnalités de list en utilisant :
- Fonctions haut niveau telles que map, filter pour traiter la liste.
- Mise en œuvre de fonctions d’opérations personnalisées sur la liste, telles que le regroupement, la mise en forme, etc.
9. Conclusion
A travers l’an analyse de ce code de contrat intelligent de TON, nous avons appris les usages de dict et list dans la langue FunC, ainsi que comment réaliser une élection de validateur efficace dans des situations réelles. La compréhension de ces structures de données est essentielle pour la création de contrats intelligents TON efficaces. J’espère que cet article puisse offrir une référence utile aux lecteurs sur leur chemin de programmation en langage FunC.
10. Conclusion
Le développement de contrats intelligents sur la plateforme TON est un processus d’apprentissage et de pratique continuel. dict et list sont des structures de données centrales de la langue FunC, et leur importance est évidente. En comprenant approfondiment ces structures de données, les développeurs pourront mieux utiliser les avantages de la plateforme blockchain TON, créant ainsi des applications décentralisées plus riches et plus puissantes. Avec le développement continu de l’écosystème TON, nous attendons voir plus d’applications intelligentes innovantes et efficaces, contribuant ainsi au développement et à la popularisation des technologies blockchain.
Cet article vise à fournir une plateforme d’apprentissage et de référence, et pour les détails techniques plus profonds et les pratiques optimales, nous conseillons aux lecteurs de continuer à explorer les documents officiels, les discussions de la communauté et les articles techniques associés. Dans les futurs projets de développement de contrats intelligents, nous souhaitons que chaque développeur puisse progresser continuellement, contribuant ainsi au progrès des technologies blockchain.