Erste Schritte mit dem Dexalot Python SDK

Diese Anleitung führt dich durch die Installation des Dexalot Python SDK, die Verbindung mit der Börse und das Ausführen deiner ersten Trades. Am Ende wirst du wissen, wie man Order Books liest, Orders platziert und storniert, Swaps ausführt und deine Guthaben prüft — alles direkt aus Python.

Wir halten es praxisnah. Jedes Beispiel hier ist etwas, das du sofort ausführen kannst.

Installation

Du brauchst Python 3.12 oder höher. Du kannst es für deine Plattform von python.org herunterladen und installieren. Nach dem Einrichten der Python-Umgebung installierst du das Dexalot Python SDK aus PyPi.

pip install dexalot-sdk

Oder wenn du uv verwendest (was wir für das schnellere Management von Abhängigkeiten empfehlen):

uv add dexalot-sdk

Als Nächstes erstellst du in deinem Projekt-Root eine .env-Datei mit der Umgebung, mit der du dich verbinden möchtest:

PARENTENV=fuji-multi

Das ist fuji-multi für Testnet oder production-multi, wenn du bereit für Mainnet bist. Für schreibgeschützte Vorgänge wie das Abrufen von Order Books und Token-Listen brauchst du das schon. Als Nächstes fügen wir Signing-Credentials hinzu. Du kannst die Datei env.example durchsuchen, um eine vollständige Liste der Variablen zu sehen, die du verwenden kannst.

Deine erste Verbindung

Das SDK ist async-first, daher laufen alle Operationen in einem async-Kontext. Hier ist die simpelste mögliche Verbindung — lies die verfügbaren Trading Pairs und gib die ersten paar aus:

import asyncio
from dexalot_sdk import DexalotClient

async def main():
    async with DexalotClient() as client:
        await client.initialize_client()

        pairs = await client.get_clob_pairs()
        if pairs.success:
            for pair in pairs.data[:5]:
                print(pair["pair"])
        else:
            print("Error:", pairs.error)

asyncio.run(main())

Ein paar Dinge, die du beachten solltest. Der Block async with übernimmt automatisch das Öffnen und Schließen der HTTP-Session für dich. Der Aufruf initialize_client() lädt die Konfiguration der Börse — Token-Metadaten, Contract-Adressen, Chain-Details — sodass der Client weiß, wie er mit dem Protokoll spricht. Und das Ergebnis kommt als Result-Objekt zurück: prüfe .success, bevor du auf .data zugreifst, und lies .error, falls etwas schiefgelaufen ist.

Dieses Muster — das Ergebnis prüfen und dann entsprechend handeln — ist konsistent bei jeder SDK-Methode. Keine versteckten Exceptions für erwartete Fehler.

Das Order Book lesen

Sobald du verbunden bist, ist das Abrufen des Order Books für ein Trading Pair nur eine Zeile:

ob = await client.get_orderbook("ALOT/USDC")
if ob.success:
    book = ob.data
    print("Best bid:", book["bids"][0])
    print("Best ask:", book["asks"][0])

Order-Book-Daten werden standardmäßig für eine Sekunde gecached, was bedeutet, dass schnelle aufeinanderfolgende Aufrufe die API nicht unnötig stressen. Wenn du für High-Frequency-Strategien aktuellere Daten brauchst, kannst du die Cache-TTL senken oder ihn komplett deaktivieren (mehr dazu weiter unten).

Einrichten eines Signers für Trading

Schreibgeschützter Zugriff ist nützlich, aber um Orders zu platzieren, Swaps auszuführen oder Gelder zu verschieben, brauchst du eine signierende Wallet. Der empfohlene Ansatz ist, ein Signer-Objekt direkt zu übergeben, sodass dein privater Schlüssel nie in einer Config-Datei landet:

from eth_account import Account

signer = Account.from_key("0xYOUR_PRIVATE_KEY")

async with DexalotClient(signer=signer) as client:
    await client.initialize_client()
    # Jetzt kannst du handeln

Für Produktions-Setups wird das SDK außerdem mit einem verschlüsselten Secrets-Tresor ausgeliefert. Er speichert deine Schlüssel in einer verschlüsselten Datei auf der Festplatte — nur die Schlüsselnamen sind sichtbar, die Werte sind im Ruhezustand verschlüsselt. Du generierst einmal einen Verschlüsselungsschlüssel, speicherst ihn in deinem Passwort-Manager und nutzt ihn, um den Tresor zur Laufzeit zu entsperren:

secrets-vault keygen          # generiere deinen Verschlüsselungsschlüssel, speichere ihn sicher
secrets-vault add PRIVATE_KEY 0xabc123...

Setze dann zur Laufzeit DEXALOT_SECRETS_VAULT_KEY als Umgebungsvariable oder lass das SDK dich auffordern. So bleibt dein Rohschlüssel komplett aus .env-Dateien und dem Quellcode-Management heraus.

