Intelligente Verträge mit AntiWhale-Funktion

Wir setzen die Serie von Artikeln fort, die sich mit der Beschreibung betrügerischer Schemata in Smart Contracts befassen. Heute werden wir Smart Contracts mit dem AntiWhale-Übertragungsgrößenbegrenzungsmechanismus analysieren.

In diesem Artikel werden wir ausführlich betrachten, was der AntiWhale-Mechanismus ist, wie er sich vom Cooldown-Mechanismus unterscheidet und wann sie zusammen und wann getrennt verwendet werden.

Cooldown-Mechanismus

Zweck:

Der Cooldown-Mechanismus soll Zeitlimits zwischen aufeinanderfolgenden Transaktionen von derselben Adresse festlegen. Sein Ziel ist es, die Häufigkeit von Transaktionen zu regulieren und übermäßige Kauf- oder Verkaufsaktivitäten innerhalb kurzer Zeitintervalle zu verhindern.

Umsetzung:

Zeitliche Begrenzungen: Cooldown-Mechanismen setzen Wartezeiten zwischen Transaktionen fest, oft basierend auf der vergangenen Zeit seit der letzten Transaktion von einer bestimmten Adresse. Benutzer müssen auf das Ablaufdatum der Wartezeit warten, bevor sie eine neue Transaktion starten können.

Indikatoren:

Zeitstempelvergleich: Suchen Sie nach Code-Segmenten, die Blockzeitstempel vergleichen oder zeitbezogene Funktionen verwenden. Zustandsvariablen vom Typ lastTransactionTimestamp können verwendet werden, um die Zeit der letzten Transaktion zu verfolgen.

AntiWhale-Mechanismus

Zweck:

Der Hauptzweck des AntiWhale-Mechanismus ist es, die Auswirkungen großer Transaktionen von einer einzelnen Adresse oder einer kleinen Gruppe von Adressen, oft als "Wale" bezeichnet, zu reduzieren. Er zielt darauf ab, eine übermäßige Konzentration von Tokens in denselben Händen zu verhindern und mögliche Manipulationen oder Destabilisierungen des Marktes zu bekämpfen.

Umsetzung:

Transaktionsgrößenbegrenzungen: AntiWhale-Mechanismen legen typischerweise Grenzen für die Größe oder den Wert einzelner Transaktionen fest. Transaktionen, die einen festgelegten Schwellenwert überschreiten, führen zu Einschränkungen wie der Ablehnung von Transaktionen, hohen Gebühren oder anderen Umverteilungsmechanismen.

Indikatoren:

Suchen Sie nach Code-Segmenten, die die Größe oder den Wert von Transaktionen überprüfen, und solchen Zustandsvariablen (wie maxTransactionAmount oder whaleThreshold), die auf die Anwesenheit des AntiWhale-Mechanismus hinweisen können. AntiWhale betrifft hauptsächlich Benutzer mit großen Transaktionsvolumina und konzentriert sich auf die Bewältigung der Tokenkonzentration bei großen Inhabern.

Hauptunterschiede zwischen Cooldown und AntiWhale:

Verwendungsszenarien:

1. Minimierung von Markmanipulation:
   Beide Mechanismen können gemeinsam eingesetzt werden, um verschiedene Probleme der Markmanipulation anzugehen. Der AntiWhale-Mechanismus hilft dabei, die Größe großer Transaktionen zu begrenzen, während der Cooldown-Mechanismus verhindert, dass innerhalb kurzer Zeitintervalle schnell mehrere Transaktionen erfolgen.
   
   Angenommen, eine Entität besitzt einen bedeutenden Teil der Gesamt-Tokenversorgung. Ohne den AntiWhale-Mechanismus könnte diese Entität große Transaktionen tätigen, die erhebliche Preisschwankungen verursachen könnten, was zu Markmanipulation führt. Durch die Begrenzung der maximalen Größe oder Häufigkeit von Transaktionen an einer einzelnen Adresse innerhalb eines bestimmten Zeitraums zielt der AntiWhale-Mechanismus darauf ab, zu verhindern, dass große Inhaber einen unangemessenen Einfluss auf den Markt haben.


