In der "Dunklen Wald"-Umgebung von Solana ist der Wettbewerb bereits in den letzten Millisekunden angebrochen, sobald Sie ein Kontostatus-Update-Signal vom Scout-Modul erhalten. Wenn Sie die Transaktion an den RPC-Node zurückschicken müssen, um ein Angebot durch "Simulieren" zu erhalten, ist die Gelegenheit oft bereits von Wettbewerbern, die die Berechnungen lokal durchgeführt haben, weggenommen, wenn Sie das Ergebnis erhalten.

Ein echter professioneller Searcher wartet niemals auf die Rückmeldung des RPC. Sie pflegen eine lokale Kopie des AMM-Zustands im Arbeitsspeicher und berechnen sofort nach Erhalt der Binärdaten über ein mathematisches Modell den optimalen Preis.

Dieser Artikel wird erläutern, wie man einen effizienten lokalen Preisgestaltungs-Engine für Raydium (CPMM) und Orca (CLMM) aufbaut.

1. Kernidee: Lokale Berechnung vs. RPC-Simulation

1.1 Warum lokale Preisgestaltung wählen?

  • Extrem geringe Latenz: RPC-Simulation benötigt normalerweise 50ms-200ms, während lokale rein mathematische Berechnungen nur Mikrosekunden benötigen.

  • Konkurrenzfähigkeit: Lokale Berechnungen verbrauchen keine Leistung von RPC-Knoten und können sofort tausende von Arbitrage-Pfaden exhaustiv bewerten.

  • Determinismus: Durch die Analyse der ursprünglichen Kontodaten (Account Data) erhalten Sie eine tiefere Zustandskontrolle als durch Simulation.

2. Raydium (CPMM): Die Kunst des konstanten Produkts

Raydiums Standard-Pool folgt der klassischen Formel x×y=kx×y=k. Obwohl die Logik einfach ist, müssen bei der technischen Umsetzung kleine Abweichungen in der Genauigkeit und den Gebühren behandelt werden.

2.1 Kernpreisformel

Im Szenario mit Gebühren lautet die ganzzahlige Versionsformel zur Berechnung von amount_out:

  1. Mit Gebühren belastete Eingabe: AmountInwith_fee=AmountIn×(FeeDenominator−FeeNumerator)AmountInwith_fee​=AmountIn×(FeeDenominator−FeeNumerator)

  2. Ausgabeberechnung: AmountOut=AmountInwith_fee×ReserveoutReservein×FeeDenominator+AmountInwith_feeAmountOut=Reservein​×FeeDenominator+AmountInwith_fee​AmountInwith_fee​×Reserveout​​

2.2 Genauigkeitswettbewerb: Die Notwendigkeit von U256

Auf Solana ist die Tokenanzahl normalerweise u64. Aber bei der Berechnung des Zählers (Numerator) der obigen Formel führt das gleichzeitige Multiplizieren von zwei großen u64 sofort zu einem Überlauf.

  • Lösung: Einführung von U256 in die Berechnungsschicht. Obwohl die offizielle Rust-Bibliothek dies nicht direkt bereitstellt, können wir durch den uint-Makro oder die primitive-types-Bibliothek sicherstellen, dass wir auch bei sehr hoher Volatilität (große Eingaben) eine absolute Genauigkeit der Berechnungen beibehalten.

3. Orca Whirlpool (CLMM): Präzise Analyse der zentralen Liquidität

Im Vergleich zu CPMM ist Orcas zentriertes Liquiditätsmodell (CLMM) viel komplexer. Es betrifft nicht nur den Preis, sondern auch den Tick (Preisspanne) und die Liquiditätstiefe.

3.1 Darstellung des Preises: Q64.64 sqrtPrice

Orca verwendet den Quadratwurzelpreis (sqrtPrice) und speichert ihn im Q64.64 Gleitkommaformat.

  • Formel: Preis=(sqrtPriceX64264)2Preis=(264sqrtPriceX64​)2

  • Bei der Analyse müssen wir mit 128-Bit-Super-Integern arbeiten und echte Preise durch Bitverschiebungen extrahieren.

3.2 Blitzanalyse: Offset-Slicing-Methode

Die Kontostruktur von Orca's Whirlpool ist sehr umfangreich (einschließlich mehrerer Belohnungen, Gebührenparameter usw.), wenn man die vollständige Deserialisierung (Borsh Deserialize) verwendet, führt dies zu erheblichen Leistungsverlusten.
Industrieoptimierungslösung:
Direkte Positionierung von Offset (Verschiebung) auf den Binärdaten des Kontos. Da die Struktur des Pools fest ist, können wir die Schlüsselbytes direkt schneiden und lesen:

  • data[49..65] -> Liquidität (Liquidity)

  • data[65..81] -> Preis (sqrtPrice)

  • data[81..85] -> Aktueller Tick
    Diese Methode ist über 10 Mal schneller als die vollständige Analyse.

