[TRIVIAL] Migrate OrderQuoteRequest to use alloy Address types (#3922)

# Description

Migrates `OrderQuoteRequest` struct from using ethcontract's `H160` to
alloy's `Address` type for address fields (`from`, `sell_token`,
`buy_token`, `receiver`). This is part of the ongoing ethcontract →
alloy library migration.

# Changes

- [x] Update `OrderQuoteRequest` struct in `model/src/quote.rs` to use
`alloy::primitives::Address` instead of `H160`
- [x] Update `orderbook/src/api/post_quote.rs` tests to use alloy
`Address` constructors
- [x] Update `orderbook/src/quoter.rs` to handle alloy Address types
- [x] Add `.into_legacy()` conversions in `shared/src/order_quoting.rs`
when converting `OrderQuoteRequest` to `PreOrderData` (which still uses
H160)
- [x] Fix all e2e tests (14 files) to properly convert between H160 and
alloy Address:
- Use `.into_alloy()` when converting H160 → Address for
OrderQuoteRequest
- Use `.into_legacy()` when converting Address → H160 for legacy
functions
  - Dereference address references where needed (`*token.address()`)


## How to test
Existing tests

<!--
## Related Issues

Fixes #
-->

---------

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

Author: jmg-duarte

crates/e2e/tests/e2e/app_data.rs

