У меня есть сырой проект арбитражного бота на дексах соланы, который я хочу протестировать в devnet. У меня есть ряд проблем на данном этапе и мне нужна твоя помощь в решении этих проблем. Структура моего проекта выглядит следующим образом: Структура моего проекта выглядит следующим образом: arbitrage-bot-rust/ ├── Cargo.toml # Workspace конфигурация ├── Anchor.toml # Anchor конфигурация ├── .env # Переменные окружения ├── .gitignore # Git игнор ├── README.md # Документация │ ├── programs/ # Смарт-контракты │ └── arbitrage-executor/ │ ├── Cargo.toml # Зависимости контракта │ ├── Xargo.toml # Cross-compilation │ └── src/ │ └── lib.rs # Основной контракт │ └── bot/ # Rust приложение бота ├── Cargo.toml # Зависимости бота └── src/ ├── main.rs # Точка входа ├── config.rs # Конфигурация ├── types.rs # Типы данных │ ├── scanner/ # Сканирование пулов │ ├── mod.rs # Модуль оркестратор │ ├── pool_monitor.rs # Мониторинг пулов │ ├── raydium_amm.rs # Raydium AMM сканер │ ├── raydium_cpmm.rs # Raydium CPMM сканер │ ├── raydium_clmm.rs # Raydium CLMM сканер │ └── meteora_dlmm.rs # Meteora DLMM сканер │ ├── arbitrage/ # Поиск арбитража │ ├── mod.rs # Модуль оркестратор │ ├── graph.rs # Граф цен │ ├── bellman_ford.rs # Алгоритм Bellman-Ford │ ├── opportunity.rs # Оценка возможностей │ └── profit_calculator.rs # Расчёт прибыли │ ├── executor/ # Исполнение транзакций │ ├── mod.rs # Модуль оркестратор │ ├── transaction_builder.rs # Построение транзакций │ ├── jito_client.rs # Jito интеграция │ └── simulator.rs # Симуляция транзакций │ └── utils/ # Утилиты ├── mod.rs # Модуль оркестратор ├── math.rs # Математические функции └── rpc.rs # RPC утилиты Проведи полный анализ кода всего проекта который я тебе вышлю. 1)Помоги решить проблему несовместимости версий rust, solana для оффчейн бота и ончейн программы. 2) Помоги доработать бота исправив все текущие ошибки 3) Помоги осуществить первый рабочий запуск бота в сети devnet 4) Необходимо реализовать логику расчета прибыльности для пулов DLMM, CLMM, CPMM На данном этапе запуска бота у меня выдает такие логи: newvovi4@DESKTOP-DDR0UB5:~/arbitrage-bot-rust/bot$ cargo run warning: unexpected `cfg` condition value: `custom-heap` --> programs/arbitrage-executor/src/lib.rs:91:1 | 91 | #[program] | ^^^^^^^^^^ | = note: expected values for `feature` are: `cpi`, `default`, `no-entrypoint`, `no-idl`, and `no-log-ix-name` = note: using a cfg inside a macro will use the cfgs from the destination crate and not the ones from the defining crate = help: try referring to `$crate::custom_heap_default` crate for guidance on how handle this unexpected cfg = help: the macro `$crate::custom_heap_default` may come from an old version of the `solana_program` crate, try updating your dependency with `cargo update -p solana_program` = note: see for more information about checking conditional configuration = note: `#[warn(unexpected_cfgs)]` on by default = note: this warning originates in the macro `$crate::custom_heap_default` which comes from the expansion of the attribute macro `program` (in Nightly builds, run with -Z macro-backtrace for more info) warning: unexpected `cfg` condition value: `solana` --> programs/arbitrage-executor/src/lib.rs:91:1 | 91 | #[program] | ^^^^^^^^^^ | = note: expected values for `target_os` are: `aix`, `amdhsa`, `android`, `cuda`, `cygwin`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `lynxos178`, `macos`, `netbsd`, `none`, `nto`, `nuttx`, `openbsd`, `psp`, `psx`, `redox`, `rtems`, `solaris`, `solid_asp3`, `teeos`, `trusty`, `tvos`, and `uefi` and 9 more = note: using a cfg inside a macro will use the cfgs from the destination crate and not the ones from the defining crate = help: try referring to `$crate::custom_heap_default` crate for guidance on how handle this unexpected cfg = help: the macro `$crate::custom_heap_default` may come from an old version of the `solana_program` crate, try updating your dependency with `cargo update -p solana_program` = note: see for more information about checking conditional configuration = note: this warning originates in the macro `$crate::custom_heap_default` which comes from the expansion of the attribute macro `program` (in Nightly builds, run with -Z macro-backtrace for more info) warning: unexpected `cfg` condition value: `custom-panic` --> programs/arbitrage-executor/src/lib.rs:91:1 | 91 | #[program] | ^^^^^^^^^^ | = note: expected values for `feature` are: `cpi`, `default`, `no-entrypoint`, `no-idl`, and `no-log-ix-name` = note: using a cfg inside a macro will use the cfgs from the destination crate and not the ones from the defining crate = help: try referring to `$crate::custom_panic_default` crate for guidance on how handle this unexpected cfg = help: the macro `$crate::custom_panic_default` may come from an old version of the `solana_program` crate, try updating your dependency with `cargo update -p solana_program` = note: see for more information about checking conditional configuration = note: this warning originates in the macro `$crate::custom_panic_default` which comes from the expansion of the attribute macro `program` (in Nightly builds, run with -Z macro-backtrace for more info) warning: unexpected `cfg` condition value: `solana` --> programs/arbitrage-executor/src/lib.rs:91:1 | 91 | #[program] | ^^^^^^^^^^ | = note: expected values for `target_os` are: `aix`, `amdhsa`, `android`, `cuda`, `cygwin`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `lynxos178`, `macos`, `netbsd`, `none`, `nto`, `nuttx`, `openbsd`, `psp`, `psx`, `redox`, `rtems`, `solaris`, `solid_asp3`, `teeos`, `trusty`, `tvos`, and `uefi` and 9 more = note: using a cfg inside a macro will use the cfgs from the destination crate and not the ones from the defining crate = help: try referring to `$crate::custom_panic_default` crate for guidance on how handle this unexpected cfg = help: the macro `$crate::custom_panic_default` may come from an old version of the `solana_program` crate, try updating your dependency with `cargo update -p solana_program` = note: see for more information about checking conditional configuration = note: this warning originates in the macro `$crate::custom_panic_default` which comes from the expansion of the attribute macro `program` (in Nightly builds, run with -Z macro-backtrace for more info) warning: unexpected `cfg` condition value: `anchor-debug` --> programs/arbitrage-executor/src/lib.rs:91:1 | 91 | #[program] | ^^^^^^^^^^ | = note: expected values for `feature` are: `cpi`, `default`, `no-entrypoint`, `no-idl`, and `no-log-ix-name` = note: using a cfg inside a attribute macro will use the cfgs from the destination crate and not the ones from the defining crate = help: try referring to `program` crate for guidance on how handle this unexpected cfg = help: the attribute macro `program` may come from an old version of the `anchor_attribute_program` crate, try updating your dependency with `cargo update -p anchor_attribute_program` = note: see for more information about checking conditional configuration = note: this warning originates in the attribute macro `program` (in Nightly builds, run with -Z macro-backtrace for more info) warning: unexpected `cfg` condition value: `anchor-debug` --> programs/arbitrage-executor/src/lib.rs:91:1 | 91 | #[program] | ^^^^^^^^^^ | = note: expected values for `feature` are: `cpi`, `default`, `no-entrypoint`, `no-idl`, and `no-log-ix-name` = note: using a cfg inside a derive macro will use the cfgs from the destination crate and not the ones from the defining crate = help: try referring to `Accounts` crate for guidance on how handle this unexpected cfg = help: the derive macro `Accounts` may come from an old version of the `anchor_derive_accounts` crate, try updating your dependency with `cargo update -p anchor_derive_accounts` = note: see for more information about checking conditional configuration = note: this warning originates in the derive macro `Accounts` (in Nightly builds, run with -Z macro-backtrace for more info) warning: unexpected `cfg` condition value: `anchor-debug` --> programs/arbitrage-executor/src/lib.rs:213:10 | 213 | #[derive(Accounts)] | ^^^^^^^^ | = note: expected values for `feature` are: `cpi`, `default`, `no-entrypoint`, `no-idl`, and `no-log-ix-name` = note: using a cfg inside a derive macro will use the cfgs from the destination crate and not the ones from the defining crate = help: try referring to `Accounts` crate for guidance on how handle this unexpected cfg = help: the derive macro `Accounts` may come from an old version of the `anchor_derive_accounts` crate, try updating your dependency with `cargo update -p anchor_derive_accounts` = note: see for more information about checking conditional configuration = note: this warning originates in the derive macro `Accounts` (in Nightly builds, run with -Z macro-backtrace for more info) warning: `arbitrage-executor` (lib) generated 12 warnings (5 duplicates) Compiling arbitrage-bot v0.1.0 (/home/newvovi4/arbitrage-bot-rust/bot) error[E0603]: trait `BorshDeserialize` is private --> bot/src/scanner/raydium_amm.rs:13:31 | 13 | use solana_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; | ^^^^^^^^^^^^^^^^ private trait | note: the trait `BorshDeserialize` is defined here --> /home/newvovi4/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/solana-program-1.18.26/src/borsh.rs:11:38 | 11 | use borsh0_10::{maybestd::io::Error, BorshDeserialize, BorshSchema, BorshSerialize}; | ^^^^^^^^^^^^^^^^ help: import `BorshDeserialize` directly | 13 | use solana_sdk::borsh::{self, borsh::de::BorshDeserialize, BorshSerialize}; | +++++++++++ error[E0603]: trait `BorshSerialize` is private --> bot/src/scanner/raydium_amm.rs:13:49 | 13 | use solana_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; | ^^^^^^^^^^^^^^ private trait | note: the trait `BorshSerialize` is defined here --> /home/newvovi4/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/solana-program-1.18.26/src/borsh.rs:11:69 | 11 | use borsh0_10::{maybestd::io::Error, BorshDeserialize, BorshSchema, BorshSerialize}; | ^^^^^^^^^^^^^^ help: import `BorshSerialize` directly | 13 | use solana_sdk::borsh::{self, BorshDeserialize, borsh::ser::BorshSerialize}; | ++++++++++++ error[E0603]: trait `BorshDeserialize` is private --> bot/src/executor/transaction_builder.rs:17:31 | 17 | use solana_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; | ^^^^^^^^^^^^^^^^ private trait | note: the trait `BorshDeserialize` is defined here --> /home/newvovi4/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/solana-program-1.18.26/src/borsh.rs:11:38 | 11 | use borsh0_10::{maybestd::io::Error, BorshDeserialize, BorshSchema, BorshSerialize}; | ^^^^^^^^^^^^^^^^ help: import `BorshDeserialize` directly | 17 | use solana_sdk::borsh::{self, borsh::de::BorshDeserialize, BorshSerialize}; | +++++++++++ error[E0603]: trait `BorshSerialize` is private --> bot/src/executor/transaction_builder.rs:17:49 | 17 | use solana_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; | ^^^^^^^^^^^^^^ private trait | note: the trait `BorshSerialize` is defined here --> /home/newvovi4/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/solana-program-1.18.26/src/borsh.rs:11:69 | 11 | use borsh0_10::{maybestd::io::Error, BorshDeserialize, BorshSchema, BorshSerialize}; | ^^^^^^^^^^^^^^ help: import `BorshSerialize` directly | 17 | use solana_sdk::borsh::{self, BorshDeserialize, borsh::ser::BorshSerialize}; | ++++++++++++ error[E0603]: trait `BorshDeserialize` is private --> bot/src/dex_structs.rs:3:31 | 3 | use solana_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; | ^^^^^^^^^^^^^^^^ private trait | note: the trait `BorshDeserialize` is defined here --> /home/newvovi4/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/solana-program-1.18.26/src/borsh.rs:11:38 | 11 | use borsh0_10::{maybestd::io::Error, BorshDeserialize, BorshSchema, BorshSerialize}; | ^^^^^^^^^^^^^^^^ help: import `BorshDeserialize` directly | 3 | use solana_sdk::borsh::{self, borsh::de::BorshDeserialize, BorshSerialize}; | +++++++++++ error[E0603]: trait `BorshSerialize` is private --> bot/src/dex_structs.rs:3:49 | 3 | use solana_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; | ^^^^^^^^^^^^^^ private trait | note: the trait `BorshSerialize` is defined here --> /home/newvovi4/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/solana-program-1.18.26/src/borsh.rs:11:69 | 11 | use borsh0_10::{maybestd::io::Error, BorshDeserialize, BorshSchema, BorshSerialize}; | ^^^^^^^^^^^^^^ help: import `BorshSerialize` directly | 3 | use solana_sdk::borsh::{self, BorshDeserialize, borsh::ser::BorshSerialize}; | ++++++++++++ warning: unused import: `self` --> bot/src/scanner/raydium_amm.rs:13:25 | 13 | use solana_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; | ^^^^ | = note: `#[warn(unused_imports)]` on by default warning: unused import: `tracing::debug` --> bot/src/arbitrage/bellman_ford.rs:7:5 | 7 | use tracing::debug; | ^^^^^^^^^^^^^^ warning: unused import: `DexProtocol` --> bot/src/arbitrage/opportunity.rs:9:62 | 9 | use crate::types::{PoolState, ArbitrageOpportunity, SwapLeg, DexProtocol}; | ^^^^^^^^^^^ warning: unused import: `self` --> bot/src/executor/transaction_builder.rs:17:25 | 17 | use solana_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; | ^^^^ warning: unused import: `signature::Signature` --> bot/src/executor/jito_client.rs:6:5 | 6 | signature::Signature, | ^^^^^^^^^^^^^^^^^^^^ warning: unused import: `Context` --> bot/src/utils/rpc.rs:4:22 | 4 | use anyhow::{Result, Context}; | ^^^^^^^ warning: unused imports: `RpcSimulateTransactionConfig` and `client_error::ClientError` --> bot/src/utils/rpc.rs:7:44 | 7 | rpc_config::{RpcSendTransactionConfig, RpcSimulateTransactionConfig}, | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 8 | client_error::ClientError, | ^^^^^^^^^^^^^^^^^^^^^^^^^ warning: unused import: `self` --> bot/src/dex_structs.rs:3:25 | 3 | use solana_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; | ^^^^ warning: unused import: `shellexpand` --> bot/src/main.rs:26:5 | 26 | use shellexpand; | ^^^^^^^^^^^ error[E0599]: no function or associated item named `try_from_slice` found for struct `AmmInfo` in the current scope --> bot/src/scanner/raydium_amm.rs:35:33 | 35 | let amm_info = AmmInfo::try_from_slice(&data) | ^^^^^^^^^^^^^^ function or associated item not found in `AmmInfo` | ::: bot/src/dex_structs.rs:8:1 | 8 | pub struct AmmInfo { | ------------------ function or associated item `try_from_slice` not found for this struct | = help: items from traits can only be used if the trait is implemented and in scope = note: the following traits define an item `try_from_slice`, perhaps you need to implement one of them: candidate #1: `borsh::de::BorshDeserialize` candidate #2: `borsh::de::BorshDeserialize` candidate #3: `borsh::de::BorshDeserialize` help: there is an associated function `try_from` with a similar name | 35 - let amm_info = AmmInfo::try_from_slice(&data) 35 + let amm_info = AmmInfo::try_from(&data) | error[E0599]: no function or associated item named `try_from_slice` found for struct `AmmInfo` in the current scope --> bot/src/executor/transaction_builder.rs:160:45 | 160 | let amm_info = AmmInfo::try_from_slice(&leg.pool_state_data) | ^^^^^^^^^^^^^^ function or associated item not found in `AmmInfo` | ::: bot/src/dex_structs.rs:8:1 | 8 | pub struct AmmInfo { | ------------------ function or associated item `try_from_slice` not found for this struct | = help: items from traits can only be used if the trait is implemented and in scope = note: the following traits define an item `try_from_slice`, perhaps you need to implement one of them: candidate #1: `borsh::de::BorshDeserialize` candidate #2: `borsh::de::BorshDeserialize` candidate #3: `borsh::de::BorshDeserialize` help: there is an associated function `try_from` with a similar name | 160 - let amm_info = AmmInfo::try_from_slice(&leg.pool_state_data) 160 + let amm_info = AmmInfo::try_from(&leg.pool_state_data) | error[E0599]: no method named `try_to_vec` found for struct `ExecuteArbitrageParams` in the current scope --> bot/src/executor/transaction_builder.rs:202:33 | 44 | struct ExecuteArbitrageParams { | ----------------------------- method `try_to_vec` not found for this struct ... 202 | let serialized = params.try_to_vec().context("Не удалось сериализовать параметры")?; | ^^^^^^^^^^ method not found in `ExecuteArbitrageParams` | = help: items from traits can only be used if the trait is implemented and in scope = note: the following traits define an item `try_to_vec`, perhaps you need to implement one of them: candidate #1: `borsh::ser::BorshSerialize` candidate #2: `borsh::ser::BorshSerialize` warning: unused variable: `iteration` --> bot/src/arbitrage/bellman_ford.rs:61:13 | 61 | for iteration in 0..max_legs { | ^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_iteration` | = note: `#[warn(unused_variables)]` on by default warning: variable does not need to be mutable --> bot/src/arbitrage/bellman_ford.rs:109:13 | 109 | let mut total_weight = 0.0; | ----^^^^^^^^^^^^ | | | help: remove this `mut` | = note: `#[warn(unused_mut)]` on by default warning: unused variable: `legs` --> bot/src/arbitrage/profit_calculator.rs:24:9 | 24 | legs: &[SwapLeg], | ^^^^ help: if this is intentional, prefix it with an underscore: `_legs` warning: unused variable: `min_required_final` --> bot/src/arbitrage/profit_calculator.rs:55:13 | 55 | let min_required_final = initial_amount + self.config.trading.min_profit_lamports; | ^^^^^^^^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_min_required_final` Some errors have detailed explanations: E0599, E0603. For more information about an error, try `rustc --explain E0599`. warning: `arbitrage-bot` (bin "arbitrage-bot") generated 13 warnings error: could not compile `arbitrage-bot` (bin "arbitrage-bot") due to 9 previous errors; 13 warnings emitted Код всего проекта: /home/newvovi4/arbitrage-bot-rust/Cargo.toml # arbitrage-bot-rust/Cargo.toml # Корневой workspace с патчами для разрешения конфликтов [workspace] members = [ "programs/arbitrage-executor", "bot", ] resolver = "2" # ═══════════════════════════════════════════════════════════════ # ОБЩИЕ ЗАВИСИМОСТИ WORKSPACE # ═══════════════════════════════════════════════════════════════ [workspace.dependencies] solana-sdk = "1.17.34" solana-client = "1.17.34" solana-program = "1.17.34" solana-account-decoder = "1.17.34" solana-transaction-status = "1.17.34" # Anchor Framework anchor-lang = "0.29.0" anchor-spl = "0.29.0" anchor-client = "0.29.0" # Async Runtime tokio = { version = "1.38", features = ["full"] } async-trait = "0.1" futures = "0.3" # Serialization serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" bincode = "1.3" borsh = "0.10" # Logging tracing = "0.1" tracing-subscriber = { version = "0.3", features = ["env-filter"] } # Error Handling anyhow = "1.0" thiserror = "1.0" # Networking reqwest = { version = "0.11", features = ["json", "rustls-tls"] } # Configuration dotenv = "0.15" # Utilities bs58 = "0.5" rayon = "1.8" dashmap = "5.5" chrono = "0.4" shellexpand = "3.1" # SPL Token spl-token = "3.5" spl-associated-token-account = "1.1" # Фиксируем curve25519-dalek на стабильной версии curve25519-dalek = { version = "=3.2.1" } # Дополнительные патчи для стабильности crypto зависимостей const-oid = { version = "=0.9.6" } der = { version = "=0.7.9" } pkcs8 = { version = "=0.10.2" } spki = { version = "=0.7.3" } # ═══════════════════════════════════════════════════════════════ # ПРОФИЛИ СБОРКИ # ═══════════════════════════════════════════════════════════════ [profile.release] opt-level = 3 lto = "fat" codegen-units = 1 panic = "abort" overflow-checks = true [profile.dev] opt-level = 1 ===== /home/newvovi4/arbitrage-bot-rust/Anchor.toml # arbitrage-bot-rust/Anchor.toml [toolchain] anchor_version = "0.29.0" solana_version = "1.18.22" [features] seeds = false skip-lint = false [programs.localnet] arbitrage_executor = "44SMYSDatw9DU6amM4d3Yv9SkxzBRphtoftLP6ep5M7T" [programs.devnet] arbitrage_executor = "44SMYSDatw9DU6amM4d3Yv9SkxzBRphtoftLP6ep5M7T" [programs.mainnet] arbitrage_executor = "44SMYSDatw9DU6amM4d3Yv9SkxzBRphtoftLP6ep5M7T" [registry] url = "https://api.apr.dev" [provider] cluster = "devnet" wallet = "~/.config/solana/id.json" [scripts] test = "cargo test-sbf" build = "anchor build" deploy-devnet = "anchor deploy --provider.cluster devnet" deploy-mainnet = "anchor deploy --provider.cluster mainnet-beta" [test] startup_wait = 10000 ===== /home/newvovi4/arbitrage-bot-rust/.env # .env (для devnet) # RPC Configuration (Devnet) SOLANA_RPC_URL=https://api.devnet.solana.com SOLANA_WS_URL=wss://api.devnet.solana.com # Для лучшей производительности используйте Helius/QuickNode devnet endpoints # SOLANA_RPC_URL=https://devnet.helius-rpc.com/?api-key=YOUR_KEY # SOLANA_WS_URL=wss://devnet.helius-rpc.com/?api-key=YOUR_KEY # Wallet WALLET_PATH=~/.config/solana/id.json # Bot Configuration MIN_PROFIT_LAMPORTS=5000 MIN_PROFIT_BPS=50 MAX_SLIPPAGE_BPS=100 INITIAL_AMOUNT_SOL=0.01 # Jito (недоступен на devnet - закомментируйте) # JITO_BLOCK_ENGINE_URL=https://mainnet.block-engine.jito.wtf # JITO_TIP_ACCOUNT=96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5 # JITO_TIP_LAMPORTS=300000 # Monitoring LOG_LEVEL=info TELEMETRY_ENABLED=false ARBITRAGE_EXECUTOR_PROGRAM_ID="2pzdxUNbTFgXSknGjACqJnjDUNRYR7N4P1fkfyuyZLG3" ===== /home/newvovi4/arbitrage-bot-rust/bot/Cargo.toml # bot/Cargo.toml (ФИНАЛЬНАЯ ВЕРСИЯ) [package] name = "arbitrage-bot" version = "0.1.0" edition = "2021" [dependencies] # Зависимость от вашего on-chain контракта arbitrage-executor = { path = "../programs/arbitrage-executor" } chrono = "0.4" dashmap = "5.5" shellexpand = "3.1" # Solana Core solana-program = "~1.18" solana-sdk = "~1.18" solana-client = "~1.18" solana-account-decoder = "~1.18" solana-transaction-status = "~1.18" # Anchor Framework anchor-client = "0.29.0" anchor-spl = "0.29.0" # Async Runtime tokio = { version = "1", features = ["full"] } futures = "0.3" async-trait = "0.1" # Serialization serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" bincode = "1.3" # Logging & Error Handling tracing = "0.1" tracing-subscriber = { version = "0.3", features = ["env-filter"] } anyhow = "1.0" # Networking (с правильной версией) reqwest = { version = "0.11", features = ["json", "rustls-tls"] } # Configuration dotenv = "0.15" config = { version = "0.14", features = ["toml"] } # Utilities bs58 = "0.5" rayon = "1.10" once_cell = "1.21.3" ===== /home/newvovi4/arbitrage-bot-rust/bot/src/config.rs // bot/src/config.rs // Configuration management for arbitrage bot use anyhow::{Context, Result}; use once_cell::sync::Lazy; use serde::{Deserialize, Serialize}; use solana_sdk::pubkey::Pubkey; use std::path::PathBuf; use std::str::FromStr; #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BotConfig { pub rpc: RpcConfig, pub wallet: WalletConfig, pub trading: TradingConfig, pub dex: DexConfig, pub jito: Option, pub monitoring: MonitoringConfig, } #[derive(Debug, Clone, Serialize, Deserialize)] pub struct RpcConfig { pub url: String, pub ws_url: String, pub commitment: String, pub timeout_seconds: u64, } #[derive(Debug, Clone, Serialize, Deserialize)] pub struct WalletConfig { pub path: PathBuf, } #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TradingConfig { // --- НОВОЕ ПОЛЕ ДОБАВЛЕНО ЗДЕСЬ --- pub executor_program_id: PubkeyString, // ------------------------------------ pub min_profit_lamports: u64, pub min_profit_bps: u16, pub max_slippage_bps: u16, pub initial_amount_sol: f64, pub max_legs: u8, pub compute_unit_limit: u32, pub priority_fee_micro_lamports: u64, } #[derive(Debug, Clone, Serialize, Deserialize)] pub struct DexConfig { pub raydium_amm_v4: PubkeyString, pub raydium_cpmm: PubkeyString, pub raydium_clmm: PubkeyString, pub meteora_dlmm: PubkeyString, } #[derive(Debug, Clone, Serialize, Deserialize)] pub struct JitoConfig { pub block_engine_url: String, pub tip_account: PubkeyString, pub tip_lamports: u64, } #[derive(Debug, Clone, Serialize, Deserialize)] pub struct MonitoringConfig { pub log_level: String, pub telemetry_enabled: bool, } #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PubkeyString(pub String); impl PubkeyString { pub fn to_pubkey(&self) -> Result { Pubkey::from_str(&self.0).context("Invalid pubkey") } } impl BotConfig { pub fn load() -> Result { dotenv::dotenv().ok(); let config = Self { rpc: RpcConfig { url: std::env::var("SOLANA_RPC_URL") .unwrap_or_else(|_| "https://api.mainnet-beta.solana.com".to_string()), ws_url: std::env::var("SOLANA_WS_URL") .unwrap_or_else(|_| "wss://api.mainnet-beta.solana.com".to_string()), commitment: "confirmed".to_string(), timeout_seconds: 30, }, wallet: WalletConfig { path: std::env::var("WALLET_PATH") .unwrap_or_else(|_| "~/.config/solana/id.json".to_string()) .into(), }, trading: TradingConfig { // --- ЛОГИКА ЗАГРУЗКИ ID ПРОГРАММЫ ДОБАВЛЕНА ЗДЕСЬ --- executor_program_id: PubkeyString( std::env::var("ARBITRAGE_EXECUTOR_PROGRAM_ID") .context("Переменная окружения ARBITRAGE_EXECUTOR_PROGRAM_ID не найдена")?, ), // ---------------------------------------------------- min_profit_lamports: std::env::var("MIN_PROFIT_LAMPORTS") .unwrap_or_else(|_| "5000".to_string()) .parse() .context("Invalid MIN_PROFIT_LAMPORTS")?, min_profit_bps: std::env::var("MIN_PROFIT_BPS") .unwrap_or_else(|_| "50".to_string()) .parse() .context("Invalid MIN_PROFIT_BPS")?, max_slippage_bps: std::env::var("MAX_SLIPPAGE_BPS") .unwrap_or_else(|_| "100".to_string()) .parse() .context("Invalid MAX_SLIPPAGE_BPS")?, initial_amount_sol: std::env::var("INITIAL_AMOUNT_SOL") .unwrap_or_else(|_| "0.01".to_string()) .parse() .context("Invalid INITIAL_AMOUNT_SOL")?, max_legs: 5, compute_unit_limit: 400_000, priority_fee_micro_lamports: 100_000, }, dex: DexConfig { raydium_amm_v4: PubkeyString( // MAINNET: "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8".to_string(), "DRaya7Kj3aMWQSy19kSjvmuwq9docCHofyP9kanQGaav".to_string(), ), raydium_cpmm: PubkeyString( // MAINNET: "CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C".to_string(), "DRaycpLY18LhpbydsBWbVJtxpNv9oXPgjRSfpF2bWpYb".to_string(), ), raydium_clmm: PubkeyString( // MAINNET: "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK".to_string(), "DRayAUgENGQBKVaX8owNhgzkEDyoHTGVEGHVJT1E9pfH".to_string(), ), meteora_dlmm: PubkeyString( "LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo".to_string(), ), }, jito: std::env::var("JITO_BLOCK_ENGINE_URL").ok().map(|url| JitoConfig { block_engine_url: url, tip_account: PubkeyString( std::env::var("JITO_TIP_ACCOUNT") .unwrap_or_else(|_| "96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5".to_string()), ), tip_lamports: std::env::var("JITO_TIP_LAMPORTS") .unwrap_or_else(|_| "300000".to_string()) .parse() .unwrap_or(300_000), }), monitoring: MonitoringConfig { log_level: std::env::var("LOG_LEVEL").unwrap_or_else(|_| "info".to_string()), telemetry_enabled: std::env::var("TELEMETRY_ENABLED") .unwrap_or_else(|_| "false".to_string()) .parse() .unwrap_or(false), }, }; Ok(config) } } pub static MAINNET_PROGRAMS: Lazy = Lazy::new(|| DexConfig { raydium_amm_v4: PubkeyString("675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8".to_string()), raydium_cpmm: PubkeyString("CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C".to_string()), raydium_clmm: PubkeyString("CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK".to_string()), meteora_dlmm: PubkeyString("LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo".to_string()), }); ===== /home/newvovi4/arbitrage-bot-rust/bot/src/dex_structs.rs // bot/src/dex_structs.rs use solana_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; use solana_sdk::pubkey::Pubkey; #[repr(C)] pub struct AmmInfo { pub status: u64, pub nonce: u64, pub order_num: u64, pub depth: u64, pub base_decimal: u64, pub quote_decimal: u64, pub state: u64, pub reset_flag: u64, pub min_size: u64, pub vol_max_cut_ratio: u64, pub amount_wave: u64, pub base_lot_size: u64, pub quote_lot_size: u64, pub min_price_multiplier: u64, pub max_price_multiplier: u64, pub system_decimal_value: u64, pub min_separate_size: u64, pub pnl_owner: Pubkey, pub pnl_own_temp: u64, pub padding: [u8; 24], pub fees: Fees, pub _padding1: [u8; 104], pub base_mint: Pubkey, pub quote_mint: Pubkey, pub lp_mint: Pubkey, pub open_orders: Pubkey, pub target_orders: Pubkey, pub base_vault: Pubkey, pub quote_vault: Pubkey, pub withdraw_queue: Pubkey, pub lp_vault: Pubkey, pub market_program_id: Pubkey, pub market_id: Pubkey, pub market_authority: Pubkey, pub market_base_vault: Pubkey, pub market_quote_vault: Pubkey, pub market_bids: Pubkey, pub market_asks: Pubkey, pub market_event_queue: Pubkey, } #[repr(C)] pub struct Fees { pub min_separate_numerator: u64, pub min_separate_denominator: u64, pub trade_fee_numerator: u64, pub trade_fee_denominator: u64, pub pnl_numerator: u64, pub pnl_denominator: u64, pub swap_fee_numerator: u64, pub swap_fee_denominator: u64, } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/main.rs // bot/src/main.rs // Точка входа арбитражного бота mod config; mod types; mod scanner; mod arbitrage; mod executor; mod utils; pub mod dex_structs; use solana_sdk::signature::Signer; use anyhow::Result; use solana_client::rpc_client::RpcClient; use solana_sdk::commitment_config::CommitmentConfig; use std::sync::Arc; use tokio::time::{interval, Duration}; use tracing::{info, error, warn}; use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt}; use config::BotConfig; use scanner::{MultiDexScanner, pool_monitor::PoolMonitor}; use arbitrage::ArbitrageFinder; use executor::TransactionExecutor; use utils::load_keypair_from_file; use shellexpand; #[tokio::main] async fn main() -> Result<()> { // Инициализация логирования init_logging(); println!("╔════════════════════════════════════════════════════════════════╗"); println!("║ SOLANA ARBITRAGE BOT - RUST EDITION (DEVNET) ║"); println!("║ Высокопроизводительный поиск и исполнение арбитража ║"); println!("╚════════════════════════════════════════════════════════════════╝\n"); // Загрузка конфигурации info!("📋 Загрузка конфигурации..."); let config = Arc::new(BotConfig::load()?); info!("✅ Конфигурация загружена"); // Загрузка кошелька info!("🔑 Загрузка кошелька..."); let wallet_path = config.wallet.path.to_str() .ok_or_else(|| anyhow::anyhow!("Неверный путь к кошельку"))?; let keypair = Arc::new(load_keypair_from_file(wallet_path)?); info!(" Публичный ключ: {}", keypair.pubkey()); // Инициализация RPC клиента info!("🌐 Подключение к Solana RPC..."); let rpc_client = Arc::new(RpcClient::new_with_commitment( config.rpc.url.clone(), CommitmentConfig::confirmed(), )); // Проверка подключения let cluster_version = rpc_client.get_version()?; info!(" Подключено к кластеру: {} (Solana {})", config.rpc.url, cluster_version.solana_core); // Проверка баланса let balance = rpc_client.get_balance(&keypair.pubkey())?; let balance_sol = balance as f64 / 1_000_000_000.0; info!("💰 Баланс кошелька: {:.9} SOL", balance_sol); if balance_sol < 0.1 { warn!("⚠️ НИЗКИЙ БАЛАНС! Пополните через фоссет: https://faucet.solana.com/"); warn!(" Адрес: {}", keypair.pubkey()); } // Инициализация компонентов info!("🔧 Инициализация компонентов бота..."); let pool_monitor = Arc::new(PoolMonitor::new(5000)); // 5 секунд TTL let dex_scanner = MultiDexScanner::new(config.clone(), rpc_client.clone()); let arbitrage_finder = ArbitrageFinder::new(config.clone()); let executor = TransactionExecutor::new( rpc_client.clone(), keypair.clone(), config.clone(), )?; info!("✅ Все компоненты инициализированы\n"); // Запуск фоновой очистки кэша let monitor_clone = pool_monitor.clone(); tokio::spawn(async move { scanner::pool_monitor::start_cache_cleanup_task(monitor_clone).await; }); // Главный цикл бота info!("🚀 Запуск главного цикла бота..."); info!("{}", "═".repeat(80)); let mut scan_interval = interval(Duration::from_millis(config.rpc.timeout_seconds * 1000)); let mut iteration = 0u64; loop { scan_interval.tick().await; iteration += 1; info!("\n⏰ Итерация #{} - {}", iteration, chrono::Local::now().format("%H:%M:%S")); // Шаг 1: Сканирование пулов match dex_scanner.scan_all_dex().await { Ok(pools) => { if pools.is_empty() { warn!(" ⚠️ Пулы не найдены. Убедитесь что тестовые пулы созданы на devnet."); continue; } // Обновление кэша for pool in &pools { pool_monitor.update_pool(pool.clone()); } info!(" 📊 Активных пулов: {}", pools.len()); // Шаг 2: Поиск арбитражных возможностей match arbitrage_finder.find_opportunities(&pools) { Ok(opportunities) => { if opportunities.is_empty() { info!(" ⏳ Прибыльных возможностей не найдено"); continue; } info!(" 🔥 Найдено возможностей: {}", opportunities.len()); // Берём лучшую возможность let best = &opportunities[0]; info!(" 💎 Лучшая возможность:"); info!(" Прибыль: {:.9} SOL ({:.4}%)", best.net_profit as f64 / 1_000_000_000.0, best.profit_percentage); info!(" Шагов: {}", best.legs.len()); // Шаг 3: Исполнение арбитража info!(" 🔧 Исполнение арбитража..."); match executor.execute(best).await { Ok(signature) => { info!(" ✅ АРБИТРАЖ УСПЕШЕН!"); info!(" Транзакция: {}", signature); info!(" Explorer: https://explorer.solana.com/tx/{}?cluster=devnet", signature); } Err(e) => { error!(" ❌ Ошибка исполнения: {}", e); } } } Err(e) => { error!(" ❌ Ошибка поиска возможностей: {}", e); } } } Err(e) => { error!(" ❌ Ошибка сканирования пулов: {}", e); } } } } /// Инициализация системы логирования fn init_logging() { let log_level = std::env::var("LOG_LEVEL").unwrap_or_else(|_| "info".to_string()); let filter = tracing_subscriber::EnvFilter::try_from_default_env() .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new(log_level)); tracing_subscriber::registry() .with(filter) .with(tracing_subscriber::fmt::layer() .with_target(false) .with_thread_ids(false) .with_line_number(false)) .init(); } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/types.rs // bot/src/types.rs // Shared types and structures use serde::{Deserialize, Serialize}; use solana_sdk::pubkey::Pubkey; use std::fmt; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] pub enum DexProtocol { RaydiumAmmV4, RaydiumCpmm, RaydiumClmm, MeteoraDlmm, } impl fmt::Display for DexProtocol { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { DexProtocol::RaydiumAmmV4 => write!(f, "Raydium AMM V4"), DexProtocol::RaydiumCpmm => write!(f, "Raydium CPMM"), DexProtocol::RaydiumClmm => write!(f, "Raydium CLMM"), DexProtocol::MeteoraDlmm => write!(f, "Meteora DLMM"), } } } /// Pool state data #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PoolState { pub id: Pubkey, pub protocol: DexProtocol, pub token_a: Pubkey, pub token_b: Pubkey, pub reserve_a: u64, pub reserve_b: u64, pub fee_bps: u16, pub last_updated: i64, pub full_state_data: Vec, } impl PoolState { pub fn price_a_to_b(&self) -> f64 { if self.reserve_b == 0 { return 0.0; } self.reserve_a as f64 / self.reserve_b as f64 } pub fn price_b_to_a(&self) -> f64 { if self.reserve_a == 0 { return 0.0; } self.reserve_b as f64 / self.reserve_a as f64 } } /// Single swap leg in arbitrage route #[derive(Debug, Clone, Serialize, Deserialize)] pub struct SwapLeg { pub protocol: DexProtocol, pub pool_id: Pubkey, pub input_mint: Pubkey, pub output_mint: Pubkey, pub amount_in: u64, pub minimum_amount_out: u64, pub estimated_amount_out: u64, pub fee_bps: u16, pub pool_state_data: Vec, } /// Complete arbitrage opportunity #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ArbitrageOpportunity { pub legs: Vec, pub initial_amount: u64, pub expected_final_amount: u64, pub gross_profit: u64, pub net_profit: u64, pub profit_percentage: f64, pub discovered_at: i64, } impl ArbitrageOpportunity { pub fn is_profitable(&self, min_profit: u64) -> bool { self.net_profit >= min_profit } } /// Price edge in graph #[derive(Debug, Clone, Copy)] pub struct PriceEdge { pub from_token: Pubkey, pub to_token: Pubkey, pub pool_id: Pubkey, pub protocol: DexProtocol, pub weight: f64, // -log(exchange_rate) for Bellman-Ford pub fee_bps: u16, } pub struct SimulationResult { pub err: Option, pub logs: Vec, pub units_consumed: Option, } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/arbitrage/mod.rs // bot/src/arbitrage/mod.rs // Оркестратор поиска арбитражных возможностей pub mod graph; pub mod bellman_ford; pub mod opportunity; pub mod profit_calculator; use anyhow::Result; use std::sync::Arc; use tracing::{info, debug}; use crate::config::BotConfig; use crate::types::{PoolState, ArbitrageOpportunity}; use graph::PriceGraph; use bellman_ford::BellmanFordSolver; use opportunity::OpportunityEvaluator; pub struct ArbitrageFinder { config: Arc, graph_builder: PriceGraph, solver: BellmanFordSolver, evaluator: OpportunityEvaluator, } impl ArbitrageFinder { pub fn new(config: Arc) -> Self { Self { config: config.clone(), graph_builder: PriceGraph::new(), solver: BellmanFordSolver::new(), evaluator: OpportunityEvaluator::new(config), } } /// Поиск всех арбитражных возможностей в заданных пулах pub fn find_opportunities(&self, pools: &[PoolState]) -> Result> { if pools.is_empty() { return Ok(vec![]); } info!("🔍 Построение графа цен из {} пулов...", pools.len()); // Шаг 1: Построение графа цен let graph = self.graph_builder.build_from_pools(pools)?; debug!(" Граф содержит {} токенов, {} рёбер", graph.token_count(), graph.edge_count()); // Шаг 2: Поиск отрицательных циклов через Bellman-Ford info!("🧮 Применение алгоритма Bellman-Ford для поиска циклов..."); let cycles = self.solver.find_negative_cycles(&graph, self.config.trading.max_legs as usize)?; if cycles.is_empty() { debug!(" Отрицательных циклов не найдено"); return Ok(vec![]); } info!(" Найдено потенциальных циклов: {}", cycles.len()); // Шаг 3: Оценка прибыльности каждого цикла let mut opportunities = Vec::new(); for cycle in cycles { match self.evaluator.evaluate_cycle(&cycle, pools) { Ok(Some(opp)) => { // Проверка минимальной прибыли if opp.net_profit >= self.config.trading.min_profit_lamports { opportunities.push(opp); } } Ok(None) => {} Err(e) => { debug!("Ошибка оценки цикла: {}", e); } } } // Сортировка по убыванию прибыли opportunities.sort_by(|a, b| b.net_profit.cmp(&a.net_profit)); info!("✅ Найдено прибыльных возможностей: {}", opportunities.len()); Ok(opportunities) } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/arbitrage/bellman_ford.rs // bot/src/arbitrage/bellman_ford.rs // Алгоритм Bellman-Ford для поиска отрицательных циклов (арбитража) use anyhow::Result; use solana_sdk::pubkey::Pubkey; use std::collections::VecDeque; use tracing::debug; use super::graph::PriceGraph; /// Найденный цикл (путь свопов) #[derive(Debug, Clone)] pub struct ArbitrageCycle { pub tokens: Vec, pub total_weight: f64, } pub struct BellmanFordSolver; impl BellmanFordSolver { pub fn new() -> Self { Self } /// Поиск всех отрицательных циклов в графе pub fn find_negative_cycles( &self, graph: &PriceGraph, max_legs: usize, ) -> Result> { let n = graph.token_count(); let mut cycles = Vec::new(); // Запускаем Bellman-Ford от каждого токена for start_idx in 0..n { if let Some(cycle) = self.find_cycle_from_token(graph, start_idx, max_legs)? { cycles.push(cycle); } } Ok(cycles) } /// Поиск отрицательного цикла от конкретного токена fn find_cycle_from_token( &self, graph: &PriceGraph, start_idx: usize, max_legs: usize, ) -> Result> { let n = graph.token_count(); // Расстояния (веса путей) let mut dist = vec![f64::INFINITY; n]; dist[start_idx] = 0.0; // Предшественники для восстановления пути let mut pred = vec![None; n]; // Релаксация рёбер (max_legs итераций для ограничения длины пути) for iteration in 0..max_legs { let mut updated = false; for from_idx in 0..n { if dist[from_idx].is_infinite() { continue; } for to_idx in 0..n { let edges = graph.get_edges(from_idx, to_idx); for edge in edges { let new_dist = dist[from_idx] + edge.weight; if new_dist < dist[to_idx] { dist[to_idx] = new_dist; pred[to_idx] = Some((from_idx, edge.pool_id)); updated = true; // Проверка отрицательного цикла if to_idx == start_idx && new_dist < -0.001 { // Найден отрицательный цикл! let cycle = self.reconstruct_cycle(graph, &pred, start_idx, to_idx)?; return Ok(Some(cycle)); } } } } } if !updated { break; // Нет изменений, можно выйти раньше } } Ok(None) } /// Восстановление цикла из массива предшественников fn reconstruct_cycle( &self, graph: &PriceGraph, pred: &[Option<(usize, Pubkey)>], start: usize, end: usize, ) -> Result { let mut path = VecDeque::new(); let mut current = end; let mut total_weight = 0.0; // Восстанавливаем путь в обратном порядке while current != start { if let Some(token) = graph.get_token(current) { path.push_front(*token); } if let Some((prev, _pool_id)) = pred[current] { current = prev; } else { anyhow::bail!("Невозможно восстановить путь цикла"); } } // Добавляем стартовый токен if let Some(token) = graph.get_token(start) { path.push_front(*token); path.push_back(*token); // Замыкаем цикл } let tokens: Vec = path.into_iter().collect(); Ok(ArbitrageCycle { tokens, total_weight, }) } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/arbitrage/graph.rs // bot/src/arbitrage/graph.rs // Построение графа цен для поиска арбитража use anyhow::Result; use solana_sdk::pubkey::Pubkey; use std::collections::HashMap; use tracing::debug; use crate::types::{PoolState, PriceEdge}; /// Граф цен между токенами pub struct PriceGraph { /// Соответствие токен -> индекс в графе token_to_index: HashMap, /// Соответствие индекс -> токен index_to_token: Vec, /// Матрица смежности: adjacency[from][to] = vec![PriceEdge] adjacency: Vec>>, } impl PriceGraph { pub fn new() -> Self { Self { token_to_index: HashMap::new(), index_to_token: Vec::new(), adjacency: Vec::new(), } } /// Построение графа из списка пулов pub fn build_from_pools(&self, pools: &[PoolState]) -> Result { let mut graph = PriceGraph::new(); // Шаг 1: Собираем все уникальные токены for pool in pools { graph.add_token_if_new(pool.token_a); graph.add_token_if_new(pool.token_b); } // Инициализация матрицы смежности let n = graph.token_count(); graph.adjacency = vec![vec![Vec::new(); n]; n]; // Шаг 2: Добавляем рёбра для каждого пула for pool in pools { // Направление A -> B let edge_ab = PriceEdge { from_token: pool.token_a, to_token: pool.token_b, pool_id: pool.id, protocol: pool.protocol, weight: Self::calculate_edge_weight(pool, true)?, fee_bps: pool.fee_bps, }; // Направление B -> A let edge_ba = PriceEdge { from_token: pool.token_b, to_token: pool.token_a, pool_id: pool.id, protocol: pool.protocol, weight: Self::calculate_edge_weight(pool, false)?, fee_bps: pool.fee_bps, }; graph.add_edge(edge_ab)?; graph.add_edge(edge_ba)?; } debug!("Граф построен: {} токенов, {} рёбер", n, graph.edge_count()); Ok(graph) } /// Вычисление веса ребра (отрицательный логарифм обменного курса) /// Bellman-Ford находит минимальные пути, отрицательный цикл = прибыль fn calculate_edge_weight(pool: &PoolState, a_to_b: bool) -> Result { let (reserve_in, reserve_out) = if a_to_b { (pool.reserve_a as f64, pool.reserve_b as f64) } else { (pool.reserve_b as f64, pool.reserve_a as f64) }; if reserve_in <= 0.0 || reserve_out <= 0.0 { anyhow::bail!("Нулевые резервы в пуле"); } // Учёт комиссии (fee_bps / 10000) let fee_multiplier = 1.0 - (pool.fee_bps as f64 / 10000.0); // Обменный курс с учётом комиссии let exchange_rate = (reserve_out / reserve_in) * fee_multiplier; // Вес = -log(exchange_rate) // Отрицательный цикл означает произведение курсов > 1 (прибыль) let weight = -(exchange_rate.ln()); Ok(weight) } /// Добавление токена если ещё не существует fn add_token_if_new(&mut self, token: Pubkey) { if !self.token_to_index.contains_key(&token) { let index = self.index_to_token.len(); self.token_to_index.insert(token, index); self.index_to_token.push(token); } } /// Добавление ребра в граф fn add_edge(&mut self, edge: PriceEdge) -> Result<()> { let from_idx = self.token_to_index.get(&edge.from_token) .ok_or_else(|| anyhow::anyhow!("Токен не найден в графе"))?; let to_idx = self.token_to_index.get(&edge.to_token) .ok_or_else(|| anyhow::anyhow!("Токен не найден в графе"))?; self.adjacency[*from_idx][*to_idx].push(edge); Ok(()) } /// Получение токена по индексу pub fn get_token(&self, index: usize) -> Option<&Pubkey> { self.index_to_token.get(index) } /// Получение индекса токена pub fn get_index(&self, token: &Pubkey) -> Option { self.token_to_index.get(token).copied() } /// Получение всех рёбер между двумя токенами pub fn get_edges(&self, from: usize, to: usize) -> &[PriceEdge] { &self.adjacency[from][to] } /// Количество токенов в графе pub fn token_count(&self) -> usize { self.index_to_token.len() } /// Количество рёбер в графе pub fn edge_count(&self) -> usize { self.adjacency.iter() .flat_map(|row| row.iter()) .map(|edges| edges.len()) .sum() } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/arbitrage/opportunity.rs // bot/src/arbitrage/opportunity.rs // Оценка и валидация арбитражных возможностей use anyhow::Result; use std::sync::Arc; use tracing::debug; use crate::config::BotConfig; use crate::types::{PoolState, ArbitrageOpportunity, SwapLeg, DexProtocol}; use super::bellman_ford::ArbitrageCycle; use super::profit_calculator::ProfitCalculator; pub struct OpportunityEvaluator { config: Arc, profit_calc: ProfitCalculator, } impl OpportunityEvaluator { pub fn new(config: Arc) -> Self { Self { profit_calc: ProfitCalculator::new(config.clone()), config, } } /// Оценка цикла и создание ArbitrageOpportunity pub fn evaluate_cycle( &self, cycle: &ArbitrageCycle, pools: &[PoolState], ) -> Result> { if cycle.tokens.len() < 3 { return Ok(None); // Минимум 2 свопа } debug!("Оценка цикла: {} токенов", cycle.tokens.len()); // Построение swap legs let mut legs: Vec = Vec::new(); for i in 0..cycle.tokens.len() - 1 { let input_mint = cycle.tokens[i]; let output_mint = cycle.tokens[i + 1]; // Находим пул для этой пары let pool = pools.iter() .find(|p| { (p.token_a == input_mint && p.token_b == output_mint) || (p.token_a == output_mint && p.token_b == input_mint) }) .ok_or_else(|| anyhow::anyhow!("Пул не найден для пары токенов"))?; let amount_in = if i == 0 { // Начальная сумма в lamports (self.config.trading.initial_amount_sol * 1_000_000_000.0) as u64 } else { legs.last().unwrap().estimated_amount_out }; // Рассчитываем ожидаемый выход let (estimated_out, min_out) = self.calculate_swap_amounts( pool, amount_in, input_mint == pool.token_a, )?; let leg = SwapLeg { protocol: pool.protocol, pool_id: pool.id, input_mint, output_mint, amount_in, minimum_amount_out: min_out, estimated_amount_out: estimated_out, fee_bps: pool.fee_bps, pool_state_data: pool.full_state_data.clone(), }; legs.push(leg); } // Расчёт чистой прибыли let initial_amount = legs[0].amount_in; let final_amount = legs.last().unwrap().estimated_amount_out; let (gross_profit, net_profit) = self.profit_calc.calculate_net_profit( initial_amount, final_amount, &legs, )?; // Проверка прибыльности if net_profit < self.config.trading.min_profit_lamports { return Ok(None); } let profit_percentage = (net_profit as f64 / initial_amount as f64) * 100.0; let opportunity = ArbitrageOpportunity { legs, initial_amount, expected_final_amount: final_amount, gross_profit, net_profit, profit_percentage, discovered_at: chrono::Utc::now().timestamp(), }; Ok(Some(opportunity)) } /// Расчёт ожидаемого и минимального выхода свопа fn calculate_swap_amounts( &self, pool: &PoolState, amount_in: u64, a_to_b: bool, ) -> Result<(u64, u64)> { let (reserve_in, reserve_out) = if a_to_b { (pool.reserve_a, pool.reserve_b) } else { (pool.reserve_b, pool.reserve_a) }; // Формула постоянного произведения (x * y = k) let fee_multiplier = 1.0 - (pool.fee_bps as f64 / 10000.0); let amount_in_with_fee = (amount_in as f64) * fee_multiplier; let amount_out = (reserve_out as f64) * amount_in_with_fee / ((reserve_in as f64) + amount_in_with_fee); let estimated_out = amount_out as u64; // Минимальный выход с учётом slippage let slippage_multiplier = 1.0 - (self.config.trading.max_slippage_bps as f64 / 10000.0); let min_out = (amount_out * slippage_multiplier) as u64; Ok((estimated_out, min_out)) } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/arbitrage/profit_calculator.rs // bot/src/arbitrage/profit_calculator.rs // Расчёт чистой прибыли с учётом всех комиссий use anyhow::Result; use std::sync::Arc; use crate::config::BotConfig; use crate::types::SwapLeg; pub struct ProfitCalculator { config: Arc, } impl ProfitCalculator { pub fn new(config: Arc) -> Self { Self { config } } /// Расчёт чистой прибыли с учётом всех комиссий pub fn calculate_net_profit( &self, initial_amount: u64, final_amount: u64, legs: &[SwapLeg], ) -> Result<(u64, u64)> { // Валовая прибыль let gross_profit = final_amount.saturating_sub(initial_amount); // Комиссии Solana let tx_base_fee = 5000_u64; // 0.000005 SOL базовая комиссия let priority_fee = self.config.trading.priority_fee_micro_lamports; // Jito tip (если настроен) let jito_tip = if let Some(jito_config) = &self.config.jito { jito_config.tip_lamports } else { 0 }; // Общие комиссии let total_fees = tx_base_fee + priority_fee + jito_tip; // Чистая прибыль let net_profit = gross_profit.saturating_sub(total_fees); Ok((gross_profit, net_profit)) } /// Оценка максимально допустимого slippage для прибыльности pub fn calculate_max_slippage( &self, initial_amount: u64, expected_profit: u64, ) -> f64 { let min_required_final = initial_amount + self.config.trading.min_profit_lamports; let max_loss = expected_profit.saturating_sub(self.config.trading.min_profit_lamports); (max_loss as f64 / expected_profit as f64) * 100.0 } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/executor/mod.rs // bot/src/executor/mod.rs pub mod transaction_builder; pub mod jito_client; pub mod simulator; use anyhow::Result; use solana_sdk::signature::{Keypair, Signature}; use solana_client::rpc_client::RpcClient; use std::sync::Arc; use tracing::info; use crate::config::BotConfig; use crate::types::ArbitrageOpportunity; use transaction_builder::TransactionBuilder; use simulator::TransactionSimulator; pub struct TransactionExecutor { rpc_client: Arc, builder: TransactionBuilder, simulator: TransactionSimulator, } impl TransactionExecutor { pub fn new( rpc_client: Arc, keypair: Arc, config: Arc, ) -> Result { Ok(Self { builder: TransactionBuilder::new( rpc_client.clone(), keypair.clone(), config.clone(), )?, simulator: TransactionSimulator::new(rpc_client.clone()), rpc_client, }) } pub async fn execute(&self, opportunity: &ArbitrageOpportunity) -> Result { let transaction = self.builder.build_arbitrage_transaction(opportunity).await?; info!("🧪 Симуляция транзакции..."); let simulation = self.simulator.simulate(&transaction).await?; if let Some(err) = simulation.err { anyhow::bail!("Симуляция провалилась: {}\nЛоги:\n{:#?}", err, simulation.logs); } info!("✅ Симуляция успешна (CU: {})", simulation.units_consumed.unwrap_or(0)); info!("📤 Отправка транзакции..."); let signature = self.rpc_client.send_and_confirm_transaction(&transaction)?; Ok(signature) } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/executor/jito_client.rs // bot/src/executor/jito_client.rs // Клиент для интеграции с Jito Block Engine (MEV защита) use anyhow::{Result, Context}; use solana_sdk::{ signature::Signature, transaction::Transaction, pubkey::Pubkey, }; use reqwest::Client; use serde::{Deserialize, Serialize}; use std::str::FromStr; use tracing::{info, warn, debug}; /// Конфигурация Jito pub struct JitoConfig { pub block_engine_url: String, pub tip_account: Pubkey, pub tip_lamports: u64, } impl Default for JitoConfig { fn default() -> Self { Self { block_engine_url: "https://mainnet.block-engine.jito.wtf".to_string(), tip_account: Pubkey::from_str("96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5") .expect("Invalid Jito tip account"), tip_lamports: 300_000, // 0.0003 SOL минимальный tip } } } /// Клиент Jito Block Engine pub struct JitoClient { config: JitoConfig, http_client: Client, } impl JitoClient { pub fn new(config: JitoConfig) -> Self { Self { config, http_client: Client::new(), } } /// Отправка bundle транзакций в Jito /// /// ВАЖНО: Jito Block Engine недоступен на devnet! /// Эта функция работает только на mainnet. pub async fn send_bundle(&self, transactions: Vec) -> Result { // Проверка devnet if self.config.block_engine_url.contains("devnet") { warn!("⚠️ Jito Block Engine недоступен на devnet. Используйте обычную отправку."); anyhow::bail!("Jito не поддерживается на devnet"); } info!("📦 Отправка bundle из {} транзакций в Jito...", transactions.len()); // Сериализация транзакций в base64 let encoded_txs: Vec = transactions .iter() .map(|tx| { let serialized = bincode::serialize(tx).expect("Failed to serialize tx"); bs58::encode(serialized).into_string() }) .collect(); debug!(" Сериализовано {} транзакций", encoded_txs.len()); // Подготовка JSON-RPC запроса let request = SendBundleRequest { jsonrpc: "2.0".to_string(), id: 1, method: "sendBundle".to_string(), params: vec![encoded_txs], }; // Отправка POST запроса к Jito API let endpoint = format!("{}/api/v1/bundles", self.config.block_engine_url); debug!(" Endpoint: {}", endpoint); let response = self.http_client .post(&endpoint) .json(&request) .send() .await .context("Не удалось отправить bundle в Jito")?; // Проверка статуса ответа let status = response.status(); if !status.is_success() { let error_text = response.text().await.unwrap_or_else(|_| "Unknown error".to_string()); anyhow::bail!("Jito вернул ошибку {}: {}", status, error_text); } // Парсинг ответа let bundle_response: SendBundleResponse = response .json() .await .context("Не удалось распарсить ответ Jito")?; if let Some(error) = bundle_response.error { anyhow::bail!("Jito RPC ошибка: {:?}", error); } let bundle_id = bundle_response.result .ok_or_else(|| anyhow::anyhow!("Нет bundle_id в ответе Jito"))?; info!(" ✅ Bundle отправлен, ID: {}", bundle_id); Ok(bundle_id) } /// Проверка статуса bundle pub async fn get_bundle_status(&self, bundle_id: &str) -> Result { let request = GetBundleStatusRequest { jsonrpc: "2.0".to_string(), id: 1, method: "getBundleStatuses".to_string(), params: vec![vec![bundle_id.to_string()]], }; let endpoint = format!("{}/api/v1/bundles", self.config.block_engine_url); let response = self.http_client .post(&endpoint) .json(&request) .send() .await .context("Не удалось получить статус bundle")?; let status_response: GetBundleStatusResponse = response .json() .await .context("Не удалось распарсить статус bundle")?; let statuses = status_response.result.value .ok_or_else(|| anyhow::anyhow!("Нет статусов в ответе"))?; let status = statuses.first() .ok_or_else(|| anyhow::anyhow!("Пустой массив статусов"))?; Ok(status.clone()) } /// Ожидание подтверждения bundle (с таймаутом) pub async fn wait_for_confirmation( &self, bundle_id: &str, timeout_seconds: u64, ) -> Result { use tokio::time::{sleep, Duration}; let start = std::time::Instant::now(); let timeout = Duration::from_secs(timeout_seconds); loop { if start.elapsed() > timeout { anyhow::bail!("Таймаут ожидания подтверждения bundle"); } let status = self.get_bundle_status(bundle_id).await?; match status.confirmation_status.as_str() { "confirmed" | "finalized" => { info!(" ✅ Bundle подтверждён: {}", status.confirmation_status); return Ok(status); } "failed" => { anyhow::bail!("Bundle провалился: {:?}", status.err); } "pending" => { debug!(" Bundle в ожидании... ({}s)", start.elapsed().as_secs()); sleep(Duration::from_millis(500)).await; } _ => { debug!(" Неизвестный статус: {}", status.confirmation_status); sleep(Duration::from_millis(500)).await; } } } } } // ============================================================================ // JSON-RPC СТРУКТУРЫ // ============================================================================ #[derive(Serialize)] struct SendBundleRequest { jsonrpc: String, id: u64, method: String, params: Vec>, } #[derive(Deserialize)] struct SendBundleResponse { result: Option, error: Option, } #[derive(Serialize)] struct GetBundleStatusRequest { jsonrpc: String, id: u64, method: String, params: Vec>, } #[derive(Deserialize)] struct GetBundleStatusResponse { result: BundleStatusResult, } #[derive(Deserialize)] struct BundleStatusResult { value: Option>, } #[derive(Debug, Clone, Deserialize)] pub struct BundleStatus { pub bundle_id: String, pub confirmation_status: String, pub err: Option, pub slot: Option, } #[derive(Debug, Deserialize)] struct JsonRpcError { code: i32, message: String, } // ============================================================================ // ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ // ============================================================================ /// Создание tip транзакции для Jito pub fn create_tip_instruction( from: &Pubkey, tip_account: &Pubkey, lamports: u64, ) -> solana_sdk::instruction::Instruction { solana_sdk::system_instruction::transfer(from, tip_account, lamports) } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/executor/simulator.rs // bot/src/executor/simulator.rs (завершение) use tracing::debug; use solana_sdk::transaction::Transaction; use crate::types::SimulationResult; use anyhow::Result; use solana_client::rpc_client::RpcClient; use std::sync::Arc; pub struct TransactionSimulator { rpc_client: Arc, } /// Симуляция транзакции impl TransactionSimulator { pub fn new(rpc_client: Arc) -> Self { Self { rpc_client } } pub async fn simulate(&self, transaction: &Transaction) -> Result { let simulation = self.rpc_client .simulate_transaction(transaction) .map_err(|e| anyhow::anyhow!("Ошибка симуляции: {}", e))?; let result = SimulationResult { err: simulation.value.err.map(|e| format!("{:?}", e)), logs: simulation.value.logs.clone().unwrap_or_default(), units_consumed: simulation.value.units_consumed, }; if let Some(ref err) = result.err { debug!("Симуляция завершилась с ошибкой: {}", err); if let Some(logs) = &simulation.value.logs { for log in logs { debug!(" Log: {}", log); } } } Ok(result) } /// Оценка compute units для транзакции pub async fn estimate_compute_units(&self, transaction: &Transaction) -> Result { let simulation = self.simulate(transaction).await?; simulation.units_consumed .ok_or_else(|| anyhow::anyhow!("Не удалось определить compute units")) } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/executor/transaction_builder.rs // bot/src/executor/transaction_builder.rs use anchor_spl::{associated_token, token}; use anyhow::{Result, Context}; use solana_sdk::{ instruction::{AccountMeta, Instruction}, pubkey::Pubkey, transaction::Transaction, signature::{Keypair, Signer}, system_program, compute_budget::ComputeBudgetInstruction, hash::Hash, }; use solana_client::rpc_client::RpcClient; use std::sync::Arc; use tracing::{info, debug}; use solana_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; use crate::config::BotConfig; use crate::types::{ArbitrageOpportunity, SwapLeg, DexProtocol}; use crate::dex_structs::AmmInfo; pub struct TransactionBuilder { rpc_client: Arc, keypair: Arc, config: Arc, program_id: Pubkey, } /// Структура swap leg для передачи в программу #[derive(BorshSerialize, BorshDeserialize)] struct ProgramSwapLeg { protocol: u8, pool_id: Pubkey, input_mint: Pubkey, output_mint: Pubkey, amount_in: u64, minimum_amount_out: u64, accounts_len: u8, } /// Параметры инструкции execute_arbitrage #[derive(BorshSerialize, BorshDeserialize)] struct ExecuteArbitrageParams { swap_legs: Vec, min_profit_lamports: u64, } impl TransactionBuilder { pub fn new( rpc_client: Arc, keypair: Arc, config: Arc, ) -> Result { let program_id = config.trading.executor_program_id.to_pubkey()?; Ok(Self { rpc_client, keypair, config, program_id, }) } pub async fn build_arbitrage_transaction( &self, opportunity: &ArbitrageOpportunity, ) -> Result { info!("🔨 Построение транзакции арбитража..."); let recent_blockhash = self.get_recent_blockhash().await?; let mut instructions = Vec::new(); instructions.push(ComputeBudgetInstruction::set_compute_unit_limit( self.config.trading.compute_unit_limit )); instructions.push(ComputeBudgetInstruction::set_compute_unit_price( self.config.trading.priority_fee_micro_lamports )); let arbitrage_ix = self.build_arbitrage_instruction(opportunity)?; instructions.push(arbitrage_ix); let mut transaction = Transaction::new_with_payer( &instructions, Some(&self.keypair.pubkey()), ); transaction.sign(&[self.keypair.as_ref()], recent_blockhash); debug!(" Размер транзакции: {} байт", bincode::serialize(&transaction)?.len()); Ok(transaction) } fn build_arbitrage_instruction( &self, opportunity: &ArbitrageOpportunity, ) -> Result { let swap_legs = self.convert_to_program_swap_legs(&opportunity.legs)?; let first_token_mint = opportunity.legs.first() .context("Нет свопов в возможности")? .input_mint; let user_token_account = associated_token::get_associated_token_address( &self.keypair.pubkey(), &first_token_mint, ); let accounts = vec![ AccountMeta::new_readonly(system_program::id(), false), AccountMeta::new(user_token_account, false), AccountMeta::new_readonly(self.keypair.pubkey(), true), ]; let remaining_accounts = self.build_remaining_accounts(&opportunity.legs)?; let all_accounts = [accounts, remaining_accounts].concat(); let instruction_data = self.build_instruction_data( swap_legs, opportunity.net_profit, )?; Ok(Instruction { program_id: self.program_id, accounts: all_accounts, data: instruction_data, }) } fn convert_to_program_swap_legs( &self, legs: &[SwapLeg], ) -> Result> { legs.iter() .map(|leg| { Ok(ProgramSwapLeg { protocol: leg.protocol as u8, pool_id: leg.pool_id, input_mint: leg.input_mint, output_mint: leg.output_mint, amount_in: leg.amount_in, minimum_amount_out: leg.minimum_amount_out, accounts_len: self.get_accounts_count_for_protocol(leg.protocol), }) }) .collect() } fn get_accounts_count_for_protocol(&self, protocol: DexProtocol) -> u8 { match protocol { DexProtocol::RaydiumAmmV4 => 18, DexProtocol::RaydiumCpmm => 10, DexProtocol::RaydiumClmm => 12, DexProtocol::MeteoraDlmm => 10, } } fn build_remaining_accounts(&self, legs: &[SwapLeg]) -> Result> { let mut accounts = Vec::new(); for leg in legs { match leg.protocol { DexProtocol::RaydiumAmmV4 => { let amm_info = AmmInfo::try_from_slice(&leg.pool_state_data) .context("Failed to deserialize AmmInfo in transaction builder")?; let pool_accounts = self.get_raydium_amm_accounts(&leg.pool_id, &amm_info, &leg.input_mint, &leg.output_mint)?; accounts.extend(pool_accounts); } _ => anyhow::bail!("Протокол {:?} пока не поддерживается", leg.protocol), } } Ok(accounts) } fn get_raydium_amm_accounts(&self, pool_id: &Pubkey, amm_info: &AmmInfo, input_mint: &Pubkey, output_mint: &Pubkey) -> Result> { debug!(" Получение аккаунтов для Raydium AMM пула {}", pool_id); let user_source_token = associated_token::get_associated_token_address(&self.keypair.pubkey(), input_mint); let user_dest_token = associated_token::get_associated_token_address(&self.keypair.pubkey(), output_mint); let (amm_authority, _) = Pubkey::find_program_address(&[b"amm authority"], &self.config.dex.raydium_amm_v4.to_pubkey()?); let accounts = vec![ AccountMeta::new_readonly(*pool_id, false), AccountMeta::new(amm_info.base_vault, false), AccountMeta::new(amm_info.quote_vault, false), AccountMeta::new(user_source_token, false), AccountMeta::new(user_dest_token, false), AccountMeta::new_readonly(amm_authority, false), AccountMeta::new_readonly(token::ID, false), ]; Ok(accounts) } fn build_instruction_data( &self, swap_legs: Vec, min_profit: u64, ) -> Result> { let discriminator: [u8; 8] = [0x7a, 0x3e, 0x9c, 0x4f, 0x1d, 0x8b, 0x2e, 0x6f]; let mut data = discriminator.to_vec(); let params = ExecuteArbitrageParams { swap_legs, min_profit_lamports: min_profit, }; let serialized = params.try_to_vec().context("Не удалось сериализовать параметры")?; data.extend_from_slice(&serialized); Ok(data) } async fn get_recent_blockhash(&self) -> Result { self.rpc_client .get_latest_blockhash() .context("Не удалось получить recent blockhash") } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/scanner/mod.rs // bot/src/scanner/mod.rs pub mod pool_monitor; pub mod raydium_amm; pub mod raydium_cpmm; pub mod raydium_clmm; pub mod meteora_dlmm; use anyhow::Result; use async_trait::async_trait; use std::sync::Arc; use tracing::info; use solana_client::rpc_client::RpcClient; use crate::config::BotConfig; use crate::types::{PoolState, DexProtocol}; use raydium_amm::RaydiumAmmScanner; use raydium_cpmm::RaydiumCpmmScanner; use raydium_clmm::RaydiumClmmScanner; use meteora_dlmm::MeteoraDlmmScanner; #[async_trait] pub trait DexScanner: Send + Sync { fn protocol(&self) -> DexProtocol; async fn scan_pools(&self) -> Result>; fn clone_box(&self) -> Box; } pub struct MultiDexScanner { scanners: Vec>, } impl MultiDexScanner { pub fn new(config: Arc, rpc_client: Arc) -> Self { let scanners: Vec> = vec![ Box::new(RaydiumAmmScanner::new(config.clone(), rpc_client.clone())), Box::new(RaydiumCpmmScanner::new(config.clone())), Box::new(RaydiumClmmScanner::new(config.clone())), Box::new(MeteoraDlmmScanner::new(config.clone())), ]; Self { scanners } } pub async fn scan_all_dex(&self) -> Result> { info!("🔍 Запуск сканирования всех DEX..."); let mut all_pools = Vec::new(); for scanner in &self.scanners { match scanner.scan_pools().await { Ok(pools) => { info!(" {:?}: найдено {} пулов", scanner.protocol(), pools.len()); all_pools.extend(pools); } Err(e) => { tracing::warn!(" {:?}: ошибка сканирования - {}", scanner.protocol(), e); } } } info!("✅ Всего пулов найдено: {}", all_pools.len()); Ok(all_pools) } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/scanner/meteora_dlmm.rs // bot/src/scanner/meteora_dlmm.rs // Сканер пулов Meteora DLMM (Dynamic Liquidity Market Maker) use anyhow::Result; use solana_sdk::pubkey::Pubkey; use std::str::FromStr; use tracing::{info, warn}; use crate::config::BotConfig; use crate::types::{PoolState, DexProtocol}; use super::DexScanner; #[derive(Clone)] pub struct MeteoraDlmmScanner { config: std::sync::Arc, program_id: Pubkey, } impl MeteoraDlmmScanner { pub fn new(config: std::sync::Arc) -> Self { let program_id = Pubkey::from_str("LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo") .expect("Invalid Meteora DLMM program ID"); Self { config, program_id } } /// Парсинг данных пула Meteora DLMM fn parse_pool_account(&self, pool_id: Pubkey, data: &[u8]) -> Result { // Meteora DLMM использует bin-based liquidity distribution // Документация: https://docs.meteora.ag/ if data.len() < 600 { anyhow::bail!("Недостаточно данных для парсинга пула Meteora DLMM"); } let token_a = Pubkey::new_from_array(data[8..40].try_into()?); let token_b = Pubkey::new_from_array(data[40..72].try_into()?); let reserve_a = 1_000_000_000; let reserve_b = 1_000_000_000; Ok(PoolState { id: pool_id, protocol: DexProtocol::MeteoraDlmm, token_a, token_b, reserve_a, reserve_b, fee_bps: 20, // Динамическая комиссия Meteora (упрощено) last_updated: chrono::Utc::now().timestamp(), full_state_data: data.to_vec(), }) } } #[async_trait::async_trait] impl DexScanner for MeteoraDlmmScanner { fn protocol(&self) -> DexProtocol { DexProtocol::MeteoraDlmm } async fn scan_pools(&self) -> Result> { info!("📡 Сканирование Meteora DLMM пулов на devnet..."); let known_pools: Vec = vec![]; if known_pools.is_empty() { warn!("⚠️ Нет известных Meteora DLMM пулов на devnet."); return Ok(vec![]); } let pools = Vec::new(); info!("✅ Meteora DLMM: найдено {} пулов", pools.len()); Ok(pools) } fn clone_box(&self) -> Box { Box::new(self.clone()) } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/scanner/pool_monitor.rs // bot/src/scanner/pool_monitor.rs // Мониторинг изменений в пулах в реальном времени // use anyhow::Result; use dashmap::DashMap; use solana_sdk::pubkey::Pubkey; use std::sync::Arc; use tokio::time::{interval, Duration}; use tracing::{info, debug}; use crate::types::PoolState; /// Кэш состояний пулов с автообновлением pub struct PoolMonitor { /// Кэш пулов: pool_id -> PoolState cache: Arc>, /// Интервал обновления в миллисекундах update_interval_ms: u64, } impl PoolMonitor { pub fn new(update_interval_ms: u64) -> Self { Self { cache: Arc::new(DashMap::new()), update_interval_ms, } } /// Обновление состояния пула pub fn update_pool(&self, pool: PoolState) { let pool_id = pool.id; // Проверяем значительность изменения if let Some(old_pool) = self.cache.get(&pool_id) { let price_change = self.calculate_price_change(&old_pool, &pool); if price_change > 0.5 { debug!("Значительное изменение цены в пуле {}: {:.2}%", pool_id, price_change); } } self.cache.insert(pool_id, pool); } /// Получение всех пулов из кэша pub fn get_all_pools(&self) -> Vec { self.cache.iter() .map(|entry| entry.value().clone()) .collect() } /// Получение конкретного пула pub fn get_pool(&self, pool_id: &Pubkey) -> Option { self.cache.get(pool_id).map(|entry| entry.value().clone()) } /// Количество пулов в кэше pub fn pool_count(&self) -> usize { self.cache.len() } /// Расчёт изменения цены в процентах fn calculate_price_change(&self, old: &PoolState, new: &PoolState) -> f64 { let old_price = old.price_a_to_b(); let new_price = new.price_a_to_b(); if old_price == 0.0 { return 0.0; } ((new_price - old_price) / old_price).abs() * 100.0 } /// Очистка устаревших пулов (старше threshold_seconds) pub fn cleanup_stale_pools(&self, threshold_seconds: i64) { let now = chrono::Utc::now().timestamp(); self.cache.retain(|_pool_id, pool| { let age = now - pool.last_updated; age < threshold_seconds }); } } /// Фоновая задача периодической очистки кэша pub async fn start_cache_cleanup_task(monitor: Arc) { let mut cleanup_interval = interval(Duration::from_secs(60)); // Каждую минуту loop { cleanup_interval.tick().await; let count_before = monitor.pool_count(); monitor.cleanup_stale_pools(300); // Удаляем старше 5 минут let count_after = monitor.pool_count(); if count_before != count_after { info!("🧹 Очистка кэша: удалено {} устаревших пулов", count_before - count_after); } } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/scanner/raydium_amm.rs // bot/src/scanner/raydium_amm.rs use anyhow::{Result, Context}; use solana_sdk::pubkey::Pubkey; use std::sync::Arc; use tracing::{info, debug}; use solana_client::{ rpc_client::RpcClient, rpc_config::{RpcProgramAccountsConfig, RpcAccountInfoConfig}, rpc_filter::RpcFilterType, }; use solana_account_decoder::UiAccountEncoding; use solana_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; use crate::config::BotConfig; use crate::types::{PoolState, DexProtocol}; use crate::dex_structs::AmmInfo; use super::DexScanner; #[derive(Clone)] pub struct RaydiumAmmScanner { config: Arc, rpc_client: Arc, program_id: Pubkey, } impl RaydiumAmmScanner { pub fn new(config: Arc, rpc_client: Arc) -> Self { let program_id = config.dex.raydium_amm_v4.to_pubkey() .expect("Invalid Raydium AMM program ID in config"); Self { config, rpc_client, program_id } } async fn parse_pool_account(&self, pool_id: Pubkey, data: Vec) -> Result { let amm_info = AmmInfo::try_from_slice(&data) .context("Failed to deserialize AmmInfo")?; // Эти вызовы блокирующие, поэтому выполняем их последовательно let base_reserve_res = self.rpc_client.get_token_account_balance(&amm_info.base_vault)?; let quote_reserve_res = self.rpc_client.get_token_account_balance(&amm_info.quote_vault)?; let reserve_a = base_reserve_res.amount.parse::()?; let reserve_b = quote_reserve_res.amount.parse::()?; Ok(PoolState { id: pool_id, protocol: DexProtocol::RaydiumAmmV4, token_a: amm_info.base_mint, token_b: amm_info.quote_mint, reserve_a, reserve_b, fee_bps: 25, last_updated: chrono::Utc::now().timestamp(), full_state_data: data, }) } } #[async_trait::async_trait] impl DexScanner for RaydiumAmmScanner { fn protocol(&self) -> DexProtocol { DexProtocol::RaydiumAmmV4 } async fn scan_pools(&self) -> Result> { info!("📡 Сканирование Raydium AMM V4 пулов на devnet..."); const AMM_INFO_DATA_SIZE: u64 = 752; let config = RpcProgramAccountsConfig { filters: Some(vec![ RpcFilterType::DataSize(AMM_INFO_DATA_SIZE) ]), account_config: RpcAccountInfoConfig { encoding: Some(UiAccountEncoding::Base64), ..Default::default() }, ..Default::default() }; let accounts = self.rpc_client .get_program_accounts_with_config(&self.program_id, config) .context("Failed to get program accounts for Raydium AMM V4")?; info!(" Найдено {} потенциальных аккаунтов пулов...", accounts.len()); let mut pools = Vec::new(); for (pubkey, account) in accounts { match self.parse_pool_account(pubkey, account.data).await { Ok(pool) => pools.push(pool), Err(e) => debug!(" Не удалось распарсить пул {}: {}", pubkey, e), } } info!("✅ Raydium AMM: успешно обработано {} пулов", pools.len()); Ok(pools) } fn clone_box(&self) -> Box { Box::new(self.clone()) } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/scanner/raydium_clmm.rs // bot/src/scanner/raydium_clmm.rs // Сканер пулов Raydium CLMM (Concentrated Liquidity) use anyhow::Result; use solana_sdk::pubkey::Pubkey; use std::str::FromStr; use tracing::{info, warn}; use crate::config::BotConfig; use crate::types::{PoolState, DexProtocol}; use super::DexScanner; #[derive(Clone)] pub struct RaydiumClmmScanner { config: std::sync::Arc, program_id: Pubkey, } impl RaydiumClmmScanner { pub fn new(config: std::sync::Arc) -> Self { let program_id = Pubkey::from_str("DRayAUgENGQBKVaX8owNhgzkEDyoHTGVEGHVJT1E9pfH") .expect("Invalid Raydium CLMM program ID"); Self { config, program_id } } /// Парсинг данных пула Raydium CLMM fn parse_pool_account(&self, pool_id: Pubkey, data: &[u8]) -> Result { // CLMM использует модель Uniswap V3 (tick-based liquidity) // Полная структура требует обработки позиций ликвидности if data.len() < 1544 { anyhow::bail!("Недостаточно данных для парсинга пула CLMM"); } // Упрощённая версия let token_a = Pubkey::new_from_array(data[73..105].try_into()?); let token_b = Pubkey::new_from_array(data[105..137].try_into()?); let reserve_a = 1_000_000_000; let reserve_b = 1_000_000_000; Ok(PoolState { id: pool_id, protocol: DexProtocol::RaydiumClmm, token_a, token_b, reserve_a, reserve_b, fee_bps: 25, last_updated: chrono::Utc::now().timestamp(), full_state_data: data.to_vec(), }) } } #[async_trait::async_trait] impl DexScanner for RaydiumClmmScanner { fn protocol(&self) -> DexProtocol { DexProtocol::RaydiumClmm } async fn scan_pools(&self) -> Result> { info!("📡 Сканирование Raydium CLMM пулов на devnet..."); let known_pools: Vec = vec![]; if known_pools.is_empty() { warn!("⚠️ Нет известных Raydium CLMM пулов на devnet."); return Ok(vec![]); } let pools = Vec::new(); info!("✅ Raydium CLMM: найдено {} пулов", pools.len()); Ok(pools) } fn clone_box(&self) -> Box { Box::new(self.clone()) } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/scanner/raydium_cpmm.rs // bot/src/scanner/raydium_cpmm.rs // Сканер пулов Raydium CPMM use anyhow::Result; use solana_sdk::pubkey::Pubkey; use std::str::FromStr; use tracing::{info, warn}; use crate::config::BotConfig; use crate::types::{PoolState, DexProtocol}; use super::DexScanner; #[derive(Clone)] pub struct RaydiumCpmmScanner { config: std::sync::Arc, program_id: Pubkey, } impl RaydiumCpmmScanner { pub fn new(config: std::sync::Arc) -> Self { let program_id = Pubkey::from_str("DRaycpLY18LhpbydsBWbVJtxpNv9oXPgjRSfpF2bWpYb") .expect("Invalid Raydium CPMM program ID"); Self { config, program_id } } /// Парсинг данных пула Raydium CPMM fn parse_pool_account(&self, pool_id: Pubkey, data: &[u8]) -> Result { // CPMM (Concentrated Pool Market Maker) layout // Документация: https://github.com/raydium-io/raydium-cpmm if data.len() < 324 { anyhow::bail!("Недостаточно данных для парсинга пула CPMM"); } // Упрощённая структура для devnet // В production нужна полная десериализация let token_a = Pubkey::new_from_array( data[8..40].try_into()? ); let token_b = Pubkey::new_from_array( data[40..72].try_into()? ); // Заглушки резервов (замените на реальное получение) let reserve_a = 1_000_000_000; let reserve_b = 1_000_000_000; Ok(PoolState { id: pool_id, protocol: DexProtocol::RaydiumCpmm, token_a, token_b, reserve_a, reserve_b, fee_bps: 25, last_updated: chrono::Utc::now().timestamp(), full_state_data: data.to_vec(), }) } } #[async_trait::async_trait] impl DexScanner for RaydiumCpmmScanner { fn protocol(&self) -> DexProtocol { DexProtocol::RaydiumCpmm } async fn scan_pools(&self) -> Result> { info!("📡 Сканирование Raydium CPMM пулов на devnet..."); // Список известных CPMM пулов на devnet let known_pools: Vec = vec![ // Добавьте адреса ваших тестовых CPMM пулов ]; if known_pools.is_empty() { warn!("⚠️ Нет известных Raydium CPMM пулов на devnet."); return Ok(vec![]); } let pools = Vec::new(); info!("✅ Raydium CPMM: найдено {} пулов", pools.len()); Ok(pools) } fn clone_box(&self) -> Box { Box::new(self.clone()) } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/utils/mod.rs // bot/src/utils/mod.rs // Модуль вспомогательных утилит pub mod math; pub mod rpc; use anyhow::{Context, Result}; use solana_sdk::signature::Keypair; use std::fs; use std::str::FromStr; use solana_sdk::pubkey::Pubkey; /// Загрузка keypair из файла pub fn load_keypair_from_file(path: &str) -> Result { // Расширение пути (~/.config -> /home/user/.config) let expanded_path = shellexpand::tilde(path).into_owned(); // Чтение файла let keypair_bytes = fs::read(&expanded_path) .context(format!("Не удалось прочитать файл кошелька: {}", expanded_path))?; // Парсинг JSON массива байт let keypair_data: Vec = serde_json::from_slice(&keypair_bytes) .context("Неверный формат файла кошелька (ожидается JSON массив байт)")?; // Создание keypair из байтов Keypair::from_bytes(&keypair_data) .context("Не удалось создать keypair из данных файла. Убедитесь, что файл содержит 64 байта.") } /// Форматирование lamports в SOL с заданной точностью pub fn lamports_to_sol(lamports: u64, decimals: usize) -> String { let sol = lamports as f64 / 1_000_000_000.0; format!("{:.decimals$}", sol, decimals = decimals) } /// Конвертация SOL в lamports pub fn sol_to_lamports(sol: f64) -> u64 { (sol * 1_000_000_000.0) as u64 } /// Проверка валидности Pubkey pub fn is_valid_pubkey(address: &str) -> bool { Pubkey::from_str(address).is_ok() } #[cfg(test)] mod tests { use super::*; #[test] fn test_lamports_conversion() { assert_eq!(sol_to_lamports(1.0), 1_000_000_000); assert_eq!(sol_to_lamports(0.5), 500_000_000); assert_eq!(lamports_to_sol(1_000_000_000, 2), "1.00"); assert_eq!(lamports_to_sol(500_000_000, 4), "0.5000"); } #[test] fn test_pubkey_validation() { assert!(is_valid_pubkey("11111111111111111111111111111111")); assert!(!is_valid_pubkey("invalid_address")); assert!(!is_valid_pubkey("")); } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/utils/math.rs // bot/src/utils/math.rs // Математические утилиты для расчётов арбитража use anyhow::Result; /// Расчёт выхода свопа по формуле постоянного произведения (AMM) /// /// # Формула /// amount_out = (reserve_out * amount_in) / (reserve_in + amount_in) /// /// # Параметры /// - reserve_in: Резерв входного токена /// - reserve_out: Резерв выходного токена /// - amount_in: Количество входного токена /// - fee_bps: Комиссия в базисных пунктах (25 = 0.25%) pub fn calculate_amm_swap_output( reserve_in: u64, reserve_out: u64, amount_in: u64, fee_bps: u16, ) -> Result { if reserve_in == 0 || reserve_out == 0 { anyhow::bail!("Нулевые резервы в пуле"); } // Применение комиссии к входной сумме let fee_multiplier = 1.0 - (fee_bps as f64 / 10000.0); let amount_in_with_fee = (amount_in as f64) * fee_multiplier; // Формула постоянного произведения let numerator = (reserve_out as f64) * amount_in_with_fee; let denominator = (reserve_in as f64) + amount_in_with_fee; let amount_out = numerator / denominator; Ok(amount_out as u64) } /// Расчёт минимального выхода с учётом slippage /// /// # Параметры /// - expected_amount: Ожидаемая сумма /// - slippage_bps: Допустимый slippage в базисных пунктах (100 = 1%) pub fn calculate_minimum_amount_out( expected_amount: u64, slippage_bps: u16, ) -> u64 { let slippage_multiplier = 1.0 - (slippage_bps as f64 / 10000.0); ((expected_amount as f64) * slippage_multiplier) as u64 } /// Расчёт цены токена A в терминах токена B pub fn calculate_price_a_to_b(reserve_a: u64, reserve_b: u64) -> f64 { if reserve_b == 0 { return 0.0; } reserve_a as f64 / reserve_b as f64 } /// Расчёт изменения цены в процентах pub fn calculate_price_change_percent(old_price: f64, new_price: f64) -> f64 { if old_price == 0.0 { return 0.0; } ((new_price - old_price) / old_price) * 100.0 } /// Расчёт прибыли в процентах pub fn calculate_profit_percentage(initial: u64, final_amount: u64) -> f64 { if initial == 0 { return 0.0; } ((final_amount as f64 - initial as f64) / initial as f64) * 100.0 } /// Проверка прибыльности с учётом минимального порога pub fn is_profitable( initial_amount: u64, final_amount: u64, min_profit_lamports: u64, ) -> bool { final_amount >= initial_amount + min_profit_lamports } /// Расчёт общих комиссий транзакции pub fn calculate_total_transaction_fees( base_fee: u64, priority_fee: u64, jito_tip: u64, ) -> u64 { base_fee + priority_fee + jito_tip } /// Расчёт точки безубыточности (breakeven) для арбитража /// /// Возвращает минимальную финальную сумму для достижения нулевой прибыли pub fn calculate_breakeven_amount( initial_amount: u64, transaction_fees: u64, ) -> u64 { initial_amount + transaction_fees } /// Расчёт эффективной APY для арбитража /// /// # Параметры /// - profit_lamports: Прибыль за одну сделку /// - capital_lamports: Использованный капитал /// - trades_per_day: Среднее количество сделок в день pub fn calculate_effective_apy( profit_lamports: u64, capital_lamports: u64, trades_per_day: f64, ) -> f64 { if capital_lamports == 0 { return 0.0; } let daily_return = (profit_lamports as f64 / capital_lamports as f64) * trades_per_day; let annual_return = daily_return * 365.0; annual_return * 100.0 // В процентах } /// Расчёт impact на пул (price impact от свопа) pub fn calculate_price_impact( reserve_in: u64, reserve_out: u64, amount_in: u64, ) -> f64 { let price_before = reserve_out as f64 / reserve_in as f64; let new_reserve_in = reserve_in + amount_in; let price_after = reserve_out as f64 / new_reserve_in as f64; ((price_after - price_before) / price_before).abs() * 100.0 } #[cfg(test)] mod tests { use super::*; #[test] fn test_amm_swap_output() { // Пул: 1000 USDC, 1000 SOL, комиссия 0.25% let output = calculate_amm_swap_output( 1_000_000_000, // 1000 USDC 1_000_000_000, // 1000 SOL 100_000_000, // 100 USDC in 25, // 0.25% fee ).unwrap(); // Ожидаем ~90.7 SOL (с учётом комиссии и slippage) assert!(output > 90_000_000 && output < 100_000_000); } #[test] fn test_minimum_amount_out() { let expected = 1_000_000_000; // 1 SOL let min_out = calculate_minimum_amount_out(expected, 100); // 1% slippage assert_eq!(min_out, 990_000_000); // 0.99 SOL } #[test] fn test_price_change() { let change = calculate_price_change_percent(100.0, 110.0); assert!((change - 10.0).abs() < 0.01); let change_down = calculate_price_change_percent(100.0, 90.0); assert!((change_down + 10.0).abs() < 0.01); } #[test] fn test_profitability_check() { assert!(is_profitable(1_000_000, 1_100_000, 50_000)); // Прибыльно assert!(!is_profitable(1_000_000, 1_040_000, 50_000)); // Не прибыльно } #[test] fn test_apy_calculation() { // Прибыль 0.01 SOL с капитала 1 SOL, 10 сделок в день let apy = calculate_effective_apy( 10_000_000, // 0.01 SOL profit 1_000_000_000, // 1 SOL capital 10.0, // 10 trades/day ); // Ожидаем ~36.5% годовых assert!((apy - 36.5).abs() < 1.0); } #[test] fn test_price_impact() { let impact = calculate_price_impact( 1_000_000_000, // 1000 tokens in reserve 1_000_000_000, // 1000 tokens out reserve 100_000_000, // 100 tokens swap ); // Impact должен быть ~9.09% assert!(impact > 9.0 && impact < 10.0); } } ===== /home/newvovi4/arbitrage-bot-rust/bot/src/utils/rpc.rs // bot/src/utils/rpc.rs // Утилиты для работы с RPC клиентами Solana use anyhow::{Result, Context}; use solana_client::{ rpc_client::RpcClient, rpc_config::{RpcSendTransactionConfig, RpcSimulateTransactionConfig}, client_error::ClientError, }; use solana_sdk::{ commitment_config::CommitmentConfig, transaction::Transaction, signature::Signature, }; use std::time::Duration; use tokio::time::sleep; use tracing::{warn, debug}; /// Конфигурация ретраев для RPC запросов pub struct RetryConfig { pub max_retries: usize, pub base_delay_ms: u64, pub exponential_backoff: bool, } impl Default for RetryConfig { fn default() -> Self { Self { max_retries: 3, base_delay_ms: 500, exponential_backoff: true, } } } /// RPC клиент с множественными endpoints и ретраями pub struct MultiRpcClient { primary: RpcClient, fallbacks: Vec, retry_config: RetryConfig, } impl MultiRpcClient { pub fn new(primary_url: String, fallback_urls: Vec) -> Self { let primary = RpcClient::new_with_commitment( primary_url, CommitmentConfig::confirmed(), ); let fallbacks: Vec = fallback_urls .into_iter() .map(|url| RpcClient::new_with_commitment(url, CommitmentConfig::confirmed())) .collect(); Self { primary, fallbacks, retry_config: RetryConfig::default(), } } /// Отправка транзакции с ретраями pub async fn send_transaction_with_retry( &self, transaction: &Transaction, ) -> Result { let config = RpcSendTransactionConfig { skip_preflight: false, preflight_commitment: Some(CommitmentConfig::confirmed().commitment), ..Default::default() }; let mut last_error = None; // Попытка через primary RPC for attempt in 0..self.retry_config.max_retries { match self.primary.send_transaction_with_config(transaction, config) { Ok(signature) => { debug!("Транзакция отправлена: {} (попытка {})", signature, attempt + 1); return Ok(signature); } Err(e) => { warn!("Ошибка отправки (попытка {}): {}", attempt + 1, e); last_error = Some(e); if attempt < self.retry_config.max_retries - 1 { let delay = self.calculate_delay(attempt); sleep(Duration::from_millis(delay)).await; } } } } // Попытка через fallback RPCs for (idx, fallback) in self.fallbacks.iter().enumerate() { match fallback.send_transaction_with_config(transaction, config) { Ok(signature) => { debug!("Транзакция отправлена через fallback #{}: {}", idx + 1, signature); return Ok(signature); } Err(e) => { warn!("Fallback #{} провалился: {}", idx + 1, e); last_error = Some(e); } } } Err(anyhow::anyhow!( "Не удалось отправить транзакцию после {} попыток: {:?}", self.retry_config.max_retries, last_error )) } /// Симуляция транзакции с ретраями pub async fn simulate_transaction_with_retry( &self, transaction: &Transaction, ) -> Result { let mut last_error = None; for attempt in 0..self.retry_config.max_retries { match self.primary.simulate_transaction(transaction) { Ok(result) => return Ok(result.value), Err(e) => { warn!("Симуляция провалилась (попытка {}): {}", attempt + 1, e); last_error = Some(e); if attempt < self.retry_config.max_retries - 1 { let delay = self.calculate_delay(attempt); sleep(Duration::from_millis(delay)).await; } } } } Err(anyhow::anyhow!( "Симуляция провалилась после {} попыток: {:?}", self.retry_config.max_retries, last_error )) } /// Расчёт задержки с exponential backoff fn calculate_delay(&self, attempt: usize) -> u64 { if self.retry_config.exponential_backoff { self.retry_config.base_delay_ms * (2_u64.pow(attempt as u32)) } else { self.retry_config.base_delay_ms } } } ===== /home/newvovi4/arbitrage-bot-rust/programs/arbitrage-executor/Cargo.toml # programs/arbitrage-executor/Cargo.toml # Зависимости смарт-контракта [package] name = "arbitrage-executor" version = "0.1.0" description = "Solana Arbitrage Executor Smart Contract" edition = "2021" [lib] crate-type = ["cdylib", "lib"] name = "arbitrage_executor" [features] no-entrypoint = [] no-idl = [] no-log-ix-name = [] cpi = ["no-entrypoint"] default = [] [dependencies] anchor-lang = "0.29.0" anchor-spl = "0.29.0" solana-program = "~1.18" toml_edit = "=0.22.14" toml_datetime = "=0.6.6" base64ct = "=1.6.0" toml_parser = "=1.0.0" ===== /home/newvovi4/arbitrage-bot-rust/programs/arbitrage-executor/src/lib.rs // programs/arbitrage-executor/src/lib.rs // Smart Contract "Executor" for Atomic Multi-Hop Swaps via CPI use anchor_lang::prelude::*; use anchor_lang::solana_program::{ instruction::{AccountMeta, Instruction}, program::invoke, }; use anchor_spl::token::{Token, TokenAccount, Mint}; use solana_program::pubkey; declare_id!("44SMYSDatw9DU6amM4d3Yv9SkxzBRphtoftLP6ep5M7T"); // ============================================================================ // DEX PROGRAM IDS (MAINNET) // ============================================================================ pub const RAYDIUM_AMM_V4: Pubkey = pubkey!("DRaya7Kj3aMWQSy19kSjvmuwq9docCHofyP9kanQGaav"); pub const RAYDIUM_CPMM: Pubkey = pubkey!("DRaycpLY18LhpbydsBWbVJtxpNv9oXPgjRSfpF2bWpYb"); pub const RAYDIUM_CLMM: Pubkey = pubkey!("DRayAUgENGQBKVaX8owNhgzkEDyoHTGVEGHVJT1E9pfH"); pub const METEORA_DLMM: Pubkey = pubkey!("LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo"); // ============================================================================ // TYPES & ENUMS // ============================================================================ #[derive(AnchorSerialize, AnchorDeserialize, Clone, Copy, PartialEq, Eq, Debug)] pub enum DexProtocol { RaydiumAmmV4, RaydiumCpmm, RaydiumClmm, MeteoraDlmm, } impl DexProtocol { pub fn program_id(&self) -> Pubkey { match self { DexProtocol::RaydiumAmmV4 => RAYDIUM_AMM_V4, DexProtocol::RaydiumCpmm => RAYDIUM_CPMM, DexProtocol::RaydiumClmm => RAYDIUM_CLMM, DexProtocol::MeteoraDlmm => METEORA_DLMM, } } } /// Single swap leg in multi-hop route #[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug)] pub struct SwapLeg { pub protocol: DexProtocol, pub pool_id: Pubkey, pub input_mint: Pubkey, pub output_mint: Pubkey, pub amount_in: u64, pub minimum_amount_out: u64, /// Number of accounts needed for CPI (extracted from remaining_accounts) pub accounts_len: u8, } // ============================================================================ // ERRORS // ============================================================================ #[error_code] pub enum ArbitrageError { #[msg("Insufficient profit - arbitrage not profitable")] InsufficientProfit, #[msg("Slippage tolerance exceeded")] SlippageExceeded, #[msg("Invalid number of accounts provided")] InvalidAccountsCount, #[msg("Invalid DEX protocol specified")] InvalidDexProtocol, #[msg("Math overflow during calculation")] MathOverflow, #[msg("Unauthorized user")] Unauthorized, #[msg("Too many swap legs (max 5)")] TooManyLegs, #[msg("Insufficient balance")] InsufficientBalance, #[msg("CPI call failed")] CpiCallFailed, #[msg("Invalid token account")] InvalidTokenAccount, } // ============================================================================ // PROGRAM MODULE // ============================================================================ #[program] pub mod arbitrage_executor { use super::*; /// Execute atomic multi-hop arbitrage swap /// /// # Parameters /// - `swap_legs`: Sequence of swaps to execute /// - `min_profit_lamports`: Minimum required profit in lamports /// /// # Logic /// 1. Record initial balance /// 2. Execute each swap via CPI to respective DEX /// 3. Verify final balance >= initial + min_profit /// 4. If profit insufficient - transaction reverts pub fn execute_arbitrage<'a, 'b, 'c, 'info>( ctx: Context<'a, 'b, 'c, 'info, ExecuteArbitrage<'info>>, swap_legs: Vec, min_profit_lamports: u64, ) -> Result<()> where 'c: 'info, { // Validate swap legs count (max 5 to limit compute units) require!( !swap_legs.is_empty() && swap_legs.len() <= 5, ArbitrageError::TooManyLegs ); msg!( "🚀 Starting arbitrage: {} legs, min profit {} lamports", swap_legs.len(), min_profit_lamports ); // Record initial balance let initial_balance = ctx.accounts.user_token_account.amount; msg!("💰 Initial balance: {} lamports", initial_balance); // Validate sufficient balance require!( initial_balance >= swap_legs[0].amount_in, ArbitrageError::InsufficientBalance ); // Execute each swap leg let mut account_cursor = 0_usize; for (idx, leg) in swap_legs.iter().enumerate() { msg!( "📊 Leg {}/{}: {:?} on pool {}", idx + 1, swap_legs.len(), leg.protocol, leg.pool_id ); // Extract accounts for current leg from remaining_accounts let accounts_end = account_cursor .checked_add(leg.accounts_len as usize) .ok_or(ArbitrageError::InvalidAccountsCount)?; let leg_accounts = ctx .remaining_accounts .get(account_cursor..accounts_end) .ok_or(ArbitrageError::InvalidAccountsCount)?; // Execute swap via CPI execute_swap_cpi(leg, leg_accounts, &ctx.accounts.user)?; account_cursor = accounts_end; // Reload balance after intermediate step if idx < swap_legs.len() - 1 { ctx.accounts.user_token_account.reload()?; msg!(" Intermediate balance: {}", ctx.accounts.user_token_account.amount); } } // Final profitability check ctx.accounts.user_token_account.reload()?; let final_balance = ctx.accounts.user_token_account.amount; msg!("💎 Final balance: {} lamports", final_balance); // Calculate net profit let profit = final_balance .checked_sub(initial_balance) .ok_or(ArbitrageError::MathOverflow)?; msg!( "📈 Profit: {} lamports ({:.4}%)", profit, (profit as f64 / initial_balance as f64) * 100.0 ); // Verify minimum profit (CRITICAL: reverts if insufficient) require!( profit >= min_profit_lamports, ArbitrageError::InsufficientProfit ); msg!("✅ ARBITRAGE SUCCESSFUL"); // Emit event for monitoring emit!(ArbitrageExecutedEvent { user: ctx.accounts.user.key(), initial_balance, final_balance, profit, legs_count: swap_legs.len() as u8, timestamp: Clock::get()?.unix_timestamp, }); Ok(()) } } // ============================================================================ // ACCOUNT STRUCTURES // ============================================================================ #[derive(Accounts)] pub struct ExecuteArbitrage<'info> { #[account(mut)] pub user: Signer<'info>, #[account( mut, constraint = user_token_account.owner == user.key() @ ArbitrageError::Unauthorized )] pub user_token_account: Account<'info, TokenAccount>, #[account( constraint = user_token_account.mint == token_mint.key() @ ArbitrageError::InvalidTokenAccount )] pub token_mint: Account<'info, Mint>, pub token_program: Program<'info, Token>, pub system_program: Program<'info, System>, } // ============================================================================ // EVENTS // ============================================================================ #[event] pub struct ArbitrageExecutedEvent { pub user: Pubkey, pub initial_balance: u64, pub final_balance: u64, pub profit: u64, pub legs_count: u8, pub timestamp: i64, } // ============================================================================ // CPI HELPER FUNCTIONS // ============================================================================ /// Execute swap via CPI to DEX fn execute_swap_cpi<'info>( leg: &SwapLeg, accounts: &'info [AccountInfo<'info>], user: &Signer<'info>, ) -> Result<()> { match leg.protocol { DexProtocol::RaydiumAmmV4 => raydium_amm_swap(leg, accounts, user), DexProtocol::RaydiumCpmm => raydium_cpmm_swap(leg, accounts, user), DexProtocol::RaydiumClmm => raydium_clmm_swap(leg, accounts, user), DexProtocol::MeteoraDlmm => meteora_dlmm_swap(leg, accounts, user), } } /// Raydium AMM V4 swap_base_in CPI fn raydium_amm_swap<'info>( leg: &SwapLeg, accounts: &'info [AccountInfo<'info>], _user: &Signer<'info>, ) -> Result<()> { require!(accounts.len() == 18, ArbitrageError::InvalidAccountsCount); // Raydium AMM V4 swap_base_in discriminator: 0x09 let mut data = vec![0x09]; data.extend_from_slice(&leg.amount_in.to_le_bytes()); data.extend_from_slice(&leg.minimum_amount_out.to_le_bytes()); let account_metas: Vec = accounts .iter() .map(|acc| AccountMeta { pubkey: *acc.key, is_signer: acc.is_signer, is_writable: acc.is_writable, }) .collect(); let ix = Instruction { program_id: RAYDIUM_AMM_V4, accounts: account_metas, data, }; invoke(&ix, accounts).map_err(|_| error!(ArbitrageError::CpiCallFailed))?; msg!(" ✅ Raydium AMM swap executed"); Ok(()) } /// Raydium CPMM swap CPI fn raydium_cpmm_swap<'info>( leg: &SwapLeg, accounts: &'info [AccountInfo<'info>], _user: &Signer<'info>, ) -> Result<()> { require!(accounts.len() >= 10, ArbitrageError::InvalidAccountsCount); // CPMM swap discriminator (verify from SDK documentation) let mut data = vec![0xf8, 0xc6, 0x9e, 0x91, 0xe1, 0x75, 0x87, 0xc8]; data.extend_from_slice(&leg.amount_in.to_le_bytes()); data.extend_from_slice(&leg.minimum_amount_out.to_le_bytes()); let account_metas: Vec = accounts .iter() .map(|acc| AccountMeta { pubkey: *acc.key, is_signer: acc.is_signer, is_writable: acc.is_writable, }) .collect(); let ix = Instruction { program_id: RAYDIUM_CPMM, accounts: account_metas, data, }; invoke(&ix, accounts).map_err(|_| error!(ArbitrageError::CpiCallFailed))?; msg!(" ✅ Raydium CPMM swap executed"); Ok(()) } /// Raydium CLMM swap CPI fn raydium_clmm_swap<'info>( leg: &SwapLeg, accounts: &'info [AccountInfo<'info>], _user: &Signer<'info>, ) -> Result<()> { require!(accounts.len() >= 12, ArbitrageError::InvalidAccountsCount); // CLMM swap discriminator let mut data = vec![0x7c, 0x1c, 0x97, 0xce, 0x3b, 0x8f, 0x8d, 0x6e]; data.extend_from_slice(&leg.amount_in.to_le_bytes()); data.extend_from_slice(&leg.minimum_amount_out.to_le_bytes()); data.extend_from_slice(&(160 as u128).to_le_bytes()); // sqrt_price_limit let account_metas: Vec = accounts .iter() .map(|acc| AccountMeta { pubkey: *acc.key, is_signer: acc.is_signer, is_writable: acc.is_writable, }) .collect(); let ix = Instruction { program_id: RAYDIUM_CLMM, accounts: account_metas, data, }; invoke(&ix, accounts).map_err(|_| error!(ArbitrageError::CpiCallFailed))?; msg!(" ✅ Raydium CLMM swap executed"); Ok(()) } /// Meteora DLMM swap CPI fn meteora_dlmm_swap<'info>( leg: &SwapLeg, accounts: &'info [AccountInfo<'info>], _user: &Signer<'info>, ) -> Result<()> { require!(accounts.len() >= 10, ArbitrageError::InvalidAccountsCount); // Meteora DLMM swap discriminator let mut data = vec![0x13, 0x98, 0xa2, 0x5f, 0x5e, 0x8f, 0x2d, 0x7c]; data.extend_from_slice(&leg.amount_in.to_le_bytes()); data.extend_from_slice(&leg.minimum_amount_out.to_le_bytes()); let account_metas: Vec = accounts .iter() .map(|acc| AccountMeta { pubkey: *acc.key, is_signer: acc.is_signer, is_writable: acc.is_writable, }) .collect(); let ix = Instruction { program_id: METEORA_DLMM, accounts: account_metas, data, }; invoke(&ix, accounts).map_err(|_| error!(ArbitrageError::CpiCallFailed))?; msg!(" ✅ Meteora DLMM swap executed"); Ok(()) }