Wichtig: Übermittle niemals private Schlüssel oder Verschlüsselungsschlüssel des Tresors an das Versionskontrollsystem. Nutze einen Passwort-Manager oder einen Secrets-Manager wie AWS Secrets Manager oder HashiCorp Vault für Produktionsumgebungen.

Platzieren deiner ersten Order

Mit einem verbundenen Signer sieht eine Limit-Buy-Order so aus:

result = await client.add_order(
    pair="ALOT/USDC",
    side="BUY",
    amount=100.0,
    price=0.15,
    order_type="LIMIT",
)
if result.success:
    print("Transaktion:", result.data["tx_hash"])
    print("Order-ID:", result.data["client_order_id"])
else:
    print("Fehlgeschlagen:", result.error)

Das SDK kümmert sich im Hintergrund um alles: Umwandlung deiner menschenlesbaren Beträge in das On-Chain-atomare Format, Verwaltung des Transaktions-Nonces, damit du keine Duplicate-Nonce-Fehler bekommst, Schätzung der Gas-Kosten, Signierung der Transaktion und das Einreichen. Du erhältst eine Transaktions-Hash und eine Client-Order-ID, die du später verwenden kannst, um die Order zu stornieren oder zu ersetzen.

Willst du sie stornieren?

result = await client.cancel_order(order_id="0xabc...")

Musst du alles stornieren?

result = await client.cancel_all_orders()

Batch-Operationen: Mehrere Orders in einem Rutsch

Wenn du mehrere Positionen verwaltest, unterstützt das SDK Batch-Operationen, die mehrere Orders in eine einzelne On-Chain-Transaktion bündeln. Das spart Gas und reduziert die Latenz:

orders = [
    {"pair": "ALOT/USDC", "side": "BUY", "amount": 50.0, "price": 0.14},
    {"pair": "ALOT/USDC", "side": "BUY", "amount": 75.0, "price": 0.13},
]
result = await client.add_limit_order_list(orders)

Es gibt außerdem eine atomare Cancel-and-Replace-Operation. Sie entfernt deine bestehenden Orders und platziert neue in derselben Transaktion — ohne Lücke, in der du nicht gehedgt bist:

result = await client.cancel_add_list(
    replacements=[
        {
            "order_id": "0xold...",
            "pair": "ALOT/USDC",
            "side": "BUY",
            "amount": 100.0,
            "price": 0.16,
        }
    ],
)

Für Market Maker, die ihre Quotes ständig aktualisieren müssen, ist das ein Game-Changer.

Schnelle Swaps ohne Order Book

Nicht jeder Trade braucht die Präzision einer Limit-Order. Das SDK enthält einen einfachen Swap-Flow auf Basis von Request-for-Quote (RFQ)-Preisbildung. Er funktioniert in drei Schritten: den Richtpreis prüfen, eine verbindliche Quote festlegen und ausführen.

# Schritt 1: Soft Quote — sieh dir an, wie der Preis aussieht, ohne Verpflichtung
soft = await client.get_swap_soft_quote(
    from_token="ALOT", to_token="USDC", amount=100.0
)

# Schritt 2: Firm Quote — fixiert den Preis für 30 Sekunden
firm = await client.get_swap_firm_quote(
    from_token="ALOT", to_token="USDC", amount=100.0
)

# Schritt 3: Swap ausführen
if firm.success:
    result = await client.execute_rfq_swap(firm.data)

Das ist ideal für Anwendungen, die eine unkomplizierte "A zu B konvertieren"-Schnittstelle benötigen, ohne das Platzieren von Orders und Fills managen zu müssen.

Kontostände prüfen und Gelder verschieben

Das SDK gibt dir volle Transparenz über deine Guthaben über dein Dexalot-Portfolio hinweg sowie über verbundene Chain-Wallets:

# Alle Portfolio-Guthaben
result = await client.get_all_portfolio_balances()
if result.success:
    for token, balance in result.data.items():
        print(token, "Total:", balance["total"], "Verfügbar:", balance["available"])

# Ein einzelner Token
result = await client.get_portfolio_balance(token="USDC")

So bewegst du Gelder hinein oder hinaus:

# Einzahlung von einer verbundenen Chain
await client.deposit(token="USDC", amount=100.0, source_chain="Avalanche")

# Auszahlung zurück auf eine Chain
await client.withdraw(token="USDC", amount=50.0, target_chain="Avalanche")

Den Cache für deinen Use Case abstimmen

Das SDK cached API-Antworten auf vier Ebenen, wobei jede Ebene dazu passt, wie schnell sich diese Daten tatsächlich ändern:

• Statische Daten (Umgebungen, Chains): cached 1 Stunde
• Semi-statische Daten (Tokens, Trading-Paare): cached 15 Minuten
• Guthaben: cached 10 Sekunden
• Orderbuch: cached 1 Sekunde

