TWAP und VWAP über die Hyperliquid API ausführen

• TWAP VWAP Hyperliquid

• Hyperliquid Execution API

• TWAP Algorithmic Trading

• Hyperliquid große Orders splitten

• VWAP On-Chain Perpetuals

Wenn eine Order groß genug ist, kann eine direkte Market Order spürbaren Price Impact verursachen: Deine eigene Kauforder treibt den Preis nach oben, wodurch der durchschnittliche Einstieg deutlich schlechter ausfallen kann als geplant. Professionelle Marktteilnehmer nutzen dafür seit langem Execution-Algorithmen. Zwei der bekanntesten sind TWAP (Time-Weighted Average Price) und VWAP (Volume-Weighted Average Price).

Die offene API von Hyperliquid macht es auch einzelnen Entwicklern möglich, solche Strategien im Markt für On-Chain Perpetuals umzusetzen. In diesem Artikel schauen wir uns an, wie TWAP und VWAP funktionieren, wie man sie grundsätzlich über die Hyperliquid API implementieren kann und wann welcher Ansatz sinnvoll ist. Wenn du nicht selbst coden möchtest, bietet OneKey Perps einen einfachen Zugang zum Handel mit On-Chain Perpetuals, ohne dass du eigene Ausführungsalgorithmen bauen musst.

Was ist TWAP?

Die Kernidee von TWAP ist einfach: Eine große Order wird gleichmäßig über die Zeit aufgeteilt. In festen Zeitabständen wird jeweils eine kleinere Teilorder platziert. Der finale Durchschnittspreis nähert sich dadurch dem zeitgewichteten Durchschnittspreis des gewählten Zeitraums an.

Beispiel: Du möchtest innerhalb von 1 Stunde BTC-Perpetuals im Wert von 1 Million US-Dollar kaufen. Eine TWAP-Strategie könnte diese Order in 60 Teilorders aufteilen und jede Minute eine Order über rund 16.700 US-Dollar ausführen. Unabhängig von kurzfristigen Schwankungen liegt der Durchschnittspreis dann näher am Zeitdurchschnitt dieser Stunde, statt durch eine einzelne große Market Order starken Impact zu erzeugen.

Der Vorteil von TWAP: Die Umsetzung ist relativ einfach und benötigt keine Echtzeitdaten zum Handelsvolumen. Der Nachteil: TWAP unterscheidet nicht zwischen aktiven und illiquiden Marktphasen. Auch in Phasen mit geringer Liquidität wird planmäßig ausgeführt, was zu höherem Slippage führen kann.

Was ist VWAP?

VWAP geht einen Schritt weiter. Der Algorithmus berücksichtigt nicht nur Zeit, sondern auch Volumen. Er schätzt oder nutzt die Volumenverteilung über verschiedene Zeitfenster und platziert mehr Ordervolumen in Phasen mit hoher Marktaktivität und weniger in Phasen mit geringem Volumen. Ziel ist ein durchschnittlicher Ausführungspreis, der möglichst nah am volumengewichteten Durchschnittspreis des Marktes liegt.

VWAP benötigt historische oder Echtzeit-Volumendaten und ist daher komplexer als TWAP. In Märkten, in denen Liquidität ungleich über den Tag verteilt ist, kann VWAP jedoch oft niedrigere Ausführungskosten erzielen.

Warum sind diese Strategien on-chain wichtig?

Bei On-Chain Perpetuals können Markttiefe und Price Discovery je nach Zeitpunkt deutlich variieren. Auch die Eigenschaften eines On-Chain-Matching-Engines führen dazu, dass große Orders das Orderbuch etwas anders beeinflussen können als auf klassischen zentralisierten Börsen.

Für Hyperliquid solltest du die offizielle Dokumentation zur Orderbuch-Tiefe, zu Gebühren und zur API-Struktur heranziehen, bevor du Parameter für einen Algorithmus festlegst. Diese Daten sind entscheidend, um Ordergröße, Slippage-Toleranz und Ausführungsintervalle realistisch zu wählen.

TWAP und VWAP im Vergleich

Für viele einzelne Entwickler ist TWAP der bessere Startpunkt. VWAP lohnt sich eher, wenn du ausreichend Daten sammelst, Volumenmuster analysierst und deine Ausführungslogik sauber testen kannst.

TWAP mit der Hyperliquid REST API umsetzen

Grundidee

Über die Order-API von Hyperliquid kannst du wiederholt Teilorders platzieren und zwischen den Ausführungen ein festes Zeitintervall abwarten:

import time
import math

def execute_twap(exchange, info, coin, total_size, is_buy, duration_seconds, num_slices):
    """
    Teilt total_size über duration_seconds in num_slices gleich große Orders auf.
    """
    slice_size = total_size / num_slices
    interval = duration_seconds / num_slices

    for i in range(num_slices):
        # Aktuellen Mark Price abrufen
        ctx = info.meta_and_asset_ctxs()
        mark_px = get_mark_price(ctx, coin)

        # Market Order mit definierter Slippage-Toleranz
        # Alternativ kann eine Limit Order nahe am Orderbuch genutzt werden
        result = exchange.market_open(
            coin=coin,
            is_buy=is_buy,
            sz=round(slice_size, 4),
            slippage=0.005  # 0,5 % tolerierte Slippage
        )

        print(f"[{i+1}/{num_slices}] Ausführung: {result}")

        if i < num_slices - 1:
            time.sleep(interval)

    print("TWAP-Ausführung abgeschlossen")

