Alors que leCours #1 que j'ai déjà fait vous a présenté les bases de la rédaction de contrats intelligents dans Move et de la création de DApps simples sur la blockchain Sui, ce cours se concentre surapprofondir votre compréhension du langage Move lui-même, de son puissant système de types aux modèles avancés tels que les génériques, les événements, les modules et les mécanismes de contrôle d'accès.

À la fin de ce cours, vous serez capable de :

• Rédigez un code Move modulaire, réutilisable et sécurisé
• Utiliser efficacement les génériques, les capacités et les types de ressources
• Implémentez un contrôle d'accès précis à l'aide de fonctionnalités
• Émettez et écoutez des événements pour une intégration hors chaîne
• Travaillez avec des structures de données complexes telles que des tableaux et des vecteurs
• Comprenez en quoi Move diffère des autres langages de contrats intelligents tels que Solidity

Plongeons au cœur du langage Move !

Étape 1 : Comprendre les fonctionnalités linguistiques de base de Move

Move est conçu dans un souci de sécurité et de clarté. Explorons certaines des fonctionnalités les plus importantes qui font de Move un langage contractuel intelligent unique.

1.1 Programmation axée sur les ressources (revisitée)

Au cœur de Move se trouve le concept deressources, qui sont des types spéciaux qui ne peuvent pas être copiés ou supprimés sauf autorisation explicite. Cela permet de gérer en toute sécurité les actifs numériques tels que les jetons ou les NFT.

module examples::token {
    use sui::object::{Self, UID};

    struct MyToken has key, store {
        id: UID,
        value: u64,
    }

    public fun mint(ctx: &mut TxContext): MyToken {
        MyToken {
            id: object::new(ctx),
            value: 100,
        }
    }
}

Dans cet exemple : MyToken- keyest uneressourcecar elle en a la capacité.

• Il peut être stocké (store) et identifié de manière unique par sonid.
• Il ne peut pas être dupliqué ou supprimé sauf indication contraire.

Cela garantit que chaque MyTokeninstance est détenue et gérée de manière unique, évitant ainsi toute duplication ou suppression accidentelle.

---

1.2 Système de capacités

Chaque type de Move possède un ensemble decapacitésqui définissent les opérations qu'il prend en charge :