Diese Default-Werte funktionieren gut für die meisten Anwendungen. Aber wenn du einen High-Frequency-Bot baust, wirst du möglicherweise eine Orderbuch-Frische unter einer Sekunde benötigen — setze cache_ttl_orderbook=0.5 für ein Ablaufintervall von 500 Millisekunden.

client = DexalotClient(
    cache_ttl_orderbook=0.5,   # 500 Millisekunden
    cache_ttl_balance=1,       # 1 Sekunde
)

Bastelst du an einem Dashboard, das keine Echtzeitdaten braucht? Erhöhe die TTLs und reduziere deinen API-Footprint drastisch. Für die Entwicklung kannst du das Caching mit enable_cache=False komplett deaktivieren.

Live-Marktdaten mit WebSocket

Für Echtzeit-Orderbuch-Updates aktiviere den WebSocket-Manager, indem du in deiner Konfiguration ws_manager_enabled=True setzt, und abonniere dann Events mit client.subscribe_to_events(). Gib einen Topic-String wie "OrderBook/ALOT/USDC" weiter und eine asynchrone Callback-Funktion, die jedes Event als Dictionary erhält.

async def on_orderbook_update(event):
    print("Update:", event)

config = DexalotConfig(ws_manager_enabled=True)

async with DexalotClient(config=config, signer=signer) as client:
    await client.initialize_client()
    await client.subscribe_to_events(
        topic="OrderBook/ALOT/USDC",
        callback=on_orderbook_update,
    )
    await asyncio.sleep(60)  # listen for a minute

Die WebSocket-Verbindung übernimmt das automatische Reconnecten. Dein Callback ist eine asynchrone Funktion, die auf der Event-Loop läuft, sodass sie mit dem Rest deiner Trading-Logik auf natürliche Weise interagieren kann.

Konfiguration auf einen Blick

Alles ist über Konstruktor-Argumente, Umgebungsvariablen oder eine .env-Datei konfigurierbar. Konstruktor-Argumente haben stets Vorrang. Hier sind die am häufigsten angepassten Optionen:

Resilienz-Funktionen, die du kostenlos bekommst

Ein paar Dinge, die das SDK automatisch übernimmt und die man wissen sollte:

Retry mit Backoff. Wenn ein API-Call oder eine RPC-Request aufgrund eines transienten Fehlers fehlschlägt, versucht das SDK es mit exponentiellem Backoff erneut. Die Defaults sind sinnvoll (einige Retries mit zunehmenden Verzögerungen), aber du kannst sie an deine Toleranz anpassen. Das bedeutet, dass dein Bot nicht wegen einer einzigen abgebrochenen Verbindung abstürzt.

RPC-Failover. Du kannst mehrere RPC-Provider-URLs pro Chain konfigurieren. Wenn einer anfängt, konsistent zu fehlschlagen, wechselt das SDK automatisch zum nächsten. Fehlgeschlagene Provider gehen in eine Cooldown-Phase, bevor sie erneut versucht werden. Wenn alles ausfällt, wird auf den letzten funktionierenden Provider zurückgefallen.

Rate Limiting. Das SDK erzwingt Rate Limits sowohl für API-Calls als auch für RPC-Requests mithilfe eines Token-Bucket-Algorithmus. Die Defaults (5 API-Requests pro Sekunde, 10 RPC-Calls pro Sekunde) halten dich innerhalb typischer serverseitiger Limits. Wenn du mehrere Instanzen von Clients betreibst, denke daran, dass jede Instanz ihren eigenen Limiter hat — sie teilen sich kein globales Kontingent.

Error-Sanitization. Wenn etwas schiefgeht, werden die Fehlermeldungen, die du in result.error siehst, bereinigt — keine Dateipfade, keine RPC-URLs, keine Stacktraces dringen durch. In der Produktion verhindert das eine versehentliche Offenlegung von Infrastrukturdaten. Für Debugging setze log_level auf DEBUG, um den vollständigen Kontext in deinen Logs zu sehen.

Wie geht es von hier aus weiter?

Dieser Guide behandelt das Wesentliche, aber das SDK hat mehr Tiefe, als wir hier unterbringen konnten. Für das vollständige Bild:

• User Guide — behandelt jede Methode mit vollständigen Beispielen
• Architecture Overview — erklärt das interne Design für Contributor
• Caching Guide — detailliertes TTL-Tuning für verschiedene Anwendungsprofile
• API Reference — automatisch generierte Doku aus dem Quellcode

Das SDK ist Open Source. Wenn du einen Fehler findest, eine Funktion hinzufügen möchtest oder eine Frage hast, ist das Repository der richtige Ort.

Starte im Testnet, mach dich mit der API vertraut und wenn deine Strategie bereit ist — wechselst du ins Mainnet, indem du einfach eine Umgebungsvariable änderst.

Python SDK | GitHub: github.com/Dexalot/dexalot-sdk-python ⧉

Python SDK | PyPi: pypi.org/project/dexalot-sdk ⧉

Viel Spaß beim Bauen.