Baseline solver limit orders support

crates/solvers/Cargo.toml

@@ -53,3 +53,5 @@ tracing = { workspace = true }
 [dev-dependencies]
 glob = "0.3"
 tempfile = "3"
+hex-literal = { workspace = true }
+ethcontract = { workspace = true }

crates/solvers/src/boundary/baseline.rs

@@ -13,7 +13,7 @@ use {
 
 pub struct Solver<'a> {
     base_tokens: BaseTokens,
-    amms: HashMap<TokenPair, Vec<Amm>>,
+    amms: HashMap<TokenPair, Vec<OnchainLiquidity>>,
     liquidity: HashMap<liquidity::Id, &'a liquidity::Liquidity>,
 }
 
@@ -100,7 +100,7 @@ impl<'a> Solver<'a> {
 
     fn traverse_path(
         &self,
-        path: &[&Amm],
+        path: &[&OnchainLiquidity],
         mut sell_token: H160,
         mut sell_amount: U256,
     ) -> Option<Vec<baseline::Segment<'a>>> {
@@ -137,7 +137,9 @@ impl<'a> Solver<'a> {
     }
 }
 
-fn to_boundary_amms(liquidity: &[liquidity::Liquidity]) -> HashMap<TokenPair, Vec<Amm>> {
+fn to_boundary_amms(
+    liquidity: &[liquidity::Liquidity],
+) -> HashMap<TokenPair, Vec<OnchainLiquidity>> {
     liquidity
         .iter()
         .fold(HashMap::new(), |mut amms, liquidity| {
@@ -149,11 +151,13 @@ fn to_boundary_amms(liquidity: &[liquidity::Liquidity]) -> HashMap<TokenPair, Ve
                             pool,
                         )
                     {
-                        amms.entry(boundary_pool.tokens).or_default().push(Amm {
-                            id: liquidity.id.clone(),
-                            token_pair: boundary_pool.tokens,
-                            pool: Pool::ConstantProduct(boundary_pool),
-                        });
+                        amms.entry(boundary_pool.tokens)
+                            .or_default()
+                            .push(OnchainLiquidity {
+                                id: liquidity.id.clone(),
+                                token_pair: boundary_pool.tokens,
+                                source: LiquiditySource::ConstantProduct(boundary_pool),
+                            });
                     }
                 }
                 liquidity::State::WeightedProduct(pool) => {
@@ -165,10 +169,10 @@ fn to_boundary_amms(liquidity: &[liquidity::Liquidity]) -> HashMap<TokenPair, Ve
                     {
                         for pair in pool.reserves.token_pairs() {
                             let token_pair = to_boundary_token_pair(&pair);
-                            amms.entry(token_pair).or_default().push(Amm {
+                            amms.entry(token_pair).or_default().push(OnchainLiquidity {
                                 id: liquidity.id.clone(),
                                 token_pair,
-                                pool: Pool::WeightedProduct(boundary_pool.clone()),
+                                source: LiquiditySource::WeightedProduct(boundary_pool.clone()),
                             });
                         }
                     }
@@ -179,14 +183,25 @@ fn to_boundary_amms(liquidity: &[liquidity::Liquidity]) -> HashMap<TokenPair, Ve
                     {
                         for pair in pool.reserves.token_pairs() {
                             let token_pair = to_boundary_token_pair(&pair);
-                            amms.entry(token_pair).or_default().push(Amm {
+                            amms.entry(token_pair).or_default().push(OnchainLiquidity {
                                 id: liquidity.id.clone(),
                                 token_pair,
-                                pool: Pool::Stable(boundary_pool.clone()),
+                                source: LiquiditySource::Stable(boundary_pool.clone()),
                             });
                         }
                     }
                 }
+                liquidity::State::LimitOrder(limit_order) => {
+                    if let Some(token_pair) =
+                        TokenPair::new(limit_order.maker.token.0, limit_order.taker.token.0)
+                    {
+                        amms.entry(token_pair).or_default().push(OnchainLiquidity {
+                            id: liquidity.id.clone(),
+                            token_pair,
+                            source: LiquiditySource::LimitOrder(limit_order.clone()),
+                        })
+                    }
+                }
                 // The baseline solver does not currently support other AMMs.
                 _ => {}
             };
@@ -195,41 +210,47 @@ fn to_boundary_amms(liquidity: &[liquidity::Liquidity]) -> HashMap<TokenPair, Ve
 }
 
 #[derive(Debug)]
-struct Amm {
+struct OnchainLiquidity {
     id: liquidity::Id,
     token_pair: TokenPair,
-    pool: Pool,
+    source: LiquiditySource,
 }
 
 #[derive(Debug)]
-enum Pool {
+enum LiquiditySource {
     ConstantProduct(boundary::liquidity::constant_product::Pool),
     WeightedProduct(boundary::liquidity::weighted_product::Pool),
     Stable(boundary::liquidity::stable::Pool),
+    LimitOrder(liquidity::limit_order::LimitOrder),
 }
 
-impl BaselineSolvable for Amm {
+impl BaselineSolvable for OnchainLiquidity {
     fn get_amount_out(&self, out_token: H160, input: (U256, H160)) -> Option<U256> {
-        match &self.pool {
-            Pool::ConstantProduct(pool) => pool.get_amount_out(out_token, input),
-            Pool::WeightedProduct(pool) => pool.get_amount_out(out_token, input),
-            Pool::Stable(pool) => pool.get_amount_out(out_token, input),
+        match &self.source {
+            LiquiditySource::ConstantProduct(pool) => pool.get_amount_out(out_token, input),
+            LiquiditySource::WeightedProduct(pool) => pool.get_amount_out(out_token, input),
+            LiquiditySource::Stable(pool) => pool.get_amount_out(out_token, input),
+            LiquiditySource::LimitOrder(limit_order) => {
+                limit_order.get_amount_out(out_token, input)
+            }
         }
     }
 
     fn get_amount_in(&self, in_token: H160, out: (U256, H160)) -> Option<U256> {
-        match &self.pool {
-            Pool::ConstantProduct(pool) => pool.get_amount_in(in_token, out),
-            Pool::WeightedProduct(pool) => pool.get_amount_in(in_token, out),
-            Pool::Stable(pool) => pool.get_amount_in(in_token, out),
+        match &self.source {
+            LiquiditySource::ConstantProduct(pool) => pool.get_amount_in(in_token, out),
+            LiquiditySource::WeightedProduct(pool) => pool.get_amount_in(in_token, out),
+            LiquiditySource::Stable(pool) => pool.get_amount_in(in_token, out),
+            LiquiditySource::LimitOrder(limit_order) => limit_order.get_amount_in(in_token, out),
         }
     }
 
     fn gas_cost(&self) -> usize {
-        match &self.pool {
-            Pool::ConstantProduct(pool) => pool.gas_cost(),
-            Pool::WeightedProduct(pool) => pool.gas_cost(),
-            Pool::Stable(pool) => pool.gas_cost(),
+        match &self.source {
+            LiquiditySource::ConstantProduct(pool) => pool.gas_cost(),
+            LiquiditySource::WeightedProduct(pool) => pool.gas_cost(),
+            LiquiditySource::Stable(pool) => pool.gas_cost(),
+            LiquiditySource::LimitOrder(limit_order) => limit_order.gas_cost(),
         }
     }
 }

crates/solvers/src/boundary/liquidity/limit_order.rs

@@ -0,0 +1,159 @@
+use {
+    crate::domain::liquidity::limit_order::{LimitOrder, TakerAmount},
+    contracts::ethcontract::{H160, U256},
+    shared::{baseline_solver::BaselineSolvable, price_estimation::gas::GAS_PER_ZEROEX_ORDER},
+};
+
+impl BaselineSolvable for LimitOrder {
+    fn get_amount_out(&self, out_token: H160, (in_amount, in_token): (U256, H160)) -> Option<U256> {
+        if in_token != self.taker.token.0
+            || out_token != self.maker.token.0
+            || in_amount > self.taker.amount
+        {
+            return None;
+        }
+
+        let fee_adjusted_amount = in_amount.checked_sub(self.fee.0)?;
+        if self.maker.amount > self.taker.amount {
+            let price_ratio = self.maker.amount.checked_div(self.taker.amount)?;
+            fee_adjusted_amount.checked_mul(price_ratio)
+        } else {
+            let inverse_price_ratio = self.taker.amount.checked_div(self.maker.amount)?;
+            fee_adjusted_amount.checked_div(inverse_price_ratio)
+        }
+    }
+
+    fn get_amount_in(&self, in_token: H160, (out_amount, out_token): (U256, H160)) -> Option<U256> {
+        if out_token != self.maker.token.0
+            || in_token != self.taker.token.0
+            || out_amount > self.maker.amount
+        {
+            return None;
+        }
+
+        let amount_before_fee = if self.maker.amount > self.taker.amount {
+            let inverse_price_ratio = self.maker.amount.checked_div(self.taker.amount)?;
+            out_amount.checked_div(inverse_price_ratio)?
+        } else {
+            let price_ratio = self.taker.amount.checked_div(self.maker.amount)?;
+            out_amount.checked_mul(price_ratio)?
+        };
+        amount_before_fee.checked_add(self.fee.0)
+    }
+
+    fn gas_cost(&self) -> usize {
+        GAS_PER_ZEROEX_ORDER as usize
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, crate::domain::eth, contracts::ethcontract::U256, shared::addr};
+
+    fn create_limit_order(maker_amount: U256, taker_amount: U256, fee_amount: U256) -> LimitOrder {
+        let maker = eth::Asset {
+            amount: maker_amount,
+            token: eth::TokenAddress(addr!("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")),
+        };
+        let taker = eth::Asset {
+            amount: taker_amount,
+            token: eth::TokenAddress(addr!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")),
+        };
+        let fee = TakerAmount(fee_amount);
+
+        LimitOrder { maker, taker, fee }
+    }
+
+    #[test]
+    fn amount_out_in_round_trip() {
+        let maker_amount = to_wei(321);
+        let taker_amount = to_wei(123);
+        let fee_amount = to_wei(10);
+        let desired_in_amount = to_wei(50);
+
+        let order = create_limit_order(maker_amount, taker_amount, fee_amount);
+        let out_token = order.maker.token.0;
+        let in_token = order.taker.token.0;
+
+        let amount_out = order
+            .get_amount_out(out_token, (desired_in_amount, in_token))
+            .unwrap();
+        let amount_in = order
+            .get_amount_in(in_token, (amount_out, out_token))
+            .unwrap();
+
+        assert_eq!(amount_in, desired_in_amount);
+    }
+
+    #[test]
+    fn amount_in_out_round_trip() {
+        let maker_amount = to_wei(123);
+        let taker_amount = to_wei(321);
+        let fee_amount = to_wei(10);
+        let desired_out_amount = to_wei(50);
+
+        let order = create_limit_order(maker_amount, taker_amount, fee_amount);
+        let out_token = order.maker.token.0;
+        let in_token = order.taker.token.0;
+
+        let amount_in = order
+            .get_amount_in(in_token, (desired_out_amount, out_token))
+            .unwrap();
+        let amount_out = order
+            .get_amount_out(out_token, (amount_in, in_token))
+            .unwrap();
+
+        assert_eq!(amount_out, desired_out_amount);
+    }
+
+    #[test]
+    fn too_high_in_amount() {
+        let maker_amount = to_wei(300);
+        let taker_amount = to_wei(100);
+        let fee_amount = to_wei(10);
+
+        let order = create_limit_order(maker_amount, taker_amount, fee_amount);
+        let out_token = order.maker.token.0;
+        let in_token = order.taker.token.0;
+        let amount_in = taker_amount.checked_mul(U256::from(2)).unwrap();
+        let amount_out = order.get_amount_out(out_token, (amount_in, in_token));
+
+        assert!(amount_out.is_none());
+    }
+
+    #[test]
+    fn too_high_out_amount() {
+        let maker_amount = to_wei(100);
+        let taker_amount = to_wei(300);
+        let fee_amount = to_wei(10);
+
+        let order = create_limit_order(maker_amount, taker_amount, fee_amount);
+        let out_token = order.maker.token.0;
+        let in_token = order.taker.token.0;
+        let amount_out = maker_amount.checked_mul(U256::from(2)).unwrap();
+        let amount_in = order.get_amount_in(in_token, (amount_out, out_token));
+
+        assert!(amount_in.is_none());
+    }
+
+    #[test]
+    fn wrong_tokens() {
+        let maker_amount = to_wei(100);
+        let taker_amount = to_wei(100);
+        let fee_amount = to_wei(10);
+
+        let order = create_limit_order(maker_amount, taker_amount, fee_amount);
+        let out_token = order.maker.token.0;
+        let in_token = order.taker.token.0;
+        let amount = to_wei(1);
+        let amount_in = order.get_amount_in(out_token, (amount, in_token));
+        let amount_out = order.get_amount_out(in_token, (amount, out_token));
+
+        assert!(amount_in.is_none());
+        assert!(amount_out.is_none());
+    }
+
+    fn to_wei(base: u32) -> U256 {
+        U256::from(base) * U256::exp10(18)
+    }
+}

crates/solvers/src/boundary/liquidity/mod.rs

@@ -1,3 +1,4 @@
 pub mod constant_product;
+mod limit_order;
 pub mod stable;
 pub mod weighted_product;