feat: working fixed arbitrageur

contracts/utils/src/ArenaController.sol

@@ -61,8 +61,8 @@ contract ArenaController {
 
         lex = new LiquidExchange(address(currency0), address(currency1), initialPrice);
 
-        require(currency0.mint(address(this), 100000000000000), "Minting currency0 to liquid exchange failed");
-        require(currency1.mint(address(this), 100000000000000), "Minting currency1 to liquid exchange failed");
+        require(currency0.mint(address(this), 10000000000000000000), "Minting currency0 to liquid exchange failed");
+        require(currency1.mint(address(this), 10000000000000000000), "Minting currency1 to liquid exchange failed");
     }
 
     function getRouter() external view returns (address) {
@@ -90,34 +90,35 @@ contract ArenaController {
         lex.swap(tokenIn, amountIn);
     }
 
-    function equalizePrice() public {
+    function equalizePrice(int256 depth) public {
         require(currency0.approve(address(swapRouter), type(uint256).max), "Approval for currency0 failed");
         require(currency1.approve(address(swapRouter), type(uint256).max), "Approval for currency1 failed");
 
         (uint160 sqrtPriceX96, int24 tick,,) = fetcher.getSlot0(poolManager, fetcher.toId(poolKey));
 
-        uint256 uniswapPrice = FullMath.mulDiv(sqrtPriceX96, sqrtPriceX96, 1 << 192) * 1e18;
+        uint256 uniswapPrice = FullMath.mulDiv(uint256(sqrtPriceX96) * 10**18, uint256(sqrtPriceX96), 1 << 192);
         uint256 lexPrice = lex.price();
 
         if (uniswapPrice > lexPrice) {
             bool zeroForOne = true;
 
             IPoolManager.SwapParams memory params = IPoolManager.SwapParams({
                 zeroForOne: zeroForOne,
-                amountSpecified: 1000000,
+                amountSpecified: depth,
                 sqrtPriceLimitX96: zeroForOne ? MIN_PRICE_LIMIT : MAX_PRICE_LIMIT // unlimited impact
             });
 
             PoolSwapTest.TestSettings memory testSettings =
                 PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false});
 
             swapRouter.swap(poolKey, params, testSettings, "");
+
         } else if (uniswapPrice < lexPrice) {
             bool zeroForOne = false;
 
             IPoolManager.SwapParams memory params = IPoolManager.SwapParams({
                 zeroForOne: zeroForOne,
-                amountSpecified: 10000,
+                amountSpecified: depth,
                 sqrtPriceLimitX96: zeroForOne ? MIN_PRICE_LIMIT : MAX_PRICE_LIMIT // unlimited impact
             });
 
@@ -161,7 +162,7 @@ contract ArenaController {
         router.modifyLiquidity(poolKey, params, "");
     }
 
-    function getPositionInfo(
+    /*function getPositionInfo(
         address owner,
         int24 tickLower,
         int24 tickUpper,
@@ -204,7 +205,7 @@ contract ArenaController {
 
     function _getPoolStateSlot(PoolId poolId) internal pure returns (bytes32) {
         return keccak256(abi.encodePacked(PoolId.unwrap(poolId), POOLS_SLOT));
-    }
+    }*/
 
     function computeSwapStep(
         uint160 sqrtPriceCurrentX96,

src/arena.rs

@@ -15,6 +15,7 @@ use crate::{
     strategy::Strategy,
     types::controller::ArenaController,
 };
+
 /// Represents an [`Arena`] that can be used to run a simulation and execute strategies.
 pub struct Arena<V> {
     /// The underlying Anvil execution environment.
@@ -46,10 +47,10 @@ impl<V> Arena<V> {
 
         controller
             .setPool(
-                Uint::from(10000),
+                Uint::from(0),
                 Signed::try_from(2).unwrap(),
                 Address::default(),
-                Uint::from(24028916059024274524587271040_u128),
+                Uint::from(79228162514264337593543950336_u128),
                 Bytes::new(),
             )
             .send()
@@ -125,6 +126,20 @@ impl<V> Arena<V> {
                 .await
                 .map_err(|e| ArenaError::PendingTransactionError(e))?;
 
+            let signal = controller.constructSignal().call().await?._0;
+
+            let signal = Signal::new(
+                signal.lexPrice,
+                None,
+                signal.currentTick,
+                signal.sqrtPriceX96,
+                signal.manager,
+                signal.pool,
+                signal.fetcher,
+                self.feed.current_value(),
+                *controller.address(),
+            );
+
             self.arbitrageur
                 .arbitrage(&signal, admin_provider.clone())
                 .await;

src/engine/arbitrageur.rs

@@ -36,7 +36,7 @@ impl Arbitrageur for FixedArbitrageur {
         let controller = ArenaController::new(signal.controller, provider.clone());
 
         controller
-            .equalizePrice()
+            .equalizePrice(Signed::try_from(100000).unwrap())
             .nonce(
                 provider
                     .clone()
@@ -50,6 +50,8 @@ impl Arbitrageur for FixedArbitrageur {
             .watch()
             .await
             .unwrap();
+
+        println!("current: {}", signal.current_value);
     }
 }
 

src/lib.rs

@@ -311,8 +311,12 @@ impl Signal {
 
 #[cfg(test)]
 mod tests {
-    use alloy::primitives::{Signed, Uint, I256};
+    use alloy::{
+        primitives::{FixedBytes, Signed, Uint, I256},
+        providers::WalletProvider,
+    };
     use async_trait::async_trait;
+    use rug::{ops::Pow, Float};
 
     use super::*;
     use crate::{
@@ -324,10 +328,8 @@ mod tests {
         },
         feed::OrnsteinUhlenbeck,
         strategy::Strategy,
+        types::controller::ArenaController,
     };
-    use alloy::providers::WalletProvider;
-    use crate::types::controller::ArenaController;
-    use alloy::primitives::FixedBytes;
 
     struct StrategyMock;
 
@@ -343,8 +345,8 @@ mod tests {
             engine
                 .modify_liquidity(
                     I256::try_from(10000000).unwrap(),
-                    Signed::try_from(-1000).unwrap(),
-                    Signed::try_from(1000).unwrap(),
+                    Signed::try_from(-887272).unwrap(),
+                    Signed::try_from(887272).unwrap(),
                     provider,
                 )
                 .await
@@ -357,20 +359,12 @@ mod tests {
             _inspector: &mut Box<dyn Inspector<T>>,
             _engine: Engine,
         ) {
-            let controller = ArenaController::new(signal.controller, provider.clone());
-
-            let position_info = controller
-                .getPositionInfo(
-                    controller.getRouter().call().await.unwrap()._0,
-                    Signed::try_from(-1000).unwrap(),
-                    Signed::try_from(1000).unwrap(),
-                    FixedBytes::ZERO,
-                )
-                .call()
-                .await
-                .unwrap();
+            let sqrt_price_x96 =
+                Float::with_val(53, Float::parse(signal.sqrt_price_x96.to_string()).unwrap());
+            let q96 = Float::with_val(53, 2).pow(96);
+            let price = Float::with_val(53, sqrt_price_x96 / q96).pow(2);
 
-            println!("position_info: {:?}", position_info);
+            println!("price: {}", price);
         }
     }
 
@@ -379,12 +373,15 @@ mod tests {
         let builder: ArenaBuilder<_> = ArenaBuilder::new();
 
         let mut arena: Arena<_> = builder
-            .with_strategy(Box::new(StrategyMock {}))
-            .with_feed(Box::new(OrnsteinUhlenbeck::new(10.0, 0.1, 0.1, 0.1, 0.1)))
+            .with_strategy(Box::new(StrategyMock))
+            .with_feed(Box::new(OrnsteinUhlenbeck::new(1.0, 0.1, 1.0, 0.1, 0.1)))
             .with_inspector(Box::new(EmptyInspector {}))
             .with_arbitrageur(Box::new(FixedArbitrageur::default()))
             .build();
 
-        arena.run(Config::new(Uint::from(5000), 10)).await.unwrap();
+        arena
+            .run(Config::new(Uint::from(5000), 10000))
+            .await
+            .unwrap();
     }
 }