Tokenizer

Tutoriel complet pour créer votre premier token BEP-20 sur la BNB Smart Chain, de zéro jusqu'à un token publié et vérifié sur BSCScan.

1. Comprendre avant de coder

Pas de panique si certains mots te semblent étranges. Voici l'essentiel en 5 minutes.

1.1 Qu'est-ce qu'un token ?

Un token est une sorte de « pièce numérique » créée sur une blockchain. Dans notre projet, il suivra la norme BEP-20 (la norme des jetons sur la BNB Chain), calquée sur l'ERC-20 d'Ethereum.

Cette norme impose un socle commun : tout token possède un name (nom), un symbol (ticker), un nombre de decimals (18 comme ETH), et des fonctions comme transfer, balanceOf, approve, transferFrom. Grâce à cela, tous les wallets et plateformes comprennent ton token automatiquement.

1.2 Blockchain, testnet et réseau réel

La BNB Chain (réseau du partenaire du projet 42) existe en deux versions :

• Réseau principal (Mainnet) : le vrai réseau, avec de l'argent réel. On n'y touche pas pour ce projet.
• Réseau de test (Testnet) : une copie gratuite pour s'entraîner. Les tokens s'y appellent des TBNB et ne valent rien. C'est ici qu'on va travailler.

1.3 Le vocabulaire à connaître

2. Installer MetaMask et ajouter le réseau de test

MetaMask est le wallet qu'on utilisera pour signer les transactions et recevoir le token.

2.1 Installer l'extension

1. Va sur metamask.io et clique sur « Download ».
2. Installe l'extension sur ton navigateur (Chrome, Firefox, Brave…).
3. Ouvre l'extension et clique sur « Créer un wallet ».
4. Choisis un mot de passe.
5. IMPORTANT : note la phrase de récupération (seed phrase) sur papier, jamais en ligne. C'est la clé de ton wallet. Quiconque l'a, contrôle tes fonds.

2.2 Ajouter le réseau BSC Testnet

Par défaut, MetaMask est sur Ethereum. On ajoute la BNB Smart Chain de test :

1. Clique sur le menu déroulant en haut à gauche (il affiche « Ethereum Mainnet »).
2. Clique sur « Add network » puis « Add a network manually ».
3. Remplis les champs suivants (à recopier exactement) :

1. Clique sur « Save ». Le réseau doit apparaître dans la liste.

2.3 Copier ton adresse

Clique sur ton adresse (sous le nom du compte, ça ressemble à 0x1234...abcd) pour la copier. Garde-la sous la main : tu t'en serviras partout.

3. Récupérer des TBNB gratuits (faucet)

Pour déployer un contrat, il faut payer le « gas » en TBNB. On les obtient gratuitement.

3.1 Utiliser le faucet de BNB Chain

1. Va sur le site officiel : https://www.bnbchain.org/ puis cherche la section Faucet (ou va directement sur faucet.bnbchain.org).
2. Sélectionne le réseau BSC Testnet.
3. Colle ton adresse MetaMask (celle du 2.3).
4. Clique sur le bouton pour recevoir des TBNB.
5. Attends la confirmation. Vérifie dans MetaMask que ton solde TBNB a augmenté.

4. Écrire le smart contract du token

