Migrate orderbook::quoter into alloy

crates/autopilot/src/boundary/order.rs

@@ -31,7 +31,7 @@ pub fn to_domain(
             .receiver
             .map(IntoLegacy::into_legacy)
             .map(Into::into),
-        owner: order.metadata.owner.into(),
+        owner: order.metadata.owner.into_legacy().into(),
         partially_fillable: order.data.partially_fillable,
         executed: remaining_order.executed_amount.into(),
         pre_interactions: if order_is_untouched {

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

@@ -240,7 +240,7 @@ impl ProtocolFees {
         let partner_fee =
             Self::get_partner_fee(&order, &reference_quote, self.max_partner_fee.into());
 
-        if surplus_capturing_jit_order_owners.contains(&order.metadata.owner.into()) {
+        if surplus_capturing_jit_order_owners.contains(&order.metadata.owner.into_legacy().into()) {
             return boundary::order::to_domain(order, partner_fee, quote);
         }
 

crates/autopilot/src/solvable_orders.rs

@@ -453,14 +453,16 @@ impl SolvableOrdersCache {
 /// users.
 async fn find_banned_user_orders(orders: &[Order], banned_users: &banned::Users) -> Vec<OrderUid> {
     let banned = banned_users
-        .banned(orders.iter().flat_map(|order| {
-            std::iter::once(order.metadata.owner.into_alloy()).chain(order.data.receiver)
-        }))
+        .banned(
+            orders
+                .iter()
+                .flat_map(|order| std::iter::once(order.metadata.owner).chain(order.data.receiver)),
+        )
         .await;
     orders
         .iter()
         .filter_map(|order| {
-            std::iter::once(order.metadata.owner.into_alloy())
+            std::iter::once(order.metadata.owner)
                 .chain(order.data.receiver)
                 .any(|addr| banned.contains(&addr))
                 .then_some(order.metadata.uid)
@@ -1206,7 +1208,7 @@ mod tests {
         .enumerate()
         .map(|(i, owner)| Order {
             metadata: OrderMetadata {
-                owner,
+                owner: owner.into_alloy(),
                 uid: OrderUid([i as u8; 56]),
                 ..Default::default()
             },

crates/e2e/tests/e2e/ethflow.rs

@@ -596,10 +596,7 @@ async fn test_order_parameters(
 ) {
     // Expected values from actual EIP1271 order instead of eth-flow order
     assert_eq!(response.data.valid_to, u32::MAX);
-    assert_eq!(
-        response.metadata.owner,
-        ethflow_contract.address().into_legacy()
-    );
+    assert_eq!(response.metadata.owner, *ethflow_contract.address());
     assert_eq!(response.data.sell_token, *contracts.weth.address());
 
     // Specific parameters return the missing values
@@ -613,7 +610,7 @@ async fn test_order_parameters(
     assert_eq!(
         response.metadata.onchain_order_data,
         Some(OnchainOrderData {
-            sender: *owner,
+            sender: owner.into_alloy(),
             placement_error: None,
         })
     );

crates/model/src/order.rs

@@ -161,7 +161,7 @@ impl OrderBuilder {
         domain: &DomainSeparator,
         key: SecretKeyRef,
     ) -> Self {
-        self.0.metadata.owner = key.address();
+        self.0.metadata.owner = Address::new(key.address().0);
         self.0.metadata.uid = self.0.data.uid(domain, &key.address());
         self.0.signature =
             EcdsaSignature::sign(signing_scheme, domain, &self.0.data.hash_struct(), key)
@@ -170,13 +170,13 @@ impl OrderBuilder {
     }
 
     pub fn with_eip1271(mut self, owner: H160, signature: Vec<u8>) -> Self {
-        self.0.metadata.owner = owner;
+        self.0.metadata.owner = Address::new(owner.0);
         self.0.signature = Signature::Eip1271(signature);
         self
     }
 
     pub fn with_presign(mut self, owner: H160) -> Self {
-        self.0.metadata.owner = owner;
+        self.0.metadata.owner = Address::new(owner.0);
         self.0.signature = Signature::PreSign;
         self
     }
@@ -707,7 +707,7 @@ pub enum OnchainOrderPlacementError {
 #[derive(Eq, PartialEq, Clone, Default, Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct OnchainOrderData {
-    pub sender: H160,
+    pub sender: Address,
     pub placement_error: Option<OnchainOrderPlacementError>,
 }
 
@@ -717,7 +717,7 @@ pub struct OnchainOrderData {
 #[serde(rename_all = "camelCase")]
 pub struct OrderMetadata {
     pub creation_date: DateTime<Utc>,
-    pub owner: H160,
+    pub owner: Address,
     pub uid: OrderUid,
     /// deprecated, always set to null
     #[serde_as(as = "Option<HexOrDecimalU256>")]
@@ -734,18 +734,18 @@ pub struct OrderMetadata {
     pub executed_fee_amount: U256,
     #[serde_as(as = "HexOrDecimalU256")]
     pub executed_fee: U256,
-    pub executed_fee_token: H160,
+    pub executed_fee_token: Address,
     pub invalidated: bool,
     pub status: OrderStatus,
     #[serde(flatten)]
     pub class: OrderClass,
-    pub settlement_contract: H160,
+    pub settlement_contract: Address,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub ethflow_data: Option<EthflowData>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub onchain_order_data: Option<OnchainOrderData>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub onchain_user: Option<H160>,
+    pub onchain_user: Option<Address>,
     pub is_liquidity_order: bool,
     /// Full app data that `OrderData::app_data` is a hash of. Can be None if
     /// the backend doesn't know about the full app data.
@@ -1139,18 +1139,18 @@ mod tests {
             metadata: OrderMetadata {
                 creation_date: Utc.timestamp_millis_opt(3_000).unwrap(),
                 class: OrderClass::Limit,
-                owner: H160::from_low_u64_be(1),
+                owner: Address::with_last_byte(1),
                 uid: OrderUid([17u8; 56]),
                 available_balance: None,
                 executed_buy_amount: BigUint::from_bytes_be(&[3]),
                 executed_sell_amount: BigUint::from_bytes_be(&[5]),
                 executed_sell_amount_before_fees: 4.into(),
                 executed_fee_amount: 1.into(),
                 executed_fee: 1.into(),
-                executed_fee_token: H160::from_low_u64_be(10),
+                executed_fee_token: Address::with_last_byte(10),
                 invalidated: true,
                 status: OrderStatus::Open,
-                settlement_contract: H160::from_low_u64_be(2),
+                settlement_contract: Address::with_last_byte(2),
                 full_app_data: Some("123".to_string()),
                 ..Default::default()
             },

crates/orderbook/src/database/orders.rs

@@ -165,7 +165,7 @@ async fn insert_order(order: &Order, ex: &mut PgConnection) -> Result<(), Insert
 
     let db_order = database::orders::Order {
         uid: order_uid,
-        owner: ByteArray(order.metadata.owner.0),
+        owner: ByteArray(order.metadata.owner.0.0),
         creation_timestamp: order.metadata.creation_date,
         sell_token: ByteArray(order.data.sell_token.0.0),
         buy_token: ByteArray(order.data.buy_token.0.0),
@@ -180,7 +180,7 @@ async fn insert_order(order: &Order, ex: &mut PgConnection) -> Result<(), Insert
         partially_fillable: order.data.partially_fillable,
         signature: order.signature.to_bytes(),
         signing_scheme: signing_scheme_into(order.signature.scheme()),
-        settlement_contract: ByteArray(order.metadata.settlement_contract.0),
+        settlement_contract: ByteArray(order.metadata.settlement_contract.0.0),
         sell_token_balance: sell_token_source_into(order.data.sell_token_balance),
         buy_token_balance: buy_token_destination_into(order.data.buy_token_balance),
         cancellation_timestamp: None,
@@ -543,7 +543,9 @@ fn full_order_with_quote_into_model_order(
     } else {
         None
     };
-    let onchain_user = order.onchain_user.map(|onchain_user| H160(onchain_user.0));
+    let onchain_user = order
+        .onchain_user
+        .map(|onchain_user| Address::new(onchain_user.0));
     let class = order_class_from(&order);
     let onchain_placement_error = onchain_order_placement_error_from(&order);
     let onchain_order_data = onchain_user.map(|onchain_user| OnchainOrderData {
@@ -553,7 +555,7 @@ fn full_order_with_quote_into_model_order(
 
     let metadata = OrderMetadata {
         creation_date: order.creation_timestamp,
-        owner: H160(order.owner.0),
+        owner: Address::new(order.owner.0),
         uid: OrderUid(order.uid.0),
         available_balance: Default::default(),
         executed_buy_amount: big_decimal_to_big_uint(&order.sum_buy)
@@ -571,12 +573,12 @@ fn full_order_with_quote_into_model_order(
             .context("executed fee amount is not a valid u256")?,
         executed_fee: big_decimal_to_u256(&order.executed_fee)
             .context("executed fee is not a valid u256")?,
-        executed_fee_token: H160(order.executed_fee_token.0),
+        executed_fee_token: Address::new(order.executed_fee_token.0),
         invalidated: order.invalidated,
         status,
         is_liquidity_order: class == OrderClass::Liquidity,
         class,
-        settlement_contract: H160(order.settlement_contract.0),
+        settlement_contract: Address::new(order.settlement_contract.0),
         ethflow_data,
         onchain_user,
         onchain_order_data,
@@ -652,7 +654,6 @@ mod tests {
                 SigningScheme as DbSigningScheme,
             },
         },
-        ethrpc::alloy::conversions::IntoAlloy,
         model::{
             interaction::InteractionData,
             order::{Order, OrderData, OrderMetadata, OrderStatus, OrderUid},
@@ -879,7 +880,7 @@ mod tests {
     #[tokio::test]
     #[ignore]
     async fn postgres_replace_order() {
-        let owner = H160([0x77; 20]);
+        let owner = Address::repeat_byte(0x77);
 
         let db = Postgres::try_new("postgresql://").unwrap();
         database::clear_DANGER(&db.pool).await.unwrap();
@@ -916,7 +917,7 @@ mod tests {
             .unwrap();
 
         let order_statuses = db
-            .user_orders(&owner.into_alloy(), 0, None)
+            .user_orders(&owner, 0, None)
             .await
             .unwrap()
             .iter()
@@ -945,7 +946,7 @@ mod tests {
     #[tokio::test]
     #[ignore]
     async fn postgres_replace_order_no_cancellation_on_error() {
-        let owner = H160([0x77; 20]);
+        let owner = Address::repeat_byte(0x77);
 
         let db = Postgres::try_new("postgresql://").unwrap();
         database::clear_DANGER(&db.pool).await.unwrap();
@@ -1020,7 +1021,7 @@ mod tests {
         let insert_presignature = |signed: bool| {
             let db = db.clone();
             let block_number = &block_number;
-            let owner = order.metadata.owner.as_bytes();
+            let owner = order.metadata.owner.as_slice();
             async move {
                 sqlx::query(
                     "INSERT INTO presignature_events (block_number, log_index, owner, order_uid, \

crates/orderbook/src/orderbook.rs

@@ -13,7 +13,7 @@ use {
     bigdecimal::ToPrimitive,
     chrono::Utc,
     database::order_events::OrderEventLabel,
-    ethrpc::alloy::conversions::IntoLegacy,
+    ethrpc::alloy::conversions::{IntoAlloy, IntoLegacy},
     model::{
         DomainSeparator,
         order::{
@@ -29,7 +29,6 @@ use {
         solver_competition::{self, SolverCompetitionAPI},
     },
     observe::metrics::LivenessChecking,
-    primitive_types::H160,
     shared::{
         fee::FeeParameters,
         order_quoting::Quote,
@@ -217,21 +216,21 @@ pub enum OrderReplacementError {
 #[derive(Debug)]
 pub struct QuoteMetadata {
     pub id: Option<QuoteId>,
-    pub solver: H160,
+    pub solver: Address,
 }
 
 impl From<&Quote> for QuoteMetadata {
     fn from(value: &Quote) -> Self {
         Self {
             id: value.id,
-            solver: value.data.solver,
+            solver: value.data.solver.into_alloy(),
         }
     }
 }
 
 pub struct Orderbook {
     domain_separator: DomainSeparator,
-    settlement_contract: H160,
+    settlement_contract: Address,
     database: crate::database::Postgres,
     database_replica: crate::database::Postgres,
     order_validator: Arc<dyn OrderValidating>,
@@ -242,7 +241,7 @@ pub struct Orderbook {
 impl Orderbook {
     pub fn new(
         domain_separator: DomainSeparator,
-        settlement_contract: H160,
+        settlement_contract: Address,
         database: crate::database::Postgres,
         database_replica: crate::database::Postgres,
         order_validator: Arc<dyn OrderValidating>,
@@ -287,7 +286,7 @@ impl Orderbook {
             .validate_and_construct_order(
                 payload,
                 &self.domain_separator,
-                self.settlement_contract,
+                self.settlement_contract.into_legacy(),
                 full_app_data_override,
             )
             .await?;
@@ -349,7 +348,10 @@ impl Orderbook {
         let signer = cancellation
             .validate(&self.domain_separator)
             .map_err(|_| OrderCancellationError::InvalidSignature)?;
-        if orders.iter().any(|order| signer != order.metadata.owner) {
+        if orders
+            .iter()
+            .any(|order| signer != order.metadata.owner.into_legacy())
+        {
             return Err(OrderCancellationError::WrongOwner);
         };
 
@@ -379,7 +381,7 @@ impl Orderbook {
         let signer = cancellation
             .validate(&self.domain_separator)
             .map_err(|_| OrderCancellationError::InvalidSignature)?;
-        if signer != order.metadata.owner {
+        if signer != order.metadata.owner.into_legacy() {
             return Err(OrderCancellationError::WrongOwner);
         };
 
@@ -633,6 +635,7 @@ mod tests {
         super::*,
         crate::database::orders::MockOrderStoring,
         ethcontract::H160,
+        ethrpc::alloy::conversions::{IntoAlloy, IntoLegacy},
         mockall::predicate::eq,
         model::{
             order::{OrderData, OrderMetadata},
@@ -647,7 +650,7 @@ mod tests {
         let old_order = Order {
             metadata: OrderMetadata {
                 uid: OrderUid([1; 56]),
-                owner: H160([1; 20]),
+                owner: Address::new([1; 20]),
                 ..Default::default()
             },
             data: OrderData {
@@ -675,7 +678,7 @@ mod tests {
                 Ok((
                     Order {
                         metadata: OrderMetadata {
-                            owner: creation.from.unwrap(),
+                            owner: creation.from.unwrap().into_alloy(),
                             uid: new_order_uid,
                             ..Default::default()
                         },
@@ -702,7 +705,7 @@ mod tests {
             database_replica,
             order_validator: Arc::new(order_validator),
             domain_separator: Default::default(),
-            settlement_contract: H160([0xba; 20]),
+            settlement_contract: Address::repeat_byte(0xba),
             app_data,
             active_order_competition_threshold: Default::default(),
         };
@@ -751,7 +754,7 @@ mod tests {
         assert!(matches!(
             orderbook
                 .add_order(OrderCreation {
-                    from: Some(old_order.metadata.owner),
+                    from: Some(old_order.metadata.owner.into_legacy()),
                     signature: Signature::PreSign,
                     app_data: OrderCreationAppData::Full {
                         full: format!(
@@ -770,7 +773,7 @@ mod tests {
         // Stars align...
         let (order_id, _) = orderbook
             .add_order(OrderCreation {
-                from: Some(old_order.metadata.owner),
+                from: Some(old_order.metadata.owner.into_legacy()),
                 signature: Signature::Eip712(Default::default()),
                 app_data: OrderCreationAppData::Full {
                     full: format!(