Contrats intelligents avec fonction AntiWhale

Nous continuons la série d'articles consacrés à la description des schémas frauduleux dans les contrats intelligents. Aujourd'hui, nous analyserons les contrats intelligents avec le mécanisme de limitation de taille de transfert AntiWhale.

Dans cet article, nous examinerons en détail ce qu'est le mécanisme AntiWhale, en quoi il diffère du mécanisme Cooldown, et quand ils sont utilisés ensemble et séparément.

Mécanisme Cooldown

Objectif :

Le mécanisme Cooldown est conçu pour imposer des délais entre les transactions consécutives provenant de la même adresse. Son objectif est de réguler la fréquence des transactions et de prévenir une activité d'achat ou de vente excessive sur de courtes périodes.

Réalisation :

Limites de temps : Les mécanismes Cooldown définissent des périodes d'attente entre les transactions, souvent basées sur le temps écoulé depuis la dernière transaction à partir d'une adresse particulière. Les utilisateurs doivent attendre que la période d'attente expire avant de démarrer une nouvelle transaction.

Indicateurs :

Comparaison des horodatages : Recherchez des segments de code qui comparent les horodatages de bloc ou utilisent des fonctions liées au temps. Les variables d'état de type lastTransactionTimestamp peuvent être utilisées pour suivre l'heure de la dernière transaction.

Mécanisme AntiWhale

Objectif :

L'objectif principal du mécanisme AntiWhale est de réduire l'impact des grandes transactions provenant d'une seule adresse ou d'un petit groupe d'adresses, souvent appelés "baleines". Il vise à prévenir la concentration excessive de jetons entre les mêmes mains et à lutter contre toute manipulation ou déstabilisation du marché.

Implémentation :

Limites de taille de transaction : Les mécanismes AntiWhale définissent généralement des limites sur la taille ou la valeur des transactions individuelles. Les transactions dépassant un seuil défini entraînent l'imposition de restrictions telles que le rejet de la transaction, des frais élevés ou d'autres mécanismes de redistribution.

Indicateurs :

Recherchez des segments de code qui vérifient la taille ou la valeur des transactions, ainsi que des variables d'état (telles que maxTransactionAmount ou whaleThreshold), qui peuvent indiquer la présence du mécanisme AntiWhale. AntiWhale affecte principalement les utilisateurs avec des volumes de transaction élevés et vise à résoudre la concentration de jetons chez les gros détenteurs.

Principales différences entre Cooldown et AntiWhale :

Scénarios d'utilisation :

1. Minimiser la manipulation du marché :
   Les deux mécanismes peuvent être utilisés ensemble pour résoudre différents problèmes de manipulation du marché. Le mécanisme AntiWhale aide à limiter la taille des grosses transactions, tandis que le mécanisme Cooldown empêche la multiplication rapide des transactions sur une courte période.
   
   Supposons qu'une entité possède une part importante de l'offre totale de jetons. Sans le mécanisme AntiWhale, cette entité pourrait effectuer de grandes transactions susceptibles de provoquer des fluctuations de prix importantes, entraînant une manipulation du marché. En limitant la taille maximale ou la fréquence des transactions à une seule adresse dans un certain laps de temps, le mécanisme AntiWhale vise à empêcher les gros détenteurs d'avoir une influence indue sur le marché.


2. Assurer une distribution équitable :
   Dans le contexte de nouveaux jetons ou de ventes de jetons, empêcher un petit nombre de participants d'acquérir une part disproportionnée de l'offre totale. Fixer des limites sur le montant maximum qu'une adresse individuelle peut acheter lors d'une vente de jetons ou dans un certain laps de temps permet une distribution plus équitable des jetons parmi un plus grand nombre de participants.


3. S'attaquer aux problèmes de liquidité :
   Les volumes élevés de transactions des gros détenteurs peuvent affecter la liquidité et perturber le processus naturel de découverte des prix sur les échanges décentralisés. En limitant la vitesse des transactions par les gros détenteurs, le mécanisme AntiWhale contribue à maintenir une situation de liquidité plus stable.


4. Stabilisation des prix :
   Empêcher les transactions rapides et à grande échelle peut contribuer à stabiliser les prix. En appliquant des restrictions AntiWhale, le prix du jeton a plus de temps pour s'adapter aux conditions du marché entre les transactions.


