Tenderly — Déboguez et Surveillez les Smart Contracts comme un Pro

# Tenderly — Déboguez et Surveillez les Smart Contracts comme un Pro

Les bugs dans les smart contracts peuvent coûter des millions. Les outils de débogage traditionnels sont limités — vous ne pouvez pas facilement parcourir les transactions échouées ou simuler des changements avant le déploiement. Tenderly résout cela avec une plateforme complète pour déboguer, surveiller, simuler et tester les smart contracts. Que vous traciez un revert mystérieux ou optimisiez les coûts de gas, Tenderly fournit les insights dont vous avez besoin pour déployer du code prêt pour la production en toute confiance.

Qu'est-ce que Tenderly ?

Tenderly est une plateforme de développement Web3 offrant :

• Débogage de transactions — Parcourir n'importe quelle transaction pas à pas, même les échecs

• Profilage de gas — Identifier les opérations coûteuses et optimiser les coûts

• Alertes — Notifications en temps réel pour les événements de contrat

• Simulations — Tester les transactions avant de les envoyer

• Forks — Créer des testnets privés depuis n'importe quel état de réseau

• Surveillance — Suivre les performances et l'utilisation des contrats

• Web3 Actions — Fonctions serverless déclenchées par des événements on-chain

Utilisée par les équipes d'Aave, Uniswap, Compound et des milliers d'autres projets, Tenderly est essentielle pour le développement professionnel de smart contracts.

Démarrage

Créer un compte

Allez sur tenderly.co

Inscrivez-vous avec GitHub, Google ou email

Créez un projet (ex: "MyDApp")

Vous êtes prêt à déboguer !

Ajouter un contrat

Option 1 : Recherche par adresse

• Cliquez sur "Add Contract"

• Collez l'adresse du contrat

• Sélectionnez le réseau (Ethereum, Polygon, Arbitrum, etc.)

• Tenderly détecte automatiquement les contrats vérifiés

Option 2 : Importer depuis Hardhat/Foundry

Installez Tenderly CLI :

npm install --save-dev @tenderly/hardhat-tenderly

Configurez hardhat.config.js :

require("@tenderly/hardhat-tenderly");

module.exports = {
  tenderly: {
    username: "your-username",
    project: "your-project"
  }
};

Poussez les contrats :

npx hardhat tenderly:verify ContractName --network mainnet

Débogage de transactions

Déboguer n'importe quelle transaction

La fonctionnalité phare de Tenderly : déboguer n'importe quelle transaction sur n'importe quelle chaîne EVM, y compris les transactions échouées.

Étapes :

Copiez un hash de transaction depuis Etherscan

Collez-le dans la barre de recherche de Tenderly

Cliquez sur la transaction

Vous verrez :

• Trace d'appel — chaque appel de fonction, appels imbriqués et appels externes

• Changements d'état — mises à jour du storage, changements de solde

• Utilisation de gas — par opération

• Événements émis — tous les logs

• Stack d'exécution — code source Solidity avec lignes surlignées

• Débogueur — exécution pas à pas

Exemple : Déboguer un transfert échoué

Déboguons une transaction qui a revert :

Transaction: 0xabc123...
Error: execution reverted

Dans Tenderly :

Trace d'appel montre l'appel de fonction qui a revert

Débogueur surligne la ligne exacte :

require(balanceOf[msg.sender] >= amount, "Insufficient balance");

Changements d'état montre que balanceOf[sender] était 50 mais amount était 100

Cause racine : Solde insuffisant

Sans Tenderly, vous ne verriez que "execution reverted" — avec lui, vous savez exactement pourquoi.

Débogage pas à pas

Cliquez sur l'onglet Debugger :

• Step Over — Exécuter la ligne courante

• Step Into — Entrer dans l'appel de fonction

• Step Out — Sortir de la fonction

• Continue — Exécuter jusqu'au prochain point d'arrêt

Survolez les variables pour voir leurs valeurs à n'importe quel point de l'exécution.

Voir les changements d'état

L'onglet State Changes montre :

• Mises à jour du storage — quels slots ont changé et vers quelles valeurs

• Changements de solde — ETH transféré

• Création de contrat — si de nouveaux contrats ont été déployés

Filtrez par contrat ou nom de variable pour plus de clarté.

Profilage de gas

Optimisez la consommation de gas de votre contrat avec le profileur de gas de Tenderly.

Comment utiliser le profileur de gas

Ouvrez une transaction dans Tenderly

Cliquez sur l'onglet Gas Profiler

Voyez la répartition de l'utilisation de gas :

- Gas total — coût global de la transaction

- Par fonction — gas utilisé par chaque fonction

- Par opcode — opérations les plus coûteuses (SSTORE, SLOAD, etc.)

- Flame graph — représentation visuelle de l'utilisation du gas

Exemple : Trouver les boucles coûteuses

function batchTransfer(address[] calldata recipients, uint256 amount) external {
    for (uint i = 0; i < recipients.length; i++) {
        _transfer(msg.sender, recipients[i], amount);
    }
}