On écrit le programme de notre token en Solidity. On réutilise la bibliothèque OpenZeppelin qui fournit un ERC-20 éprouvé (pas besoin de tout réinventer, c'est plus sûr).

4.1 Le code complet du contrat

Ce fichier doit aller dans le dossier code/ de ton dépôt sous le nom token.sol :

// SPDX-License-Identifier: MIT
// GOLD42 - jeton BEP-20 (standard ERC-20 d'OpenZeppelin)
// Norme : BEP-20 sur la BNB Smart Chain
pragma solidity ^0.8.0;

// Import du contrat ERC-20 d'OpenZeppelin : fournit name, symbol,
// decimals, totalSupply, balanceOf, transfer, approve, transferFrom...
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract GOLD42 is ERC20 {
    // --- Propriétés du token ---
    string public constant NAME = "GOLD42";   // Nom du token (doit contenir 42)
    string public constant SYMBOL = "G42";     // Ticker (symbole court)
    uint8 public constant DECIMALS = 18;       // 18 décimales, comme l'ETH

    // --- Approvisionnement total (1 000 000 G42) : plafond absolu ---
    uint256 public constant TOTAL_SUPPLY = 1_000_000 * 10 ** uint256(DECIMALS);

    // --- Supply initiale (800 000 G42) : créée au déploiement,
    //     les 200 000 G42 restants sont réservés au futur mint du propriétaire ---
    uint256 public constant INITIAL_SUPPLY = 800_000 * 10 ** uint256(DECIMALS);

    // --- Propriétaire du contrat ---
    address public owner;

    // --- Événements (traces lisibles sur la blockchain) ---
    event Mint(address indexed to, uint256 amount);
    event Burn(address indexed from, uint256 amount);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    // --- Constructeur : exécuté une seule fois au déploiement ---
    constructor() ERC20(NAME, SYMBOL) {
        owner = msg.sender;                        // Le déployeur devient propriétaire
        _mint(msg.sender, INITIAL_SUPPLY);         // On crée 80 % de la supply pour lui
    }

    // --- Créer (mint) des tokens, réservé au propriétaire ---
    function mint(address recipient, uint256 amount) public onlyOwner {
        require(totalSupply() + amount <= TOTAL_SUPPLY,
            "GOLD42: minting exceeds total supply");
        _mint(recipient, amount);
        emit Mint(recipient, amount);
    }

    // --- Détruire (burn) ses propres tokens ---
    function burn(uint256 amount) public {
        _burn(msg.sender, amount);
        emit Burn(msg.sender, amount);
    }

    // --- Transférer la propriété du contrat ---
    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0), "GOLD42: new owner is the zero address");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

    // --- Restriction : seule la fonction ne peut être appelée que par le propriétaire ---
    modifier onlyOwner() {
        require(msg.sender == owner, "GOLD42: only owner can perform this action");
        _;
    }
}

4.2 Expliquer les mots du code

4.3 Mettre à jour ton dépôt

1. Ouvre code/token.sol et remplace son contenu par le code ci-dessus.
2. Assure-toi que chaque fonction a bien un commentaire lisible. C'est exigé par le sujet (revue de code à l'évaluation).

5. Compiler avec Remix

Remix IDE est l'outil recommandé par le sujet : un environnement gratuit dans le navigateur pour écrire, compiler et déployer des smart contracts.

5.1 Ouvrir Remix et créer le fichier

1. Va sur https://remix.ethereum.org.
2. Dans le panneau de gauche (explorateur de fichiers), crée un dossier contracts s'il n'existe pas, puis un fichier token.sol (icône « nouveau fichier »).
3. Colle le code du contrat dedans et enregistre (Ctrl+S).

5.2 Installer OpenZeppelin (import)

Le code importe @openzeppelin/contracts/.... Remix doit le télécharger :

1. Ouvre l'onglet « Solidity Compiler » (icône en forme de « S » sur le côté gauche).
2. Clique sur « Compile token.sol ». Remix détectera l'import manquant et proposera de l'installer - accepte.
3. Sinon, va dans l'onglet « File explorer » → clic droit sur le dossier racine → « Import from GitHub » et colle : OpenZeppelin/openzeppelin-contracts@master/contracts/token/ERC20/ERC20.sol.

5.3 Choisir la version et compiler

1. Dans « Solidity Compiler », choisis la version 0.8.x (ex. 0.8.26) - elle doit correspondre à pragma solidity ^0.8.0.
2. Clique sur « Compile token.sol ».
3. La barre verte « Compilation successful » doit s'afficher.

6. Déployer sur la BSC Testnet

Maintenant qu'on compile, on déploie réellement le token sur le testnet via MetaMask.

6.1 Connecter Remix à MetaMask

1. Dans Remix, ouvre l'onglet « Deploy & Run Transactions » (icône en forme de flèche « Run »).
2. Dans le menu Environment, choisis « Injected Provider - MetaMask ».
3. Une fenêtre MetaMask s'ouvre : choisis ton compte et clique « Connect ».
4. Vérifie que le réseau affiché dans MetaMask est bien BSC Testnet (chain ID 97).

6.2 Lancer le déploiement

1. Dans le panneau « Deploy & Run », le contrat GOLD42 doit être sélectionné (en haut).
2. Clique sur « Deploy ».
3. Une fenêtre MetaMask apparaît : vérifie le « gas » estimé et clique « Confirmer ».
4. Attends que la transaction soit incluse dans un bloc (généralement quelques secondes).

6.3 Récupérer l'adresse du contrat

