bisection matching engine

bin/testnet/pool_key_config.toml

@@ -4,6 +4,6 @@
 # currency1 = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
 fee = 0
 tick_spacing = 60
-liquidity = "34028236692"
+liquidity = "34028236692221234111"
 # weird bug were round down
 tick = 100020

bin/testnet/src/cli/compare_engines.rs

@@ -0,0 +1,11 @@
+use clap::Parser;
+
+use super::testnet::TestnetCli;
+
+#[derive(Debug, Clone, Parser)]
+pub struct CompareEnginesCli {
+    #[arg(short = 'z', default_value_t = false)]
+    pub include_amm:    bool,
+    #[clap(flatten)]
+    pub testnet_config: TestnetCli
+}

bin/testnet/src/cli/mod.rs

@@ -1,8 +1,10 @@
+pub mod compare_engines;
 pub mod devnet;
 pub mod e2e_orders;
 pub mod testnet;
 use angstrom_metrics::{initialize_prometheus_metrics, METRICS_ENABLED};
 use clap::{ArgAction, Parser, Subcommand};
+use compare_engines::CompareEnginesCli;
 use devnet::DevnetCli;
 use e2e_orders::End2EndOrdersCli;
 use reth_tasks::TaskExecutor;
@@ -13,7 +15,10 @@ use tracing_subscriber::{
     filter, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter, Layer, Registry
 };
 
