Migrate model::OrderData to alloy (cowprotocol#3898)

My apologies for the long diff.

Migrating the endpoints requires migrating some of these structures
which leads to changes like this.
<!-- List of detailed changes (how the change is accomplished) -->

- [ ] Migrates the model::OrderData to alloy
- [ ] Refactors the code downstream from the struct
Existing tests

<!--

Fixes #
-->

Author: xdecentralix

crates/autopilot/src/boundary/order.rs

@@ -1,5 +1,6 @@
 use {
-    crate::{domain, domain::eth},
+    crate::domain::{self, eth},
+    ethrpc::alloy::conversions::IntoLegacy,
     shared::remaining_amounts,
 };
 
@@ -14,18 +15,22 @@ pub fn to_domain(
     domain::Order {
         uid: order.metadata.uid.into(),
         sell: eth::Asset {
-            token: order.data.sell_token.into(),
-            amount: order.data.sell_amount.into(),
+            token: order.data.sell_token.into_legacy().into(),
+            amount: order.data.sell_amount.into_legacy().into(),
         },
         buy: eth::Asset {
-            token: order.data.buy_token.into(),
-            amount: order.data.buy_amount.into(),
+            token: order.data.buy_token.into_legacy().into(),
+            amount: order.data.buy_amount.into_legacy().into(),
         },
         protocol_fees,
         created: u32::try_from(order.metadata.creation_date.timestamp()).unwrap_or(u32::MIN),
         valid_to: order.data.valid_to,
         side: order.data.kind.into(),
-        receiver: order.data.receiver.map(Into::into),
+        receiver: order
+            .data
+            .receiver
+            .map(IntoLegacy::into_legacy)
+            .map(Into::into),
         owner: order.metadata.owner.into(),
         partially_fillable: order.data.partially_fillable,
         executed: remaining_order.executed_amount.into(),

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

@@ -550,11 +550,11 @@ async fn get_quote(
     .map_err(|_| OnchainOrderPlacementError::Other)?;
 
     let parameters = QuoteSearchParameters {
-        sell_token: H160::from(order_data.sell_token.0),
-        buy_token: H160::from(order_data.buy_token.0),
-        sell_amount: order_data.sell_amount,
-        buy_amount: order_data.buy_amount,
-        fee_amount: order_data.fee_amount,
+        sell_token: order_data.sell_token.into_legacy(),
+        buy_token: order_data.buy_token.into_legacy(),
+        sell_amount: order_data.sell_amount.into_legacy(),
+        buy_amount: order_data.buy_amount.into_legacy(),
+        fee_amount: order_data.fee_amount.into_legacy(),
         kind: order_data.kind,
         signing_scheme: quote_signing_scheme,
         additional_gas: 0,
@@ -572,7 +572,7 @@ async fn get_quote(
         quoter,
         &parameters.clone(),
         Some(*quote_id),
-        Some(order_data.fee_amount),
+        Some(order_data.fee_amount.into_legacy()),
     )
     .await
     .map_err(|err| match err {
@@ -611,14 +611,14 @@ fn convert_onchain_order_placement(
         uid: ByteArray(order_uid.0),
         owner: ByteArray(owner.0),
         creation_timestamp: Utc.timestamp_opt(event_timestamp, 0).unwrap(),
-        sell_token: ByteArray(order_data.sell_token.0),
-        buy_token: ByteArray(order_data.buy_token.0),
-        receiver: order_data.receiver.map(|h160| ByteArray(h160.0)),
-        sell_amount: u256_to_big_decimal(&order_data.sell_amount),
-        buy_amount: u256_to_big_decimal(&order_data.buy_amount),
+        sell_token: ByteArray(order_data.sell_token.0.0),
+        buy_token: ByteArray(order_data.buy_token.0.0),
+        receiver: order_data.receiver.map(|addr| ByteArray(addr.0.0)),
+        sell_amount: u256_to_big_decimal(&order_data.sell_amount.into_legacy()),
+        buy_amount: u256_to_big_decimal(&order_data.buy_amount.into_legacy()),
         valid_to: order_data.valid_to as i64,
         app_data: ByteArray(order_data.app_data.0),
-        fee_amount: u256_to_big_decimal(&order_data.fee_amount),
+        fee_amount: u256_to_big_decimal(&order_data.fee_amount.into_legacy()),
         kind: order_kind_into(order_data.kind),
         partially_fillable: order_data.partially_fillable,
         signature: order_placement.signature.data.to_vec(),
@@ -662,14 +662,14 @@ fn extract_order_data_from_onchain_order_placement_event(
     };
 
     let order_data = OrderData {
-        sell_token: order_placement.order.sellToken.into_legacy(),
-        buy_token: order_placement.order.buyToken.into_legacy(),
-        receiver: receiver.map(IntoLegacy::into_legacy),
-        sell_amount: order_placement.order.sellAmount.into_legacy(),
-        buy_amount: order_placement.order.buyAmount.into_legacy(),
+        sell_token: order_placement.order.sellToken,
+        buy_token: order_placement.order.buyToken,
+        receiver,
+        sell_amount: order_placement.order.sellAmount,
+        buy_amount: order_placement.order.buyAmount,
         valid_to: order_placement.order.validTo,
         app_data: AppDataHash(order_placement.order.appData.0),
-        fee_amount: order_placement.order.feeAmount.into_legacy(),
+        fee_amount: order_placement.order.feeAmount,
         kind: OrderKind::from_contract_bytes(order_placement.order.kind.0)?,
         partially_fillable: order_placement.order.partiallyFillable,
         sell_token_balance: SellTokenSource::from_contract_bytes(
@@ -793,7 +793,10 @@ mod test {
             order::{BuyTokenDestination, OrderData, OrderKind, SellTokenSource},
             signature::SigningScheme,
         },
-        number::conversions::u256_to_big_decimal,
+        number::conversions::{
+            alloy::u256_to_big_decimal as alloy_u256_to_big_decimal,
+            u256_to_big_decimal,
+        },
         shared::{
             db_order_conversions::{
                 buy_token_destination_into,
@@ -856,14 +859,14 @@ mod test {
             )
             .unwrap();
         let expected_order_data = OrderData {
-            sell_token: sellToken.into_legacy(),
-            buy_token: buyToken.into_legacy(),
-            receiver: Some(receiver.into_legacy()),
-            sell_amount: sellAmount.into_legacy(),
-            buy_amount: buyAmount.into_legacy(),
+            sell_token: sellToken,
+            buy_token: buyToken,
+            receiver: Some(receiver),
+            sell_amount: sellAmount,
+            buy_amount: buyAmount,
             valid_to: validTo,
             app_data: AppDataHash(appData.0),
-            fee_amount: feeAmount.into_legacy(),
+            fee_amount: feeAmount,
             kind: OrderKind::Sell,
             partially_fillable: order_placement.order.partiallyFillable,
             sell_token_balance: SellTokenSource::Erc20,
@@ -906,14 +909,14 @@ mod test {
             )
             .unwrap();
         let expected_order_data = OrderData {
-            sell_token: sellToken.into_legacy(),
-            buy_token: buyToken.into_legacy(),
+            sell_token: sellToken,
+            buy_token: buyToken,
             receiver: None,
-            sell_amount: sellAmount.into_legacy(),
-            buy_amount: buyAmount.into_legacy(),
+            sell_amount: sellAmount,
+            buy_amount: buyAmount,
             valid_to: validTo,
             app_data: AppDataHash(appData.0),
-            fee_amount: feeAmount.into_legacy(),
+            fee_amount: feeAmount,
             kind: OrderKind::Sell,
             partially_fillable: order_placement.order.partiallyFillable,
             sell_token_balance: SellTokenSource::Erc20,
@@ -938,14 +941,14 @@ mod test {
         let owner = Address::from([5; 20]);
 
         let order_data = OrderData {
-            sell_token: sell_token.into_legacy(),
-            buy_token: buy_token.into_legacy(),
-            receiver: Some(receiver.into_legacy()),
-            sell_amount: sell_amount.into_legacy(),
-            buy_amount: buy_amount.into_legacy(),
+            sell_token,
+            buy_token,
+            receiver: Some(receiver),
+            sell_amount,
+            buy_amount,
             valid_to,
             app_data: AppDataHash(app_data),
-            fee_amount: fee_amount.into_legacy(),
+            fee_amount,
             kind: OrderKind::Sell,
             partially_fillable: false,
             sell_token_balance: SellTokenSource::Erc20,
@@ -992,14 +995,14 @@ mod test {
             Metrics::get(),
         );
         let expected_order_data = OrderData {
-            sell_token: sell_token.into_legacy(),
-            buy_token: buy_token.into_legacy(),
-            receiver: Some(receiver.into_legacy()),
-            sell_amount: sell_amount.into_legacy(),
-            buy_amount: buy_amount.into_legacy(),
+            sell_token,
+            buy_token,
+            receiver: Some(receiver),
+            sell_amount,
+            buy_amount,
             valid_to,
             app_data: AppDataHash(app_data),
-            fee_amount: fee_amount.into_legacy(),
+            fee_amount,
             kind: OrderKind::Sell,
             partially_fillable: order_placement.order.partiallyFillable,
             sell_token_balance: SellTokenSource::Erc20,
@@ -1015,14 +1018,14 @@ mod test {
             owner: ByteArray(owner.into_legacy().0),
             creation_timestamp: order.creation_timestamp, /* Using the actual result to keep test
                                                            * simple */
-            sell_token: ByteArray(expected_order_data.sell_token.0),
-            buy_token: ByteArray(expected_order_data.buy_token.0),
-            receiver: expected_order_data.receiver.map(|h160| ByteArray(h160.0)),
-            sell_amount: u256_to_big_decimal(&expected_order_data.sell_amount),
-            buy_amount: u256_to_big_decimal(&expected_order_data.buy_amount),
+            sell_token: ByteArray(expected_order_data.sell_token.0.0),
+            buy_token: ByteArray(expected_order_data.buy_token.0.0),
+            receiver: expected_order_data.receiver.map(|addr| ByteArray(addr.0.0)),
+            sell_amount: alloy_u256_to_big_decimal(&expected_order_data.sell_amount),
+            buy_amount: alloy_u256_to_big_decimal(&expected_order_data.buy_amount),
             valid_to: expected_order_data.valid_to as i64,
             app_data: ByteArray(expected_order_data.app_data.0),
-            fee_amount: u256_to_big_decimal(&expected_order_data.fee_amount),
+            fee_amount: alloy_u256_to_big_decimal(&expected_order_data.fee_amount),
             kind: order_kind_into(expected_order_data.kind),
             class: OrderClass::Market,
             partially_fillable: expected_order_data.partially_fillable,
@@ -1050,14 +1053,14 @@ mod test {
         let fee_amount = U256::from(0);
         let owner = Address::from([5; 20]);
         let order_data = OrderData {
-            sell_token: sell_token.into_legacy(),
-            buy_token: buy_token.into_legacy(),
-            receiver: Some(receiver.into_legacy()),
-            sell_amount: sell_amount.into_legacy(),
-            buy_amount: buy_amount.into_legacy(),
+            sell_token,
+            buy_token,
+            receiver: Some(receiver),
+            sell_amount,
+            buy_amount,
             valid_to,
             app_data: AppDataHash(app_data),
-            fee_amount: fee_amount.into_legacy(),
+            fee_amount,
             kind: OrderKind::Sell,
             partially_fillable: false,
             sell_token_balance: SellTokenSource::Erc20,
@@ -1106,14 +1109,14 @@ mod test {
             Metrics::get(),
         );
         let expected_order_data = OrderData {
-            sell_token: sell_token.into_legacy(),
-            buy_token: buy_token.into_legacy(),
-            receiver: Some(receiver.into_legacy()),
-            sell_amount: sell_amount.into_legacy(),
-            buy_amount: buy_amount.into_legacy(),
+            sell_token,
+            buy_token,
+            receiver: Some(receiver),
+            sell_amount,
+            buy_amount,
             valid_to,
             app_data: AppDataHash(app_data),
-            fee_amount: 0.into(),
+            fee_amount: alloy::primitives::U256::ZERO,
             kind: OrderKind::Sell,
             partially_fillable: order_placement.order.partiallyFillable,
             sell_token_balance: SellTokenSource::Erc20,
@@ -1129,11 +1132,11 @@ mod test {
             owner: ByteArray(owner.into_legacy().0),
             creation_timestamp: order.creation_timestamp, /* Using the actual result to keep test
                                                            * simple */
-            sell_token: ByteArray(expected_order_data.sell_token.0),
-            buy_token: ByteArray(expected_order_data.buy_token.0),
-            receiver: expected_order_data.receiver.map(|h160| ByteArray(h160.0)),
-            sell_amount: u256_to_big_decimal(&expected_order_data.sell_amount),
-            buy_amount: u256_to_big_decimal(&expected_order_data.buy_amount),
+            sell_token: ByteArray(expected_order_data.sell_token.0.0),
+            buy_token: ByteArray(expected_order_data.buy_token.0.0),
+            receiver: expected_order_data.receiver.map(|addr| ByteArray(addr.0.0)),
+            sell_amount: alloy_u256_to_big_decimal(&expected_order_data.sell_amount),
+            buy_amount: alloy_u256_to_big_decimal(&expected_order_data.buy_amount),
             valid_to: expected_order_data.valid_to as i64,
             app_data: ByteArray(expected_order_data.app_data.0),
             fee_amount: u256_to_big_decimal(&fee_amount.into_legacy()),
@@ -1278,14 +1281,14 @@ mod test {
             .await
             .unwrap();
         let expected_order_data = OrderData {
-            sell_token: sell_token.into_legacy(),
-            buy_token: buy_token.into_legacy(),
-            receiver: Some(receiver.into_legacy()),
-            sell_amount: sell_amount.into_legacy(),
-            buy_amount: buy_amount.into_legacy(),
+            sell_token,
+            buy_token,
+            receiver: Some(receiver),
+            sell_amount,
+            buy_amount,
             valid_to,
             app_data: AppDataHash(app_data),
-            fee_amount: fee_amount.into_legacy(),
+            fee_amount,
             kind: OrderKind::Sell,
             partially_fillable: order_placement.order.partiallyFillable,
             sell_token_balance: SellTokenSource::Erc20,

crates/autopilot/src/domain/fee/mod.rs

@@ -231,9 +231,9 @@ impl ProtocolFees {
         // being considered out of market price.
         let reference_quote = quote.clone().unwrap_or(domain::Quote {
             order_uid: order.metadata.uid.into(),
-            sell_amount: order.data.sell_amount.into(),
+            sell_amount: order.data.sell_amount.into_legacy().into(),
             buy_amount: U256::ZERO.into_legacy().into(),
-            fee: order.data.fee_amount.into(),
+            fee: order.data.fee_amount.into_legacy().into(),
             solver: Address::ZERO,
         });
 

crates/autopilot/src/domain/settlement/transaction/tokenized.rs

@@ -22,17 +22,15 @@ pub fn order_uid(
 
     let order = model::order::OrderData {
         sell_token: tokens
-            [usize::try_from(trade.sellTokenIndex).expect("SC was able to look up this index")]
-        .into_legacy(),
+            [usize::try_from(trade.sellTokenIndex).expect("SC was able to look up this index")],
         buy_token: tokens
-            [usize::try_from(trade.buyTokenIndex).expect("SC was able to look up this index")]
-        .into_legacy(),
-        receiver: Some(trade.receiver.into_legacy()),
-        sell_amount: trade.sellAmount.into_legacy(),
-        buy_amount: trade.buyAmount.into_legacy(),
+            [usize::try_from(trade.buyTokenIndex).expect("SC was able to look up this index")],
+        receiver: Some(trade.receiver),
+        sell_amount: trade.sellAmount,
+        buy_amount: trade.buyAmount,
         valid_to: trade.validTo,
         app_data: AppDataHash(trade.appData.0),
-        fee_amount: trade.feeAmount.into_legacy(),
+        fee_amount: trade.feeAmount,
         kind: match flags.side() {
             domain::auction::order::Side::Buy => model::order::OrderKind::Buy,
             domain::auction::order::Side::Sell => model::order::OrderKind::Sell,

crates/autopilot/src/infra/persistence/mod.rs

@@ -27,7 +27,7 @@ use {
         SigningScheme as DomainSigningScheme,
     },
     futures::{StreamExt, TryStreamExt},
-    number::conversions::{big_decimal_to_u256, u256_to_big_decimal, u256_to_big_uint},
+    number::conversions::{alloy::u256_to_big_uint, big_decimal_to_u256, u256_to_big_decimal},
     primitive_types::H256,
     shared::db_order_conversions::full_order_into_model_order,
     std::{