2. Sicherstellung einer fairen Verteilung:
   Im Kontext neuer Token oder Tokenverkäufe wird verhindert, dass eine kleine Anzahl von Teilnehmern einen unverhältnismäßigen Anteil an der Gesamtversorgung erwirbt. Die Festlegung von Grenzen für den maximalen Betrag, den eine individuelle Adresse während eines Tokenverkaufs oder innerhalb eines bestimmten Zeitraums erwerben kann, ermöglicht eine gleichmäßigere Verteilung der Token unter einer größeren Anzahl von Teilnehmern.


3. Bewältigung von Liquiditätsproblemen:
   Hohe Transaktionsvolumina großer Inhaber können die Liquidität beeinträchtigen und den natürlichen Preisfindungsprozess auf dezentralen Börsen stören. Indem die Geschwindigkeit von Transaktionen durch große Inhaber begrenzt wird, trägt der AntiWhale-Mechanismus dazu bei, eine stabilere Liquiditätssituation aufrechtzuerhalten.


4. Preisstabilisierung:
   Die Verhinderung von schnellen und groß angelegten Transaktionen kann helfen, die Preise zu stabilisieren. Durch die Durchsetzung von AntiWhale-Beschränkungen hat der Tokenpreis mehr Zeit, sich zwischen Transaktionen an die Marktbedingungen anzupassen.


5. Verhinderung von Front-Running:
   AntiWhale kann implementiert werden, um Front-Running zu bekämpfen, bei dem Händler zeitkritische Informationen nutzen, um Trades vor anderen auszuführen. Der AntiWhale-Mechanismus kann den Vorteil verringern, der durch schnelle Ausführung von Trades erlangt wird.


6. Abmilderung von Flash-Kredit- und Reentrancy-Angriffen:
   AntiWhale kann eine zusätzliche Verteidigungsebene gegen einige Flash-Kredit- und Reentrancy-Angriffe bieten, indem die Geschwindigkeit der Transaktionsausführung begrenzt wird.

Potentielle Risiken für Token-Inhaber:

1. Das Festlegen von zu engen AntiWhale-Grenzen kann ein Problem für Benutzer sein, die wirklich große Transaktionen benötigen.


2. Eine übermäßige Abhängigkeit vom AntiWhale-Mechanismus kann unbeabsichtigt die Zentralisierung fördern, wenn er implementiert wird, ohne das breitere Ökosystem zu berücksichtigen.

Wie können Sie unabhängig feststellen, ob solche Bedrohungen in Smart Contracts vorhanden sind?

Die Feststellung, ob ein AntiWhale-Beschränkungsmechanismus in einem Smart Contract vorhanden ist, ist eine wichtige Aufgabe. Hier sind einige Tipps, die Ihnen dabei helfen können:

1. Lernen Sie die Vertragsdokumentation kennen: Beginnen Sie mit der Überprüfung der Vertragsdokumentation und Spezifikationen.


2. Analysieren Sie die Transferfunktionen: Untersuchen Sie die Funktionen, die für die Übertragung von Tokens zuständig sind (transfer, transferFrom usw.). Suchen Sie nach bedingten Anweisungen, die Einschränkungen für Transaktionen auferlegen.


3. Überprüfen Sie Zeitstempelvergleiche: Suchen Sie nach Fällen, in denen der Vertrag Blockzeitstempel vergleicht.


4. Überprüfen Sie Zustandsvariablen: Untersuchen Sie Zustandsvariablen, die verwendet werden können, um AntiWhale-bezogene Informationen zu speichern.


5. Suchen Sie nach Funktionen oder Modifikatoren, die sich auf Zeitberechnungen beziehen, wie block.timestamp, block.number oder now.


