[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"article-deep-evm-14-arbitrage-zyklen-finder-dfs-pool-graph":3},{"article":4,"author":54},{"id":5,"category_id":6,"title":7,"slug":8,"excerpt":9,"content_md":10,"content_html":11,"locale":12,"author_id":13,"published":14,"published_at":15,"meta_title":7,"meta_description":16,"focus_keyword":17,"og_image":18,"canonical_url":18,"robots_meta":19,"created_at":15,"updated_at":15,"tags":20,"category_name":34,"related_articles":35},"d7000000-0000-0000-0000-000000000114","a0000000-0000-0000-0000-000000000076","Deep EVM #14: Arbitrage-Zyklen-Finder — DFS auf einem Pool-Graphen","deep-evm-14-arbitrage-zyklen-finder-dfs-pool-graph","Einen Produktions-Arbitrage-Zyklen-Finder in Rust mit Tiefensuche auf einem Token-Pool-Graphen bauen. Tausende Pools, Millionen Zyklen und Deduplizierung mit keccak256.","## Das Problem\n\nArbitrage in DeFi bedeutet, Preisunterschiede zwischen Liquiditaetspools auszunutzen. Aber wie findet man profitable Zyklen unter Tausenden von Pools?\n\nDer Token-Pool-Graph modelliert das Problem:\n- **Knoten:** Token (ETH, USDC, DAI, ...)\n- **Kanten:** Liquiditaetspools (Uniswap V2-Paare, V3-Pools, Curve-Pools)\n- **Zyklen:** Pfade, die zum Start-Token zurueckkehren\n\nEin Arbitrage-Zyklus beginnt und endet beim selben Token (z.B. ETH -> USDC -> DAI -> ETH) und ist profitabel, wenn das Produkt der Wechselkurse > 1 ist.\n\n## Tiefensuche (DFS) fuer Zyklen\n\n```rust\nuse std::collections::{HashMap, HashSet};\n\nstruct PoolGraph {\n    adjacency: HashMap\u003CAddress, Vec\u003C(Address, Pool)>>,\n}\n\nimpl PoolGraph {\n    fn find_cycles(\n        &self,\n        start: Address,\n        max_hops: usize,\n    ) -> Vec\u003CVec\u003CPool>> {\n        let mut cycles = Vec::new();\n        let mut path = Vec::new();\n        let mut visited = HashSet::new();\n        \n        self.dfs(\n            start,\n            start,\n            max_hops,\n            &mut path,\n            &mut visited,\n            &mut cycles,\n        );\n        cycles\n    }\n    \n    fn dfs(\n        &self,\n        current: Address,\n        target: Address,\n        remaining_hops: usize,\n        path: &mut Vec\u003CPool>,\n        visited: &mut HashSet\u003CAddress>,\n        cycles: &mut Vec\u003CVec\u003CPool>>,\n    ) {\n        if remaining_hops == 0 { return; }\n        \n        if let Some(neighbors) = self.adjacency.get(&current) {\n            for (next_token, pool) in neighbors {\n                if *next_token == target && !path.is_empty() {\n                    \u002F\u002F Zyklus gefunden!\n                    let mut cycle = path.clone();\n                    cycle.push(pool.clone());\n                    cycles.push(cycle);\n                    continue;\n                }\n                \n                if visited.contains(next_token) { continue; }\n                \n                visited.insert(*next_token);\n                path.push(pool.clone());\n                self.dfs(*next_token, target, remaining_hops - 1,\n                         path, visited, cycles);\n                path.pop();\n                visited.remove(next_token);\n            }\n        }\n    }\n}\n```\n\n## Skalierung: Millionen von Zyklen\n\nMit 5.000+ Pools auf Ethereum explodiert die Anzahl moeglicher Zyklen. Strategien zur Bewaeltigung:\n\n### 1. Hop-Begrenzung\nBeschraenke die maximale Zykluslaenge auf 3-4 Hops. Laengere Zyklen haben selten genug Profit, um die Gaskosten zu decken.\n\n### 2. Deduplizierung mit keccak256\nSortiere die Pool-Adressen in jedem Zyklus und hashe sie:\n```rust\nuse tiny_keccak::{Hasher, Keccak};\n\nfn cycle_hash(pools: &[Pool]) -> [u8; 32] {\n    let mut sorted: Vec\u003CAddress> = pools.iter()\n        .map(|p| p.address)\n        .collect();\n    sorted.sort();\n    \n    let mut hasher = Keccak::v256();\n    for addr in &sorted {\n        hasher.update(addr.as_bytes());\n    }\n    let mut output = [0u8; 32];\n    hasher.finalize(&mut output);\n    output\n}\n```\n\n### 3. Parallelisierung\nVerwende rayon fuer parallele DFS auf verschiedenen Start-Token:\n```rust\nuse rayon::prelude::*;\n\nlet all_cycles: Vec\u003CVec\u003CPool>> = tokens.par_iter()\n    .flat_map(|token| graph.find_cycles(*token, 4))\n    .collect();\n```\n\n## Profitabilitaetsberechnung\n\nFuer jeden gefundenen Zyklus berechnen Sie den erwarteten Gewinn:\n\n```rust\nfn calculate_profit(\n    cycle: &[Pool],\n    amount_in: U256,\n) -> Option\u003CU256> {\n    let mut current_amount = amount_in;\n    \n    for pool in cycle {\n        current_amount = pool.get_amount_out(current_amount)?;\n    }\n    \n    if current_amount > amount_in {\n        Some(current_amount - amount_in)\n    } else {\n        None\n    }\n}\n```\n\n## Fazit\n\nDer Arbitrage-Zyklen-Finder ist der erste Schritt in der MEV-Pipeline. Er identifiziert alle moeglichen profitablen Pfade auf dem DEX-Graphen. Die naechsten Schritte — Simulation, optimale Eingabemenge und Bundle-Erstellung — bauen auf diesen Zyklen auf.","\u003Ch2 id=\"das-problem\">Das Problem\u003C\u002Fh2>\n\u003Cp>Arbitrage in DeFi bedeutet, Preisunterschiede zwischen Liquiditaetspools auszunutzen. Aber wie findet man profitable Zyklen unter Tausenden von Pools?\u003C\u002Fp>\n\u003Cp>Der Token-Pool-Graph modelliert das Problem:\u003C\u002Fp>\n\u003Cul>\n\u003Cli>\u003Cstrong>Knoten:\u003C\u002Fstrong> Token (ETH, USDC, DAI, …)\u003C\u002Fli>\n\u003Cli>\u003Cstrong>Kanten:\u003C\u002Fstrong> Liquiditaetspools (Uniswap V2-Paare, V3-Pools, Curve-Pools)\u003C\u002Fli>\n\u003Cli>\u003Cstrong>Zyklen:\u003C\u002Fstrong> Pfade, die zum Start-Token zurueckkehren\u003C\u002Fli>\n\u003C\u002Ful>\n\u003Cp>Ein Arbitrage-Zyklus beginnt und endet beim selben Token (z.B. ETH -> USDC -> DAI -> ETH) und ist profitabel, wenn das Produkt der Wechselkurse > 1 ist.\u003C\u002Fp>\n\u003Ch2 id=\"tiefensuche-dfs-fuer-zyklen\">Tiefensuche (DFS) fuer Zyklen\u003C\u002Fh2>\n\u003Cpre>\u003Ccode class=\"language-rust\">use std::collections::{HashMap, HashSet};\n\nstruct PoolGraph {\n    adjacency: HashMap<Address, Vec<(Address, Pool)>>,\n}\n\nimpl PoolGraph {\n    fn find_cycles(\n        &self,\n        start: Address,\n        max_hops: usize,\n    ) -> Vec<Vec<Pool>> {\n        let mut cycles = Vec::new();\n        let mut path = Vec::new();\n        let mut visited = HashSet::new();\n        \n        self.dfs(\n            start,\n            start,\n            max_hops,\n            &mut path,\n            &mut visited,\n            &mut cycles,\n        );\n        cycles\n    }\n    \n    fn dfs(\n        &self,\n        current: Address,\n        target: Address,\n        remaining_hops: usize,\n        path: &mut Vec<Pool>,\n        visited: &mut HashSet<Address>,\n        cycles: &mut Vec<Vec<Pool>>,\n    ) {\n        if remaining_hops == 0 { return; }\n        \n        if let Some(neighbors) = self.adjacency.get(&current) {\n            for (next_token, pool) in neighbors {\n                if *next_token == target && !path.is_empty() {\n                    \u002F\u002F Zyklus gefunden!\n                    let mut cycle = path.clone();\n                    cycle.push(pool.clone());\n                    cycles.push(cycle);\n                    continue;\n                }\n                \n                if visited.contains(next_token) { continue; }\n                \n                visited.insert(*next_token);\n                path.push(pool.clone());\n                self.dfs(*next_token, target, remaining_hops - 1,\n                         path, visited, cycles);\n                path.pop();\n                visited.remove(next_token);\n            }\n        }\n    }\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Ch2 id=\"skalierung-millionen-von-zyklen\">Skalierung: Millionen von Zyklen\u003C\u002Fh2>\n\u003Cp>Mit 5.000+ Pools auf Ethereum explodiert die Anzahl moeglicher Zyklen. Strategien zur Bewaeltigung:\u003C\u002Fp>\n\u003Ch3>1. Hop-Begrenzung\u003C\u002Fh3>\n\u003Cp>Beschraenke die maximale Zykluslaenge auf 3-4 Hops. Laengere Zyklen haben selten genug Profit, um die Gaskosten zu decken.\u003C\u002Fp>\n\u003Ch3>2. Deduplizierung mit keccak256\u003C\u002Fh3>\n\u003Cp>Sortiere die Pool-Adressen in jedem Zyklus und hashe sie:\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-rust\">use tiny_keccak::{Hasher, Keccak};\n\nfn cycle_hash(pools: &[Pool]) -> [u8; 32] {\n    let mut sorted: Vec<Address> = pools.iter()\n        .map(|p| p.address)\n        .collect();\n    sorted.sort();\n    \n    let mut hasher = Keccak::v256();\n    for addr in &sorted {\n        hasher.update(addr.as_bytes());\n    }\n    let mut output = [0u8; 32];\n    hasher.finalize(&mut output);\n    output\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Ch3>3. Parallelisierung\u003C\u002Fh3>\n\u003Cp>Verwende rayon fuer parallele DFS auf verschiedenen Start-Token:\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-rust\">use rayon::prelude::*;\n\nlet all_cycles: Vec<Vec<Pool>> = tokens.par_iter()\n    .flat_map(|token| graph.find_cycles(*token, 4))\n    .collect();\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Ch2 id=\"profitabilitaetsberechnung\">Profitabilitaetsberechnung\u003C\u002Fh2>\n\u003Cp>Fuer jeden gefundenen Zyklus berechnen Sie den erwarteten Gewinn:\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-rust\">fn calculate_profit(\n    cycle: &[Pool],\n    amount_in: U256,\n) -> Option<U256> {\n    let mut current_amount = amount_in;\n    \n    for pool in cycle {\n        current_amount = pool.get_amount_out(current_amount)?;\n    }\n    \n    if current_amount > amount_in {\n        Some(current_amount - amount_in)\n    } else {\n        None\n    }\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Ch2 id=\"fazit\">Fazit\u003C\u002Fh2>\n\u003Cp>Der Arbitrage-Zyklen-Finder ist der erste Schritt in der MEV-Pipeline. Er identifiziert alle moeglichen profitablen Pfade auf dem DEX-Graphen. Die naechsten Schritte — Simulation, optimale Eingabemenge und Bundle-Erstellung — bauen auf diesen Zyklen auf.\u003C\u002Fp>\n","de","b0000000-0000-0000-0000-000000000001",true,"2026-03-28T10:44:30.158395Z","Produktions-Arbitrage-Zyklen-Finder in Rust mit Tiefensuche auf einem Token-Pool-Graphen. Tausende Pools, Millionen Zyklen und keccak256-Deduplizierung.","Arbitrage Zyklen-Finder DFS",null,"index, follow",[21,26,30],{"id":22,"name":23,"slug":24,"created_at":25},"c0000000-0000-0000-0000-000000000016","EVM","evm","2026-03-28T10:44:21.513630Z",{"id":27,"name":28,"slug":29,"created_at":25},"c0000000-0000-0000-0000-000000000019","MEV","mev",{"id":31,"name":32,"slug":33,"created_at":25},"c0000000-0000-0000-0000-000000000001","Rust","rust","Ingenieurwesen",[36,42,48],{"id":37,"title":38,"slug":39,"excerpt":40,"locale":12,"category_name":34,"published_at":41},"d0000000-0000-0000-0000-000000000680","Warum Bali 2026 zum Impact-Tech-Hub Südostasiens wird","warum-bali-2026-impact-tech-hub-suedostasiens","Bali rangiert auf Platz 16 unter den Startup-Ökosystemen Südostasiens. Mit einer wachsenden Konzentration von Web3-Entwicklern, AI-Nachhaltigkeits-Startups und Eco-Travel-Tech-Unternehmen formt die Insel ihre Nische als Impact-Tech-Hauptstadt der Region.","2026-03-28T10:44:49.720230Z",{"id":43,"title":44,"slug":45,"excerpt":46,"locale":12,"category_name":34,"published_at":47},"d0000000-0000-0000-0000-000000000679","ASEAN-Datenschutz-Flickenteppich: Compliance-Checkliste für Entwickler","asean-datenschutz-flickenteppich-compliance-checkliste-entwickler","Sieben ASEAN-Länder verfügen mittlerweile über umfassende Datenschutzgesetze mit unterschiedlichen Einwilligungsmodellen, Lokalisierungsanforderungen und Sanktionsstrukturen. Eine praktische Compliance-Checkliste für Entwickler.","2026-03-28T10:44:49.715484Z",{"id":49,"title":50,"slug":51,"excerpt":52,"locale":12,"category_name":34,"published_at":53},"d0000000-0000-0000-0000-000000000678","Indonesias 29-Milliarden-Dollar-Digitaltransformation: Chancen für Softwareunternehmen","indonesias-29-milliarden-dollar-digitaltransformation-chancen-softwareunternehmen","Indonesias IT-Dienstleistungsmarkt wird voraussichtlich 2026 29,03 Milliarden Dollar erreichen, gegenüber 24,37 Milliarden im Jahr 2025. Cloud-Infrastruktur, AI, E-Commerce und Rechenzentren treiben das schnellste Wachstum in Südostasien.","2026-03-28T10:44:49.697275Z",{"id":13,"name":55,"slug":56,"bio":57,"photo_url":18,"linkedin":18,"role":58,"created_at":59,"updated_at":59},"Open Soft Team","open-soft-team","The engineering team at Open Soft, building premium software solutions from Bali, Indonesia.","Engineering Team","2026-03-28T08:31:22.226811Z"]