# Comment Déployer un Smart Contract sur Ethereum — Étape par Étape

Déployer un smart contract est le moment où votre code devient réalité immuable sur la blockchain. C'est permanent, public, et imparable.

Dans ce guide, nous passerons en revue trois méthodes de déploiement—Remix (navigateur), Hardhat (JavaScript), et Foundry (Rust)—du testnet au mainnet, incluant la vérification sur Etherscan.

Prérequis

Avant de déployer, vous avez besoin de :

Un wallet : MetaMask (extension navigateur)

ETH pour le gas :

- Testnet : Obtenez de l'ETH Sepolia gratuit depuis faucet

- Mainnet : ETH réel depuis un exchange

Point de terminaison RPC : Infura, Alchemy, ou QuickNode (l'offre gratuite fonctionne)

Clé API Etherscan : Pour la vérification de contrat (gratuit sur etherscan.io)

Estimation de coût :

Testnet : Gratuit (ETH faucet)

Mainnet : ~$5-50 selon la taille du contrat et le prix du gas

Le Smart Contract Que Nous Allons Déployer

Nous utiliserons un exemple simple mais complet :

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

contract SimpleStorage {
    uint256 public storedValue;
    address public owner;

    event ValueUpdated(uint256 newValue, address updatedBy);

    constructor(uint256 _initialValue) {
        storedValue = _initialValue;
        owner = msg.sender;
    }

    function setValue(uint256 _value) public {
        require(msg.sender == owner, "Only owner can update");
        storedValue = _value;
        emit ValueUpdated(_value, msg.sender);
    }

    function getValue() public view returns (uint256) {
        return storedValue;
    }
}

Simple, mais inclut :

Constructeur avec arguments

Variables d'état

Contrôle d'accès

Events

Fonction view

Méthode 1 : Remix (Plus Rapide, Pas de Configuration)

Meilleur pour : Débutants, tests rapides, apprentissage.

Étape 1 : Écrire le Contrat

Allez sur remix.ethereum.org

Créez SimpleStorage.sol dans le dossier contracts

Collez le code ci-dessus

Étape 2 : Compiler

Cliquez sur l'onglet "Solidity Compiler" (barre latérale gauche)

Sélectionnez la version du compilateur 0.8.20

Cliquez "Compile SimpleStorage.sol"

Vérifiez les erreurs (devrait être une coche verte)

Étape 3 : Connecter le Wallet

Cliquez sur l'onglet "Deploy & Run Transactions"

Dans le menu déroulant "Environment", sélectionnez "Injected Provider - MetaMask"

MetaMask apparaîtra—connectez votre wallet

Assurez-vous d'être sur le testnet Sepolia dans MetaMask

Étape 4 : Déployer

Dans le menu déroulant "Contract", sélectionnez SimpleStorage

Entrez l'argument du constructeur : 42 (valeur initiale)

Cliquez "Deploy"

MetaMask apparaît—confirmez la transaction

Attendez 10-30 secondes pour la confirmation

Étape 5 : Vérifier le Déploiement

Copiez l'adresse du contrat depuis la console Remix

Allez sur sepolia.etherscan.io

Collez l'adresse—vous verrez le contrat !

Étape 6 : Interagir

Dans Remix, sous "Deployed Contracts" :

Cliquez getValue : Retourne 42

Cliquez setValue, entrez 100, transact

Cliquez getValue à nouveau : Retourne 100

Avantages : Pas d'installation, visuel, instantané.

Inconvénients : Pas scriptable, difficile à reproduire, pas de contrôle de version.

---

Méthode 2 : Hardhat (Écosystème JavaScript)

Meilleur pour : Équipes Web3, développeurs JavaScript, projets Node.js existants.

Étape 1 : Configurer le Projet

mkdir simple-storage-hardhat cd simple-storage-hardhat npm init -y npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox npx hardhat init

# Sélectionnez : Create a JavaScript project

Étape 2 : Écrire le Contrat

Créez contracts/SimpleStorage.sol (même code que ci-dessus).

Étape 3 : Configurer le Réseau

Éditez hardhat.config.js :

require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

module.exports = {
  solidity: "0.8.20",
  networks: {
    sepolia: {
      url: process.env.SEPOLIA_RPC_URL,
      accounts: [process.env.PRIVATE_KEY]
    }
  },
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY
  }
};

Créez .env :

SEPOLIA_RPC_URL=https://sepolia.infura.io/v3/YOUR_INFURA_KEY PRIVATE_KEY=your_wallet_private_key_here

ETHERSCAN_API_KEY=your_etherscan_api_key

⚠️ Ne jamais commit .env sur git ! Ajoutez à .gitignore.

Étape 4 : Écrire le Script de Déploiement

Créez scripts/deploy.js :

const hre = require("hardhat");

