Baseline solver limit orders support

crates/e2e/src/nodes/forked_node.rs

@@ -61,4 +61,16 @@ impl<T: Transport> ForkedNodeApi<T> {
                 .execute("anvil_setBalance", vec![json_address, json_balance]),
         )
     }
+
+    // Makes GPv2 auth contract always return `true` to make any solver to be
+    // whitelisted.
+    pub fn set_mocked_settle(&self) -> CallFuture<(), T::Out> {
+        let gpv2_auth_address_json =
+            serde_json::json!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE");
+        let bytecode_json = serde_json::json!("0x600160005260206000F3");
+        CallFuture::new(
+            self.transport
+                .execute("anvil_setCode", vec![gpv2_auth_address_json, bytecode_json]),
+        )
+    }
 }

crates/e2e/tests/e2e/liquidity.rs

@@ -62,7 +62,8 @@ async fn zero_ex_liquidity(web3: Web3) {
     let forked_node_api = web3.api::<ForkedNodeApi<_>>();
 
     let [solver] = onchain.make_solvers_forked(to_wei(1)).await;
-    let [trader_a, trader_b, zeroex_maker, zeroex_taker] = onchain.make_accounts(to_wei(1)).await;
+    let [trader, zeroex_maker] = onchain.make_accounts(to_wei(1)).await;
+    forked_node_api.set_mocked_settle().await.unwrap();
 
     let token_usdc = ERC20::at(
         &web3,
@@ -78,65 +79,54 @@ async fn zero_ex_liquidity(web3: Web3) {
             .unwrap(),
     );
 
+    let zeroex = IZeroEx::deployed(&web3).await.unwrap();
+
+    let amount = 500;
+
     // Give trader some USDC
     let usdc_whale = forked_node_api
         .impersonate(&crate::limit_orders::USDC_WHALE)
         .await
         .unwrap();
     tx!(
         usdc_whale,
-        token_usdc.transfer(trader_a.address(), to_wei_with_exp(500, 6))
+        token_usdc.transfer(trader.address(), to_wei_with_exp(amount, 6))
     );
 
     // Give trader some USDT
     let usdt_whale = forked_node_api.impersonate(&USDT_WHALE).await.unwrap();
     tx!(
         usdt_whale,
-        token_usdt.transfer(trader_b.address(), to_wei_with_exp(500, 6))
+        token_usdt.transfer(zeroex_maker.address(), to_wei_with_exp(amount * 3, 6))
     );
 
     // Approve GPv2 for trading
     tx!(
-        trader_a.account(),
-        token_usdc.approve(onchain.contracts().allowance, to_wei_with_exp(500, 6))
+        trader.account(),
+        token_usdc.approve(onchain.contracts().allowance, to_wei_with_exp(amount, 6))
     );
     tx!(
-        trader_b.account(),
-        token_usdt.approve(onchain.contracts().allowance, to_wei_with_exp(500, 6))
+        zeroex_maker.account(),
+        token_usdt.approve(zeroex.address(), to_wei_with_exp(amount * 3, 6))
     );
 
-    let order_a = OrderCreation {
+    let order = OrderCreation {
         sell_token: token_usdc.address(),
-        sell_amount: to_wei_with_exp(500, 6),
+        sell_amount: to_wei_with_exp(amount, 6),
         buy_token: token_usdt.address(),
-        buy_amount: to_wei_with_exp(500, 6),
-        valid_to: model::time::now_in_epoch_seconds() + 300,
-        kind: OrderKind::Sell,
-        ..Default::default()
-    }
-    .sign(
-        EcdsaSigningScheme::Eip712,
-        &onchain.contracts().domain_separator,
-        SecretKeyRef::from(&SecretKey::from_slice(trader_a.private_key()).unwrap()),
-    );
-    let order_b = OrderCreation {
-        sell_token: token_usdt.address(),
-        sell_amount: to_wei_with_exp(500, 6),
-        buy_token: token_usdc.address(),
-        buy_amount: to_wei_with_exp(500, 6),
+        buy_amount: to_wei_with_exp(amount, 6),
         valid_to: model::time::now_in_epoch_seconds() + 300,
         kind: OrderKind::Sell,
         ..Default::default()
     }
     .sign(
         EcdsaSigningScheme::Eip712,
         &onchain.contracts().domain_separator,
-        SecretKeyRef::from(&SecretKey::from_slice(trader_b.private_key()).unwrap()),
+        SecretKeyRef::from(&SecretKey::from_slice(trader.private_key()).unwrap()),
     );
 
-    let zeroex = IZeroEx::deployed(&web3).await.unwrap();
     let zeroex_api_port = {
-        let order = order_a.clone();
+        let order = order.clone();
         let chain_id = web3.eth().chain_id().await.unwrap().as_u64();
         let gpv2_addr = onchain.contracts().gp_settlement.address();
         let zeroex_addr = zeroex.address();
@@ -145,7 +135,6 @@ async fn zero_ex_liquidity(web3: Web3) {
                 query,
                 order.clone(),
                 zeroex_maker.clone(),
-                zeroex_taker.clone(),
                 zeroex_addr,
                 gpv2_addr,
                 chain_id,
@@ -161,7 +150,8 @@ async fn zero_ex_liquidity(web3: Web3) {
 
     // Place Orders
     let services = Services::new(onchain.contracts()).await;
-    let solver_endpoint = colocation::start_naive_solver().await;
+    let solver_endpoint =
+        colocation::start_baseline_solver(onchain.contracts().weth.address()).await;
     colocation::start_driver_with_zeroex_liquidity(
         onchain.contracts(),
         vec![SolverEngine {
@@ -179,20 +169,20 @@ async fn zero_ex_liquidity(web3: Web3) {
             "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver".to_string(),
         ])
         .await;
-    let order_id = services.create_order(&order_a).await.unwrap();
-    services.create_order(&order_b).await.unwrap();
+    let order_id = services.create_order(&order).await.unwrap();
+    println!("newlog order_id={:?}", order_id);
     let limit_order = services.get_order(&order_id).await.unwrap();
     assert_eq!(limit_order.metadata.class, OrderClass::Limit);
 
     // Drive solution
     tracing::info!("Waiting for trade.");
     let sell_token_balance_before = token_usdc
-        .balance_of(trader_a.address())
+        .balance_of(trader.address())
         .call()
         .await
         .unwrap();
     let buy_token_balance_before = token_usdt
-        .balance_of(trader_a.address())
+        .balance_of(trader.address())
         .call()
         .await
         .unwrap();
@@ -206,47 +196,46 @@ async fn zero_ex_liquidity(web3: Web3) {
         .unwrap();
 
     let sell_token_balance_after = token_usdc
-        .balance_of(trader_a.address())
+        .balance_of(trader.address())
         .call()
         .await
         .unwrap();
     let buy_token_balance_after = token_usdt
-        .balance_of(trader_a.address())
+        .balance_of(trader.address())
         .call()
         .await
         .unwrap();
 
     assert!(sell_token_balance_before > sell_token_balance_after);
-    assert!(buy_token_balance_after >= buy_token_balance_before + to_wei_with_exp(500, 6));
+    assert!(buy_token_balance_after >= buy_token_balance_before + to_wei_with_exp(amount, 6));
 }
 
 fn orders_query_handler(
     query: &OrdersQuery,
     order_creation: OrderCreation,
     zeroex_maker: TestAccount,
-    zeroex_taker: TestAccount,
     zeroex_addr: H160,
     gpv2_addr: H160,
     chain_id: u64,
 ) -> Result<Vec<OrderRecord>, ZeroExResponseError> {
     if query.sender == Some(gpv2_addr) {
         let typed_order = Eip712TypedZeroExOrder {
-            maker_token: order_creation.sell_token,
-            taker_token: order_creation.buy_token,
-            maker_amount: order_creation.sell_amount.as_u128() * 2,
-            taker_amount: order_creation.buy_amount.as_u128() * 2,
+            maker_token: order_creation.buy_token,
+            taker_token: order_creation.sell_token,
+            maker_amount: order_creation.buy_amount.as_u128() * 3,
+            taker_amount: order_creation.sell_amount.as_u128() * 2,
             taker_token_fee_amount: 0,
             maker: zeroex_maker.address(),
-            taker: zeroex_taker.address(),
-            sender: zeroex_maker.address(),
+            taker: gpv2_addr,
+            sender: gpv2_addr,
             fee_recipient: zeroex_addr,
             pool: H256::default(),
             expiry: NaiveDateTime::MAX.timestamp() as u64,
             salt: U256::from(Utc::now().timestamp()),
         };
         Ok(vec![typed_order.to_order_record(
             chain_id,
-            gpv2_addr,
+            zeroex_addr,
             zeroex_maker,
         )])
     } else if query.sender
@@ -337,17 +326,17 @@ impl Eip712TypedZeroExOrder {
     fn hash_struct(&self) -> [u8; 32] {
         let mut hash_data = [0u8; 416];
         hash_data[0..32].copy_from_slice(&Self::ZEROEX_LIMIT_ORDER_TYPEHASH);
-        hash_data[32..52].copy_from_slice(self.maker_token.as_fixed_bytes());
-        hash_data[64..84].copy_from_slice(self.taker_token.as_fixed_bytes());
-        hash_data[96..112].copy_from_slice(&self.maker_amount.to_be_bytes());
-        hash_data[128..144].copy_from_slice(&self.taker_amount.to_be_bytes());
-        hash_data[160..176].copy_from_slice(&self.taker_token_fee_amount.to_be_bytes());
-        hash_data[192..212].copy_from_slice(self.maker.as_fixed_bytes());
-        hash_data[224..244].copy_from_slice(self.taker.as_fixed_bytes());
-        hash_data[256..276].copy_from_slice(self.sender.as_fixed_bytes());
-        hash_data[288..308].copy_from_slice(self.fee_recipient.as_fixed_bytes());
+        hash_data[44..64].copy_from_slice(self.maker_token.as_fixed_bytes());
+        hash_data[76..96].copy_from_slice(self.taker_token.as_fixed_bytes());
+        hash_data[112..128].copy_from_slice(&self.maker_amount.to_be_bytes());
+        hash_data[144..160].copy_from_slice(&self.taker_amount.to_be_bytes());
+        hash_data[176..192].copy_from_slice(&self.taker_token_fee_amount.to_be_bytes());
+        hash_data[204..224].copy_from_slice(self.maker.as_fixed_bytes());
+        hash_data[236..256].copy_from_slice(self.taker.as_fixed_bytes());
+        hash_data[268..288].copy_from_slice(self.sender.as_fixed_bytes());
+        hash_data[300..320].copy_from_slice(self.fee_recipient.as_fixed_bytes());
         hash_data[320..352].copy_from_slice(self.pool.as_fixed_bytes());
-        hash_data[352..360].copy_from_slice(&self.expiry.to_be_bytes());
+        hash_data[376..384].copy_from_slice(&self.expiry.to_be_bytes());
         self.salt.to_big_endian(&mut hash_data[384..416]);
         signing::keccak256(&hash_data)
     }
@@ -371,9 +360,9 @@ impl ZeroExDomainSeparator {
             );
         }
         let abi_encode_string = encode(&[
-            Token::Uint((*DOMAIN_TYPE_HASH).into()),
-            Token::Uint((*DOMAIN_NAME).into()),
-            Token::Uint((*DOMAIN_VERSION).into()),
+            Token::FixedBytes((*DOMAIN_TYPE_HASH).into()),
+            Token::FixedBytes((*DOMAIN_NAME).into()),
+            Token::FixedBytes((*DOMAIN_VERSION).into()),
             Token::Uint(chain_id.into()),
             Token::Address(contract_addr),
         ]);

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 }