Le profileur de gas montre :

• Les opérations SSTORE dominent (90% du gas)

• Chaque _transfer écrit dans le mapping balanceOf deux fois

Optimisation : Mettre à jour les soldes en batch en mémoire, écrire dans le storage une fois.

function batchTransfer(address[] calldata recipients, uint256 amount) external {
    uint256 totalAmount = recipients.length * amount;
    require(balanceOf[msg.sender] >= totalAmount);

    balanceOf[msg.sender] -= totalAmount; // Un SSTORE

    for (uint i = 0; i < recipients.length; i++) {
        balanceOf[recipients[i]] += amount; // Plusieurs SSTORE, mais inévitable
    }
}

Gas économisé : ~5,000 par transfert (un SSTORE éliminé).

Simulations

Testez les transactions avant de les envoyer pour éviter les transactions échouées et le gas gaspillé.

Simuler une transaction

Allez dans Simulator dans Tenderly

Sélectionnez le réseau (mainnet, testnet ou fork)

Entrez :

- Adresse From — appelant

- Adresse To — contrat

- Fonction — méthode à appeler

- Paramètres — arguments de fonction

Cliquez sur Simulate

Tenderly exécute la transaction dans un environnement sandbox et montre :

• Va-t-elle réussir ou revert ?

• Coût de gas

• Changements d'état

• Événements émis

Cas d'usage

Tester avant le déploiement :

// Simuler le minting de 1M tokens pour voir le coût de gas
simulate: mint(0x123..., 1000000)

Tester des interactions complexes :

// Simuler une attaque flash loan pour vérifier les défenses
simulate: flashLoan(10000 ETH) → swap() → exploit()

Tester avec différents états :

• Fork à un bloc spécifique

• Modifier le storage du contrat (ex: définir le solde à 1M ETH)

• Simuler la transaction dans cet état modifié

Forks — Testnets privés depuis n'importe quel état

Les Forks Tenderly créent une version privée et simulée de n'importe quel réseau EVM à n'importe quelle hauteur de bloc.

Créer un Fork

Allez dans Forks dans Tenderly

Cliquez sur Create Fork

Sélectionnez :

- Réseau — Ethereum Mainnet, Polygon, Arbitrum, etc.

- Numéro de bloc — bloc actuel ou historique

Cliquez sur Create

