feat: Liquorice protocol simulation

examples/rfq_quickstart/main.rs

@@ -40,6 +40,7 @@ use tycho_simulation::{
         protocols::{
             bebop::{client_builder::BebopClientBuilder, state::BebopState},
             hashflow::{client_builder::HashflowClientBuilder, state::HashflowState},
+            liquorice::{client_builder::LiquoriceClientBuilder, state::LiquoriceState},
         },
         stream::RFQStreamBuilder,
     },
@@ -114,10 +115,13 @@ async fn main() {
     let (bebop_user, bebop_key) = (env::var("BEBOP_USER").ok(), env::var("BEBOP_KEY").ok());
     let (hashflow_user, hashflow_key) =
         (env::var("HASHFLOW_USER").ok(), env::var("HASHFLOW_KEY").ok());
+    let (liquorice_user, liquorice_key) =
+        (env::var("LIQUORICE_USER").ok(), env::var("LIQUORICE_KEY").ok());
     if (bebop_user.is_none() || bebop_key.is_none()) &&
-        (hashflow_user.is_none() || hashflow_key.is_none())
+        (hashflow_user.is_none() || hashflow_key.is_none()) &&
+        (liquorice_user.is_none() || liquorice_key.is_none())
     {
-        panic!("No RFQ credentials found. Please set BEBOP_USER and BEBOP_KEY or HASHFLOW_USER and HASHFLOW_KEY environment variables.");
+        panic!("No RFQ credentials found. Please set BEBOP_USER and BEBOP_KEY, HASHFLOW_USER and HASHFLOW_KEY, or LIQUORICE_USER and LIQUORICE_KEY environment variables.");
     }
 
     println!("Loading tokens from Tycho... {url}", url = tycho_url.as_str());
@@ -195,14 +199,24 @@ async fn main() {
     if let (Some(user), Some(key)) = (hashflow_user, hashflow_key) {
         println!("Setting up Hashflow RFQ client...\n");
         let hashflow_client = HashflowClientBuilder::new(chain, user, key)
-            .tokens(rfq_tokens)
+            .tokens(rfq_tokens.clone())
             .tvl_threshold(cli.tvl_threshold)
             .poll_time(Duration::from_secs(5))
             .build()
             .expect("Failed to create Hashflow RFQ client");
         rfq_stream_builder =
             rfq_stream_builder.add_client::<HashflowState>("hashflow", Box::new(hashflow_client))
     }
+    if let (Some(user), Some(key)) = (liquorice_user, liquorice_key) {
+        println!("Setting up Liquorice RFQ client...\n");
+        let liquorice_client = LiquoriceClientBuilder::new(chain, user, key)
+            .tokens(rfq_tokens.clone())
+            .tvl_threshold(cli.tvl_threshold)
+            .build()
+            .expect("Failed to create Liquorice RFQ client");
+        rfq_stream_builder =
+            rfq_stream_builder.add_client::<LiquoriceState>("liquorice", Box::new(liquorice_client))
+    }
 
     // Start the RFQ stream in a background task
     let (tx, mut rx) = mpsc::channel::<Update>(100);
@@ -441,7 +455,7 @@ async fn main() {
                                         input: Some(AlloyBytes::from(tx.data)),
                                         data: None,
                                     },
-                                    gas: Some(800_000u64),
+                                    gas: Some(1_000_000u64),
                                     chain_id: Some(chain.id()),
                                     max_fee_per_gas: Some(max_fee_per_gas.into()),
                                     max_priority_fee_per_gas: Some(max_priority_fee_per_gas.into()),

src/rfq/constants.rs

@@ -28,6 +28,26 @@ pub fn get_hashflow_auth() -> Result<HashflowAuth, RFQError> {
     Ok(HashflowAuth { user, key })
 }
 
+/// Liquorice authentication configuration
+pub struct LiquoriceAuth {
+    pub solver: String,
+    pub key: String,
+}
+
+/// Read Liquorice authentication from environment variables
+/// Returns the LIQUORICE_USER and LIQUORICE_KEY environment variables
+pub fn get_liquorice_auth() -> Result<LiquoriceAuth, RFQError> {
+    let solver = env::var("LIQUORICE_USER").map_err(|_| {
+        RFQError::InvalidInput("LIQUORICE_USER environment variable is required".into())
+    })?;
+
+    let key = env::var("LIQUORICE_KEY").map_err(|_| {
+        RFQError::InvalidInput("LIQUORICE_KEY environment variable is required".into())
+    })?;
+
+    Ok(LiquoriceAuth { solver, key })
+}
+
 /// Read Bebop authentication from environment variables
 /// Returns the BEBOP_USER and BEBOP_KEY environment variables
 pub fn get_bebop_auth() -> Result<BebopAuth, RFQError> {