[TRIVIAL] Migrate order, quote, and validation modules to alloy (#3926)

Large but overall trivial

# Description
This PR continues the migration from the deprecated `ethcontract`
library to the modern `alloy` library by converting order, quote, and
validation-related modules to use alloy primitive types (`Address`,
`U256`).

This is part of a broader effort to modernize the codebase and adopt
alloy as the standard Ethereum library, replacing ethcontract's `H160`
and `U256` types with their alloy equivalents.

# Changes

- **Model layer**
- [x] Migrate `QuoteAmounts` struct to use `alloy::primitives::U256` in
`crates/model/src/order.rs`
- [x] Simplify `within_market` method by removing manual byte
conversions
- [x] Migrate `OrderQuoteRequest`, `OrderQuote`, `OrderQuoteResponse` to
use `alloy::primitives::Address` in `crates/model/src/quote.rs`
  - [x] Update solver competition models to use alloy types

- **Shared layer**
- [x] Migrate `QuoteParameters`, `Quote`, and `QuoteData` structs to
alloy types in `crates/shared/src/order_quoting.rs`
- [x] Update quote scaling logic to use `widening_mul` instead of
`full_mul`
- [x] Migrate `Amounts` struct and validation logic in
`crates/shared/src/order_validation.rs`
- [x] Update `is_order_outside_market_price` to use typed `widening_mul`
calls
- [x] Migrate fee calculations, event storage, and price estimation
modules

- **Orderbook layer**
- [x] Update database operations to handle alloy types with proper
conversions
  - [x] Migrate DTOs (auction, order) to use alloy primitives
  - [x] Update quote API endpoints and quoter logic
  - [x] Migrate solver competition storage

- **Autopilot**
  - [x] Update onchain order event handling
  - [x] Migrate quote domain logic
  - [x] Update run loop to work with alloy types

- **E2E tests**
- [x] Update all test files to use alloy `Address` creation methods
(`with_last_byte` instead of `from_low_u64_be`)
  - [x] Update test setup infrastructure and onchain components

- **Math utilities**
  - [x] Remove deprecated math functions from solvers util module
  - [x] Update driver math utilities

## How to test
Existing tests

---------

Co-authored-by: Claude <[email protected]>

Author: jmg-duarte

crates/autopilot/src/database/onchain_order_events/mod.rs

@@ -600,9 +600,9 @@ fn convert_onchain_order_placement(
     // executed fast (we don't want to reserve the user's ETH for too long)
     if quote.as_ref().is_ok_and(|quote| {
         !order_data.within_market(QuoteAmounts {
-            sell: quote.sell_amount.into_legacy(),
-            buy: quote.buy_amount.into_legacy(),
-            fee: quote.fee_amount.into_legacy(),
+            sell: quote.sell_amount,
+            buy: quote.buy_amount,
+            fee: quote.fee_amount,
         })
     }) {
         tracing::debug!(%order_uid, ?owner, "order is outside market price");

crates/autopilot/src/run_loop.rs

@@ -472,7 +472,9 @@ impl RunLoop {
             .map(|(index, participant)| SolverSettlement {
                 solver: participant.driver().name.clone(),
                 solver_address: participant.solution().solver().0.into_alloy(),
-                score: Some(Score::Solver(participant.solution().score().get().0)),
+                score: Some(Score::Solver(
+                    participant.solution().score().get().0.into_alloy(),
+                )),
                 ranking: index + 1,
                 orders: participant
                     .solution()

crates/driver/src/util/math.rs

@@ -28,14 +28,14 @@ pub fn mul_ratio_ceil(x: U256, q: U256, d: U256) -> Option<U256> {
 
     // fast path when math in U256 doesn't overflow
     if let Some(p) = x.checked_mul(q) {
-        let (div, rem) = (p / d, p % d);
+        let (div, rem) = p.div_rem(d);
         return div.checked_add(U256::from(!rem.is_zero()));
     }
 
     let p = x.widening_mul(q);
     let d = U512::from(d);
     // SAFETY: at this point !d.is_zero() upholds
-    let (div, rem) = (p / d, p % d);
+    let (div, rem) = p.div_rem(d);
 
     let result = U256::uint_try_from(div).ok()?;
     result.checked_add(U256::from(!rem.is_zero()))

crates/e2e/src/api/zeroex.rs

@@ -1,15 +1,12 @@
 use {
     crate::setup::TestAccount,
-    autopilot::domain::eth::U256,
+    alloy::primitives::{Address, B256, U256},
     chrono::{DateTime, NaiveDateTime, Utc},
-    driver::domain::eth::H256,
     ethcontract::common::abi::{Token, encode},
+    ethrpc::alloy::conversions::IntoLegacy,
     hex_literal::hex,
     model::DomainSeparator,
-    shared::{
-        zeroex_api,
-        zeroex_api::{Order, OrderMetadata, OrderRecord, ZeroExSignature},
-    },
+    shared::zeroex_api::{self, Order, OrderMetadata, OrderRecord, ZeroExSignature},
     std::{net::SocketAddr, sync::LazyLock},
     warp::{Filter, Reply},
     web3::{signing, types::H160},
@@ -55,17 +52,17 @@ impl ZeroExApi {
 }
 
 pub struct Eip712TypedZeroExOrder {
-    pub maker_token: H160,
-    pub taker_token: H160,
+    pub maker_token: Address,
+    pub taker_token: Address,
     pub maker_amount: u128,
     pub taker_amount: u128,
     pub remaining_fillable_taker_amount: u128,
     pub taker_token_fee_amount: u128,
-    pub maker: H160,
-    pub taker: H160,
-    pub sender: H160,
-    pub fee_recipient: H160,
-    pub pool: H256,
+    pub maker: Address,
+    pub taker: Address,
+    pub sender: Address,
+    pub fee_recipient: Address,
+    pub pool: B256,
     pub expiry: u64,
     pub salt: U256,
 }
@@ -85,15 +82,15 @@ impl Eip712TypedZeroExOrder {
             Order {
                 chain_id,
                 expiry: NaiveDateTime::MAX.and_utc().timestamp() as u64,
-                fee_recipient: self.fee_recipient,
-                maker: self.maker,
-                maker_token: self.maker_token,
+                fee_recipient: self.fee_recipient.into_legacy(),
+                maker: self.maker.into_legacy(),
+                maker_token: self.maker_token.into_legacy(),
                 maker_amount: self.maker_amount,
-                pool: self.pool,
-                salt: self.salt,
-                sender: self.sender,
-                taker: self.taker,
-                taker_token: self.taker_token,
+                pool: self.pool.into_legacy(),
+                salt: self.salt.into_legacy(),
+                sender: self.sender.into_legacy(),
+                taker: self.taker.into_legacy(),
+                taker_token: self.taker_token.into_legacy(),
                 taker_amount: self.taker_amount,
                 taker_token_fee_amount: self.taker_token_fee_amount,
                 verifying_contract,
@@ -131,18 +128,18 @@ 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[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[44..64].copy_from_slice(self.maker_token.as_slice());
+        hash_data[76..96].copy_from_slice(self.taker_token.as_slice());
         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[204..224].copy_from_slice(self.maker.as_slice());
+        hash_data[236..256].copy_from_slice(self.taker.as_slice());
+        hash_data[268..288].copy_from_slice(self.sender.as_slice());
+        hash_data[300..320].copy_from_slice(self.fee_recipient.as_slice());
+        hash_data[320..352].copy_from_slice(self.pool.as_slice());
         hash_data[376..384].copy_from_slice(&self.expiry.to_be_bytes());
-        self.salt.to_big_endian(&mut hash_data[384..416]);
+        hash_data[384..416].copy_from_slice(&self.salt.to_be_bytes::<32>());
         signing::keccak256(&hash_data)
     }
 }