In einer produktiven Umgebung brauchst du zusätzliche Schutzmechanismen, unter anderem:

• Retry-Logik bei API- oder Netzwerkfehlern
• Behandlung von Teilausführungen
• Logging aller Teilorders
• Positions- und Margin-Prüfung vor jeder Order
• automatische Pause bei extremen Marktbewegungen

Verbesserung: Limit Orders zur Kostensenkung

Statt jede Teilorder als Market Order zu platzieren, kannst du Limit Orders verwenden, die leicht besser als der aktuelle Marktpreis liegen. Das kann Gebühren und Slippage reduzieren, bringt aber das Risiko mit sich, dass die Order nicht ausgeführt wird.

Eine typische Lösung ist ein Timeout: Wird die Limit Order innerhalb einer bestimmten Zeit nicht gefüllt, wird sie storniert und die Restmenge per Market Order ausgeführt.

def place_with_timeout(exchange, coin, is_buy, sz, limit_px, timeout_seconds=30):
    result = exchange.order(
        coin=coin,
        is_buy=is_buy,
        sz=sz,
        limit_px=limit_px,
        order_type={"limit": {"tif": "Gtc"}}
    )

    oid = result["response"]["data"]["statuses"][0]["resting"]["oid"]

    time.sleep(timeout_seconds)

    # Prüfen, ob die Order noch offen ist
    open_orders = get_open_orders(coin)

    if any(o["oid"] == oid for o in open_orders):
        exchange.cancel(coin=coin, oid=oid)

        # Restmenge per Market Order ausführen
        exchange.market_open(
            coin=coin,
            is_buy=is_buy,
            sz=get_remaining_size(oid),
            slippage=0.01
        )

In der Praxis solltest du zusätzlich absichern, dass get_remaining_size() korrekt mit Teilausführungen umgeht und keine doppelte Ausführung entsteht.

Echtzeit-VWAP mit WebSocket-Tradedaten berechnen

Für VWAP musst du laufend Preis mal Volumen aufsummieren und durch das Gesamtvolumen teilen:

class VWAPTracker:
    def __init__(self):
        self.cumulative_pv = 0.0  # Summe aus price * volume
        self.cumulative_v = 0.0   # Summe des Volumens

    def on_trade(self, price, size):
        self.cumulative_pv += price * size
        self.cumulative_v += size

    @property
    def vwap(self):
        if self.cumulative_v == 0:
            return None
        return self.cumulative_pv / self.cumulative_v

Über WebSocket kannst du den Trade-Stream von Hyperliquid abonnieren. Jede neue Transaktion ruft on_trade auf und aktualisiert den VWAP in Echtzeit. Ein VWAP-Execution-Algorithmus vergleicht diesen Wert anschließend mit dem aktuellen Marktpreis und entscheidet, ob die nächste Teilorder ausgeführt, reduziert oder verschoben wird.

Das genaue WebSocket-Format und die verfügbaren Subscriptions solltest du in der offiziellen Hyperliquid-Dokumentation prüfen, da API-Details sich ändern können.

Hinweise zur Parameterauswahl

Bei TWAP und VWAP hängen die Ergebnisse stark von den Parametern ab. Wichtige Stellschrauben sind:

• Gesamtdauer: Je länger die Ausführung, desto geringer kann der unmittelbare Impact sein. Gleichzeitig steigt das Risiko, dass sich der Markt gegen dich bewegt.
• Anzahl der Slices: Mehr Teilorders bedeuten feinere Ausführung, aber auch mehr API-Aufrufe und potenziell mehr operative Komplexität.
• Slippage-Toleranz: Zu eng kann zu fehlgeschlagenen Orders führen, zu weit kann unnötig schlechte Ausführungen erlauben.
• Ordertyp: Market Orders sind zuverlässiger, Limit Orders können günstiger sein, werden aber nicht garantiert gefüllt.
• Pausenlogik: Bei starken Preisbewegungen kann es sinnvoll sein, die Ausführung automatisch zu pausieren.
• Positionsgröße: Je größer die Order im Verhältnis zur Markttiefe ist, desto wichtiger wird eine saubere Ausführungslogik.

Teste solche Strategien zunächst mit kleinen Beträgen und dokumentiere jede Ausführung, bevor du größere Orders darüber laufen lässt.

Vergleich mit anderen DEX-Execution-Ansätzen

• dYdX unterstützt ebenfalls Orderplatzierung über REST APIs. Eine ähnliche TWAP-Logik lässt sich dort grundsätzlich umsetzen.
• GMX arbeitet stärker mit Oracle-basierten Preismechanismen, weshalb sich die Ausführungslogik von orderbuchbasierten Märkten unterscheidet.
• Hyperliquid ist durch sein Orderbuchmodell näher an zentralisierten Börsen. Viele Konzepte aus CEX-Execution, darunter TWAP und VWAP, lassen sich daher vergleichsweise direkt übertragen.