5. Prévenir le front-running :
   AntiWhale peut être mis en œuvre pour lutter contre le front-running, où les traders utilisent des informations sensibles au temps pour exécuter des transactions avant les autres. Le mécanisme AntiWhale peut réduire l'avantage obtenu en exécutant rapidement des transactions.


6. Atténuation des attaques de prêt flash et de réentrance :
   AntiWhale peut ajouter une couche de défense supplémentaire contre certaines attaques de prêt flash et de réentrance en limitant la vitesse d'exécution des transactions.

Risques potentiels pour les détenteurs de jetons :

1. Fixer des limites AntiWhale trop strictes peut poser problème aux utilisateurs ayant vraiment besoin de grosses transactions.


2. Une dépendance excessive au mécanisme AntiWhale peut involontairement favoriser la centralisation s'il est mis en œuvre sans considérer l'écosystème global.

Comment pouvez-vous déterminer de manière indépend ante si de telles menaces sont présentes dans les contrats intelligents ?

Déterminer si un mécanisme de contrainte AntiWhale est présent dans un contrat intelligent est une tâche importante, voici quelques conseils pour vous aider :

1. Apprenez la documentation du contrat : commencez par examiner la documentation et les spécifications du contrat.


2. Analysez les fonctions de transfert : examinez les fonctions responsables du transfert des jetons (transfer, transferFrom, etc.). Recherchez des instructions conditionnelles imposant des restrictions sur les transactions.


3. Vérifiez les comparaisons d'horodatage : recherchez les cas où le contrat compare les horodatages de bloc.


4. Vérifiez les variables d'état : examinez les variables d'état qui peuvent être utilisées pour stocker des informations liées à AntiWhale.


5. Recherchez des fonctions ou des modificateurs liés aux calculs temporels, tels que block.timestamp, block.number ou now.


6. Recherchez des paramètres contrôlant le comportement AntiWhale : ceux-ci peuvent être maxTransferAmount, maxTxLimit, etc. Ces paramètres sont souvent définis par le propriétaire du contrat ou à travers les mécanismes de gestion des transactions individuelles.


7. Analysez les journaux d'événements : vérifiez les journaux d'événements pour les événements spéciaux. Les implémentations peuvent consigner des informations pertinentes lors de l'exécution d'une transaction, fournissant un aperçu du processus de refroidissement.


8. Analysez la logique spécifique à l'utilisateur : si des restrictions utilisateur sont mises en œuvre dans le contrat, vérifiez la logique pour déterminer les limites de transfert individuelles. Cette logique peut inclure des attributs d'utilisateur, des soldes ou d'autres critères.


9. Soyez informé : Restez à jour avec les derniers développements dans notre communauté (chaîne Telegram) et les meilleures pratiques pour la détection de fraudes (notre blog et chaîne YouTube).

Bonne nouvelle : notre scanner de sécurité trouve (y compris les cachés) ainsi que calcule les restrictions de transfert (AntiWhale) dans 90% des cas. Utilisez notre abonnement premium et protégez vos fonds des menaces.

Bien que le mécanisme AntiWhale soit conçu pour prévenir la manipulation du marché et assurer la distribution des jetons, les fraudeurs peuvent utiliser ses capacités pour tromper les utilisateurs. Ci-dessous, quelques scénarios possibles et des conseils pour sécuriser les investissements en jetons avec le mécanisme AntiWhale en place.

Exemple 1 : Limitations sur le montant des transactions avec période de refroidissement (Limites de montant de transaction avec Cooldown)

    uint256 public maxTransactionAmount = 1000000; // Montant maximum de la transaction
    uint256 public cooldownTime = 1 days; // Temps de refroidissement entre les transactions
    
    mapping(address => uint256) private lastTransactionTimestamp;
    
    function transfer(address to, uint256 value) public {
        require(value <= maxTransactionAmount, "Dépassement du montant maximum de transaction");
        require(block.timestamp - lastTransactionTimestamp[msg.sender] >= cooldownTime, "Attendez la fin de la période de refroidissement");
        ...
        lastTransactionTimestamp[msg.sender] = block.timestamp;
    }

Cet exemple limite le montant maximum qu'une seule adresse peut transférer dans un certain laps de temps.

Il comprend un mécanisme de refroidissement qui prévoit une période d'attente entre les transactions à la même adresse. Le tableau lastTransactionTimestamp suit l'horodatage de la dernière transaction pour chaque adresse.