-use crate::{run_devnet, run_testnet, simulations::e2e_orders::run_e2e_orders};
+use crate::{
+    run_devnet, run_testnet,
+    simulations::{e2e_orders::run_e2e_orders, matching_comp::compare_matching_engines}
+};
 
 #[derive(Parser)]
 pub struct AngstromTestnetCli {
@@ -70,15 +75,18 @@ pub enum TestnetSubcommmand {
     #[command(name = "devnet")]
     Devnet(DevnetCli),
     #[command(name = "e2e")]
-    End2EndOrders(End2EndOrdersCli)
+    End2EndOrders(End2EndOrdersCli),
+    #[command(name = "engine-sim")]
+    Compare(CompareEnginesCli)
 }
 
 impl TestnetSubcommmand {
     async fn run_command(self, executor: TaskExecutor) -> eyre::Result<()> {
         match self {
             TestnetSubcommmand::Testnet(testnet_cli) => run_testnet(executor, testnet_cli).await,
             TestnetSubcommmand::Devnet(devnet_cli) => run_devnet(executor, devnet_cli).await,
-            TestnetSubcommmand::End2EndOrders(e2e_cli) => run_e2e_orders(executor, e2e_cli).await
+            TestnetSubcommmand::End2EndOrders(e2e_cli) => run_e2e_orders(executor, e2e_cli).await,
+            TestnetSubcommmand::Compare(cli) => compare_matching_engines(executor, cli).await
         }
     }
 }
@@ -92,20 +100,31 @@ pub fn init_tracing(verbosity: u8) {
         _ => Level::TRACE
     };
 
-    let layers = vec![
-        layer_builder(format!("testnet={level}")),
-        layer_builder(format!("devnet={level}")),
-        layer_builder(format!("angstrom_rpc={level}")),
-        layer_builder(format!("angstrom={level}")),
-        layer_builder(format!("testing_tools={level}")),
-        layer_builder(format!("matching_engine={level}")),
-        layer_builder(format!("uniswap_v4={level}")),
-        layer_builder(format!("consensus={level}")),
-        layer_builder(format!("validation={level}")),
-        layer_builder(format!("order_pool={level}")),
-    ];
+    let envfilter = filter::EnvFilter::builder().try_from_env().ok();
+    let format = tracing_subscriber::fmt::layer()
+        .with_ansi(true)
+        .with_target(true);
 
-    tracing_subscriber::registry().with(layers).init();
+    if let Some(f) = envfilter {
+        tracing_subscriber::registry().with(format).with(f).init();
+    } else {
+        let filter = filter::Targets::new()
+            .with_target("testnet", level)
+            .with_target("devnet", level)
+            .with_target("angstrom_rpc", level)
+            .with_target("angstrom", level)
+            .with_target("testing_tools", level)
+            .with_target("angstrom_eth", level)
+            .with_target("matching_engine", level)
+            .with_target("uniswap_v4", level)
+            .with_target("consensus", level)
+            .with_target("validation", level)
+            .with_target("order_pool", level);
+        tracing_subscriber::registry()
+            .with(format)
+            .with(filter)
+            .init();
+    }
 }
 
 fn layer_builder(filter_str: String) -> Box<dyn Layer<Registry> + Send + Sync> {

bin/testnet/src/simulations/e2e_orders.rs

@@ -45,8 +45,8 @@ fn end_to_end_agent<'a>(
         let mut generator = OrderGenerator::new(
             agent_config.uniswap_pools.clone(),
             agent_config.current_block,
-            7..10,
-            0.1..0.6
+            5..10,
+            0.1..0.9
         );
 
         let mut stream =

bin/testnet/src/simulations/matching_comp.rs

@@ -0,0 +1,217 @@
+use std::{pin::Pin, sync::atomic::AtomicBool};
+
+use alloy_primitives::{FixedBytes, U256};
+use angstrom_eth::manager::ChainExt;
+use angstrom_types::{
+    matching::Ray,
+    orders::{OrderId, OrderOrigin, OrderPriorityData},
+    sol_bindings::{
+        grouped_orders::{AllOrders, OrderWithStorageData},
+        RawPoolOrder
+    },
+    testnet::InitialTestnetState
+};
+use futures::{Future, StreamExt};
+use matching_engine::{
+    book::{sort::SortStrategy, BookOrder, OrderBook},
+    matcher::binary_search::BinarySearchMatcher,
+    strategy::{MatchingStrategy, SimpleCheckpointStrategy}
+};
+use reth_provider::{noop::NoopProvider, CanonStateSubscriptions};
+use reth_tasks::TaskExecutor;
+use testing_tools::{
+    agents::AgentConfig,
+    controllers::enviroments::AngstromTestnet,
+    order_generator::{self, GeneratedPoolOrders, OrderGenerator},
+    types::{
+        actions::WithAction, checked_actions::WithCheckedAction, checks::WithCheck,
+        config::DevnetConfig
+    }
+};
+use tracing::{debug, info, span, Instrument, Level};
+
+use crate::cli::compare_engines::CompareEnginesCli;
+
+static USE_AMM: AtomicBool = AtomicBool::new(false);
+
+pub async fn compare_matching_engines(
+    executor: TaskExecutor,
+    cli: CompareEnginesCli
+) -> eyre::Result<()> {
+    let config = cli.testnet_config.make_config()?;
+    USE_AMM.store(cli.include_amm, std::sync::atomic::Ordering::SeqCst);
+
+    let agents = vec![cmp_agent];
+    tracing::info!("spinning up e2e nodes for angstrom");
+
+    // spawn testnet
+    let testnet = AngstromTestnet::spawn_testnet(NoopProvider::default(), config, agents).await?;
+    tracing::info!("e2e testnet is alive");
+
+    executor
+        .spawn_critical_blocking("testnet", testnet.run_to_completion(executor.clone()))
+        .await?;
+    Ok(())
+}
+
+fn cmp_agent<'a>(
+    _: &'a InitialTestnetState,
+    agent_config: AgentConfig
+) -> Pin<Box<dyn Future<Output = eyre::Result<()>> + Send + 'a>> {
+    Box::pin(async move {
+        let mut generator = OrderGenerator::new(
+            agent_config.uniswap_pools.clone(),
+            agent_config.current_block,
+            10..12,
+            0.2..0.6
+        );
+
+        let mut stream =
+            agent_config
+                .state_provider
+                .canonical_state_stream()
+                .map(|node| match node {
+                    reth_provider::CanonStateNotification::Commit { new }
+                    | reth_provider::CanonStateNotification::Reorg { new, .. } => new.tip_number()
+                });
+
+        tokio::spawn(
+            async move {
+                tracing::info!("waiting for new block");
+                let use_amm = USE_AMM.load(std::sync::atomic::Ordering::SeqCst);
+
+                while let Some(block) = stream.next().await {
+                    generator.new_block(block);
+                    let new_orders = generator.generate_orders();
+                    for orders in new_orders {
+                        let GeneratedPoolOrders { pool_id, tob, book } = orders;
+                        let pool = agent_config.uniswap_pools.get(&pool_id).unwrap();
+                        let (_, _, amm) = pool.read().unwrap().fetch_pool_snapshot().unwrap();
+                        let asks =
+                            book.iter()
+                                .filter(|f| !f.is_bid())
+                                .map(|ask| {
+                                    OrderWithStorageData {
+                invalidates: vec![],
+                order: ask.clone(),
+                priority_data: OrderPriorityData {
+                    price:     *ask.price(),
+                    volume:    ask.amount(),
+                    gas:       U256::ZERO,
+                    gas_units: 0
+                },
+                is_bid: false,
+                is_valid: true,
+                is_currently_valid: true,
+                order_id: OrderId {
+                    flash_block:     None,
+                    reuse_avoidance: angstrom_types::sol_bindings::RespendAvoidanceMethod::Block(0),
+                    hash:            ask.order_hash(),
+                    address:         Default::default(),
+                    deadline:        None,
+                    pool_id,
+                    location:        angstrom_types::orders::OrderLocation::Limit
+                },
+                pool_id,
+                valid_block: 0,
+                tob_reward: U256::ZERO
+                            }
+                                })
+                                .collect::<Vec<BookOrder>>();
+                        let bids =
+                            book.iter()
+                                .filter(|f| f.is_bid())
+                                .map(|bid| {
+                                    OrderWithStorageData {
+                invalidates: vec![],
+                order: bid.clone(),
+                priority_data: OrderPriorityData {
+                    price:     *bid.price(),
+                    volume:    bid.amount(),
+                    gas:       U256::ZERO,
+                    gas_units: 0
+                },
+                is_bid: true,
+                is_valid: true,
+                is_currently_valid: true,
+                order_id: OrderId {
+                    flash_block:     None,
+                    reuse_avoidance: angstrom_types::sol_bindings::RespendAvoidanceMethod::Block(0),
+                    hash:            bid.order_hash(),
+                    address:         Default::default(),
+                    deadline:        None,
+                    pool_id,
+                    location:        angstrom_types::orders::OrderLocation::Limit
+                },
+                pool_id,
+                valid_block: 0,
+                tob_reward: U256::ZERO
+                            }
+                                })
+                                .collect::<Vec<BookOrder>>();
+
+                        let book = OrderBook::new(
+                            pool_id,
+                            use_amm.then_some(amm),
+                            bids,
+                            asks,
+                            Some(SortStrategy::ByPriceByVolume)
+                        );
+
+                        let tob = OrderWithStorageData {
+                            invalidates: vec![],
+                            order: tob.clone(),
+                            priority_data: OrderPriorityData {
+                                price:     tob.limit_price(),
+                                volume:    tob.amount(),
+                                gas:       U256::ZERO,
+                                gas_units: 0
+                            },
+                            is_bid: tob.is_bid(),
+                            is_valid: true,
+                            is_currently_valid: true,
+                            order_id: OrderId {
+                                flash_block: None,
+                                reuse_avoidance:
+                                    angstrom_types::sol_bindings::RespendAvoidanceMethod::Block(0),
+                                hash: tob.order_hash(),
+                                address: Default::default(),
+                                deadline: None,
+                                pool_id,
+                                location: angstrom_types::orders::OrderLocation::Limit
+                            },
+                            pool_id,
+                            valid_block: 0,
+                            tob_reward: U256::ZERO
+                        };
+
+                        let debt_engine = SimpleCheckpointStrategy::run(&book)
+                            .unwrap()
+                            .solution(Some(tob.clone()));
+
+                        let bisection = BinarySearchMatcher::new(&book, Some(tob.clone()))
+                            .solution(Some(tob.clone()));
+
+                        if debt_engine.ucp != bisection.ucp {
+                            // lets save the book
+                            book.save(bisection.ucp, debt_engine.ucp).unwrap();
+
+                            let r = BinarySearchMatcher::new(&book, Some(tob.clone()))
+                                .calculate_solver_move(debt_engine.ucp);
+                            println!("\n\n\n\n\n when using the debt engine ucp, we get: {:#?}", r);
+                        }
+
+                        if bisection != debt_engine {
+                            println!(
+                                "\n\n\n\n bisection_results:{:#?}\n\n debt_results:{:#?} ",
+                                bisection, debt_engine,
+                            );
+                        }
+                    }
+                }
+            }
+            .instrument(span!(Level::ERROR, "matching engine cmp", ?agent_config.agent_id))
+        );
+        Ok(())
+    })
+}

bin/testnet/src/simulations/mod.rs

@@ -1 +1,2 @@
 pub mod e2e_orders;
+pub mod matching_comp;