Vous obtenez une URL RPC privée (ex: https://rpc.tenderly.co/fork/abc123).

Utiliser le Fork

Avec MetaMask :

Ajouter un RPC personnalisé

Coller l'URL RPC du Fork Tenderly

Chain ID : identique au réseau d'origine

Se connecter et transacter

Avec Hardhat :

module.exports = {
  networks: {
    tenderlyFork: {
      url: "https://rpc.tenderly.co/fork/abc123"
    }
  }
};

Exécuter les tests :

npx hardhat test --network tenderlyFork

Fonctionnalités des Forks

Modifier l'état :

• Définir n'importe quel solde d'adresse

• Changer le storage du contrat

• Avancer le temps rapidement

ETH illimité :

• Pas besoin de faucets

• Tester de grandes transactions

Minage instantané :

• Pas d'attente pour les confirmations de blocs

• Parfait pour CI/CD

Exemple : Tester un protocole live

Vous voulez tester une liquidation Aave :

Fork Ethereum Mainnet au dernier bloc

Définir le solde de votre adresse à 1,000 ETH

Déposer de l'ETH dans Aave

Emprunter de l'USDC

Simuler une chute de prix (modifier le storage de l'oracle)

Déclencher la liquidation

Déboguer tout le flux dans Tenderly

Le tout sans dépenser de vrais ETH ni affecter le mainnet.

Alertes — Surveillance en temps réel

Configurez des alertes pour être notifié lorsque des événements spécifiques se produisent.

Créer une alerte

Allez dans Alerts

Cliquez sur New Alert

Configurez :

- Contrat — quel contrat surveiller

- Événement — quel événement déclenche (ex: Transfer, Approval, OwnershipTransferred)

- Conditions — filtrer par paramètres (ex: amount > 10 ETH)

- Destination — Email, Slack, Discord, Webhook

Sauvegardez

Exemples d'alertes

Surveiller les gros transferts :

Event: Transfer
Condition: value > 1000000 (1M tokens)
Destination: Slack #security

Détecter les changements de propriété du contrat :

Event: OwnershipTransferred
Destination: Email

Suivre les transactions échouées :

Status: Failed
Destination: Discord #dev-ops

Surveiller les pics de gas :

Condition: gasUsed > 5000000
Destination: Webhook

Web3 Actions — Fonctions serverless

Les Web3 Actions sont des fonctions serverless déclenchées par des événements blockchain.

Créer une Web3 Action

Allez dans Web3 Actions

Cliquez sur New Action

Sélectionnez le déclencheur :

- Webhook — endpoint HTTP

- Block — tous les N blocs

- Transaction — contrat/événement spécifique

Écrivez le code JavaScript :

const { ethers } = require("ethers");


   module.exports = async (context) => {
     const { transaction, network } = context;

     // Votre logique ici
     console.log(New transfer: ${transaction.hash});

     // Envoyer une notification, mettre à jour une base de données, déclencher une autre transaction, etc.
   };

Déployez

Exemple : Bot de rééquilibrage automatique

Déclencher lorsque le prix du token dévie de la cible :

module.exports = async (context) => {
  const { provider, secrets } = context;

  const price = await getTokenPrice(provider);
  const targetPrice = 1.0;

  if (Math.abs(price - targetPrice) > 0.05) {
    // Prix dévié > 5%
    await rebalance(provider, secrets.PRIVATE_KEY);
  }
};

Exemple : Gestion automatisée de trésorerie

Transférer des fonds lorsque le solde est bas :

module.exports = async (context) => {
  const { provider, secrets } = context;

  const balance = await provider.getBalance(treasuryAddress);

  if (balance < ethers.parseEther('10')) {
    // Remplir la trésorerie
    const signer = new ethers.Wallet(secrets.PRIVATE_KEY, provider);
    await signer.sendTransaction({
      to: treasuryAddress,
      value: ethers.parseEther('100')
    });
  }
};

Tableaux de bord de surveillance

Créez des tableaux de bord personnalisés pour suivre les performances des contrats.

Métriques disponibles

• Volume de transactions — nombre de transactions

• Utilisation de gas — gas total consommé

• Utilisateurs uniques — appelants distincts

• Appels de fonctions — quelles fonctions sont appelées le plus

• Taux d'erreur — pourcentage de transactions échouées

• Coût moyen de gas — par transaction ou fonction

Créer un tableau de bord

Allez dans Dashboards

Cliquez sur New Dashboard

Ajoutez des widgets :

- Graphique en ligne (transactions dans le temps)

- Graphique en barres (top fonctions par gas)

- Tableau (transactions échouées récentes)

Filtrez par contrat, plage de temps, réseau

Bonnes pratiques

1. Déboguer immédiatement les transactions échouées

Lorsqu'une transaction échoue en production :

Copiez le hash depuis Etherscan

Ouvrez dans Tenderly

Utilisez le débogueur pour trouver la cause racine

Corrigez le problème et simulez la transaction corrigée

2. Simuler avant chaque déploiement mainnet

Avant de déployer sur mainnet :

Déployez sur un Fork Tenderly

Simulez toutes les fonctions critiques

Vérifiez les coûts de gas

Vérifiez les changements d'état

Seulement alors déployez sur mainnet

3. Configurer des alertes pour les événements critiques

Surveillez :

• Transferts de propriété

• Gros retraits

• Transactions échouées

• Pics de gas

• Activité inhabituelle

4. Utiliser les Forks pour les tests d'intégration

Testez votre dApp contre de vrais protocoles :

Fork mainnet

Déployez votre contrat sur le fork

Interagissez avec Uniswap, Aave live, etc.

Déboguez tout le flux

5. Profiler le gas à chaque release

Exécutez le profileur de gas sur les fonctions clés :

• Identifier les régressions (augmentations de gas)

• Optimiser les chemins critiques

• Comparer avant/après les optimisations

Tarification

Tier Gratuit :

• 5,000 transactions/mois

• Débogage basique

• 3 alertes

• 1 fork

Tier Développeur ($50/mois) :

• 50,000 transactions/mois

• Débogage avancé

• Alertes illimitées

• 10 forks

• Web3 Actions

Tier Équipe ($200/mois) :

• 500,000 transactions/mois

• Collaboration d'équipe

• SLA personnalisés

• Support prioritaire

La plupart des développeurs solo et petites équipes peuvent rester sur le tier gratuit.

Tenderly CLI

Installation :

npm install -g @tenderly/cli

Login :

tenderly login

Exporter l'ABI :

tenderly export init
tenderly export

Pousser les contrats :

tenderly contracts upload

Conclusion

Tenderly est un outil essentiel pour le développement professionnel de smart contracts. Ses puissantes capacités de débogage, simulation et surveillance détectent les bugs avant qu'ils n'atteignent la production, optimisent les coûts de gas et fournissent des insights en temps réel sur le comportement des contrats. Que vous construisiez un simple token ou un protocole DeFi complexe, Tenderly vous aide à déployer en toute confiance.

Commencez à déboguer plus intelligemment aujourd'hui — inscrivez-vous sur Tenderly et connectez votre premier contrat. Pratiquez les techniques de débogage avancées avec les défis sécurité de Solingo pour construire des smart contracts à toute épreuve.

Prochaines étapes :

• Déboguez une transaction échouée depuis Etherscan

• Créez un fork et testez une interaction complexe

• Configurez des alertes pour vos contrats déployés

• Utilisez le profileur de gas pour optimiser une fonction coûteuse