Exemple 2 : Restrictions de transaction dynamiques (Limites progressives de transaction)

      uint256 public initialMaxTransactionAmount = 500000; // Montant initial maximum de la transaction
      uint256 public maxTransactionIncreaseRate = 20000; // Taux d'augmentation maximum par transaction
      uint256 public cooldownTime = 2 jours; // Temps de refroidissement entre les transactions
              
      mapping(address => uint256) private lastTransactionTimestamp;
              
      function transfer(address to, uint256 value) public {
          uint256 currentMaxTransactionAmount = initialMaxTransactionAmount + (maxTransactionIncreaseRate * (block.timestamp - lastTransactionTimestamp[msg.sender]) / cooldownTime);
          require(value <= currentMaxTransactionAmount, "Montant de transaction maximum dépassé");
          ...
          lastTransactionTimestamp[msg.sender] = block.timestamp;
      }

Cet exemple utilise un mécanisme dynamique dans lequel le montant maximum de la transaction augmente progressivement avec le temps.

Le paramètre maxTransactionIncreaseRate contrôle le taux d'augmentation du montant maximum de la transaction. Le tableau lastTransactionTimestamp suit l'horodatage de la dernière transaction pour chaque adresse.

Exemple 3 : Exceptions sur liste blanche (Exemption sur liste blanche)

    address[] public whitelistedAddresses;
    mapping(address => bool) public isWhitelisted;
    
    uint256 public maxTransactionAmount = 1000000; // Montant maximum de la transaction
    
    function transfer(address to, uint256 value) public {
        require(value <= maxTransactionAmount || isWhitelisted[msg.sender], "Montant de transaction maximum dépassé");
        ...
    }

Cet exemple utilise des exemptions sur liste blanche pour certaines adresses par rapport aux restrictions AntiWhale.

Les adresses dans le tableau whitelistedAddresses sont exemptées de la restriction du montant maximum de transaction. Le tableau isWhitelisted détermine si une adresse particulière est sur liste blanche.

Exemple 4 : Limites de transaction à paliers (Limites de transaction à paliers)

    uint256[] public tieredLimits = [5000000, 2000000, 1000000]; // Limites de transaction à paliers pour différents soldes d'adresses

    function transfer(address to, uint256 value) public {
        require(value <= getTransactionLimit(msg.sender), "Montant de transaction maximum dépassé");
        ...
    }
    
    function getTransactionLimit(address user) internal view returns (uint256) {
        uint256 userBalance = balanceOf(user);
    
        if (userBalance < 10000) {
            return tieredLimits[0];
        } else if (userBalance < 50000) {
            return tieredLimits[1];
        } else {
            return tieredLimits[2];
        }
    }

Cet exemple met en œuvre des limites de transaction à paliers en fonction du solde de l'adresse de l'expéditeur. Les utilisateurs avec un solde plus faible ont une limite de transaction plus élevée, et ceux avec un solde plus élevé ont une limite de transaction plus basse.

La fonction getTransactionLimit détermine la limite de transaction appropriée en fonction du solde de l'utilisateur.

Exemple 5 : Frais sur les grandes transactions (Taxe sur les grandes transactions)

    uint256 public taxRate = 75; // Taux de taxe de 5% sur les transactions dépassant la limite
    uint256 public maxTransactionAmount = 1000000; // Montant maximum de la transaction
    
    function transfer(address to, uint256 value) public {
        if (value > maxTransactionAmount) {
            uint256 taxAmount = (value * taxRate) / 100;
            uint256 netTransferAmount = value - taxAmount;
    
            // Logique de transfert ici pour le montant net transféré
            ...
        } else {
            // Logique de transfert ici pour les montants dans la limite
            ...
        }
    }

Dans cet exemple, des frais sont appliqués aux transactions dépassant le montant maximum de transaction.

Le taux de commission (taxRate) détermine le pourcentage du montant de la transaction. La commission est déduite et ensuite le montant net du transfert est traité.

Exemple 6 : Limites à plusieurs niveaux (Limites de transaction à plusieurs niveaux)

    uint256 public maxTransactionAmount1 = 500000; // Montant maximum de transaction pour le niveau 1 (500,000 jetons)
    uint256 public maxTransactionAmount2 = 200000; // Montant maximum de transaction pour le niveau 2 (200,000 jetons)
    
    function transfer(address to, uint256 value) public {
        if (value <= maxTransactionAmount1) {
            ...
        } else if (value <= maxTransactionAmount2) {
            ...
        } else {
            revert("Montant de transaction maximum dépassé");
        }
    }