6. Suchen Sie nach Parametern, die das Verhalten von AntiWhale steuern: Diese können maxTransferAmount, maxTxLimit und ähnliches sein. Diese Parameter werden häufig vom Vertragsinhaber festgelegt oder durch individuelle Transaktionsverwaltungsmechanismen eingestellt.


7. Analysieren Sie Ereignisprotokolle: Überprüfen Sie die Ereignisprotokolle auf besondere Ereignisse. Implementierungen können relevante Informationen protokollieren, wenn eine Transaktion ausgeführt wird, was Einblicke in den Abkühlungsprozess bietet.


8. Analysieren Sie benutzerspezifische Logik: Wenn Benutzerbeschränkungen im Vertrag implementiert sind, überprüfen Sie die Logik zur Bestimmung individueller Transferlimits. Diese Logik kann Benutzerattribute, Guthaben oder andere Kriterien umfassen.


9. Informieren Sie sich: Bleiben Sie über die neuesten Entwicklungen in unserer Community (Telegram-Kanal) und bewährte Verfahren zur Betrugserkennung (unser Blog und YouTube-Kanal) auf dem Laufenden.

Gute Nachrichten: Unser Security Scanner findet (einschließlich versteckter) Transferbeschränkungen (AntiWhale) in 90 % der Fälle erfolgreich. Nutzen Sie unser Premium-Abonnement und schützen Sie Ihre Mittel vor Bedrohungen.

Obwohl der AntiWhale-Mechanismus darauf ausgelegt ist, Marktmanipulationen zu verhindern und die Tokenverteilung sicherzustellen, können Betrüger seine Fähigkeiten nutzen, um Benutzer zu betrügen. Unten finden Sie einige mögliche Szenarien und Tipps zur Sicherung von Token-Investitionen mit aktiviertem AntiWhale-Mechanismus.

Beispiel 1: Beschränkungen für die Höhe der Transaktionen mit Abkühlzeit (Transaktionsbetragsbeschränkungen mit Abkühlung)

    uint256 public maxTransactionAmount = 1000000; // Maximum transaction amount
    uint256 public cooldownTime = 1 days; // Cooldown time between transactions
    
    mapping(address => uint256) private lastTransactionTimestamp;
    
    function transfer(address to, uint256 value) public {
        require(value <= maxTransactionAmount, "Exceeded maximum transaction amount");
        require(block.timestamp - lastTransactionTimestamp[msg.sender] >= cooldownTime, "Wait for cooldown period to end");
        ...
        lastTransactionTimestamp[msg.sender] = block.timestamp;
    }
  

Dieses Beispiel beschränkt den maximalen Betrag, den eine einzelne Adresse innerhalb eines bestimmten Zeitraums übertragen kann.

Es enthält einen Abkühlmechanismus, der eine Wartezeit zwischen Transaktionen derselben Adresse vorsieht. Das Array lastTransactionTimestamp speichert den Zeitstempel der letzten Transaktion für jede Adresse.

Beispiel 2: Dynamische Transaktionsbeschränkungen (Progressive Transaktionslimits)

    uint256 public initialMaxTransactionAmount = 500000; // Initial maximum transaction amount
    uint256 public maxTransactionIncreaseRate = 20000; // Maximum increase rate per transaction
    uint256 public cooldownTime = 2 days; // Cooldown time between 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, "Exceeded maximum transaction amount");
        ...
        lastTransactionTimestamp[msg.sender] = block.timestamp;
    }
  

Dieses Beispiel verwendet einen dynamischen Mechanismus, bei dem der maximale Transaktionsbetrag im Laufe der Zeit allmählich erhöht wird.

Der Parameter maxTransactionIncreaseRate steuert die Rate, mit der der maximale Transaktionsbetrag erhöht wird. Das Array lastTransactionTimestamp speichert den Zeitstempel der letzten Transaktion für jede Adresse.

