Fastlane Arbitrage Bot

The project distinguishes between two internal modules: tools and helpers.

• tools module: These modules are designed to be importable from within the Carbon library.
• helpers module: These modules cannot be imported from within the Carbon library.

Warning: Neither tools nor helpers are part of the official Carbon API. Their structure and availability may change at any time without notice.

The Invariants Module is designed for high-performance analysis of Automated Market Maker (AMM) invariant functions, specifically of the form $f(x,y) = k$.

Its primary goal is to allow the FastLane Arbitrage bot to approximate complex, non-analytically tractable invariant functions (like the Solidly stable swap invariant $f(x,y) = x^3y + xy^3$) using piecewise constant product invariant functions ($f(x,y) = xy$). This approach avoids the performance penalty of purely numerical solutions while maintaining accuracy for arbitrage calculations.

The invariants.py module provides a class to represent invariant functions in two distinct formats:

1. Invariant format: $f(x,y) = k$
2. Swap equation format: $y = y(x,k)$

Specific implementations for Bancor and Solidly invariants are provided in bancor.py and solidly.py respectively.

In the fastlane-bot ecosystem, a Constant Product Curve (CPC) refers to the hyperbolic curve defined by the formula $xy=k$, which is the standard model for many Automated Market Makers (AMMs).

To ensure compatibility with the Optimizer module, all curve implementations must derive from the CurveBase abstract base class. CurveBase defines the required interface and functions that any curve class must implement to be used by the optimizer for arbitrage calculations.

The bot provides several specialized optimizer classes for arbitrage calculations. All these modules derive from the CPCArbOptimizer base class. Depending on your specific arbitrage strategy, you should choose one of the following:

• MargPOptimizer: Used for specific marginal profit optimization.
• PairOptimizer: Used for optimizing arbitrage between specific pairs.
• ConvexOptimizer: Used when the optimization problem can be modeled as a convex optimization problem.

The weight ratio $\lambda$ is a parameterization of the token weight $\alpha$. Use these formulas to convert between the two:

• Definition of $\lambda$: $\lambda = \frac{\alpha}{1-\alpha}$
• Reverse $\lambda$ (finding $\alpha$): $\alpha = \frac{\lambda}{1-\lambda}$
• Lambda relationship: $\frac{1}{\lambda-1} = \alpha - 1$

To build a complete arbitrage model, use the following component classes:

• Node: Represents an individual asset or state in the graph.
• Edge: Represents a directed liquidity path or exchange rate between two nodes.
• Path: A sequence of edges representing a traversal through the graph.
• Cycle: A specific type of path that starts and ends at the same node, used to identify potential arbitrage loops.
• Amount: A utility class for handling the quantities of assets involved in the graph operations.

The Weighted Constant Product model uses a parameter $\alpha$ to define the weight of token $x$ in a liquidity pool. When $\alpha = 1/2$, it behaves as a standard constant product market maker. The model uses several mathematical relationships to determine token balances, the pool invariant $k$, and the marginal price $p$.

### Parameter Definitions
- $x, y$: Token balances in native units
- $\alpha$: Weight of the $x$ token
- $\lambda$: Weight ratio, where $\lambda = \alpha / (1 - \alpha)$
- $k$: The pool invariant