1. Sous la section « Deployed Contracts » de Remix, tu verras ton contrat déployé avec son adresse 0x....
2. Clique sur la copie de l'adresse (icône) et sauvegarde-la quelque part. On en a besoin pour BSCScan et pour le README.
3. Note aussi le réseau : BSC Testnet.

7. Tester le token (démonstration)

On démontre que le token fonctionne. Ces actions seront montrées à l'évaluation.

7.1 Vérifier le solde initial

1. Dans Remix, déploie le contrat (section « Deployed Contracts »).
2. Clique sur balanceOf et colle ton adresse MetaMask, puis clique le bouton.
3. Tu dois voir 1000000000000000000000000 (1 000 000 G42 avec 18 décimales).

7.2 Transférer des tokens

1. Dans MetaMask, copie une deuxième adresse (compte de test 2.3).
2. Appelle transfer avec : adresse destinataire + montant 10000000000000000000 (soit 10 G42).
3. Confirme dans MetaMask. Vérifie avec balanceOf que le destinataire a bien reçu 10 G42.

7.3 Mint et burn

1. mint (réservé au propriétaire) : renseigne une adresse + un montant. Confirme.
2. Pour prouver la sécurité : appelle mint depuis une autre adresse (change de compte dans MetaMask) → la transaction doit échouer avec GOLD42: only owner can perform this action.
3. burn : brûle des tokens de ton propre compte, par ex. 1 G42. Vérifie que ton solde baisse.
4. transferOwnership : teste de transférer la propriété à une autre adresse.

8. Vérifier et publier sur BSCScan

Un block explorer est le « Google de la blockchain ». On y rend notre contrat public et vérifiable.

8.1 Trouver le contrat

1. Va sur https://testnet.bscscan.com (le testnet, pas le mainnet !).
2. Colle l'adresse du contrat dans la barre de recherche.
3. La page du contrat s'affiche avec les transactions, les holders, etc. Le symbole y apparaît encore comme « Unknown Token » tant que ce n'est pas vérifié.

8.2 Vérifier le code source

1. Ouvre l'onglet « Contract » puis clique « Verify and Publish ».
2. Remplis le formulaire exactement comme à la compilation :
   • Compiler type : Solidity (Single file)
   • Compiler version : celle choisie dans Remix (ex. 0.8.26)
   • Open Source License Type : MIT License
3. Colle le code complet de token.sol dans le champ « Solidity Contract Code ».
4. Clique « Verify and Publish ».

8.3 Publier le ticker et les infos du token

1. Sur la page du contrat, ouvre « Contract → Update Token Info » (ou « Update Token Information »).
2. Renseigne : nom GOLD42, symbole G42, 18 décimales.
3. Tu peux aussi uploader un logo (optionnel).

9. Dépannage et questions fréquentes

Les erreurs les plus courantes et leurs solutions.

9.1 « Not enough funds for gas »

Tu n'as pas assez de TBNB sur ton wallet testnet.

→ Récupère des TBNB au faucet (partie C) ou vérifie que MetaMask est bien sur le BSC Testnet (chain ID 97), pas sur Ethereum Mainnet.

9.2 La transaction reste « pending »

Le réseau de test est parfois lent ou le gas nonce est bloqué.

→ Attends, ou dans MetaMask va dans Paramètres → Avancé → « Clear activity tab data » pour réinitialiser. Puis réessaie.

9.3 « Identifier already declared » à la compilation

C'est le fameux conflit decimals : une constante uint8 public constant decimals entre en collision avec le getter decimals() de l'ERC-20.

→ Supprime la constante (et renomme-la DECIMALS en majuscule si tu la gardes en interne). Le getter d'OpenZeppelin renvoie déjà 18.

9.4 La vérification BSCScan échoue

→ Compare paramètre par paramètre avec Remix : version Solidity identique, licence MIT, et colle le code exact de token.sol (mêmes espaces, mêmes commentaires, c'est un hash qui doit matcher).

9.5 « revert » quand j'appelle mint depuis un autre compte

Normal ! mint est protégé par onlyOwner. C'est le comportement attendu et c'est exactement ce qu'il faut montrer à l'évaluation.

9.6 Est-ce que je risque de perdre de l'argent ?

Non. On ne travaille que sur la BSC Testnet avec des TBNB de test qui ne valent rien. N'utilise jamais le Mainnet ni des fonds réels.

Lien vers source : BNB Chain · Remix IDE · BSCScan Testnet · OpenZeppelin