Beispiel 3: Ausnahmen von der Whitelist (Whitelist-Ausnahmen)

    address[] public whitelistedAddresses;
    mapping(address => bool) public isWhitelisted;
    
    uint256 public maxTransactionAmount = 1000000; // Maximum transaction amount
    
    function transfer(address to, uint256 value) public {
        require(value <= maxTransactionAmount || isWhitelisted[msg.sender], "Exceeded maximum transaction amount");
        ...
    }
  

In diesem Beispiel werden Whitelist-Ausnahmen für bestimmte Adressen von AntiWhale-Beschränkungen verwendet.

Adressen im Array whitelistedAddresses sind von der Beschränkung der maximalen Transaktionsmenge ausgenommen. Das Array isWhitelisted bestimmt, ob eine bestimmte Adresse auf der Whitelist steht.

Beispiel 4: Gestaffelte Transaktionslimits (Gestaffelte Transaktionslimits)

    uint256[] public tieredLimits = [5000000, 2000000, 1000000]; // Tiered transaction limits for different address balances

    function transfer(address to, uint256 value) public {
        require(value <= getTransactionLimit(msg.sender), "Exceeded maximum transaction amount");
        ...
    }
    
    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];
        }
    }
  

Dieses Beispiel implementiert gestaffelte Transaktionslimits abhängig vom Guthaben der Senderadresse. Benutzer mit einem niedrigeren Guthaben haben ein höheres Transaktionslimit, und Benutzer mit einem höheren Guthaben haben ein niedrigeres Transaktionslimit.

Die Funktion getTransactionLimit bestimmt das geeignete Transaktionslimit basierend auf dem Guthaben des Benutzers.

Beispiel 5: Gebühren für große Transaktionen (Steuern auf große Transaktionen)

    uint256 public taxRate = 75; // 5% tax rate on transactions exceeding the limit
    uint256 public maxTransactionAmount = 1000000; // Maximum transaction amount
    
    function transfer(address to, uint256 value) public {
        if (value > maxTransactionAmount) {
            uint256 taxAmount = (value * taxRate) / 100;
            uint256 netTransferAmount = value - taxAmount;
    
            // Transfer logic here for the net transfer amount
            ...
        } else {
            // Transfer logic here for amounts within the limit
            ...
        }
    }
  

In diesem Beispiel wird eine Gebühr auf Transaktionen erhoben, die die maximale Transaktionsmenge überschreiten.

Der Steuersatz (TaxRate) bestimmt den Prozentsatz des Transaktionsbetrags. Die Steuer wird abgezogen und dann wird der Nettobetrag des Transfers verarbeitet.

Beispiel 6: Gestaffelte Limits (Transaktionslimits auf mehreren Ebenen)

    uint256 public maxTransactionAmount1 = 500000; // Maximum transaction amount for tier 1 (500,000 tokens)
    uint256 public maxTransactionAmount2 = 200000; // Maximum transaction amount for tier 2 (200,000 tokens)
    
    function transfer(address to, uint256 value) public {
        if (value <= maxTransactionAmount1) {
            ...
        } else if (value <= maxTransactionAmount2) {
            ...
        } else {
            revert("Exceeded maximum transaction amount");
        }
    }
  

Dieses Beispiel implementiert mehrere Ebenen von Transaktionslimits, bei denen je nach Höhe der Transaktion unterschiedliche Limits angewendet werden.

Dies ermöglicht es, Transaktionslimits für verschiedene Token-Volumina auf unterschiedlichen Granularitätsebenen festzulegen.

Beispiel 7: Dynamische Transaktionslimits abhängig vom Guthaben (Dynamische Transaktionslimits basierend auf Token-Guthaben)

    uint256 public maxTransactionPercentage = 5; // Maximum transaction percentage relative to total token supply
    
    function transfer(address to, uint256 value) public {
        uint256 maxTransactionAmount = (totalSupply() * maxTransactionPercentage) / 100;
        require(value <= maxTransactionAmount, "Exceeded maximum transaction amount");
        ...
    }
  

