ArbSight Core

ArbSight Core is a high-frequency Rust arbitrage bot framework for Stellar. It is designed to monitor DEX order books, evaluate cross-market price paths, and execute atomic routes within the same ledger sequence.

The goal of this repo is to become a contribution-ready starter for building low-latency arbitrage infrastructure, strategy modules, and the supporting tooling needed to test atomic execution safely.

Architecture

The codebase is organized around a small number of focused layers:

• contracts/ contains Soroban examples and integration points used to exercise the scaffold locally.
• packages/ contains generated TypeScript clients for contract interaction and explorer workflows.
• src/ contains the React app used for local inspection, debugging, and developer documentation.
• Rust strategy code, once introduced, should be split into modules for market discovery, path search, risk checks, and execution orchestration.

Planned backend modules:

• Order book ingestion and normalization.
• Graph construction for route discovery across pools and assets.
• Latency-sensitive path scoring and pruning.
• Atomic transaction assembly and submission.
• Safety checks for slippage, stale data, and ledger-window timing.

Getting Started

1. Install the required Rust and Node.js toolchains for the Stellar scaffold.
2. Run npm install from the repository root.
3. Start the local app with npm run dev.
4. Use the Contract Explorer and Transaction Explorer to confirm the scaffold still works while backend strategy code is added.

When you begin adding arbitrage logic, keep each module small enough to test in isolation and prefer deterministic fixtures for market data and execution paths.

Roadmap

• Build order book graph utilities for routing across Stellar DEX liquidity.
• Add path scoring and pruning logic tuned for low-latency execution.
• Implement atomic execution helpers that stay inside a single ledger sequence.
• Add exhaustive unit tests for graph traversal, pricing, and edge cases.
• Add automated integration and fuzz tests for transaction assembly and replay.
• Expand documentation for strategy authors and protocol integrators.

Wave Issue Strategy

Issues should map to the technical backbone of the bot framework:

• Wave 1: order book graph algorithms, liquidity discovery, and data models.
• Wave 2: latency optimization, path selection, and atomic execution flows.
• Wave 3: automated testing, fixtures, docs, and developer experience.

Use issues that are narrow, measurable, and reviewable. For backend work, each issue should state the target market behavior, the expected ledger timing, and the tests required to prove the change is safe.