4. Architekturdesign: Preisangebotsschicht

Um sicherzustellen, dass die Strategieebene (Strategy) sich nicht um mathematische Unterschiede zwischen verschiedenen DEX kümmern muss, müssen wir eine einheitliche Preisgestaltungs-Engine erstellen:

Flussdiagramm LR
RawData[Originalkontodaten] -->|Analyse| AMMState[AMM-Speicherabbild]
AMMState -->|Eingabebetrag| LocalMath[Lokales mathematisches Modell]
LocalMath -->|Ausgabe| AmountOut[Strukturiertes Angebot]

Subgraph "Lokale Rechenleistungsschicht"
LocalMath
AMMState
Ende

Diese Engine wird den Vault-Balance (Goldsaldo) des Pools in Echtzeit pflegen. Wenn Scout eine Änderung in einem Vault erkennt, wird die Preisgestaltungs-Engine sofort das gesamte Preisspektrum für dieses Token-Paar neu berechnen.

5. Ingenieuroptimierung: Geschwindigkeit aus Details

  1. Nullzuweisungsberechnung: Vermeiden Sie nach Möglichkeit Speicherzuweisungen (Heap Allocation) während des Berechnungsprozesses und verwenden Sie native Typen auf dem Stack.

  2. Batch-RPC-Anfrage: Obwohl die Preisgestaltung lokal ist, muss der Vault-Saldo synchronisiert werden. Verwenden Sie getMultipleAccounts, um alle relevanten Vault-Zustände in einem Batch abzurufen und die Netzwerk-Roundtrips zu reduzieren.

  3. Vorberechnung: Für feste Parameter wie Gebührenraten die Analyse in der Kaltstartphase durchführen, vermeiden Sie es, in jedem Millisekunden-Hot-Path (Hot Path) wiederholt zu berechnen.

6. Technische Demonstration: CPMM-Preislogik (Python-Version)

Obwohl Produktionsumgebungen die extreme Leistung von Rust anstreben, kann die zugrunde liegende mathematische Logik klar in Python demonstriert werden:

# Hochleistungs-lokale Preisberechnung simulieren
def calculate_local_quote(amount_in, res_in, res_out, fee_pct=0.0025):
"""
CPMM lokale Preisgestaltung: x * y = k
"""
# Simulation der U256-Berechnung, um Überlauf zu vermeiden
fee_numerator = int(fee_pct * 10000)
fee_denominator = 10000

# 1. Berechnung des effektiven Eingabewertes nach Abzug der Gebühren
amount_in_with_fee = amount_in * (fee_denominator - fee_numerator)

# 2. Berechnung der Ausgabe gemäß der Formel.
Zähler = amount_in_with_fee * res_out
Nenner = (res_in * fee_denominator) + amount_in_with_fee

amount_out = Zähler // Nenner

# 3. Preisbeeinflussung berechnen (Price Impact)
preis_beeinflussung = (amount_out / res_out) wenn res_out > 0 sonst 1

return amount_out, preis_beeinflussung

# Simulation: 1 SOL gegen USDC, im Pool sind 1000 SOL / 100.000 USDC
out, impact = calculate_local_quote(1 10*9, 1000 10*9, 100000 10*6)
print(f"[*] Geschätzte Ausgabe: {out / 10**6} USDC")
print(f"[*] Preisbeeinflussung: {impact:.4%}")

7. Zusammenfassung: Rechenleistung gleich Erträge

In der Welt von Solana MEV bestimmt die Fähigkeit zur lokalen Preisgestaltung Ihre Wettbewerbsfähigkeit.

  • Anfänger verlassen sich auf RPC-Simulation und können nur die übrig gebliebene Suppe essen.

  • Fortgeschrittene Spieler implementieren CPMM lokal.

  • Fortgeschrittene Spieler können jeden Tick von CLMM präzise analysieren und in Kombination mit Jito atomare Arbitrage umsetzen.

Nächster Schritt Vorschau

Jetzt, wo wir „Scout“ und „Gehirn“ (AMM Math) haben, gehen wir zum aufregendsten Teil über: Wie entwickelt man eine Strategie für Arbitrage über DEX hinweg? Wie findet man den profitabelsten Pfad in einem komplexen Umfeld mit vielen Pfaden und Protokollen?

Dieser Artikel wurde von Levi.eth verfasst. Auf Solana kann jede Optimierung einer mathematischen Formel in greifbare On-Chain-Erträge umgewandelt werden.

JTO
JTOUSDT
0.4157
-9.37%
SOL
SOLUSDT
141.67
-3.36%