Cet exemple met en œuvre plusieurs niveaux de limites de transaction, où différentes limites sont appliquées en fonction du montant de la transaction.

Cela permet de définir des limites de transaction à différents niveaux de granularité pour différents volumes de jetons.

Exemple 7 : Limites de transaction dynamiques en fonction du solde (Limites de transaction dynamiques basées sur le solde des jetons)

    uint256 public maxTransactionPercentage = 5; // Pourcentage maximum de transaction par rapport à l'offre totale de jetons
    
    function transfer(address to, uint256 value) public {
        uint256 maxTransactionAmount = (totalSupply() * maxTransactionPercentage) / 100;
        require(value <= maxTransactionAmount, "Montant de transaction maximum dépassé");
        ...
    }

Cet exemple calcule dynamiquement le montant maximum de transaction en pourcentage de l'offre totale. Le paramètre maxTransactionPercentage définit le pourcentage autorisé pour une transaction unique.

Exemple 8 : Limites de transaction dépendant du temps (Limites de transaction dépendant du temps)

    uint256 public maxTransactionAmount = 1000000; // Montant maximum de transaction (1 million de jetons)
    uint256 public startTime = 1700000000; // Heure de début au format Unix timestamp
    uint256 public endTime = 1800000000; // Heure de fin au format Unix timestamp

    function transfer(address to, uint256 value) public {
        require(block.timestamp >= startTime && block.timestamp <= endTime, "Transaction non autorisée à ce moment");
        require(value <= maxTransactionAmount, "Montant de transaction maximum dépassé");
        ...
    }

Dans cet exemple, des restrictions de transaction dépendant du temps sont appliquées, permettant les transactions uniquement dans une période donnée.

Les paramètres startTime et endTime définissent la période pendant laquelle les transactions sont autorisées.

Exemple 9 : Taxation progressive (Taxation progressive)

    uint256 public maxTransactionAmount = 1000000; // Montant maximum de transaction (1 million de jetons)
    uint256 public taxRate = 2; // Taux de taxe initial en pourcentage
    
    function transfer(address to, uint256 value) public {
        require(value <= maxTransactionAmount, "Montant de transaction maximum dépassé");
    
        uint256 taxAmount = (value * taxRate) / 100;
        uint256 netTransferAmount = value - taxAmount;
    
        // Logique de transfert ici pour le montant net transféré
        ...
    }

Cet exemple présente un mécanisme de taxation progressive, où une taxe est prélevée sur les transactions dépassant un montant maximum.

Le taux de taxe peut être ajusté avec le temps ou en fonction de certaines conditions.

Exemple 10 : Limites de transaction basées sur les soldes des détenteurs (Limites de transaction pondérées basées sur les soldes des détenteurs de jetons)

    uint256 public maxTotalTransactionAmount = 5000000; // Montant total maximum de transaction pour tous les détenteurs de jetons
    mapping(address => uint256) public userTransactionLimit; // Limites de transaction basées sur les soldes individuels des détenteurs de jetons
    
    function transfer(address to, uint256 value) public {
        require(value <= maxTotalTransactionAmount, "Montant total de transaction maximum dépassé");
        require(value <= userTransactionLimit[msg.sender], "Limite de transaction individuelle dépassée");
        ...
    }

Cet exemple met en œuvre des limites de transaction basées à la fois sur le montant total des transactions et sur le solde individuel des détenteurs de jetons.

La liaison userTransactionLimit permet de définir des limites personnalisées basées sur les soldes de certaines adresses.

Nous espérons que ces exemples vous ont aidé à mieux comprendre le mécanisme AntiWhale dans les contrats intelligents.

Comme toutes les informations de la blockchain sont ouvertes (pour autant bien sûr que le code source du contrat soit vérifié), armé de cette connaissance, vous pouvez étudier indépendamment les contrats intelligents et identifier divers schémas d'arnaque.

Cependant, nous l'avons déjà fait pour vous ! Inscrivez-vous à un abonnement premium et accédez à des filtres exclusifs sur les fonctionnalités des contrats intelligents et à des analyses fraîches. Augmentez vos chances d'investir avec succès dans des jetons rentables.

Cordialement, l'équipe Lotus Market.

All posts