async function main() {
  const initialValue = 42;

  console.log("Deploying SimpleStorage with initial value:", initialValue);

  const SimpleStorage = await hre.ethers.getContractFactory("SimpleStorage");
  const simpleStorage = await SimpleStorage.deploy(initialValue);

  await simpleStorage.waitForDeployment();

  const address = await simpleStorage.getAddress();
  console.log("SimpleStorage deployed to:", address);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Étape 5 : Déployer sur Sepolia

npx hardhat run scripts/deploy.js --network sepolia

Sortie :

Deploying SimpleStorage with initial value: 42

SimpleStorage deployed to: 0x1234567890AbcdEF1234567890aBcdef12345678

Étape 6 : Vérifier sur Etherscan

npx hardhat verify --network sepolia 0x1234...5678 42

(Remplacez l'adresse par votre adresse déployée, 42 est l'arg du constructeur)

Avantages : Standard de l'industrie, excellent outillage, intégration avec npm.

Inconvénients : Plus lent que Foundry, enfer des dépendances JavaScript.

---

Méthode 3 : Foundry (Plus Rapide, Plus Puissant)

Meilleur pour : Développeurs avancés, besoins haute performance, tests natifs Solidity.

Étape 1 : Installer Foundry

curl -L https://foundry.paradigm.xyz | bash

foundryup

Étape 2 : Créer le Projet

forge init simple-storage-foundry

cd simple-storage-foundry

Étape 3 : Écrire le Contrat

Remplacez src/Counter.sol par src/SimpleStorage.sol (même code).

Étape 4 : Écrire le Test

Créez test/SimpleStorage.t.sol :

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import "forge-std/Test.sol";
import "../src/SimpleStorage.sol";

contract SimpleStorageTest is Test {
    SimpleStorage public store;

    function setUp() public {
        store = new SimpleStorage(42);
    }

    function testInitialValue() public {
        assertEq(store.getValue(), 42);
    }

    function testSetValue() public {
        store.setValue(100);
        assertEq(store.getValue(), 100);
    }

    function testOnlyOwner() public {
        vm.prank(address(0x123)); // Simule un appelant différent
        vm.expectRevert("Only owner can update");
        store.setValue(999);
    }
}

Lancez les tests :

forge test -vvv

Étape 5 : Configurer .env

SEPOLIA_RPC_URL=https://sepolia.infura.io/v3/YOUR_KEY
PRIVATE_KEY=your_private_key
ETHERSCAN_API_KEY=your_api_key

Étape 6 : Déployer

source .env forge create src/SimpleStorage.sol:SimpleStorage \ --rpc-url $SEPOLIA_RPC_URL \ --private-key $PRIVATE_KEY \ --constructor-args 42 \ --verify \

--etherscan-api-key $ETHERSCAN_API_KEY

Ou utilisez un script (script/Deploy.s.sol) :

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import "forge-std/Script.sol";
import "../src/SimpleStorage.sol";

contract DeployScript is Script {
    function run() external {
        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");

        vm.startBroadcast(deployerPrivateKey);

        SimpleStorage store = new SimpleStorage(42);
        console.log("Deployed at:", address(store));

        vm.stopBroadcast();
    }
}

Déployez avec le script :

forge script script/Deploy.s.sol:DeployScript \ --rpc-url $SEPOLIA_RPC_URL \ --broadcast \ --verify \

-vvvv

Avantages : Ultra rapide, tests natifs Solidity, meilleur outillage.

Inconvénients : Courbe d'apprentissage Rust pour les contributions.

---

Déployer sur Mainnet

⚠️ ATTENTION : Le mainnet est permanent et coûteux. Vérifiez tout trois fois.

Checklist Pré-Mainnet

[ ] Tous les tests passent

[ ] Audit de sécurité (pour les contrats de haute valeur)

[ ] Déployé et testé sur Sepolia

[ ] Vérifié sur Sepolia Etherscan

[ ] Revu tous les arguments du constructeur

[ ] Calculé le coût du gas (vérifiez etherscan.io/gastracker)

[ ] Sauvegardé l'adresse du contrat déployé

Déployer

Même processus que Sepolia, changez juste le réseau :

Hardhat :

npx hardhat run scripts/deploy.js --network mainnet

Foundry :

forge script script/Deploy.s.sol:DeployScript \ --rpc-url $MAINNET_RPC_URL \ --broadcast \

--verify

Remix :

Changez MetaMask vers Ethereum Mainnet, déployez normalement.

---

Vérification sur Etherscan

Pourquoi vérifier ?

Les utilisateurs peuvent lire le code source

Interaction directe via l'interface Etherscan

Confiance et transparence

Les dApps peuvent interroger les métadonnées du contrat

Vérification Automatique :

Foundry et Hardhat supportent --verify flag.

Vérification Manuelle :

Allez sur etherscan.io/verifyContract

Entrez l'adresse du contrat

Sélectionnez le compilateur et la version

Collez le code source

Entrez les arguments du constructeur (ABI-encoded)

Soumettez

---

Résolution de Problèmes

"Transaction underpriced"

Augmentez le prix du gas dans MetaMask ou maxFeePerGas.

"Out of gas"

Augmentez la limite de gas. Estimez d'abord avec eth_estimateGas.

"Nonce too low"

Réinitialisez l'état du compte dans MetaMask : Paramètres → Avancé → Réinitialiser le compte.

"Contract verification failed"

Assurez-vous que la version du compilateur correspond exactement

Vérifiez que l'optimiseur correspond (activé/désactivé, runs)

Encodez correctement les arguments du constructeur

---

Meilleures Pratiques

Testez d'abord sur testnet — TOUJOURS

Utilisez des clés API d'environnement — jamais hardcodées

Vérifiez immédiatement — pour la transparence

Documentez l'adresse de déploiement — sauvegardez dans README

Configurez le monitoring — Tenderly, Defender

Planifiez les mises à niveau — patterns proxy si nécessaire

---

Conclusion

Vous savez maintenant comment déployer un smart contract sur Ethereum en utilisant :

Remix : Rapide et visuel pour les débutants

Hardhat : Standard de l'industrie pour les équipes JavaScript

Foundry : Rapide et puissant pour les développeurs avancés

Prochaines étapes :

Déployez sur mainnet (avec prudence)

Explorez les déploiements multi-chaînes

Apprenez les patterns proxy pour l'évolutivité

Configurez le CI/CD pour les déploiements automatisés

Bon déploiement ! 🚀

Comment Déployer un Smart Contract sur Ethereum — Étape par Étape