In diesem Beispiel wird der maximale Transaktionsbetrag dynamisch als Prozentsatz des Gesamtangebots berechnet. Der Parameter maxTransactionPercentage definiert den zulässigen Prozentsatz für eine einzelne Transaktion.

Beispiel 8: Zeitabhängige Limits (Zeitabhängige Transaktionslimits)

    uint256 public maxTransactionAmount = 1000000; // Maximum transaction amount (1 million tokens)
    uint256 public startTime = 1700000000; // Start time in Unix timestamp
    uint256 public endTime = 1800000000; // End time in Unix timestamp

    function transfer(address to, uint256 value) public {
        require(block.timestamp >= startTime && block.timestamp <= endTime, "Transaction not allowed at this time");
        require(value <= maxTransactionAmount, "Exceeded maximum transaction amount");
        ...
    }
  

In diesem Beispiel werden zeitabhängige Transaktionsbeschränkungen angewendet, die Transaktionen nur innerhalb eines festgelegten Zeitrahmens zulassen.

Die Parameter startTime und endTime definieren den Zeitraum, innerhalb dessen Transaktionen erlaubt sind.

Beispiel 9: Progressive Besteuerung (Progressive Besteuerung)

    uint256 public maxTransactionAmount = 1000000; // Maximum transaction amount (1 million tokens)
    uint256 public taxRate = 2; // Initial tax rate in percentage
    
    function transfer(address to, uint256 value) public {
        require(value <= maxTransactionAmount, "Exceeded maximum transaction amount");
    
        uint256 taxAmount = (value * taxRate) / 100;
        uint256 netTransferAmount = value - taxAmount;
    
        // Transfer logic here for the net transfer amount
        ...
    }
  

Dieses Beispiel stellt einen Mechanismus für progressive Besteuerung dar, bei dem eine Steuer (Gebühr) auf Transaktionen erhoben wird, die einen maximalen Betrag überschreiten.

Der Steuersatz kann im Laufe der Zeit angepasst oder auf bestimmte Bedingungen hin geändert werden.

Beispiel 10: Transaktionslimits basierend auf Haltersalden (Gewichtete Transaktionslimits basierend auf Token-Halter-Salden)

    uint256 public maxTotalTransactionAmount = 5000000; // Maximum total transaction amount for all token holders
    mapping(address => uint256) public userTransactionLimit; // Transaction limits based on individual token holder balances
    
    function transfer(address to, uint256 value) public {
        require(value <= maxTotalTransactionAmount, "Exceeded maximum total transaction amount");
        require(value <= userTransactionLimit[msg.sender], "Exceeded individual transaction limit");
        ...
    }
  

Dieses Beispiel implementiert Transaktionslimits basierend sowohl auf der Gesamtmenge der Transaktionen als auch auf dem Guthaben einzelner Token-Inhaber.

Die Zuordnung userTransactionLimit ermöglicht es Ihnen, personalisierte Limits basierend auf den Salden bestimmter Adressen festzulegen.

Wir hoffen, dass Ihnen diese Beispiele geholfen haben, den AntiWhale-Mechanismus in Smart Contracts besser zu verstehen.

Da alle Informationen in der Blockchain offen sind (vorausgesetzt natürlich, dass der Quellcode des Vertrags überprüft wird), können Sie mit diesem Wissen Smart Contracts unabhängig studieren und verschiedene Betrugsschemata identifizieren.

Aber wir haben das alles bereits für Sie erledigt! Melden Sie sich für ein Premium-Abonnement an und erhalten Sie Zugang zu exklusiven Filtern für Smart Contract-Funktionen und aktuellen Analysen. Erhöhen Sie Ihre Chancen auf erfolgreiche Investitionen in profitable Tokens.

Mit freundlichen Grüßen, Lotus Market Team.

All posts