@@ -114,8 +114,8 @@ async fn app_data(web3: Web3) {
     });
     services
         .submit_quote(&OrderQuoteRequest {
-            sell_token: order3.sell_token,
-            buy_token: order3.buy_token,
+            sell_token: order3.sell_token.into_alloy(),
+            buy_token: order3.buy_token.into_alloy(),
             side: OrderQuoteSide::Sell {
                 sell_amount: SellAmount::AfterFee {
                     value: order3.sell_amount.try_into().unwrap(),

crates/e2e/tests/e2e/banned_users.rs

@@ -12,10 +12,7 @@ use {
         to_wei,
         to_wei_with_exp,
     },
-    ethrpc::{
-        Web3,
-        alloy::conversions::{IntoAlloy, IntoLegacy},
-    },
+    ethrpc::{Web3, alloy::conversions::IntoAlloy},
     model::quote::{OrderQuoteRequest, OrderQuoteSide, SellAmount},
     reqwest::StatusCode,
 };
@@ -96,14 +93,14 @@ async fn forked_mainnet_onchain_banned_user_test(web3: Web3) {
 
     let result = services
         .submit_quote(&OrderQuoteRequest {
-            sell_token: token_dai.address().into_legacy(),
-            buy_token: token_usdt.address().into_legacy(),
+            sell_token: *token_dai.address(),
+            buy_token: *token_usdt.address(),
             side: OrderQuoteSide::Sell {
                 sell_amount: SellAmount::BeforeFee {
                     value: to_wei_with_exp(1000, 18).try_into().unwrap(),
                 },
             },
-            from: BANNED_USER.into_legacy(),
+            from: BANNED_USER,
             ..Default::default()
         })
         .await;

crates/e2e/tests/e2e/cow_amm.rs

@@ -621,8 +621,8 @@ factory = "0xf76c421bAb7df8548604E60deCCcE50477C10462"
     // may time out)
     let _ = services
         .submit_quote(&OrderQuoteRequest {
-            sell_token: usdc.address().into_legacy(),
-            buy_token: usdt.address().into_legacy(),
+            sell_token: *usdc.address(),
+            buy_token: *usdt.address(),
             side: OrderQuoteSide::Sell {
                 sell_amount: SellAmount::BeforeFee {
                     value: to_wei_with_exp(1000, 6).try_into().unwrap(),
@@ -1008,9 +1008,9 @@ async fn cow_amm_opposite_direction(web3: Web3) {
     mock_solver.configure_solution(Some(mocked_quote_solution));
 
     let quote_request = OrderQuoteRequest {
-        from: bob.address(),
-        sell_token: dai.address().into_legacy(),
-        buy_token: onchain.contracts().weth.address().into_legacy(),
+        from: bob.address().into_alloy(),
+        sell_token: *dai.address(),
+        buy_token: *onchain.contracts().weth.address(),
         side: OrderQuoteSide::Sell {
             sell_amount: SellAmount::AfterFee {
                 value: NonZeroU256::try_from(executed_amount).unwrap(),

crates/e2e/tests/e2e/eth_integration.rs

@@ -62,7 +62,7 @@ async fn eth_integration(web3: Web3) {
             let request = OrderQuoteRequest {
                 sell_token,
                 buy_token,
-                from: Address::default(),
+                from: Address::default().into_alloy(),
                 side: OrderQuoteSide::Sell {
                     sell_amount: SellAmount::AfterFee {
                         value: NonZeroU256::try_from(to_wei(43)).unwrap(),
@@ -73,11 +73,11 @@ async fn eth_integration(web3: Web3) {
             services.submit_quote(&request).await
         }
     };
-    quote(token.address().into_legacy(), BUY_ETH_ADDRESS)
+    quote(*token.address(), BUY_ETH_ADDRESS.into_alloy())
         .await
         .unwrap();
     // Eth is only supported as the buy token
-    let (status, body) = quote(BUY_ETH_ADDRESS, token.address().into_legacy())
+    let (status, body) = quote(BUY_ETH_ADDRESS.into_alloy(), *token.address())
         .await
         .unwrap_err();
     assert_eq!(status, 400, "{body}");

crates/e2e/tests/e2e/ethflow.rs

@@ -102,9 +102,9 @@ async fn eth_flow_tx(web3: Web3) {
         .await;
 
     // Get a quote from the services
-    let buy_token = dai.address().into_legacy();
-    let receiver = H160([0x42; 20]);
-    let sell_amount = to_wei(1);
+    let buy_token = *dai.address();
+    let receiver = Address::repeat_byte(0x42);
+    let sell_amount = eth(1);
     let intent = EthFlowTradeIntent {
         sell_amount,
         buy_token,
@@ -157,7 +157,10 @@ async fn eth_flow_tx(web3: Web3) {
         app_data: OrderCreationAppData::Hash {
             hash: app_data::AppDataHash(const_hex::decode(&hash[2..]).unwrap().try_into().unwrap()),
         },
-        ..intent.to_quote_request(trader.account().address(), &onchain.contracts().weth)
+        ..intent.to_quote_request(
+            trader.account().address().into_alloy(),
+            &onchain.contracts().weth,
+        )
     };
 
     let quote: OrderQuoteResponse = test_submit_quote(&services, &quote_request).await;
@@ -182,7 +185,7 @@ async fn eth_flow_tx(web3: Web3) {
     test_order_availability_in_api(
         &services,
         &ethflow_order,
-        &trader.address(),
+        &trader.address().into_alloy(),
         onchain.contracts(),
         ethflow_contract,
     )
@@ -299,7 +302,7 @@ async fn eth_flow_without_quote(web3: Web3) {
     test_order_availability_in_api(
         &services,
         &ethflow_order,
-        &trader.address(),
+        &trader.address().into_alloy(),
         onchain.contracts(),
         ethflow_contract,
     )
@@ -330,11 +333,14 @@ async fn eth_flow_indexing_after_refund(web3: Web3) {
         &test_submit_quote(
             &services,
             &(EthFlowTradeIntent {
-                sell_amount: 42.into(),
-                buy_token: dai.address().into_legacy(),
-                receiver: H160([42; 20]),
+                sell_amount: alloy::primitives::U256::from(42),
+                buy_token: *dai.address(),
+                receiver: Address::repeat_byte(42),
             })
-            .to_quote_request(dummy_trader.account().address(), &onchain.contracts().weth),
+            .to_quote_request(
+                dummy_trader.account().address().into_alloy(),
+                &onchain.contracts().weth,
+            ),
         )
         .await,
         valid_to,
@@ -356,7 +362,7 @@ async fn eth_flow_indexing_after_refund(web3: Web3) {
 
     // Create the actual order that should be picked up by the services and matched.
     let buy_token = dai.address().into_legacy();
-    let receiver = H160([0x42; 20]);
+    let receiver = Address::repeat_byte(0x42);
     let sell_amount = to_wei(1);
     let valid_to = chrono::offset::Utc::now().timestamp() as u32
         + timestamp_of_current_block_in_seconds(&web3.alloy)
@@ -367,11 +373,14 @@ async fn eth_flow_indexing_after_refund(web3: Web3) {
         &test_submit_quote(
             &services,
             &(EthFlowTradeIntent {
-                sell_amount,
-                buy_token,
+                sell_amount: sell_amount.into_alloy(),
+                buy_token: buy_token.into_alloy(),
                 receiver,
             })
-            .to_quote_request(trader.account().address(), &onchain.contracts().weth),
+            .to_quote_request(
+                trader.account().address().into_alloy(),
+                &onchain.contracts().weth,
+            ),
         )
         .await,
         valid_to,
@@ -451,7 +460,7 @@ async fn submit_order(
 async fn test_order_availability_in_api(
     services: &Services<'_>,
     order: &ExtendedEthFlowOrder,
-    owner: &H160,
+    owner: &Address,
     contracts: &Contracts,
     ethflow_contract: &CoWSwapEthFlow::Instance,
 ) {
@@ -460,16 +469,26 @@ async fn test_order_availability_in_api(
     let is_available = || async { services.get_order(&uid).await.is_ok() };
     wait_for_condition(TIMEOUT, is_available).await.unwrap();
 
-    test_orders_query(services, order, owner, contracts, ethflow_contract).await;
+    test_orders_query(
+        services,
+        order,
+        &owner.into_legacy(),
+        contracts,
+        ethflow_contract,
+    )
+    .await;
 
     // Api returns eth flow orders for both eth-flow contract address and actual
     // owner
-    for address in [owner, &ethflow_contract.address().into_legacy()] {
+    for address in [
+        &owner.into_legacy(),
+        &ethflow_contract.address().into_legacy(),
+    ] {
         test_account_query(
             address,
             services.client(),
             order,
-            owner,
+            &owner.into_legacy(),
             contracts,
             ethflow_contract,
         )
@@ -821,18 +840,18 @@ impl From<CoWSwapEthFlow::CoWSwapEthFlow::ordersReturn> for EthFlowOrderOnchainS
 }
 
 pub struct EthFlowTradeIntent {
-    pub sell_amount: U256,
-    pub buy_token: H160,
-    pub receiver: H160,
+    pub sell_amount: alloy::primitives::U256,
+    pub buy_token: Address,
+    pub receiver: Address,
 }
 
 impl EthFlowTradeIntent {
     // How a user trade intent is converted into a quote request by the frontend
-    pub fn to_quote_request(&self, from: H160, weth: &WETH9::Instance) -> OrderQuoteRequest {
+    pub fn to_quote_request(&self, from: Address, weth: &WETH9::Instance) -> OrderQuoteRequest {
         OrderQuoteRequest {
             from,
             // Even if the user sells ETH, we request a quote for WETH
-            sell_token: weth.address().into_legacy(),
+            sell_token: *weth.address(),
             buy_token: self.buy_token,
             receiver: Some(self.receiver),
             validity: Validity::For(3600),
@@ -843,7 +862,7 @@ impl EthFlowTradeIntent {
             },
             side: OrderQuoteSide::Sell {
                 sell_amount: model::quote::SellAmount::AfterFee {
-                    value: NonZeroU256::try_from(self.sell_amount).unwrap(),
+                    value: NonZeroU256::try_from(self.sell_amount.into_legacy()).unwrap(),
                 },
             },
             buy_token_balance: BuyTokenDestination::Erc20,
@@ -898,7 +917,7 @@ async fn eth_flow_zero_buy_amount(web3: Web3) {
         test_order_availability_in_api(
             &services,
             &ethflow_order,
-            &trader.address(),
+            &trader.address().into_alloy(),
             onchain.contracts(),
             ethflow_contract,
         )

crates/e2e/tests/e2e/hooks.rs

@@ -647,9 +647,9 @@ async fn quote_verification(web3: Web3) {
 
     let quote = services
         .submit_quote(&OrderQuoteRequest {
-            from: trader.address(),
-            sell_token: token.address().into_legacy(),
-            buy_token: onchain.contracts().weth.address().into_legacy(),
+            from: trader.address().into_alloy(),
+            sell_token: *token.address(),
+            buy_token: *onchain.contracts().weth.address(),
             side: OrderQuoteSide::Sell {
                 sell_amount: SellAmount::BeforeFee {
                     value: NonZeroU256::try_from(to_wei(5)).unwrap(),

crates/e2e/tests/e2e/limit_orders.rs

@@ -734,9 +734,9 @@ async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) {
         .await;
 
     let quote_request = OrderQuoteRequest {
-        from: trader.address(),
-        sell_token: token.address().into_legacy(),
-        buy_token: onchain.contracts().weth.address().into_legacy(),
+        from: trader.address().into_alloy(),
+        sell_token: *token.address(),
+        buy_token: *onchain.contracts().weth.address(),
         side: OrderQuoteSide::Sell {
             sell_amount: SellAmount::BeforeFee {
                 value: NonZeroU256::try_from(to_wei(5)).unwrap(),
@@ -894,8 +894,8 @@ async fn forked_mainnet_single_limit_order_test(web3: Web3) {
     // may time out)
     let _ = services
         .submit_quote(&OrderQuoteRequest {
-            sell_token: token_usdc.address().into_legacy(),
-            buy_token: token_usdt.address().into_legacy(),
+            sell_token: *token_usdc.address(),
+            buy_token: *token_usdt.address(),
             side: OrderQuoteSide::Sell {
                 sell_amount: SellAmount::BeforeFee {
                     value: to_wei_with_exp(1000, 6).try_into().unwrap(),

crates/e2e/tests/e2e/order_cancellation.rs

@@ -1,10 +1,7 @@
 use {
     database::order_events::OrderEventLabel,
     e2e::setup::{eth, *},
-    ethrpc::alloy::{
-        CallBuilderExt,
-        conversions::{IntoAlloy, IntoLegacy},
-    },
+    ethrpc::alloy::{CallBuilderExt, conversions::IntoAlloy},
     model::{
         order::{
             CancellationPayload,
@@ -92,9 +89,9 @@ async fn order_cancellation(web3: Web3) {
         let trader = &trader;
 
         let request = OrderQuoteRequest {
-            from: trader.address(),
-            sell_token: token.address().into_legacy(),
-            buy_token: onchain.contracts().weth.address().into_legacy(),
+            from: trader.address().into_alloy(),
+            sell_token: *token.address(),
+            buy_token: *onchain.contracts().weth.address(),
             side: OrderQuoteSide::Sell {
                 sell_amount: SellAmount::AfterFee {
                     value: NonZeroU256::try_from(to_wei(1)).unwrap(),

crates/e2e/tests/e2e/place_order_with_quote.rs

@@ -63,9 +63,9 @@ async fn place_order_with_quote(web3: Web3) {
     tracing::info!("Quoting");
     let quote_sell_amount = to_wei(1);
     let quote_request = OrderQuoteRequest {
-        from: trader.address(),
-        sell_token: onchain.contracts().weth.address().into_legacy(),
-        buy_token: token.address().into_legacy(),
+        from: trader.address().into_alloy(),
+        sell_token: *onchain.contracts().weth.address(),
+        buy_token: *token.address(),
         side: OrderQuoteSide::Sell {
             sell_amount: SellAmount::BeforeFee {
                 value: NonZeroU256::try_from(quote_sell_amount).unwrap(),

crates/e2e/tests/e2e/protocol_fee.rs

@@ -606,8 +606,8 @@ async fn get_quote(
         },
     };
     let quote_request = OrderQuoteRequest {
-        sell_token,
-        buy_token,
+        sell_token: sell_token.into_alloy(),
+        buy_token: buy_token.into_alloy(),
         side,
         validity: Validity::To(valid_to),
         ..Default::default()