Keine Lust zu coden? Probiere OneKey Perps

Nicht jeder Nutzer muss eigene Execution-Algorithmen schreiben. OneKey Perps bietet eine übersichtliche Oberfläche für den Handel mit On-Chain Perpetuals und kombiniert sie mit sicherem Signieren über OneKey Hardware Wallets. So kannst du auf Hyperliquid handeln, ohne selbst API-Skripte, WebSocket-Listener oder Retry-Logik zu bauen.

Für mittelgroße Trades kann bereits ein praktischer Workflow helfen: Limit Orders sinnvoll setzen, Positionen manuell in mehrere Tranchen aufteilen und die Markttiefe vor jeder Ausführung prüfen. Das ersetzt keinen vollautomatischen Algorithmus, kann aber den Impact gegenüber einer einzelnen großen Market Order reduzieren.

Wenn du eine sichere und einfache Einstiegsumgebung suchst, lade OneKey herunter, verbinde dein Wallet und teste OneKey Perps zunächst mit kleinen Beträgen. So bekommst du ein Gefühl für Orderbuch, Slippage und Perpetual-Risiken, bevor du größere Positionen handelst.

Häufige Fragen

Q1: Ist TWAP oder VWAP besser für Hyperliquid geeignet?

Für die meisten einzelnen Entwickler ist TWAP einfacher und robuster umzusetzen. VWAP kann sinnvoll sein, wenn das Handelsvolumen auf dem jeweiligen Markt erkennbare Muster hat und du genügend historische sowie Echtzeitdaten auswerten kannst. Ein pragmatischer Ansatz ist: zuerst TWAP sauber beherrschen, Daten sammeln und danach VWAP testen.

Q2: Können Execution-Algorithmen Market Impact vollständig vermeiden?

Nein. Sie können Market Impact reduzieren, aber nicht vollständig eliminieren. Die Untergrenze der Ausführungskosten hängt vor allem vom Verhältnis deiner Ordergröße zur verfügbaren Liquidität ab. Der Algorithmus verteilt den Impact über Zeit und liquidere Phasen, er entfernt ihn nicht.

Q3: Wie bewertet man die Qualität der Ausführung?

Üblich ist der Vergleich zwischen dem tatsächlichen durchschnittlichen Ausführungspreis und einem Benchmark wie TWAP oder VWAP im Ausführungszeitraum. Diese Abweichung wird oft als Implementation Shortfall betrachtet. Dafür solltest du jede Teilorder mit Zeitstempel, Größe, Preis, Gebühren und Ordertyp protokollieren.

Q4: Kann ein OneKey Hardware Wallet mit Execution-Skripten integriert werden?

Ja. OneKey unterstützt standardisierte Ethereum-Signaturflüsse. Ein Algorithmus kann zu signierende Nachrichten an einen lokalen Signing-Service oder an das Wallet weitergeben und die signierte Transaktion anschließend an Hyperliquid übermitteln. Bei eher niedrigfrequenten Strategien wie TWAP ist die Signaturlatenz in vielen Fällen unproblematisch. Trotzdem solltest du den kompletten Ablauf gründlich testen.

Q5: Was passiert bei starken Marktbewegungen während der Ausführung?

Du solltest eine Preis-Schutzlogik einbauen. Wenn der Marktpreis beispielsweise mehr als einen festgelegten Schwellenwert, etwa 2 %, vom Startpreis abweicht, kann der Algorithmus automatisch pausieren oder die Ausführung abbrechen. So vermeidest du, in einem stark ungünstigen Marktumfeld weiter Position aufzubauen.

Fazit

TWAP und VWAP sind bewährte Werkzeuge, um die Ausführungskosten großer Orders zu reduzieren. Durch die offene API von Hyperliquid lassen sie sich auch im Markt für On-Chain Perpetuals einsetzen. Ob per Code oder durch manuelles Aufteilen: Die Grundidee bleibt gleich — Ausführung über Zeit verteilen, Impact reduzieren und den durchschnittlichen Einstieg kontrollierter gestalten.

Wenn du nicht selbst entwickeln möchtest, ist OneKey Perps ein praktischer Startpunkt für den Handel mit On-Chain Perpetuals. Lade OneKey herunter, nutze OneKey Perps und beginne mit kleinen, gut kontrollierten Trades, bevor du komplexere Workflows oder größere Positionen nutzt.

Risikohinweis: Execution-Algorithmen garantieren keinen bestimmten Ausführungspreis. Marktvolatilität, geringe Liquidität, technische Fehler oder API-Probleme können dazu führen, dass die tatsächlichen Kosten deutlich von der Erwartung abweichen. Der Handel mit Perpetuals ist hochriskant und kann zum teilweisen oder vollständigen Verlust deines Kapitals führen. Dieser Artikel dient nur als technische Information und stellt keine Anlage-, Rechts- oder Finanzberatung dar. Handle nur, wenn du die Risiken verstehst und deine persönliche Situation berücksichtigt hast.