លទ្ធផល 1 - - -ក្នុងរោងចក្រពន្លឺខ្មៅ
លទ្ធផល 1 - - -ថ្ងៃមួយថ្ងៃ, លោក Dan Robinson ដែលជាអ្នកស្រាវជ្រាវនៅក្នុងក្រុមហ៊ុនវិនិយោគ Paradigm បានមើលឃើញការទូរស័ព្ទបញ្ហានៅក្នុងកំណែ Uniswap Discord ។ មនុស្សមួយបានផ្ញើ tokens ដែលមានតម្លៃប្រហែល $ 12,000 ដោយគ្មានការបញ្ហានេះ។2 ។អ្នកប្រើប្រាស់ផ្សេងទៀតប៉ុន្តែទៅក្នុងការគណនី Uniswap របស់ខ្លួន, នៅពេលដែលពួកគេត្រូវបានកាត់បន្ថយដោយគ្មានការកាត់បន្ថយ។
ទោះជាយ៉ាងណាលោក Robinson បានមើលឃើញពន្លឺនៃការអរគុណ។ លោកបានយល់ដឹងថាអ្នកណាមួយអាចបង្កើនការអរគុណរបស់លោក។burnគោលបំណងសាធារណៈដែលនឹងបំពាក់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណង។
លោក Robinson បានរៀបចំនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បងនៃការសាកល្បង។
ដើម្បីជឿទុកចិត្តពួកគេ, លោក Robinson បានរចនាឡើងនូវប្រតិបត្តិការពីរដងដែលមានជំនាញវិជ្ជាជីវៈដែលមានជំនាញវិជ្ជាជីវៈដែលមានជំនាញវិជ្ជាជីវៈដែលមានជំនាញវិជ្ជាជីវៈដែលមានជំនាញវិជ្ជាជីវៈដែលមានជំនាញវិជ្ជាជីវៈនិងវិជ្ជាជីវៈវិជ្ជាជីវៈដែលមានជំនាញវិជ្ជាជីវៈដែលមានជំនាញវិជ្ជាជីវៈនិងវិជ្ជាជីវៈវិជ្ជាជីវៈដែលមានជំនាញវិជ្ជាជីវៈវិជ្ជាជីវៈ។
នៅក្នុងសៀវភៅមួយដែលមានប្រសិទ្ធិភាពឥឡូវនេះអំពីបញ្ហានេះលោក Robinson បានផ្តល់ឈ្មោះដល់ប្រព័ន្ធអាកាសធាតុអាកាសធាតុអាកាសធាតុអាកាសធាតុអាកាសធាតុអាកាសធាតុអាកាសធាតុអាកាសធាតុអាកាសធាតុអាកាសធាតុអាកាសធាតុអាកាសធាតុអាកាសធាតុអាកាសធាតុ។Ethereum is a Dark Forest.
ក្នុងអត្ថបទនេះយើងនឹងដោះស្រាយលើការរចនាប្រព័ន្ធដែលអាចអានប្រតិបត្តិការក្នុងអំឡុងពេលនិងទិន្នន័យពីប្រតិបត្តិការ blockchain ជាមួយនឹងគោលបំណងនៃការអនុវត្ត arbitration ។mathematical models underlying AMM pricingសូមចូលទៅក្នុងការalgorithms for opportunity detection and optimal price entryការកំណត់architectural componentsរបស់យើង, និងពិភាក្សាអំពីcritical strategiesវាគឺជាការចាំបាច់ដើម្បីធ្វើដំណើរការ arbitration ជាជោគជ័យនិងសុវត្ថិភាពនៅក្នុងបរិស្ថានដែលមានតម្លៃខ្ពស់នេះ។
2. The DeFi Landscape: AMMs, liquidity, និងឱកាស arbitration
នេះជាប្រព័ន្ធអស្ចារ្យដែលបានបង្កើតឡើងនៅលើគំនិតថ្មីនៃការហិរញ្ញវត្ថុ: ការហិរញ្ញវត្ថុ decentralized (DeFi) ។ នៅក្នុងគោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងរបស់គោលបំណងនេះគឺដើម្បីកំណត់សេវាកម្មហិរញ្ញវត្ថុធម្មជាតិនៅលើបណ្តាញ blockchain, ការកាត់បន្ថយការតម្រូវការសម្រាប់មជ្ឈមណ្ឌលតាមរយៈការប្រើប្រាស់នៃការអនុវត្តដោយខ្លួនឯងគោលបំណងអស្ចារ្យ។ ការយល់ដឹងអំពីគោលបំណងមូលដ្ឋាននៃគំនិតនេះគឺសំខាន់ក្នុងការយល់ដឹងអំពីរបៀបដែលឱកាសហិរញ្ញវត្ថុបានបង្កើតឡើងនិងហេតុអ្វីដែលពួកគេត្រូវបានសាកល្បងយ៉ាងខ្លាំង។
អ្នកបង្កើតទីផ្សារដោយស្វ័យប្រវត្តិ (AMMs): កញ្ចក់នៃការផ្លាស់ប្តូរ decentralized
ការផ្លាស់ប្តូរច្នៃប្រឌិតផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ្លាស់ប្តូរផ
តម្លៃនៃឧបករណ៍ក្នុងក្រុមប្រឹក្សាភិបាល AMM ត្រូវបានកំណត់ដោយ algorithmic ដោយ aconstant product formulaបានបង្កើតឡើងដោយ Uniswap:
នៅទីនេះ, x និង y អនុញ្ញាតឱ្យមានចំនួននៃទីម៉ែត្រទាំងពីរនៅក្នុងក្រុមប្រឹក្សាភិបាលហិរញ្ញវត្ថុ, និង k គឺជាធម្មតា។ នៅពេលដែលអ្នកប្រើពាណិជ្ជកម្មទីម៉ែត្រមួយសម្រាប់ទីម៉ែត្រផ្សេងទៀតចំនួននៃ x និង y នៅក្នុងក្រុមប្រឹក្សាភិបាលមានការផ្លាស់ប្តូរទេប៉ុន្តែផលិតផលរបស់ពួកគេ k នឹងគ្មានការផ្លាស់ប្តូរ។ ម៉ាស៊ីននេះធ្វើឱ្យប្រសើរឡើងតម្លៃ: ការទិញបន្ថែមទៀតនៃទីម៉ែត្រ A នឹងកាត់បន្ថយតម្លៃរបស់វានៅក្នុងក្រុមប្រឹក្សាភិបាល, ដូច្នេះបង្កើនតម្លៃរបស់វាប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលbonding curve, ដែលអនុញ្ញាតឱ្យកំណត់តម្លៃដែលអាចរកបានសម្រាប់ពាណិជ្ជកម្ម។
ពីម៉ូដែលនេះវាអាចកំណត់ទូទៅទូទៅទូទៅ (dy) នៃការផ្លាស់ប្តូរពីការផ្លាស់ប្តូរដោយសារតែទូទៅទូទៅទូទៅ (dx) និងការផ្លាស់ប្តូរមុនពីការផ្លាស់ប្តូរនៃទីពីរ (x និង y) ។
Key characteristics of AMMs:
- ទោះបីជាសៀវភៅការបញ្ជាដែលអាចកាត់បន្ថយ, AMMs នឹងផ្តល់នូវការបញ្ជាទូទៅនៅពេលដែលមាន tokens នៅក្នុងការបំពង់។
- ដោយគ្មានការអនុញ្ញាត: មនុស្សណាមួយអាចក្លាយជាអ្នកផ្គត់ផ្គង់ប្រសិទ្ធិភាពឬការផ្លាស់ប្តូរនៅលើ AMM ដោយគ្មានការអនុញ្ញាត។
- ការរកឃើញតម្លៃ: តម្លៃត្រូវបានកាត់បន្ថយដោយគុណភាពនៃសមត្ថភាពក្នុងការកាត់បន្ថយក្នុងការកាត់បន្ថយជាមួយនឹងការជួញដូរទាំងអស់។
- Slippage: អាជីវកម្មធំទូលំទូលាយអាចផ្លាស់ប្តូរតម្លៃក្នុងការបំពង់បានយ៉ាងសំខាន់, ដែលនាំទៅនឹងប្រសិទ្ធិភាពដែលត្រូវបានគេស្គាល់ថា sllippage, ដែលមានតម្លៃដែលត្រូវបានដំណើរការគឺខ្ពស់ជាងតម្លៃដែលបានផ្តល់ជូន។ នេះគឺជាปัจจัยសំខាន់សម្រាប់ bots arbitrage ។
នៅពេលដែលគំរូ x⋅y=k (ដែលជាទូទៅត្រូវបានគេហៅថា Uniswap V2) បានបង្កើតមូលដ្ឋាននេះ, AMMs បានអភិវឌ្ឍ។ ឧទាហរណ៍, Uniswap V3 បានបង្កើត "ការផ្ទុកផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃផ្ទៃwe will primarily focus on AMMsការប្រើប្រាស់រចនាសម្ព័ន្ធផលិតផលធម្មតានិងធម្មតានិងធម្មតានិងធម្មតានិងធម្មតានិងធម្មតានិងធម្មតានិងធម្មតាន។ ការប្រើប្រាស់រចនាសម្ព័ន្ធផលិតផលធម្មតានិងធម្មតានិងធម្មតានិងធម្មតានិងធម្មតានិងធម្មតាន។
The Essence of Arbitrage in DeFi
ការ arbitration គឺជាការទិញនិងលក់សម្ភារៈមួយនៅលើទីផ្សារផ្សេងគ្នាដើម្បីទទួលបានអត្ថប្រយោជន៍ពីការខុសគ្នានៅក្នុងតម្លៃរបស់វា។ នៅក្នុង DeFi នេះធ្វើឱ្យប្រសើរឡើងដល់ការប្រើប្រាស់ការខុសគ្នានៅក្នុងតម្លៃរវាងក្រុមហ៊ុនផ្សេងគ្នានៃ AMM ឬរវាងក្រុមហ៊ុនផ្សេងគ្នានៃ AMM និងក្រុមហ៊ុនផ្សេងគ្នានៃ Centralized Exchange (CEX) សម្រាប់ក្រុមហ៊ុនផ្សេងគ្នានៃគ្នានៃ token មួយដូចគ្នានេះ។ សម្ភារៈគ្នានៃ DeFi និងសម្ភារៈគ្នានៃគ្នានៃគ្នានៃគ្នានៃគ្នានៃគ្នានៃគ្នានៃគ្នានៃគ្នានៃគ្នានៃគ្នានៃគ្ន
ប្រភេទនៃឱកាស arbitration នៅក្នុង DeFi
- ឧទាហរណ៍, ប្រសិនបើ 1 ETH បានធ្វើពាណិជ្ជកម្មសម្រាប់ 2000 DAI នៅលើ Uniswap A, ប៉ុន្តែ 1 ETH បានធ្វើពាណិជ្ជកម្មសម្រាប់ 2010 DAI នៅលើ Uniswap B, អ្នកអាចទិញ ETH នៅលើ Uniswap A ជាមួយនឹង DAI, និងលក់ ETH នេះដោយ DAI នៅលើ Uniswap B ដោយឥតគិតថ្លៃ, ការបាត់បន្ថយការផ្សេងគ្នានៃ 10 DAI (បាត់បន្ថយការទូទាត់និងការបាត់បន្ថយ) ។
- ប្រភេទនេះនៃការអនុម័តនេះរួមបញ្ចូលទាំងបីឬច្រើនទៀតនៅក្នុងការអនុម័តដូចគ្នា (ឬនៅលើការអនុម័តជាច្រើន) ដើម្បីបង្កើតរចនាសម្ព័ន្ធជោគជ័យ។ ឧទាហរណ៍អ្នកអនុម័តអាចចាប់ផ្តើមជាមួយ token A, ការអនុម័តសម្រាប់ token B, បន្ទាប់មក token B សម្រាប់ token C, និងបញ្ចប់ token C ទៅ token A, បានបញ្ចប់ជាមួយ token A ច្រើនជាងពួកគេបានចាប់ផ្តើមជាមួយ។ ឧទាហរណ៍ដែលធម្មតានៅលើ Uniswap អាចជា: WETH -> DAI -> USDC -> WETH ។ គោលបំណងដំបូងរបស់យើងគឺដើម្បីអនុវត្តនិងធ្វើការអនុម័ត Multi-Leg ក្នុងរយៈពេលផ្សេងគ្នានៃ DEX AMMs ។
- Flash Loan Arbitration: ឧបករណ៍មួយដែលមានប្រសិទ្ធិភាពនិងតែមួយគត់នៃ DeFi, Flash Loans អនុញ្ញាតឱ្យអ្នកប្រើដើម្បីរក្សាទុកឧបករណ៍ដែលមិនមានគោលបំណង, ប្រើវាសម្រាប់ដំណាក់កាលនៃប្រតិបត្តិការ (ដូចជាការ arbitration) និងបង់ប្រាក់រង្វាន់ - ទាំងអស់នៅក្នុងប្រតិបត្តិការ blockchain មួយ។ ប្រសិនបើដំណាក់កាលទាំងអស់នៃប្រតិបត្តិការ (រក្សាទុក, ការពាណិជ្ជកម្ម, ការបង់ប្រាក់) មិនអាចត្រូវបានបញ្ចប់យ៉ាងជោគជ័យនៅក្នុងប្រតិបត្តិការតែមួយនេះ, ការប្រតិបត្តិការទាំងអស់ត្រូវបានបង្វិល, ដូចគ្នានេះមិនបានកើតឡើងទេ។ នេះបាត់បន្ថយការតម្រូវការនៃប្រាក់រង្វាន់មុនយ៉ាងខ្លាំងនិងកាត់បន្ថយការបង់ប្រាក់រង្វាន់សម្រាប់ការ arbitr
ការជួញដូរសម្រាប់លទ្ធផល: ការជួញដូរនិងការជួញដូរ
នេះជាទីផ្សារដែលមានប្រសិទ្ធិភាពខ្ពស់។ លក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈពិសេសលក្ខណៈពិសេសលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈ
-
Gas Fees: Every interaction with a smart contract incurs a transaction fee (gas), which can vary significantly based on network congestion. A profitable arbitrage opportunity must yield enough profit to cover these costs.
-
Slippage: The larger the trade relative to the pool’s liquidity, the greater the slippage, eroding potential profits. Accurately modeling slippage is crucial for calculating true profitability.
-
Latency: The speed at which an arbitrage bot can detect an opportunity, calculate the optimal trade, construct a transaction, and submit it to the network is paramount. Even milliseconds can make the difference between profit and loss.
-
Frontrunning and MEV: As discussed in the introduction, the “Dark Forest” is dominated by generalized frontrunners. These bots actively monitor the mempool for pending profitable transactions, replicate them, and submit their own transaction with a higher gas price to ensure their transaction is included in a block before the original one. This phenomenon falls under the umbrella of Maximal Extractable Value (MEV), representing the total value that can be extracted from block production in excess of the standard block reward and gas fees by arbitraging, liquidating, or reordering transactions within a block. Successfully navigating this environment often requires advanced strategies like leveraging MEV-Boost relays or private transaction pools. To mitigate the risk of being intercepted in public mempools, our implementation will primarily operate on Base, an EVM-compatible Layer 2 (L2) blockchain. Base’s architecture, which currently does not expose a public mempool in the same manner as Ethereum’s Layer 1, offers a different environment for transaction submission, potentially reducing traditional frontrunning risks.
-
Complexity of AMMs: As AMMs evolve (e.g., Uniswap V3’s concentrated liquidity), the mathematical modeling and state tracking required for accurate arbitrage calculations become significantly more complex.
Understanding these foundational elements of DeFi, from the mechanics of AMMs to the cut-throat nature of arbitrage competition, sets the stage for designing a robust and effective arbitrage bot. In the next chapter, we will begin to lay out the architectural blueprint for such a system.
ការរចនាសម្ព័ន្ធវិជ្ជាជីវៈ: ការបង្កើតវិជ្ជាជីវៈ Arbitrage Bot
ការបង្កើត bot arbitrage ដែលមានអត្ថប្រយោជន៍នៅក្នុង “Dark Forest” នៃ DeFi មានតម្រូវឱ្យមានអគ្គិសនីដែលផ្តល់អំណាចដល់ល្បឿនលឿន, ការសាកល្បងនិងភាពជាក់លាក់។ ការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀប
Go ត្រូវបានជ្រើសរើសជាភាសាអភិវឌ្ឍន៍ដំបូងដោយសារតែសម្តែងពិសេសរបស់វាមានប្រសិទ្ធិភាពសមរម្យ (goroutines និងប្រព័ន្ធផ្សព្វផ្សាយ) និងប្រព័ន្ធអេក្រង់ខ្លាំងសម្រាប់កម្មវិធីបណ្តាញនិងទំនាក់ទំនងប្រព័ន្ធកម្រិតទាប។ លក្ខណៈពិសេសទាំងនេះគឺសំខាន់សម្រាប់ការគ្រប់គ្រងទិន្នន័យ blockchain ដែលមានទំហំខ្ពស់និងតម្រូវការសម្រាប់ការដំណើរការឆ្លងកាត់នៅក្នុងប្រព័ន្ធអេក្រង់អេក្រង់អ៊ីនធឺណិត។ លើសពីនេះទៀត, ការប្រសិទ្ធិភាពរបស់ Go ត្រូវបានបង្ហាញដោយការអនុវត្តរបស់វាមានប្រព័ន្ធអេក្រង់អេក្រង់អេក្រង់អេក្រង់អ៊ីនធឺណិតដូចជាgo-ethereumអ្នកអតិថិជន Ethereum ។
ប្រព័ន្ធ ប្រព័ន្ធ ប្រតិបត្តិការ Android ត្រូវបានបង្កើតឡើងជាevent-driven systemវាត្រូវបានបង្កើតឡើងដោយផ្នែកមួយនៃសេវាកម្ម (ម៉ូឌុល) មួយចំនួនដោយខ្លួនឯងដែលគ្រប់គ្រងនៅក្នុងដំណើរការបន្ទាប់ (goroutines) ។ សេវាកម្មទាំងនេះផ្លាស់ប្តូរដោយការផ្លាស់ប្តូរទិន្នន័យដោយផ្លាស់ប្តូរទិន្នន័យតាមរយៈទិន្នន័យតាមរយៈទិន្នន័យតាមរយៈទិន្នន័យ Go, ការធានាការរចនាសម្រាប់ការរួមបញ្ចូលយ៉ាងងាយស្រួលនិងការឆ្លើយតបខ្ពស់។ គោលបំណងនេះអនុញ្ញាតឱ្យមានប្រសិទ្ធិភាពក្នុងការប្រើប្រាស់ឧបករណ៍ដែលមានប្រសិទ្ធិភាពយ៉ាងងាយស្រួលការកាត់បន្ថយបញ្ហានិងអនុញ្ញាតឱ្យការកាត់បន្ថយទិន្នន័យនៃផ្នែកមួយ។
មជ្ឈមណ្ឌលប្រព័ន្ធទាំងអស់
ឧបករណ៍អ៊ីនធឺណិតនៃ bot arbitrage អាចត្រូវបានគេស្គាល់ថាជាបំពង់បំពង់ដែលទិន្នន័យចេញពី blockchain ត្រូវបានដំណើរការនិងពិនិត្យឡើងវិញហើយបញ្ចប់នៅក្នុងការអនុវត្តពាណិជ្ជកម្មដែលមានប្រាក់ចំណេញ។ ផ្នែកសំខាន់ដែលធ្វើការតាមដានគឺ:
-
Blockchain Data Reader Service: Responsible for real-time ingestion of blockchain events data.
-
Market Graph Service: Maintains an in-memory representation of the DeFi market and identifies arbitrage paths.
-
Arbitrage Strategy Service: Evaluates detected opportunities for profitability and prepares trade instructions.
-
Transaction Builder Service: Constructs and dispatches blockchain transactions.
-
Honeywall Service: A post-execution checker that enhances security and maintains market integrity by identifying and blacklisting malicious pools.
This modularity allows each service to focus on a specific task, minimizing dependencies and optimizing performance for its particular workload. Communication between services is strictly asynchronous, leveraging Go’s channels for message passing, which naturally facilitates a non-blocking and highly concurrent operation.
ការសរសេរទិន្នន័យ Blockchain Data Reader Service: The Eyes and Ears of Our Bot in the Data Stream
សេវាកម្មនេះធ្វើការជាការផ្លាស់ប្តូរសំខាន់នៃ bot ជាមួយនឹងទិន្នន័យប្រវត្តិនៅពេលពិតប្រាកដដែលដំណើរការតាមរយៈ blockchain ។ នៅក្នុង "Dark Forest" ទិន្នន័យគឺជាប្រាក់រង្វាន់និងសមត្ថភាពរបស់យើងដើម្បីទាញយកវាយ៉ាងឆាប់រហ័សនិងត្រឹមត្រូវគឺជាការសំខាន់បំផុត។ យើងមិនគ្រាន់តែ "សរសេរ" blockchain ។ យើងមានប្រសិទ្ធភាព។extract crucial financial data pointsនេះនឹងផ្គត់ផ្គង់ម៉ាស៊ីនដោះស្រាយ arbitration របស់យើង។
- ការភ្ជាប់និងការទាញយកទិន្នន័យ: Reader បានភ្ជាប់ទៅនឹងខ្សែក្រវ៉ាត់ blockchain ដោយប្រើ WebSockets ។ ការភ្ជាប់ពីរដំណាក់កាលនេះអនុញ្ញាតឱ្យការទទួលយកផ្ទាល់ខ្លួននៃកំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណ
- សៀវភៅប្លុកថ្មី: ដោយការទិញសៀវភៅប្លុកថ្មីយើងទទួលបានការយល់ដឹងបន្ទាប់ពីការផ្លាស់ប្តូរស្ថានភាព។ រាល់ប្លុកថ្មីនេះជារូបថតដែលបានបញ្ជាក់ពីការពិតប្រាកដនៃ blockchain នេះរួមបញ្ចូលទាំងការប្រតិបត្តិការថ្មី, ការទូទាត់សកម្មភាពនិងស្ថានភាពប្លុកសកម្មភាពថ្មី។ ការផ្លាស់ប្តូរនេះផ្តល់នូវទិន្នន័យសំខាន់សម្រាប់ការបច្ចុប្បន្នភាពនៃក្រាហ្វិកទីផ្សាររបស់យើងនិងសម្រាប់ការបញ្ជាក់ផលិតផលនៃប្រតិបត្តិការរបស់យើង។
func (er *EthereumReader) SubscribePairs() error {
parsedABI := constants.PairAbi
// Set up the filter
query := ethereum.FilterQuery{
Topics: [][]common.Hash{
{
parsedABI.Events["Swap"].ID,
parsedABI.Events["Mint"].ID,
parsedABI.Events["Burn"].ID,
parsedABI.Events["Sync"].ID,
},
},
}
logs := make(chan types.Log)
sub, err := er.ethClient.SubscribeFilterLogs(context.Background(), query, logs)
if err != nil {
return err
}
// Start Routine to read swaps events
log.Println("[READING SWAPS...]")
go func() {
for {
select {
case err = <-sub.Err():
log.Println("[RESET CONNECTION...] Subscription error: ", err)
pairInfo := GraphMessage{
Ok: false,
}
*er.pairChan <- pairInfo
time.Sleep(5 * time.Minute)
er.ethClient = clients.ResetConnection()
er.SubscribePairs()
return
case vLog := <-logs:
start := time.Now()
pairAddress := vLog.Address
if er.filter.IsPairBlackListed(pairAddress.Hex()) {
continue
}
blockNumber := vLog.BlockNumber
if blockNumber > er.currentBlockNumber {
// New block detected, reset cache
er.lastUpdatedBlock = nil
er.lastUpdatedBlock = make(map[common.Address]uint64)
er.currentBlockNumber = blockNumber
}
// Check if already updated for this pair in current block
if _, exists := er.lastUpdatedBlock[pairAddress]; exists {
continue
}
t0, t1, f, r0, r1, err := er.getPairDataFromHelper(pairAddress)
if err != nil {
continue
}
dex := f.String()
router, err := constants.GetRouterAddressFromFactory(dex)
if err != nil {
continue
}
// Update cache
er.lastUpdatedBlock[pairAddress] = blockNumber
elapsed := time.Until(start)
pairInfo := GraphMessage{
Ok: true,
DexCheck: true,
Pair: pairAddress.Hex(),
Token0: Token{Address: t0.Hex()},
Token1: Token{Address: t1.Hex()},
Reserve0: r0,
Reserve1: r1,
Dex: router,
GetTime: elapsed,
}
*er.pairChan <- pairInfo
}
}
}()
return nil
}
- ការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្ចូលគ្នានៃការបញ្
- ខាងក្រោមនេះគឺការអនុវត្ត Solidity នៃការជួយនេះ។ គោលបំណងសំខាន់នេះមាននៅក្នុងវិធី checkPair ដែលតម្លៃសុវត្ថិភាពនៃជួរ token និងផ្ញើទិន្នន័យទូទៅ។
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract ArbHelperMap {
mapping(address => address) public factoryToRouter;
address public owner;
modifier onlyOwner() {
require(msg.sender == owner, "Not owner");
_;
}
constructor() {
owner = msg.sender;
// Pre-populate known mappings
factoryToRouter[0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6] = 0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24;
factoryToRouter[0x02a84c1b3BBD7401a5f7fa98a384EBC70bB5749E] = 0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb;
factoryToRouter[0xFDa619b6d20975be80A10332cD39b9a4b0FAa8BB] = 0x327Df1E6de05895d2ab08513aaDD9313Fe505d86;
factoryToRouter[0x71524B4f93c58fcbF659783284E38825f0622859] = 0x6BDED42c6DA8FBf0d2bA55B2fa120C5e0c8D7891;
factoryToRouter[0x3E84D913803b02A4a7f027165E8cA42C14C0FdE7] = 0x8c1A3cF8f83074169FE5D7aD50B978e1cD6b37c7;
factoryToRouter[0x9A9A171c69cC811dc6B59bB2f9990E34a22Fc971] = 0x1b7655aa64b7BD54077dE56B64a0f92BCba05b85;
}
function addFactoryRouter(address factory, address router) external onlyOwner {
require(factory != address(0) && router != address(0), "Zero address");
factoryToRouter[factory] = router;
}
struct Result {
bool success;
address token0;
address token1;
address factory;
uint112 reserve0;
uint112 reserve1;
}
// Helper function to get pair data
function _getPairData(address pairAddress) private view returns (
bool success,
address token0,
address token1,
address factory,
uint112 reserve0,
uint112 reserve1,
address router
) {
success = false;
try IPair(pairAddress).token0() returns (address _token0) {
token0 = _token0;
try IPair(pairAddress).token1() returns (address _token1) {
token1 = _token1;
try IPair(pairAddress).factory() returns (address _factory) {
factory = _factory;
try IPair(pairAddress).getReserves() returns (uint112 r0, uint112 r1, uint32) {
reserve0 = r0;
reserve1 = r1;
router = factoryToRouter[factory];
if (router != address(0)) {
success = true;
}
} catch {}
} catch {}
} catch {}
} catch {}
}
// Helper function to check if pair passes tax limit
function _checkTaxLimit(
address router,
address token0,
address token1,
uint amountIn,
uint maxTaxPermille
) private view returns (bool) {
address[] memory path = new address[](2);
path[0] = token0;
path[1] = token1;
try IRouter(router).getAmountsOut(amountIn, path) returns (uint[] memory buyOuts) {
if (buyOuts.length < 2) return false;
address[] memory reversePath = new address[](2);
reversePath[0] = token1;
reversePath[1] = token0;
try IRouter(router).getAmountsOut(buyOuts[1], reversePath) returns (uint[] memory sellOuts) {
if (sellOuts.length < 2) return false;
uint minReturn = amountIn - (amountIn * maxTaxPermille / 1000);
return sellOuts[1] >= minReturn;
} catch {
return false;
}
} catch {
return false;
}
}
function checkPair(address pairAddress, uint amountIn, uint maxTaxPermille) external view returns (Result memory r) {
// Initialize result with default values
r.success = false;
// Skip processing if pair address is zero
if (pairAddress == address(0)) return r;
// Get pair data
bool success;
address token0;
address token1;
address factory;
uint112 reserve0;
uint112 reserve1;
address router;
(success, token0, token1, factory, reserve0, reserve1, router) = _getPairData(pairAddress);
// If we couldn't get pair data or there's no router, return early
if (!success) return r;
// Check tax limits
bool passedTaxCheck = _checkTaxLimit(router, token0, token1, amountIn, maxTaxPermille);
// Populate result if tax check passed
if (passedTaxCheck) {
r.success = true;
r.token0 = token0;
r.token1 = token1;
r.factory = factory;
r.reserve0 = reserve0;
r.reserve1 = reserve1;
}
return r;
}
}
- ការផ្លាស់ប្តូរប្រព័ន្ធប្រតិបត្តិការ (Event-Driven Communication) នៅពេលដែលអ្នកទទួលបាននិងដំណើរការប្រព័ន្ធប្រតិបត្តិការ (Event-Driven Communication) នេះធ្វើឱ្យទិន្នន័យមានប្រសិទ្ធិភាពនិងផ្លាស់ប្តូរប្រព័ន្ធប្រតិបត្តិការ (Event-Driven Communication) និងផ្លាស់ប្តូរប្រព័ន្ធប្រតិបត្តិការ (Event-Driven Communication) ក្នុងការផ្លាស់ប្តូរប្រព័ន្ធប្រតិបត្តិការ (Event-Driven Communication) ក្នុងការផ្លាស់ប្តូរប្រព័ន្ធប្រតិបត្តិការ (Event-Driven Communication) ក្នុងប្រព័ន្ធប្រតិបត្តិការ (Event-Driven Communication) ។
សេវាកម្មក្រាហ្វិកទីផ្សារ: គំនូរទីផ្សារ DeFi
Market Graph Service គឺជាឧបករណ៍វិជ្ជាជីវៈមជ្ឈមណ្ឌលដែលមានការរក្សាទុកការបង្ហាញនៅក្នុងពេលវេលាពិតប្រាកដនៃទីផ្សារ DeFi ។ វាត្រូវបានគំរូទីផ្សារដូចជាdirected graphនៅទីនេះ:
- Nodes: បង្ហាញពី cryptocurrencies មួយចំនួន (ដូចជា WETH, USDC, DAI) ។
- លក្ខខណ្ឌ: ការប្រៀបធៀបប្រៀបធៀបប្រៀបធៀបប្រៀបធៀបប្រៀបធៀបប្រៀបធៀបប្រៀបធៀបប្រៀបធៀបប្រៀបធៀបប្រៀបធៀបប្រៀបធៀបប្រៀបធៀបប្រៀបធៀបប្រៀបធៀបប្រៀបធៀបប្រៀបធៀបប្រៀបធៀប
- រចនាសម្ព័ន្ធទិន្នន័យនិងការបច្ចុប្បន្នភាព: សេវាកម្មនេះទទួលបានការបច្ចុប្បន្នភាពពីសេវាកម្មការសរសេរទិន្នន័យ Blockchain តាមរយៈប្រព័ន្ធផ្សព្វផ្សាយ។ នៅពេលដែលទទួលបានទិន្នន័យការផ្គត់ផ្គង់ថ្មីសម្រាប់ក្រុមប្រឹក្សាភិបាលនេះវាបានបច្ចុប្បន្នភាពទិន្នន័យទិន្នន័យដែលបើយោងតាមគោលបំណងនៅក្នុងក្រាហ្វិក។ វាត្រូវបានដំណើរការជាមួយនឹងការបន្ថែមទិន្នន័យទិន្នន័យថ្មីឬ DEXs នៅពេលដែលពួកគេត្រូវបានរកឃើញ។
- ការត្រឹមត្រូវជាមួយនឹង BigInt: ការទូទាត់ទាំងអស់ដែលរួមបញ្ចូលទាំងទូទាត់ token និងទូទាត់ការផ្លាស់ប្តូរប្រើទូទាត់ទូទាត់ទូទាត់ / ទូទាត់ធំរបស់ Go (BigInt ឬ BigFloat) ។ នេះគឺជាការសំខាន់សម្រាប់ការរក្សាទុកភាពត្រឹមត្រូវដោយគ្មានការត្រឹមត្រូវដែលអាចធ្វើឱ្យមានឱកាសលំបាកឬការទូទាត់ប្រាក់រង្វាន់មិនត្រឹមត្រូវ។ នេះជាការសំខាន់ណាស់ដោយសារតែទូទាត់ផ្សេងគ្នានៅក្នុង DeFi ដែលអាចមានទំហំពី 8 ទៅ 18 (ឬច្រើនជាង) ពិន្ទុសំខាន់ហើយធ្វើឱ្យទូទាត់ទូទាត់ទូទាត់ទូទាត់មិនត្រឹមត្រូវ។
- ការរកឃើញដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយដំណោះស្រាយ
សេវាកម្មគោលបំណងអ៊ីនធឺណិត: វិញ្ញាបនប័ត្រនិងអតិថិជន
សូមអរគុណចំពោះការដំឡើងកម្មវិធីពីការMarket Graph Serviceសេវាកម្ម Strategy Arbitration ធ្វើការត្រួតពិនិត្យតាមរយៈក្រាហ្វិកទីផ្សារសម្រាប់ដំណើរការ arbitration ដែលបានរកឃើញថ្មីៗ។
- ការពិនិត្យឡើងវិញឱកាស: នៅពេលដែលក្រាហ្វិកនេះត្រូវបានបច្ចុប្បន្នភាពឬដំណើរការ arbitration ដែលអាចរកឃើញដោយ FindArbitrage, សេវាកម្មនេះបានចាប់ផ្តើមដំណើរការ។ វាមានដំណើរការខ្សែភាពយន្ត (ដំណើរការ arbitration) ដែលបានរកឃើញដោយសេវាកម្មក្រាហ្វិកទីផ្សារនិងចាប់ផ្តើមការគណនានៃលទ្ធផលពេញលេញ។
- ការកំណត់ទូទាត់អតិបរមា (Convex Optimization) គឺជាដំណោះស្រាយសំខាន់ក្នុងការកំណត់ទូទាត់អតិបរមា (dx) សម្រាប់ដំណោះស្រាយអតិបរមា។ នេះគឺជាបញ្ហានេះមិនមែនជាទូទាត់, ដូចជាការកំណត់ទូទាត់គឺជាប្រតិបត្តិនៃទូទាត់អតិបរមាអតិបរមាដែលមិនមែនជាលក្ខណៈសម្បត្តិដូចដែលបានបង្ហាញនៅក្នុងសៀវភៅ “An analysis of Uniswap markets” នេះ។ វាត្រូវបានកាត់បន្ថយដោយការលទ្ធផលនិងទូទាត់នៅលើការផ្លាស់ប្តូរជាច្រើន។ សេវាកម្មនេះដំណោះស្រាយបញ្ហានេះជាបញ្ហានេះជាទូទាត់អតិបរម
- ការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀបធៀបការប្រៀប
- តម្លៃទាំងអស់: រួមទាំងតម្លៃពាណិជ្ជកម្ម DEX (ដូចជា 0.3% សម្រាប់ Uniswap V2) ។
- Slippage: ទូទាត់យ៉ាងត្រឹមត្រូវប្រសិទ្ធិភាពនៃតម្លៃនៃការជួញដូរទាំងអស់ក្នុងរយៈពេលមួយ។
- តម្លៃឧស្ម័ន: តម្លៃទូទៅនៃតម្លៃឧស្ម័នដែលត្រូវការសម្រាប់ប្រតិបត្តិការទាំងអស់ដែលមានគោលបំណងក្នុងការគណនានៅលើខ្សែ (មូលដ្ឋាន) និងតំបន់បណ្តាញឥឡូវនេះ។
- លក្ខណៈពិសេសនៃការទទួលបានអត្ថប្រយោជន៍នេះគឺប្រសិនបើអត្ថប្រយោជន៍ដោយឥតគិតថ្លៃគឺប្រសិនបើអត្ថប្រយោជន៍ដោយឥតគិតថ្លៃគឺប្រសិនបើអត្ថប្រយោជន៍ដោយឥតគិតថ្លៃគឺប្រសិនបើអត្ថប្រយោជន៍ដោយឥតគិតថ្លៃគឺប្រសិនបើអត្ថប្រយោជន៍ដោយឥតគិតថ្លៃគឺប្រសិនបើអត្ថប្រយោជន៍ដោយឥតគិតថ្លៃគឺប្រសិនបើអត្ថប្រយោជន៍ដោយឥតគិតថ្លៃគឺប្រសិនបើអត្ថប្រយោជន៍ដោយឥតគិតថ្លៃ។
- ការអនុម័តសម្រាប់ការអនុវត្ត: ប្រសិនបើឱកាសជោគជ័យបានបំពេញតម្រូវការសេវាកម្មអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម័តបម្រើអនុម
សេវាកម្មរចនាសម្ព័ន្ធប្រតិបត្តិការ: Swift Execution
សេវាកម្ម Transaction Builder គឺជាការអនុវត្តរបស់ bot ដែលមានតម្រូវការរចនាឡើងយ៉ាងឆាប់រហ័សនិងផ្តល់ជូននូវប្រតិបត្តិការ arbitration ទៅលើ blockchain ។ ល្បឿនគឺជាការសំខាន់នៅទីនេះ, ដូចជាឱកាសគឺមានអារម្មណ៍យ៉ាងខ្លាំងលើពេលវេលា។
- ការសាងសង់ប្រតិបត្តិការ: នៅពេលដែលទទួលបានឱកាសពីសេវាកម្មវិជ្ជាជីវៈវិជ្ជាជីវៈ, សេវាកម្មនេះចាប់ផ្តើមរចនាប្រតិបត្តិការ blockchain atomic ដោយឥឡូវនេះ។ នេះរួមបញ្ចូលទាំង:
- Smart Contract Interaction (Atomic Swaps): សេវាកម្មនេះមានការរួមបញ្ចូលជាមួយគណនីគណនីគណនីគណនីដែលត្រូវបានរចនាឡើងពិសេសដើម្បីដំណើរការប្រតិបត្តិការអេឡិចត្រូនិទាំងអស់ (ការអេឡិចត្រូនិជាច្រើន) ក្នុងការប្រតិបត្តិការអេឡិចត្រូនិតែមួយ។ សេវាកម្មនេះក៏គ្រប់គ្រងការអនុញ្ញាត token ក្នុងអំឡុងពេលប្រតិបត្តិការដូចគ្នានេះ។ គណនីនេះមានគោលបំណងដើម្បីកាត់បន្ថយការបាត់បន្ថយឬការបាត់បន្ថយនៅមជ្ឈមណ្ឌលការអេឡិចត្រូនិដូចជាប្រតិបត្តិការទាំងអស់បានជោគជ័យឬមិនជោគជ័យជាផ្នែកមួយ។
- Here is the Solidity function that handles an arbitrage execution without a flash loan, requiring the owner (the bot) to fund the initial amountIn:
struct SwapStep {
address router;
address[] path;
uint minOut;
}
function executeArb(
address inputToken,
uint amountIn,
SwapStep[] calldata steps,
uint minFinalOut
) external onlyOwner returns (uint finalAmountOut) {
require(steps.length > 0, "No steps");
// Transfer tokens from msg.sender to contract
require(IERC20(inputToken).transferFrom(msg.sender, address(this), amountIn), "Transfer in failed");
address currentToken = inputToken;
uint currentAmount = amountIn;
for (uint i = 0; i < steps.length; i++) {
SwapStep calldata step = steps[i];
require(step.path[0] == currentToken, "Path mismatch");
address outputToken = step.path[step.path.length - 1];
// Save balance before swap
uint balanceBefore = IERC20(outputToken).balanceOf(address(this));
// Safe approve
require(IERC20(currentToken).approve(step.router, 0), "Reset approve failed");
require(IERC20(currentToken).approve(step.router, currentAmount), "Approve failed");
IUniswapV2Router(step.router).swapExactTokensForTokens(
currentAmount,
step.minOut,
step.path,
address(this),
block.timestamp
);
uint balanceAfter = IERC20(outputToken).balanceOf(address(this));
uint received = balanceAfter - balanceBefore;
require(received >= step.minOut, "Slippage too high");
currentToken = outputToken;
currentAmount = received;
}
require(currentAmount >= minFinalOut, "Final output too low");
require(IERC20(currentToken).transfer(owner, currentAmount), "Final transfer failed");
return currentAmount;
}
- ការរួមបញ្ចូលគណនី Flash Loan: ប្រសិនបើទំហំអតិបរមាសម្រាប់ការអនុម័តត្រូវការគណនី Flash, អ្នកបង្កើតរួមបញ្ចូលគណនី Flash Loan (ការគណនី Flash → ការអនុវត្តការផ្លាស់ប្តូរ → ការបាត់បង់) ក្នុងការប្រតិបត្តិការមួយតែមួយដែលមិនអាចបាត់បង់បានដោយប្រើការគណនីដែលអនុញ្ញាតឱ្យប្រតិបត្តិការ atomic នេះតាមរយៈការផ្លាស់ប្តូរ FlashLoanSimple នៃ Aave ។ នេះអនុញ្ញាតឱ្យ bot ដើម្បីអនុវត្តការអនុម័តធំទូលំទូលំទូលាយដោយមិនចាំបាច់រក្សាទុកប្រាក់ចំណេញជាច្រើនមុន។
- Here is the Solidity contract function executeOperation (part of a larger FlashLoanReceiver contract) that gets called by the Aave Pool and contains the arbitrage logic using the borrowed funds:
function startArbitrage(
address token,
uint256 amount,
SwapStep[] calldata steps,
uint256 minFinalOut
) external onlyOwner {
bytes memory params = abi.encode(steps, minFinalOut);
POOL.flashLoanSimple(address(this), token, amount, params, 0);
}
function executeOperation(
address asset,
uint256 amount,
uint256 premium,
address initiator,
bytes calldata params
) external override returns (bool) {
require(msg.sender == address(POOL), "Untrusted lender");
require(initiator == address(this), "Unauthorized initiator");
(SwapStep[] memory steps, uint256 minFinalOut) = abi.decode(params, (SwapStep[], uint256));
// Execute the arbitrage
address currentToken = asset;
uint currentAmount = amount;
for (uint i = 0; i < steps.length; i++) {
SwapStep memory step = steps[i];
require(step.path[0] == currentToken, "Path mismatch");
address outputToken = step.path[step.path.length - 1];
// Save balance before swap
uint balanceBefore = IERC20(outputToken).balanceOf(address(this));
// Safe approve
require(IERC20(currentToken).approve(step.router, 0), "Reset approve failed");
require(IERC20(currentToken).approve(step.router, currentAmount), "Approve failed");
IUniswapV2Router(step.router).swapExactTokensForTokens(
currentAmount,
step.minOut,
step.path,
address(this),
block.timestamp
);
uint balanceAfter = IERC20(outputToken).balanceOf(address(this));
uint received = balanceAfter - balanceBefore;
require(received >= step.minOut, "Slippage too high");
currentToken = outputToken;
currentAmount = received;
}
require(currentAmount >= amount + premium, "Insufficient profit");
require(currentAmount >= minFinalOut, "Final output too low");
// Repay the loan
require(IERC20(asset).approve(address(POOL), amount + premium), "Approval failed");
// Transfer profits to owner
uint profit = IERC20(asset).balanceOf(address(this)) - (amount + premium);
if (profit > 0) {
require(IERC20(asset).transfer(owner, profit), "Profit transfer failed");
}
return true;
}
- ការគណនានិងតម្លៃឧស្ម័ន: ការគណនានិងតម្លៃឧស្ម័នដែលត្រូវការសម្រាប់ប្រតិបត្តិការនេះនិងកំណត់តម្លៃឧស្ម័នដែលសមរម្យ (ឬតម្លៃតម្រូវការសម្រាប់ L2s ដូចជា Base) ដើម្បីធានាឱ្យមានការរួមបញ្ចូលពេលវេលានៅក្នុងប្លុក។
- ការផ្លាស់ប្តូរប្រតិបត្តិការ: នៅពេលដែលការផ្លាស់ប្តូរត្រូវបានរចនាឡើង, ការផ្លាស់ប្តូរប្រតិបត្តិការត្រូវបានផ្លាស់ប្តូរទៅកាន់កូដ blockchain Base ។ ការជ្រើសរើសនៃមូលដ្ឋានគឺមានគោលបំណងវិជ្ជាជីវៈ: មិនដូចជា Ethereum L1 នេះ, មជ្ឈមណ្ឌលបច្ចុប្បន្ននៃមូលដ្ឋាននេះមិនមាន mempool ដែលអាចមើលឃើញដោយសាធារណៈនៅក្នុងគោលបំណងច្នៃប្រឌិត។ នេះមានន័យថាប្រតិបត្តិការគឺមានប្រសិនបើមានប្រសិនបើមានប្រសិនបើមានប្រសិនបើមានការផ្លាស់ប្តូរ frontrunning ដោយធ្លាស់ប្តូរដោយ bots ការសាកល្បង mempool ។ ខណៈពេលដែល Maximal Extractable Value (MEV) មាននៅលើ L
- ការផ្លាស់ប្តូរអាជីវកម្ម: បន្ទាប់ពីការផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្មផ្លាស់ប្តូរសេវាកម្ម
សេវាកម្ម Honeywall: ការត្រួតពិនិត្យនិងសុវត្ថិភាពបន្ទាប់ពីការអនុវត្ត
សេវាកម្ម Honeywall ធ្វើការជាការត្រួតពិនិត្យបន្ទាប់ពីការអនុវត្តសំខាន់និងកម្រិតសុវត្ថិភាពដែលមានប្រសិទ្ធិភាពសម្រាប់ bot ការអនុម័ត។ សមត្ថភាពរបស់វាគឺដើម្បីត្រួតពិនិត្យផលិតផលនៃប្រតិបត្តិការដែលត្រូវបានអនុវត្តនិងការពារប្រឆាំងនឹងការអនុវត្តដែលមានប្រសិទ្ធិភាព។
- ការត្រួតពិនិត្យផលិតផលប្រតិបត្តិការ: បន្ទាប់ពីអ្នកបង្កើតប្រតិបត្តិការផ្ញើប្រតិបត្តិការ, សេវាកម្ម Honeywall ការត្រួតពិនិត្យការរួមបញ្ចូលរបស់វានៅក្នុងប្លុកនិងផលិតផលរបស់វា។
- Profit Logging: If the transaction is successful and yields a profit (as expected from the simulation), the profit details are logged for performance tracking and analysis.
- ការដោះស្រាយបញ្ហា: នៅក្នុងករណីនៃការបញ្ហាប្រតិបត្តិការ Honeywall ការដោះស្រាយបញ្ហាបញ្ហាបញ្ហាបញ្ហានេះ។
- Honeypot / Scam Detection និង Blacklisting: ឧបករណ៍សុវត្ថិភាពសំខាន់មួយគឺជាសមត្ថភាពរបស់វាដើម្បីកំណត់ tokens "honeypot" ឬ pools ដែលអនុវត្តលក្ខណៈសម្បត្តិពហុ (ឧទាហរណ៍អនុញ្ញាតការទិញប៉ុន្តែការពារការលក់ឬអនុញ្ញាតទូទាត់ការលក់).
- ការរួមបញ្ចូលក្រុមហ៊ុនផ្គត់ផ្គង់ខាងក្រៅ: វាត្រូវបានរួមបញ្ចូលជាមួយក្រុមហ៊ុនផ្គត់ផ្គង់ខាងក្រៅឬទិន្នន័យនៃការគណនី Honeypot ដែលបានដឹងដើម្បីផ្លាស់ប្តូរការផ្លាស់ប្តូរដែលត្រូវបានប្រើសម្រាប់ក្រុមហ៊ុនផ្គត់ផ្គង់ដែលបានប្រើសម្រាប់អាជីវកម្មដែលមិនបានប្រើសម្រាប់អាជីវកម្មដែលបានប្រើសម្រាប់អាជីវកម្មដែលបានប្រើសម្រាប់អាជីវកម្មដែលបានប្រើសម្រាប់អាជីវកម្មដែលបានប្រើសម្រាប់អាជីវកម្មដែលបានប្រើសម្រាប់អាជីវកម្ម។
- Dynamic Blacklisting: If a specific pair or pool is identified as an honeypot or problematic due to unexpected high taxes, it is immediately added to a database-backed blacklist. This ensures that the bot avoids these risky assets in future operations.
- Bloom Filter Integration: ប្លាស្ទិចនេះត្រូវបានគ្រប់គ្រងយ៉ាងប្រសិទ្ធិភាពតាមរយៈម៉ាស៊ីនប្លាស្ទិច Bloom នេះ។ នេះអនុញ្ញាតឱ្យសេវាកម្ម Blockchain Data Reader ដើម្បីត្រួតពិនិត្យយ៉ាងឆាប់រហ័សប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហែលប្រហ
ការបញ្ចប់នៃការរចនាសម្ព័ន្ធ
The modular, event-driven architecture implemented in Go, combined with specialized services for data ingestion, market modeling, opportunity optimization, rapid execution, and robust security, forms the backbone of our high-performance arbitrage bot. This design ensures that the system can react with unparalleled speed to fleeting market opportunities while also mitigating significant risks inherent to the DeFi “Dark Forest.” In the subsequent chapters, we will delve into the specific algorithms and implementation details of each of these services, starting with the intricate mathematics of opportunity detection.
ការរកឃើញឱកាសនិងការអនុវត្តល្អបំផុត: ម្សៅរបស់ Bot
ការអត្ថប្រយោជន៍ពិតប្រាកដនៃ bot arbitrage គឺនៅក្នុងសមត្ថភាពរបស់វាដើម្បីកំណត់យ៉ាងឆាប់រហ័សនិងត្រឹមត្រូវនូវឱកាសដែលមានប្រាក់ចំណេញក្នុងទីផ្សារដែលមានការផ្លាស់ប្តូរយ៉ាងឆាប់រហ័សហើយបន្ទាប់មកដើម្បីប្រសើរឡើងការអនុវត្តសម្រាប់ប្រាក់ចំណេញអតិបរមា។ កញ្ចក់នេះបង្ហាញអំពីអាសយដ្ឋានសំខាន់និងម៉ូដែលទូទាត់ដែលអនុញ្ញាតឱ្យដំណើរការដោះស្រាយនៃ bot របស់យើង, ពីការកំណត់ទីផ្សារជាកែច្នៃប្រឌិតទៅនឹងការកំណត់យ៉ាងត្រឹមត្រូវនៃទំហំពាណិជ្ជកម្មដែលមានគុណភាពបំផុតនិងការធ្វើតេស្តផលិតផល។
Modeling the DeFi Market as a Graph
ដូចដែលបានបង្ហាញនៅក្នុងការពិនិត្យឡើងវិញរចនាសម្ព័ន្ធរបស់យើងសេវាកម្មក្រាហ្វិកទីផ្សាររបស់យើងបានបង្ហាញនូវពិព័រណ៍ DeFi ដូចជាក្រាហ្វិកប្ដូរ។ នៅក្នុងម៉ូដែលនេះ tokens មួយចំនួន (ដូចជា WETH, DAI, USDC) ធ្វើឱ្យប្រសើរឡើងជាnodes, ខណៈពេលដែលការកាត់បន្ថយទូទាត់នៅលើការផ្លាស់ប្តូរ decentralized (DEXes) ជាedgesការផ្លាស់ប្តូរ tokens ទាំងនេះ។ ទំងន់នៃការផ្លាស់ប្តូរទាំងអស់នេះបង្ហាញពីការចំណាយនៃការធ្វើការតាមរយៈការផ្លាស់ប្តូរ។
ដើម្បីរកឃើញឱកាស arbitration ដែលមានប្រសិទ្ធិភាពដែលធ្វើឱ្យប្រសើរឡើងជាជីវចលប្រសើរឡើងយើងផ្លាស់ប្តូរបញ្ហានៃការរកឃើញជំហានពាណិជ្ជកម្មដែលមានប្រសិទ្ធិភាពក្នុងការរកឃើញការធ្វើឱ្យប្រសើរឡើងnegative cycleការផ្លាស់ប្តូរនេះត្រូវបានទទួលបានដោយការអនុវត្តបច្ចុប្បន្នភាពបច្ចុប្បន្នភាព logarithmic មួយទៅនឹងកម្រិតទូទាត់។
ការតម្រូវការនៃ logarithms សម្រាប់ការកាត់បន្ថយប្រវត្តិ
គំនិតសំខាន់នៃការ arbitration គឺជាការបង្កើនប្រាក់ចំណេញចាប់ផ្តើមដោយប្រភេទនៃតម្រូវការផ្លាស់ប្តូរដើម្បីបញ្ចប់ជាមួយនឹងច្រើនទៀតនៃសមត្ថភាពដំបូង។ ដូច្នេះ, ប្រសិនបើយើងចាប់ផ្តើមជាមួយក្រុមហ៊ុន ATokenXនិងការផ្លាស់ប្តូរវាTokenYបន្ទាប់មកTokenYសម្រាប់TokenZនិងចុងក្រោយTokenZដោះស្រាយTokenXតម្លៃចុងក្រោយរបស់យើងនឹងជា:
ការធ្វើការជាមួយផលិតផលនៅក្នុងកំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់
ឥឡូវនេះ, សម្រាប់ប្រព័ន្ធប្រតិបត្តិការល្អឥតខ្ចោះយើងត្រូវការលក្ខណៈពិសេស: លក្ខណៈពិសេសដែលមានន័យថាអេឡិចត្រូនិងអេឡិចត្រូនិងអេឡិចត្រូនិងអេឡិចត្រូនិងអេឡិចត្រូនិងអេឡិចត្រូន។ទោះជាយ៉ាងណាក៏ដោយអេឡិចត្រូនិកដែលមានដំណោះស្រាយទាបបំផុតជាធម្មតា (ដូចជា Bellman-Ford ដែលយើងប្រើ) ត្រូវបានរចនាឡើងដើម្បីរកដំណោះស្រាយដែលមានកម្រិតខ្ពស់បំផុត។សត្វដើម្បីធ្វើឱ្យប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិប្រវត្តិ
អេឡិចត្រូនិងអេឡិចត្រូនិងអេឡិចត្រូនិងអេឡិចត្រូនិងអេឡិចត្រូនិងអេឡិចត្រូន។
ជាមួយនឹងការផ្លាស់ប្តូរនេះ, ទំហំទំហំទំហំទំហំដែលធ្វើឱ្យមានតម្លៃទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំ។
ការធ្វើតេស្តយ៉ាងត្រឹមត្រូវជាមួយBigInt
The amounts of tokens in DeFi can vary wildly, from tiny fractions (e.g., for ERC-20 tokens with 18 decimal places) to very large numbers (e.g., stablecoins). This extreme heterogeneity in magnitude, spanning up to 18 significant figures, makes standard floating-point arithmetic highly susceptible to precision errors. Such errors, though seemingly small, can lead to misidentified opportunities or, worse, unprofitable trades.
To overcome this, our Market Graph Service, and indeed all calculations involving token amounts and exchange rates within the bot, utilize Go’s math/bigសៀវភៅពិសេសBigIntសម្រាប់ទំហំអ៊ីនធឺណិតនិងBigFloatការធ្វើតេស្តនៅពេលដែលអ្នកត្រូវការ។BigFloatការផ្តល់ជូននូវភាពត្រឹមត្រូវដោយស្វ័យប្រវត្តិlog2 ។BigIntឬBigFloatតម្រូវឱ្យមានការគ្រប់គ្រងយ៉ាងឆាប់រហ័សដូចជាទូទៅmath.Logសកម្មភាពដែលធ្វើការនៅលើ Nativefloat64ប្រភេទ។ ការដំឡើងផ្ទាល់ខ្លួនឬសៀវភៅខាងក្រៅដែលអាចមានលក្ខណៈពិសេស logarithms គឺជាការសំខាន់នៅទីនេះ។
func getLogRate(reserve0, reserve1 *big.Int) *big.Float {
const prec = 1024
resIn := new(big.Float).SetPrec(prec).SetInt(reserve0)
resOut := new(big.Float).SetPrec(prec).SetInt(reserve1)
// Effective Rate
rate := new(big.Float).SetPrec(prec).Quo(resOut, resIn)
logRate := bigfloat.Log(rate)
return logRate.Neg(logRate)
}
ការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយការកាត់បន្ថយ
បន្ទាប់ពីទីផ្សារ DeFi ត្រូវបានរចនាឡើងយ៉ាងត្រឹមត្រូវដូចជាក្រាហ្វិកជាមួយនឹងកម្រិតខុសគ្នានៃកម្រិតខុសគ្នានៃកម្រិតខុសគ្នានៃកម្រិតខុសគ្នានៃកម្រិតខុសគ្នានៃកម្រិតខុសគ្នានៃកម្រិតខុសគ្នានៃកម្រិតខុសគ្នានៃកម្រិតខុសគ្នានៃកម្រិតខុសគ្នានៃកម្រិត។negative cycles within this graph. For this, we employ the Bellman-Ford algorithm.
Bellman-Ford គឺជាកំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណត់កំណ
ប្រព័ន្ធប្រតិបត្តិការនេះធ្វើការដោយធ្វើការដោយការបាត់បន្ថយទម្រង់ដោយធ្វើឱ្យប្រសិនបើមានដំណោះស្រាយកាត់បន្ថយប្រសិនបើដំណោះស្រាយកាត់បន្ថយប្រសិនបើដំណោះស្រាយកាត់បន្ថយប្រសិនបើដំណោះស្រាយកាត់បន្ថយប្រសិនបើដំណោះស្រាយកាត់បន្ថយប្រសិនបើដំណោះស្រាយកាត់បន្ថយប្រសិនបើដំណោះស្រាយកាត់បន្ថយប្រសិនបើដំណោះស្រាយកាត់បន្ថយប្រសិនបើដំណោះស្រាយកាត់បន្ថយប្រសិនបើដំណោះស្រាយកាត់បន្ថយប្រសិនបើដំណោះស្រាយកាត់បន្ថយប្រសិនបើដំណោះ
type Edge struct {
Pair string
From Token
To Token
LogRate *big.Float
Reserve0 *big.Int
Reserve1 *big.Int
Dex string
MinOut *big.Int
}
type Graph struct {
nodes map[string]Token
Edges map[string][]*Edge
pairChan *chan GraphMessage
dexCheckChan *chan DexDexMessage
subscriptions []*chan time.Duration
mu sync.RWMutex
}
// Bellman-Ford algorithm to find arbitrage cycles
func (g *Graph) FindArbitrage(source Token) ([]*Edge, bool) {
sourceKey := source.Address
g.mu.RLock()
defer g.mu.RUnlock()
distance := make(map[string]*big.Float)
predecessor := make(map[string]*Edge)
// 1. Init
for token := range g.nodes {
distance[token] = new(big.Float).SetInf(false)
}
distance[sourceKey] = new(big.Float).SetFloat64(0)
// 2. Relax edges V-1 times
for i := 0; i < len(g.nodes)-1; i++ {
for _, edgeList := range g.Edges {
for _, e := range edgeList {
from := e.From.Address
to := e.To.Address
if !distance[from].IsInf() && new(big.Float).Add(distance[from], e.LogRate).Cmp(distance[to]) < 0 {
distance[to].Add(distance[from], e.LogRate)
predecessor[to] = e
}
}
}
}
// 3. Negative cycle detection
var cycleStartToken string
for _, edgeList := range g.Edges {
for _, e := range edgeList {
from := e.From.Address
to := e.To.Address
if !distance[from].IsInf() && new(big.Float).Add(distance[from], e.LogRate).Cmp(distance[to]) < 0 {
cycleStartToken = to
break
}
}
if cycleStartToken != "" {
break
}
}
if cycleStartToken == "" {
return nil, false // No Arbitrage
}
// 4. detect first cycle node
visited := make(map[string]bool)
current := cycleStartToken
for !visited[current] {
visited[current] = true
edge := predecessor[current]
if edge == nil {
return nil, false // missing edge
}
current = edge.From.Address
}
// 5. Complete cycle
cycleStart := current
cycle := []*Edge{}
for {
edge := predecessor[current]
if edge == nil {
return nil, false // missing edge
}
cycle = append(cycle, edge)
current = edge.From.Address
if current == cycleStart {
break
}
}
// 6. Invert cycle
for i, j := 0, len(cycle)-1; i < j; i, j = i+1, j-1 {
cycle[i], cycle[j] = cycle[j], cycle[i]
}
return cycle, true
}
ការកំណត់ទំហំអតិបរមា: អតិបរមា អត្ថប្រយោជន៍
Once a negative cycle (arbitrage opportunity) is identified, the next critical step is to determine the optimal input amount(dx) សម្រាប់ការជួញដូរដំបូងនៅក្នុងការជួញដូរ។ នេះមិនមែនជាការជួញដូរទេ។ ការជួញដូរនៃឱកាសជួញដូរគឺជាបច្ចេកវិទ្យានៃទំហំការជួញដូរដែលមិនមែនជាលក្ខណៈលក្ខណៈលក្ខណៈដោយសារតែលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈលក្ខណៈ។
ជាពិសេសនៅពេលដែលទំហំអាជីវកម្មបានកើនឡើងទំហំអាជីវកម្មនេះនឹងកើនឡើងទំហំអាជីវកម្មដែលមានប្រសិទ្ធិភាពដោយសារតែទំហំអាជីវកម្មនេះមិនមានប្រសិទ្ធិភាព។ នេះមានន័យថាមានពាក់កណ្តាល: ទំហំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំ
គោលបំណងនៃការបង្កើនអត្ថប្រយោជន៍គឺ aconvex optimization problemសម្រាប់ស៊េរីនៃការផ្លាស់ប្តូរ N នៅលើដំណើរការ arbitration, ទំហំផលិតផលចុងក្រោយ (និងដូច្នេះប្រាក់រង្វាន់) អាចត្រូវបានបង្ហាញជាប្រតិបត្ដិការនៃប្រាក់រង្វាន់ដំណើរការដំបូង (dx) ។ ខណៈពេលដែលដំណោះស្រាយវិជ្ជាជីវៈវិជ្ជាជីវៈត្រឹមត្រូវសម្រាប់ការ arbitration បន្ថែមទៀតអាចមានភាពងាយស្រួល, ជាពិសេសជាមួយនឹងរចនាសម្ព័ន្ធប្រាក់រង្វាន់ផ្សេងគ្នានិងទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហ
Our Arbitrage Strategy Service addresses this by employing an optimization solver from Go’s gonum/optimizeការដោះស្រាយនេះទទួលបានបច្ចេកទេសដែលបង្ហាញនូវប្រាក់រង្វាន់សូម្បីតែប្រាក់រង្វាន់សូម្បីតែប្រាក់រង្វាន់ហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គីហ្គី។amountOutគំរូdy = (x + dx) / (dx⋅ y)សម្រាប់ដំណោះស្រាយទាំងអស់នៅក្នុងដំណោះស្រាយ arbitration, ការគណនានៃការផ្លាស់ប្តូរការផ្លាស់ប្តូរការផ្លាស់ប្តូរការផ្លាស់ប្តូរការផ្លាស់ប្តូរការផ្លាស់ប្តូរការផ្លាស់ប្តូរការផ្លាស់ប្តូរការផ្លាស់ប្តូរការផ្លាស់ប្តូរការផ្លាស់ប្តូរការផ្លាស់ប្តូរ។
func getOptimalAmoutIn(edges []*Edge, decimals int) (*float64, error) {
factor := math.Pow10(decimals)
intMax, _ := constants.GetRouterReserveFromToken(edges[0].From.Address)
maxCapital := new(big.Float).Mul(new(big.Float).SetInt64(intMax), big.NewFloat(factor))
fee := big.NewFloat(0.997)
problem := optimize.Problem{
Func: func(x []float64) float64 {
delta := big.NewFloat(x[0])
if delta.Cmp(big.NewFloat(0)) < 0 || delta.Cmp(maxCapital) > 0 {
return math.Inf(1)
}
delta_i := new(big.Float).Set(delta)
for _, edge := range edges {
effectiveIn := new(big.Float).Mul(delta_i, fee)
reserveIn := new(big.Float).SetInt(edge.Reserve0)
reserveOut := new(big.Float).SetInt(edge.Reserve1)
num := new(big.Float).Mul(reserveOut, effectiveIn)
denom := new(big.Float).Add(reserveIn, effectiveIn)
delta_i = new(big.Float).Quo(num, denom)
}
profit := new(big.Float).Sub(delta_i, delta)
result, _ := profit.Float64()
return -result
},
}
result, err := optimize.Minimize(problem, []float64{1.0}, nil, nil)
if err != nil {
return nil, err
}
return &result.X[0], nil
}
ការប្រៀបធៀបនៃ swaps និងការប្រៀបធៀបការប្រៀបធៀបនៃការប្រៀបធៀប
មុនពេលធ្វើប្រតិបត្តិការណាមួយត្រូវបានដំណើរការសេវាកម្ម Strategy Arbitration បានធ្វើការពិនិត្យឡើងវិញsimulated execution of the entire arbitrage path. This step is crucial for verifying the actual profitability, given the real-time market conditions and the exact parameters of the proposed trade.
ការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃការរៀបចំនៃ
func (ab *ArbitrageBuilderV2) calculateProfitabilityWithSlippage(edges []*Edge, decimals int) (*big.Float, *big.Float, error) {
opt, err := getOptimalAmoutIn(edges, decimals)
if err != nil {
return nil, nil, err
}
optBig := new(big.Float).SetFloat64(*opt)
amount := new(big.Float).Set(optBig)
fee := big.NewFloat(0.997)
for _, edge := range edges {
if edge.Reserve0 == nil || edge.Reserve1 == nil ||
edge.Reserve0.Cmp(big.NewInt(0)) == 0 || edge.Reserve1.Cmp(big.NewInt(0)) == 0 {
return nil, nil, errors.New("edge has invalid reserves")
}
reserveIn := new(big.Float).SetInt(edge.Reserve0)
reserveOut := new(big.Float).SetInt(edge.Reserve1)
amountInWithFee := new(big.Float).Mul(amount, fee)
if amountInWithFee.Cmp(reserveIn) >= 0 {
return big.NewFloat(-1.0), nil, errors.New("amount exceeds available reserves")
}
// "x * y = k"
numerator := new(big.Float).Mul(reserveOut, amountInWithFee)
denominator := new(big.Float).Add(reserveIn, amountInWithFee)
amountOut := new(big.Float).Quo(numerator, denominator)
amount = amountOut
}
profit := new(big.Float).Sub(amount, optBig)
profit.Sub(profit, ab.EstimateGasCost(len(edges)))
profit.Sub(profit, new(big.Float).Mul(optBig, big.NewFloat(0.005)))
normalizedProfit := new(big.Float).Quo(profit, new(big.Float).SetFloat64(math.Pow10(decimals)))
return normalizedProfit, optBig, nil
}
ជាការសំខាន់ណាស់, ការធ្វើតេស្តនេះក៏រួមបញ្ចូលminimum output amount (minOut)ការត្រួតពិនិត្យសម្រាប់ជំហានរវាងទាំងអស់នេះ។minOutទិន្នន័យនៃតម្លៃនេះត្រូវបានបង្កើតឡើងពីផលិតផលដែលគួរឱ្យចាប់អារម្មណ៍និងត្រូវបានកំណត់ជាទំហំនៅក្នុងការធ្វើប្រតិបត្តិការនៅលើខ្សែពិតប្រាកដ។ ប្រសិនបើ, ដោយសារតែការឆ្លងកាត់បន្ថយនៃបណ្តាញ, ការឆ្លងកាត់បន្ថយ, ឬស្ថានភាពទីផ្សារដែលមិនគួរឱ្យចាប់អារម្មណ៍, ការធ្វើប្រតិបត្តិការនៅលើខ្សែពិតប្រាកដនៃការផ្លាស់ប្តូរគឺតិចជាងការបញ្ជាក់របស់វា។minOutឧបករណ៍នេះគឺជាការធានារ៉ាប់រងសំខាន់មួយដែលការពារ bot ពីការបញ្ចប់ជំហានអាជីវកម្មដែលមិនមានប្រសិទ្ធិភាពនិងការកាត់បន្ថយការបាត់បន្ថយទៅគ្រាន់តែឧស្ម័នដែលបានបាត់បន្ថយលើប្រតិបត្តិការដែលត្រូវបានបាត់បន្ថយ។
ប្រសិនបើអត្ថប្រយោជន៍ឥតគិតថ្លៃចុងក្រោយ, បន្ទាប់ពីទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទាំងទូទៅ។profit threshold(ឧទាហរណ៍, 0.5% នៃទូទាត់បញ្ចូលដំបូង) គឺជាឱកាសដែលត្រូវបានគេស្គាល់ថាអាចធ្វើបានហើយត្រូវបានផ្ញើដល់សេវាកម្ម Transaction Builder ដើម្បីដំណើរការ។ លក្ខខណ្ឌនេះធានាថានឹងថានឹងរក្សាទុកឱកាសប៉ុណ្ណោះដែលមានលក្ខខណ្ឌសំខាន់ណាស់ដើម្បីធានាថានឹងមានតម្លៃទូទាត់និងនៅលើខ្សែក្រណាត់។
ការវិជ្ជាជីវៈប្រតិបត្តិការ: Swift Execution in the Dark Forest
ការយល់ដឹងអំពីឱកាស arbitration ដែលមានអត្ថប្រយោជន៍គឺគ្រាន់តែផ្នែកមួយនៃការសាកល្បង។ ការយល់ដឹងអំពីឱកាស arbitration ដែលមានអត្ថប្រយោជន៍គឺជាផ្នែកមួយ។ ការយល់ដឹងអំពីឱកាស arbitration ដែលមានអត្ថប្រយោជន៍គឺគ្រាន់តែផ្នែកមួយនៃការសាកល្បងដែលមានអត្ថប្រយោជន៍ជាងមុន។ នៅក្នុងការប្រកួតប្រជែងរបស់ DeFi "Dark Forest" ដែលមានអត្ថប្រយោជន៍ជាច្រើនដែលមានភាពងាយស្រួលនិងប្លាស្ទិចដែលមានភាពងាយស្រួលក្នុងរយៈពេល ២ វិនាទី, ការវិស្វកម្មពាណិជ្ជកម្មបានក្លាយជាវិធីសាស្រ្ត។ វាត្រូវបានបង្កើតឡើងក្នុងផ្នែកនេះដើម្បីបន្ថែមអំពីប្រព័ន្ធប្រតិបត្តិការនិងការបច្ចេកទេសក្នុងចំណោមTransaction Builder Service designed to ensure lightning-fast and secure execution.
គោលបំណងនៃល្បឿន
ការជួញដូរសម្រាប់ឱកាសជួញដូរនៅលើការផ្លាស់ប្តូរ decentralized គឺជាធម្មតានៅក្នុងគីឡូម៉ែត្រ។ ការខុសគ្នានៃតម្លៃត្រូវបានរកឃើញយ៉ាងឆាប់រហ័សនិងត្រូវបានប្រើប្រាស់ដោយប្រព័ន្ធដោយស្វ័យប្រវត្តិជាច្រើនដែលបង្កើតការជួញដូរយ៉ាងឆាប់រហ័សដើម្បីជាលើកដំបូងក្នុងការរួមបញ្ចូលការជួញដូរជួញដូរនៅក្នុងប្លុកថ្មី។ ការជួញដូរណាមួយប៉ុណ្ណោះអាចធ្វើឱ្យជួញដូរត្រូវបានទទួលបានដោយអ្នកជួញដូរដែលនាំទៅនឹងការជួញដូរដែលមិនបានជួញដូរនិងតម្លៃឧស្ម័ន។ ដូច្នេះការជួញដូរទាំងអស់នៅក្នុងសេវាកម្ម Transaction Builder ត្រូវបានបង្កើត
In-Memory Optimization for Instantaneous Transaction Building
ដើម្បីទទួលបានល្បឿនដែលត្រូវការ, ប្រព័ន្ធរបស់យើងផ្តល់គោលបំណងដើម្បីមានសមាសធាតុប្រតិបត្តិការសំខាន់ទាំងអស់ដែលអាចរកបានយ៉ាងឆាប់រហ័សនៅក្នុងការចែកចាយការប្រតិបត្តិការ I/O ដែលមានតម្លៃខ្ពស់ឬការទូរស័ព្ទនៅលើខ្សែនៅពេលដំណើរការប្រតិបត្តិការសំខាន់។
- ប្រព័ន្ធរបស់យើងបានបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់។
- ទិន្នន័យ On-Chain Cached for Transaction Fields: ដើម្បីជួសជុលទិន្នន័យ transaction metadata នៅលើខ្សែក្រវ៉ាត់បន្ថយការចែករំលែកការចែករំលែកការចែករំលែកការចែករំលែកការចែករំលែកការចែករំលែកការចែករំលែកការចែករំលែកការចែករំលែកការចែករំលែកការចែករំលែកការចែករំលែកការចែករំលែក។
- គណនីគណនី: គណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនី
- ទំហំឧស្ម័នល្អឥតគិតថ្លៃ: ទំហំឧស្ម័នល្អឥតគិតថ្លៃនេះគឺជាឧស្ម័នល្អឥតគិតថ្លៃ។ ទំហំឧស្ម័នល្អឥតគិតថ្លៃគឺជាឧស្ម័នល្អឥតគិតថ្លៃ។ ទំហំឧស្ម័នល្អឥតគិតថ្លៃគឺជាឧស្ម័នល្អឥតគិតថ្លៃនិងឧស្ម័នល្អឥតគិតថ្លៃ។
- វិញ្ញាបនប័ត្រសញ្ញាបនប័ត្រ: វិញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រសញ្ញាបនប័ត្រស
ដោយការរក្សាទុកឧបករណ៍សំខាន់ទាំងនេះនៅក្នុងការចែកចាយសេវាកម្ម Transaction Builder អាចរចនាឡើងនិងសន្សំការ blockchain ទាំងស្រុងនៅក្នុង microseconds សរុបសម្រាប់ការដឹកជញ្ជូនឆាប់រហ័ស។
ការជ្រើសរើសគំនិតគំនិត Smart Contract: Flash Loans vs. Direct Swaps
សេវាកម្ម Strategy Arbitration ផ្តល់ជូននូវដំណោះស្រាយ arbitrage ដែលមានប្រសិទ្ធិភាពនិងចំនួនដំណោះស្រាយអតិបរមាដែលបានកំណត់ទៅកាន់អ្នកបង្កើតពាណិជ្ជកម្ម ដោយផ្អែកលើទំហំនៃការamountInនិងប្រសិនបើវាបានបន្ថែមទំហំទូលំទូលាយដែលបានកំណត់មុន (ឬប្រសិនបើគោលដៅរបស់វាជាការច្នៃប្រឌិត) Transaction Builder បានជ្រើសរើសរើសរើសរើសរើសរើសរើសរើសរើសរើសរើសរើសរើសរើសរើសគំនិតគំនិតគំនិតគំនិតសម្រាប់ការអនុវត្ត:
- គោលបំណងការដោះស្រាយការផ្លាស់ប្តូរដោយផ្ទាល់: សម្រាប់ឱកាសដែលអាចត្រូវបានផ្តល់សេវាកម្មដោយផ្ទាល់ដោយមូលនិធិរបស់ bot នេះអ្នកដោះស្រាយប្រើគោលបំណង executeArb (ឬដូចគ្នានេះ) នៅលើគោលបំណង proxy multi-swap ដែលបានផ្លាស់ប្តូរដោយផ្ទាល់។ ដូចជាគោលបំណងនេះបានបង្ហាញនៅក្នុងគោលបំណងទី 3 ។ គោលបំណងនេះទទួលបានគោលបំណងការផ្លាស់ប្តូរពីកុំព្យូទ័ររបស់ bot និងដោះស្រាយបញ្ជីទាំងអស់នៃការផ្លាស់ប្តូរក្នុងការប្រតិបត្តិការ atomic មួយ។ គោលបំណងនេះជៀសវាងភាពងាយស្រួលនិងការបន្ថែមទៀតនៃការផ្តល់ឥណទាន flash នៅពេលដែលមិន
- ការគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនីគណនី
ការជ្រើសរើសអត្ថប្រយោជន៍នេះធានាឱ្យមានប្រសិទ្ធិភាពក្នុងការបម្រើមធ្យមនិងការអនុវត្តគោលបំណងដែលមានប្រសិទ្ធិភាពដោយផ្អែកលើលក្ខណៈពិសេសនៃឱកាសដែលបានរកឃើញ។
Mempool Dynamics: Navigating Ethereum L1 vs. Layer 2 ខ្សែភាពយន្ត
ការអនុវត្ត arbitration គឺជាផ្នែកសំខាន់នៃការយល់ដឹងអំពីម៉ាស៊ីនបម្រើប្រតិបត្តិការ blockchain, ជាពិសេសmempool.
-
Ethereum L1 Mempool: On Ethereum’s Layer 1, the mempool is a public, transparent waiting room for all pending transactions. Transactions broadcasted by users or bots are relayed to various nodes across the network, becoming visible to anyone monitoring the mempool. This transparency is the breeding ground for generalized frontrunning bots (often referred to as “searchers” or “MEV bots”). These sophisticated entities continuously scan the mempool for profitable transactions (e.g., large swaps that cause significant price impact, liquidations, or other arbitrage attempts). Upon detecting such a transaction, they quickly construct an identical or similar transaction, replace the original recipient address with their own, and submit it with a higher gas price (or higher priority fee in EIP-1559) to ensure their transaction is included in the block before the original, thereby stealing the profit. This competitive landscape makes direct arbitrage on L1 highly challenging without leveraging specialized MEV relays.
-
Layer 2 (L2) Chains and Reduced Mempool Visibility (e.g., Base): Our bot strategically operates on Base, an EVM-compatible Layer 2 blockchain. The architecture of many L2s, including Base, fundamentally alters the traditional L1 mempool dynamic. Base does not currently expose a publicly visible mempool in the same manner as Ethereum Layer 1. Instead, transactions are typically sent directly to a centralized sequencer or a private mempool before being batched and committed to the L1.
This architectural difference significantly reduces the direct threat of generalized frontrunning. While MEV still exists on L2s (e.g., through sequencer-controlled ordering or other means), the immediate, public visibility of pending transactions that enables L1 frontrunning is largely absent. This provides a more predictable and secure execution environment for our arbitrage transactions, as the bot’s crafted atomic operations are less likely to be “sniped” before they even reach a block producer. This improved execution predictability contributes directly to higher success rates for profitable arbitrages.
ល្បឿននិងសុវត្ថិភាព Node: មជ្ឈមណ្ឌលនៃការអនុវត្តដែលមានសុវត្ថិភាព
ការតភ្ជាប់ទៅនឹងកុង blockchain គឺជាទីតាំងមួយនៃការចូលនិងចេញសម្រាប់ទិន្នន័យនិងប្រតិបត្តិការទាំងអស់។ ល្បឿននិងសុវត្ថិភាពរបស់វាគឺជាការសំខាន់បំផុត:
- ការតភ្ជាប់ Node ខ្ពស់: សេវាកម្ម Transaction Builder បានតភ្ជាប់ជាមួយអ្នកផ្គត់ផ្គង់ Node ខ្ពស់ដែលមានតម្លៃខ្ពស់ (ដូចជា Alchemy, Infura ឬ Node ដោយខ្លួនឯង) ។ ការតភ្ជាប់ដែលមានល្បឿនលឿននិងមានទម្ងន់ទាបគឺជាការសំខាន់ដើម្បីកាត់បន្ថយពេលវេលារវាងការសន្សំប្រតិបត្តិការនិងការបម្រើវាទៅលើបណ្តាញ។ ការតភ្ជាប់បណ្តាញណាមួយនៅទីនេះត្រូវបានផ្លាស់ប្តូរដោយផ្ទាល់ទៅនឹងឱកាសការតភ្ជាប់ដែលបានបាត់បន្ថយ។ ការតភ្ជាប់ (ការតភ្ជាប់ទៅនឹងខ្សែជាច្រើន) អាចត្រូវបានគេស្គាល់ផងដែរដើម្បីធ្វើឱ្យមានភាពសុវត្ថិភាពខ្ពស់បំផុត។
- Node Security and Integrity: ការសុវត្ថិភាពនៃការបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះប
ដោយការធ្វើឱ្យប្រសើរឡើងយ៉ាងតឹងរឹងសម្រាប់ល្បឿននៅកម្រិតទាំងអស់ពីការរចនាសម្ព័ន្ធទិន្នន័យក្នុងការចែកចាយនិងការគណនាសម្ព័ន្ធមុនទៅនឹងការជ្រើសរើសរើសបណ្តាញវិជ្ជាជីវៈនិងវិជ្ជាជីវៈកម្រិតខ្ពស់របស់យើង, arbitrage bot របស់យើងត្រូវបានរចនាឡើងដើម្បីធ្វើឱ្យប្រសើរជាងការប្រកួតប្រជែងនិងទទួលបានអត្ថប្រយោជន៍ដោយសុវត្ថិភាពពីឱកាសរលាយនៅក្នុងតំបន់ DeFi ។ នៅក្នុងគំនិតបន្ទាប់យើងនឹងពិភាក្សាអំពីវិជ្ជាជីវៈប្រតិបត្តិការសំខាន់ដែលត្រូវការដើម្បីរក្សាទុកនិងអភិវឌ្ឍប្រព័ន្ធមានតម្លៃខ្ពស់ដូច្នេះ។
ការដោះស្រាយនៅក្នុងខ្នាតខ្នាតខ្នាត: ការបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តាល
ការបង្កើតនិងប្រតិបត្តិការ bot arbitrage នៅក្នុង DeFi “Dark Forest” គឺជាការបង្ហាញនូវថាមពលនៃបច្ចេកវិទ្យា decentralized, ប៉ុន្តែវាបានបង្ហាញនូវបញ្ហាសំខាន់និងគោលបំណងអ៊ីនធឺណិត។ ខណៈពេលដែលប្រព័ន្ធរបស់យើងបង្ហាញនូវសមត្ថភាពបច្ចុប្បន្ននិងបច្ចុប្បន្ននៃ arbitrage ដោយស្វ័យប្រវត្តិ, វាគឺជាការសំខាន់ដើម្បីទទួលបានការយល់ដឹងអំពីកម្រិតខុសគ្នានិងផលប៉ះពាល់ទូលំទូលាយរបស់វា។
The Constant Battle Against Malicious Actors: The Role of Bloom ស្លាក
ការអស្ចារ្យដំបូងអំពីលក្ខណៈពិសេសគ្មានការអនុញ្ញាតរបស់ DeFi បានកាត់បន្ថយដោយការកើនឡើងនៃការកើនឡើងនៃអ្នកលេងគួរឱ្យចាប់អារម្មណ៍។Honeywall Serviceវាគឺជាដំណោះស្រាយចុងក្រោយនៃការការពារដ៏សំខាន់មួយប៉ុន្តែការច្នៃប្រឌិតនៃអ្នកលេងគួរឱ្យចាប់អារម្មណ៍ទាំងនេះបានតម្រូវឱ្យមានការប្រឆាំងនឹងការអភិវឌ្ឍបច្ចុប្បន្ន។
ជាផ្នែកសំខាន់នៃការពារនេះគឺBloom filterBloom filter គឺជារចនាសម្ព័ន្ធទិន្នន័យប្រសិទ្ធិភាពដែលអាចធ្វើតេស្តយ៉ាងឆាប់រហ័សនិងមានប្រសិទ្ធិភាពប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើប្រសិនបើ
ទោះបីជាការត្រួតពិនិត្យមុនដែលមានភាពងាយស្រួលដែលត្រូវបានអនុវត្តនៅក្នុងលក្ខខណ្ឌរបស់យើងArbHelperMapក្រុមហ៊ុន Smart Contract (ជាពិសេសក្រុមហ៊ុន_checkTaxLimitក្នុងនាមជាការប្រៀបធៀបដែលធ្វើឱ្យប្រៀបធៀបការផ្លាស់ប្តូរការធ្វើដំណើរដើម្បីកំណត់ទិន្នន័យទិន្នន័យមួយចំនួនដែលមានគោលបំណងដើម្បីប្រៀបធៀបការផ្លាស់ប្តូរទិន្នន័យដែលមានគោលបំណងដើម្បីប្រៀបធៀបការផ្លាស់ប្តូរទិន្នន័យដែលមានគោលបំណងដើម្បីប្រៀបធៀបការផ្លាស់ប្តូរទិន្នន័យដែលមានគោលបំណងដើម្បីប្រៀបធៀបការផ្លាស់ប្តូរទិន្នន័យនេះ។getAmountsOutសកម្មភាព (ដែលត្រូវបានប្រើសម្រាប់សំណួរតម្លៃ) ដើម្បីបង្ហាញពីផលិតផលធម្មតាដែលមានតម្លៃទាប។ ទោះបីជាយ៉ាងណាក៏ដោយគោលបំណងពិតប្រាកដនៃ "Honeyypot" ត្រូវបានបណ្តុះបណ្តាលយ៉ាងទូលំទូលាយក្នុងការពិតប្រាកដ។swapExactTokensForTokensឬបច្ចុប្បន្នtransferសមត្ថភាពទាំងនេះអាចអនុញ្ញាតឱ្យទូទាត់ទូទាត់ទូទាត់យ៉ាងទូលំទូលំទូលាយ (ដូចជា 99%) នៅលើប្រតិបត្តិការលក់ឬគ្របដណ្តប់ទូទាត់យ៉ាងទូលំទូលំទូលំទូលំទូលាយ។
ក្នុងអំឡុងពេលនៃដំណើរការសាកល្បងរបស់យើងយើងបានរកឃើញចំនួនសំខាន់នៃការបាត់បង់ដូច្នេះ។ ខ្ញុំបានទទួលបានអាសយដ្ឋានមួយចំនួនដែលបានដំណើរការយ៉ាងជោគជ័យនៅដំបូងgetAmountsOutការត្រួតពិនិត្យប៉ុន្តែបានបង្ហាញការត្រួតពិនិត្យការទូទាត់ឬការលក់ត្រួតពិនិត្យតែនៅក្នុងដំណើរការពិតប្រាកដ (ប្រៀបធៀបឬបិទ) នៅលើទិន្នន័យកន្លែង។ ឯកសារ db នេះនឹងត្រូវបានធ្វើឱ្យអាចរកបាននៅលើការត្រួតពិនិត្យ GitHub នៃគម្រោងនេះជាប្រសិទ្ធិភាពសង្គមដើម្បីជួយអ្នកផ្សេងទៀតដើម្បីជៀសវាងការបាត់បង់ទាំងនេះ។ ការប្រកួតប្រជែងរំខាននេះបង្ហាញពីការតម្រូវការនៃការត្រួតពិនិត្យរំខាន, ការចែកចាយរំខានយ៉ាងឆាប់រហ័សនិងប្រព័ន្ធការពារជាច្រើន។
លក្ខណៈសម្បត្តិវិញ្ញាបនប័ត្រនិងពន្លឺនៃខ្នាតខ្នាតខ្នាត
ការប្រៀបធៀបនៃ "Dark Forest" មិនត្រឹមតែសម្រាប់ការជួញដូរកាត់បន្ថយក្នុងចំណោមប្លាស្ទិចប៉ុណ្ណោះប៉ុណ្ណោះប៉ុណ្ណោះសម្រាប់ពិព័រណ៍អាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាសអាភាស
គំនិតអាសអាភាសនៃFOMO (Fear Of Missing Out), រួមជាមួយនឹងការគ្មានការយល់ដឹងជាទូទៅអំពីឧបករណ៍ blockchain និងឧបករណ៍គោលបំណងដែលមានមូលដ្ឋានធ្វើឱ្យអ្នកប្រើពាណិជ្ជកម្មជាច្រើនមានភាពងាយស្រួលក្នុងបរិស្ថាននេះ។ ពួកគេចូលទៅក្នុងទីផ្សារដែលមានភាពខុសគ្នានៃលក្ខណៈខុសគ្នានៃលក្ខណៈខុសគ្នានៃលក្ខណៈខុសគ្នានៃលក្ខណៈខុសគ្នានៃលក្ខណៈខុសគ្នានៃលក្ខណៈខុសគ្នានៃលក្ខណៈខុសគ្នានៃលក្ខណៈខុសគ្នានៃលក្ខណៈខុសគ្នានៃលក្ខណៈខុសគ្នានៃលក្ខណៈពាណិជ្ជកម្ម។
គោលការណ៍នេះអាចផ្លាស់ប្តូរយ៉ាងឆាប់រហ័សពី "ការអនុញ្ញាតប្រាក់ចំណេញ" ទៅ "ការអនុញ្ញាតប្រាក់ចំណេញ" ទៅ "ការអនុញ្ញាតប្រាក់ចំណេញ" ដែលអាចកាត់បន្ថយការជឿទុកចិត្តក្នុងកន្លែងដែលមានបទពិសោធដ៏អស្ចារ្យ។ DeFi ជាគោលបំណងនៃគោលបំណងរបស់គោលបំណងរបស់គោលបំណងនេះគឺដើម្បីបង្កើតប្រសិទ្ធិភាពសេវាកម្មដោយផ្តល់នូវការចូលរួមនិងការឆ្លើយតបដោយគ្មានការអនុញ្ញាត។ ទោះបីជាយ៉ាងណាក៏ដោយគោលបំណងនៃ MEV និងការលៃតម្រូវការនៃការបាត់បន្ថយការអនុញ្ញាតប្រាក់ចំណេញរបស់គោលបំណងនេះអាចកាត់បន្ថយគោលបំណងទាំងនេះដោយមិន
សៀវភៅ សៀវភៅ សៀវភៅ សៀវភៅ សៀវភៅ សៀវភៅ សៀវភៅ សៀវភៅ សៀវភៅ
ទោះជាយ៉ាងណាក៏ដោយភាពងាយស្រួលដែលមានលក្ខណៈពិសេសនិងបញ្ហាដែលមានលក្ខណៈពិសេសនៅលើពិព័រណ៍ DeFi, ការធ្វើដំណើរនៃការរចនាសម្ព័ន្ធ bot arbitrage នេះគឺជាការត្រួតពិនិត្យដ៏អស្ចារ្យនៃគោលនយោបាយបច្ចេកទេសដែលមានការអនុវត្តបច្ចេកទេស។ យើងបានធ្វើឱ្យប្រសើរឡើងក្នុងការបង្ហាញថាមពលនៃការរចនាសម្ព័ន្ធប្រព័ន្ធប្រតិបត្តិការ Go ដែលមានមូលដ្ឋាននៅលើព្រឹត្តិការណ៍ដែលមានប្រសិទ្ធិភាពសម្រាប់speed, precision, and data-driven insights, ដែលអាចរកឃើញនិងអនុវត្តសមត្ថភាព arbitration multi-leg ។
ជាលើកដំបូងគួរឱ្យចាប់អារម្មណ៍មួយនៅក្នុង "Dark Forest" គឺថាអតិបរមាជាច្រើននៃគុណភាព arbitration នឹងត្រូវបានឆ្លើយតបដោយអ្នកលេងធំទូលំទូលាយដែលមានសមត្ថភាពល្អដោយប្រើកូដដោយខ្លួនឯងនិងការចូលទៅដោយផ្ទាល់ទៅនឹងក្រុមហ៊ុនផលិតប្លុក។ ប៉ុន្តែការធ្វើតេស្តនិងការធ្វើតេស្តដែលមានជោគជ័យរបស់យើងបានបង្ហាញថាវាជាការពិតប្រាកដសម្រាប់ប្លុកធំទូលំទូលាយដែលមានគុណភាពក្នុងការស្វែងរកនិងទទួលបានអត្ថប្រយោជន៍ទាំងនេះ:
នៅពេលដែលការអនុម័តប្រសើរឡើងនៅលើម៉ូដែល AMM ដំបូងដូចជា Uniswap V2 (ដែលមានមូលដ្ឋានជាច្រើននៅលើក្រុមហ៊ុនផលិតផលធម្មតា) អាចត្រូវបានគួរឱ្យចាប់អារម្មណ៍ដើម្បីរក្សាទុករយៈពេលវែងដោយសារតែតម្លៃឧស្ម័នកម្រិតខ្ពស់និងការប្រកួតប្រជែងខ្ពស់ជាងនេះ, “Dark Forest” បានបន្តអភិវឌ្ឍ។ ការអនុវត្តថ្មីជាងនេះដូចជាការអនុម័ត Liquidity Concentrated AMMs (CLAMMs) នៃ Uniswap V3 បានបង្កើតវេជ្ជសាស្រ្តអនុម័តថ្មីដែលតម្រូវឱ្យមានម៉ូឌុលដែលមានភាពងាយស្រួលជាងមុនប៉ុណ្ណោះប៉ុន្តែជាធម្មតាដែលធ្វើឱ្យផលិតផលខ្ពស់ជាងមុនដោយសារតែការប្រសើរឡើងនៃ
ដូច្នេះនៅពេលដែលខ្ញុំនៅតែធ្លាប់មានសុវត្ថិភាពខ្ញុំអាចនិយាយថាខ្ញុំបានក្លាយជាអ្នកដោះស្រាយដោះស្រាយស្រស់ស្អាត។My compass is sharper, my map more detailed, and I understand the whispers of the canopy.
គម្រោង Repository
សម្រាប់អ្នកដែលចង់ទាញយកដំណោះស្រាយបន្ថែមទៀតក្នុងការអនុវត្តបច្ចុប្បន្ននិងទិន្នន័យពិតប្រាកដនៅចុងក្រោយនៃចំណុចមួយចំនួនដែលយើងបានពិភាក្សា, កំណែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែប្រែមាត្រា GitHubទោះបីជាទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទ
មាត្រា GitHubគំនិត
- លោក Dan Robinson, លោក Georgios Konstantopoulos. “Ethereum is a Dark Forest” ។
- លោក Guillermo Angeris, លោក Hsien-Tang Kao, លោក Rei Chiang, លោក Charlie Noyes និងលោក Tarun Chitra ។ «ការពិនិត្យឡើងវិញនៃទីផ្សារ Uniswap », Cryptoeconomic Systems ។
- Claudio Gebbia. “ការដោះស្រាយនិងការអនុវត្តនៃ arbitrage bots នៅក្នុងការហិរញ្ញវត្ថុកណ្តាលនិង decentralized”, សាកលវិទ្យាល័យ Zurich.
- លោក Y. Zhang, លោក Z. Li, លោក T. Yan, លោក Q. Liu, លោក N. Vallarano និងលោក C. J. Tessone, “អត្ថប្រយោជន៍អតិបរមាក្នុងការអនុម័ត។ archiv.