Capacité	Signification
copy	Peut être dupliqué
drop	Peut être jeté sans destruction
store	Peut être stocké dans le stockage mondial
key	Peut être utilisé comme structure avec un champ ID (c'est-à-dire un objet)

Exemple :

struct Example has copy, drop { value: u64 }

Il est essentiel de comprendre ces capacités pour concevoir des contrats intelligents sécurisés et prévisibles.

Pourquoi les capacités sont importantes

Les capacités appliquent des règles strictes au moment de la compilation. Par exemple :

• Une structure contenant uniquement keyet storene pouvant pas être copiée ou supprimée.
• Vous ne pouvez pas renvoyer une structure non supprimable à partir d'une fonction à moins qu'elle ne soit stockée ou transférée.

Cela permet d'éviter des bugs tels que la double dépense ou la perte accidentelle de jetons.

---

1.3 Génériques et paramètres de type

Move prend en charge les types génériques, ce qui permet aux développeurs d'écrire du code flexible et réutilisable.

module examples::storage {
    use sui::object::{Self, UID};

    struct Box<phantom T> has key {
        id: UID,
        content: T,
    }

    public fun new_box<T>(ctx: &mut TxContext, content: T): Box<T> {
        Box {
            id: object::new(ctx),
            content,
        }
    }
}

<T>Voici unparamètre de type, qui permet de Boxfonctionner avec n'importe quel type tout en restant sûr et efficace.

Remarque : Le phantommot clé indique que Tcela n'affecte pas la représentation d'exécution de la structure, ce qui est utile pour la modélisation abstraite.

---

Étape 2 : Développement modulaire et gestion des packages

À mesure que la complexité de vos projets Move augmente, l'organisation de votre code devient essentielle.

2.1 Création et publication de packages Move

Unpackage Movecontient un ou plusieurs modules et définit les dépendances. Il s'agit de l'unité de déploiement et de gestion des versions dans Move.

Structure du répertoire :

sources/
  place.move
  user.move
Move.toml

Définissez les dépendances dans Move.toml:

[dependencies]
Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework" }
MyLibrary = { local = "../my-library" }

Vous pouvez publier des packages sur le réseau Sui et les réutiliser sur plusieurs DApps.

2.2 Réutiliser les modules existants

coin``transfer``tx_contextLeSui Frameworkfournit des modules testés au combat tels que, et. Vérifiez toujours ce qui est disponible avant d'écrire une logique personnalisée.

Par exemple, pour transférer un objet :

use sui::transfer;

public entry fun send_place(place: Place, recipient: address) {
    transfer::public_transfer(place, recipient);
}

L'utilisation de bibliothèques standard garantit un développement plus sûr et plus rapide ainsi qu'une meilleure interopérabilité.

---

Étape 3 : Événements et communication hors chaîne

Pour créer des applications réelles, vos contrats Move doivent communiquer avec des systèmes hors chaîne tels que les frontends ou les indexeurs.

3.1 Émission d'événements

Move permet d'émettre desévénementsqui peuvent être indexés par des services externes.

use sui::event;

struct PlaceCreated has drop {
    name: String,
}

public fun emit_place_created(name: String) {
    event::emit(PlaceCreated { name });
}

Cet événement apparaîtra sur la blockchain et pourra être récupéré par des explorateurs ou des outils d'indexation.

3.2 Écouter les événements

Utilisez des outils tels queSuite Explorer,Subsquidou l'API Sui JSON-RPC pour écouter les événements émis et réagir en conséquence dans votre application.

En Javascript/TypeScript :

import { JsonRpcProvider } from '@mysten/sui.js';

const provider = new JsonRpcProvider('https://fullnode.devnet.sui.io');

const events = await provider.getEvents({
  MoveEventType: '0x...::example::PlaceCreated'
});

---

Étape 4 : Contrôle d'accès et modèles de sécurité

La sécurité est primordiale lorsqu'il s'agit de contrats intelligents. Move fournit plusieurs outils pour mettre en œuvre un contrôle d'accès robuste.

4.1 Modèle de propriété des objets

Sui applique la propriété au niveau du protocole. Seul le propriétaire d'un objet peut le muter ou le transférer.

public entry fun update_name(sweet_place: &mut SweetPlace, new_name: String) {
    sweet_place.name = new_name;
}

Seul le propriétaire actuel peut appeler cette fonction.

4.2 Modèle de capacités

Pour des autorisations plus précises, utilisez lemodèle de capacité : créez des objets spéciaux qui accordent un accès limité à certaines fonctions.

struct AdminCap has key { id: UID }

public entry fun grant_admin_cap(ctx: &mut TxContext) {
    let cap = AdminCap { id: object::new(ctx) };
    transfer::public_transfer(cap, tx_context::sender(ctx));
}

public entry fun restricted_action(_: &AdminCap) {
    // perform admin action
}

Désormais, seuls les utilisateurs qui détiennent la touche AdminCappeuvent exécuterrestricted_action.

Ce modèle est largement utilisé dans DeFi et les DAO pour déléguer des pouvoirs en toute sécurité.

---

Étape 5 : Utilisation de structures de données complexes

Move prend en charge les types de données structurés qui permettent aux développeurs de modéliser des logiques et des relations complexes.

5.1 Vecteurs

Les vecteurs sont utilisés pour stocker des collections ordonnées d'articles du même type.

let names = vector[String::utf8(b"Alice"), String::utf8(b"Bob")];

Ils sont utiles pour stocker des listes de NFT, de rôles d'utilisateurs ou de métadonnées dynamiques.

Exemple d'utilisation :

vector::push_back(&mut names, String::utf8(b"Charlie"));

5.2 Tableaux (via la bibliothèque Sui Standard)

Bien que Move ne prenne pas en charge nativement les cartes ou les tables de hachage, Sui fournit le Tabletype dans sa bibliothèque standard.

use sui::table::{Self, Table};

struct Registry has key {
    id: UID,
    entries: Table<u64, String>,
}

public fun add_entry(registry: &mut Registry, key: u64, value: String) {
    table::add(&mut registry.entries, key, value);
}

Utilisez des tableaux pour gérer efficacement de grands ensembles de données.

---

Étape 6 : Tester et déboguer vos contrats

Les tests garantissent que votre code Move se comporte comme prévu dans diverses conditions.

6.1 Tests unitaires dans Move

Écrivez des tests unitaires directement dans vos modules Move à l'aide du framework de test.

#[test]
public fun test_create_sweet_place() {
    let ctx = tx_context::dummy();
    create_sweet_place(&mut ctx, String::utf8(b"My House"));
}

Exécutez des tests avec :

sui move test

6.2 Utilisation de Sui Explorer

Après avoir déployé votre contrat, utilisez le Sui Explorer pour inspecter les transactions, afficher l'état des objets et résoudre les problèmes.

---

Étape 7 : Applications concrètes des concepts de déplacement avancés

Maintenant que vous comprenez les principales fonctionnalités du langage, voyons comment elles s'appliquent à des scénarios du monde réel.

Plateforme de frappe NFT 7.1

Créez une plate-forme qui permet aux utilisateurs de créer des NFT soutenus par les ressources de Move, en tirant parti des modèles de propriété et de ressources.

7.2 Système de vote DAO

Implémentez une organisation autonome décentralisée (DAO) utilisant Move pour le vote, les propositions et la gouvernance, en utilisant des événements et des fonctionnalités pour des actions sécurisées.

7.3 Échanges de jetons et guichets automatiques

Créez un échange décentralisé (DEX) à l'aide des modules Move pour représenter les pools de liquidités et les échanges de jetons, en utilisant des génériques et des tableaux pour une gestion efficace de l'état.