Support JIT orders in the trade verifier

crates/autopilot/src/run.rs

@@ -333,6 +333,7 @@ pub async fn run(args: Arguments) {
             code_fetcher: code_fetcher.clone(),
         },
     )
+    .await
     .expect("failed to initialize price estimator factory");
 
     let native_price_estimator = price_estimator_factory

crates/contracts/solidity/Solver.sol

@@ -29,10 +29,10 @@ contract Solver {
     /// @param settlementContract - address of the settlement contract because
     /// it does not have a stable address in tests.
     /// @param trader - address of the order owner doing the trade
-    /// @param sellToken - address of the token being sold
+    /// @param sellTokenIndex - index in the tokens array of the token being sold
     /// @param sellAmount - amount being sold
-    /// @param buyToken - address of the token being bought
     /// @param nativeToken - ERC20 version of the chain's token
+    /// @param tokens - list of tokens used in the trade
     /// @param receiver - address receiving the bought tokens
     /// @param settlementCall - the calldata of the `settle()` call
     /// @param mockPreconditions - controls whether things like ETH wrapping
@@ -45,10 +45,10 @@ contract Solver {
     function swap(
         ISettlement settlementContract,
         address payable trader,
-        address sellToken,
+        uint256 sellTokenIndex,
         uint256 sellAmount,
-        address buyToken,
         address nativeToken,
+        address[] calldata tokens,
         address payable receiver,
         bytes calldata settlementCall,
         bool mockPreconditions
@@ -64,7 +64,7 @@ contract Solver {
             Trader(trader)
                 .prepareSwap(
                     settlementContract,
-                    sellToken,
+                tokens[sellTokenIndex],
                     sellAmount,
                     nativeToken
                 );
@@ -76,13 +76,14 @@ contract Solver {
         // contract.
         receiver.call{value: 0}("");
 
-        this.storeBalance(sellToken, address(settlementContract), false);
-        this.storeBalance(buyToken, address(settlementContract), false);
-        uint256 gasStart = gasleft();
-        address(settlementContract).doCall(settlementCall);
-        gasUsed = gasStart - gasleft() - _simulationOverhead;
-        this.storeBalance(sellToken, address(settlementContract), false);
-        this.storeBalance(buyToken, address(settlementContract), false);
+        // Store pre-settlement balances
+        _storeSettlementBalances(tokens, settlementContract);
+
+        gasUsed = _executeSettlement(address(settlementContract), settlementCall);
+
+        // Store post-settlement balances
+        _storeSettlementBalances(tokens, settlementContract);
+
         queriedBalances = _queriedBalances;
     }
 
@@ -104,4 +105,26 @@ contract Solver {
             _simulationOverhead += gasStart - gasleft() + 4460;
         }
     }
+
+    /// @dev Helper function that reads and stores the balances of the `settlementContract` for each token in `tokens`.
+    /// @param tokens - list of tokens used in the trade
+    /// @param settlementContract - the settlement contract whose balances are being read
+    function _storeSettlementBalances(address[] calldata tokens, ISettlement settlementContract) internal {
+        for (uint256 i = 0; i < tokens.length; i++) {
+            this.storeBalance(tokens[i], address(settlementContract), false);
+        }
+    }
+
+    /// @dev Executes the settlement and measures the gas used.
+    /// @param settlementContract The address of the settlement contract.
+    /// @param settlementCall The calldata for the settlement function.
+    /// @return gasUsed The amount of gas used during the settlement execution.
+    function _executeSettlement(
+        address settlementContract,
+        bytes calldata settlementCall
+    ) private returns (uint256 gasUsed) {
+        uint256 gasStart = gasleft();
+        address(settlementContract).doCall(settlementCall);
+        gasUsed = gasStart - gasleft() - _simulationOverhead;
+    }
 }

crates/e2e/Cargo.toml

@@ -11,6 +11,7 @@ anyhow = { workspace = true }
 async-trait = { workspace = true }
 autopilot = { path = "../autopilot" }
 axum = { workspace = true }
+bigdecimal = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
 contracts = { path = "../contracts" }

crates/e2e/tests/e2e/quote_verification.rs

@@ -1,4 +1,5 @@
 use {
+    bigdecimal::{BigDecimal, Zero},
     e2e::setup::*,
     ethcontract::H160,
     ethrpc::Web3,
@@ -13,7 +14,7 @@ use {
             Estimate,
             Verification,
         },
-        trade_finding::{Interaction, Trade},
+        trade_finding::{Interaction, LegacyTrade, TradeKind},
     },
     std::{str::FromStr, sync::Arc},
 };
@@ -61,8 +62,10 @@ async fn test_bypass_verification_for_rfq_quotes(web3: Web3) {
         block_stream,
         onchain.contracts().gp_settlement.address(),
         onchain.contracts().weth.address(),
-        0.0,
-    );
+        BigDecimal::zero(),
+    )
+    .await
+    .unwrap();
 
     let verify_trade = |tx_origin| {
         let verifier = verifier.clone();
@@ -86,7 +89,7 @@ async fn test_bypass_verification_for_rfq_quotes(web3: Web3) {
                         sell_token_source: SellTokenSource::Erc20,
                         buy_token_destination: BuyTokenDestination::Erc20,
                     },
-                    Trade {
+                    TradeKind::Legacy(LegacyTrade {
                         out_amount: 16380122291179526144u128.into(),
                         gas_estimate: Some(225000),
                         interactions: vec![Interaction {
@@ -98,7 +101,7 @@ async fn test_bypass_verification_for_rfq_quotes(web3: Web3) {
                         solver: H160::from_str("0xe3067c7c27c1038de4e8ad95a83b927d23dfbd99")
                             .unwrap(),
                         tx_origin,
-                    },
+                    }),
                 )
                 .await
         }

crates/orderbook/src/run.rs

@@ -274,6 +274,7 @@ pub async fn run(args: Arguments) {
             code_fetcher: code_fetcher.clone(),
         },
     )
+    .await
     .expect("failed to initialize price estimator factory");
 
     let native_price_estimator = price_estimator_factory

crates/shared/src/price_estimation.rs

@@ -5,6 +5,7 @@ use {
         trade_finding::Interaction,
     },
     anyhow::Result,
+    bigdecimal::BigDecimal,
     ethcontract::{H160, U256},
     futures::future::BoxFuture,
     itertools::Itertools,
@@ -192,7 +193,7 @@ pub struct Arguments {
     /// E.g. a value of `0.01` means at most 1 percent of the sell or buy tokens
     /// can be paid out of the settlement contract buffers.
     #[clap(long, env, default_value = "1.")]
-    pub quote_inaccuracy_limit: f64,
+    pub quote_inaccuracy_limit: BigDecimal,
 
     /// How strict quote verification should be.
     #[clap(

crates/shared/src/price_estimation/factory.rs

@@ -74,28 +74,30 @@ pub struct Components {
 }
 
 impl<'a> PriceEstimatorFactory<'a> {
-    pub fn new(
+    pub async fn new(
         args: &'a Arguments,
         shared_args: &'a arguments::Arguments,
         network: Network,
         components: Components,
     ) -> Result<Self> {
         Ok(Self {
-            trade_verifier: Self::trade_verifier(args, shared_args, &network, &components),
+            trade_verifier: Self::trade_verifier(args, shared_args, &network, &components).await?,
             args,
             network,
             components,
             estimators: HashMap::new(),
         })
     }
 
-    fn trade_verifier(
+    async fn trade_verifier(
         args: &'a Arguments,
         shared_args: &arguments::Arguments,
         network: &Network,
         components: &Components,
-    ) -> Option<Arc<dyn TradeVerifying>> {
-        let web3 = network.simulation_web3.clone()?;
+    ) -> Result<Option<Arc<dyn TradeVerifying>>> {
+        let Some(web3) = network.simulation_web3.clone() else {
+            return Ok(None);
+        };
         let web3 = ethrpc::instrumented::instrument_with_label(&web3, "simulator".into());
 
         let tenderly = shared_args
@@ -112,14 +114,17 @@ impl<'a> PriceEstimatorFactory<'a> {
             None => Arc::new(web3.clone()),
         };
 
-        Some(Arc::new(TradeVerifier::new(
-            web3,
-            simulator,
-            components.code_fetcher.clone(),
-            network.block_stream.clone(),
-            network.settlement,
-            network.native_token,
-            args.quote_inaccuracy_limit,
+        Ok(Some(Arc::new(
+            TradeVerifier::new(
+                web3,
+                simulator,
+                components.code_fetcher.clone(),
+                network.block_stream.clone(),
+                network.settlement,
+                network.native_token,
+                args.quote_inaccuracy_limit.clone(),
+            )
+            .await?,
         )))
     }