Migrate OrderMetadata and OnchainOrderData models to alloy

Author: jmg-duarte

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,
 };
 
@@ -26,7 +27,7 @@ pub fn to_domain(
         valid_to: order.data.valid_to,
         side: order.data.kind.into(),
         receiver: order.data.receiver.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

@@ -217,7 +217,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

@@ -444,16 +444,14 @@ async fn find_banned_user_orders(orders: &[Order], banned_users: &banned::Users)
     let banned = banned_users
         .banned(orders.iter().flat_map(|order| {
             std::iter::once(order.metadata.owner)
-                .chain(order.data.receiver)
-                .map(IntoAlloy::into_alloy)
+                .chain(order.data.receiver.map(IntoAlloy::into_alloy))
         }))
         .await;
     orders
         .iter()
         .filter_map(|order| {
             std::iter::once(order.metadata.owner)
-                .chain(order.data.receiver)
-                .map(IntoAlloy::into_alloy)
+                .chain(order.data.receiver.map(IntoAlloy::into_alloy))
                 .any(|addr| banned.contains(&addr))
                 .then_some(order.metadata.uid)
         })
@@ -1173,7 +1171,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().into_legacy()
@@ -616,7 +613,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
     }
@@ -687,7 +687,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>,
 }
 
@@ -697,7 +697,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>")]
@@ -714,18 +714,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.
@@ -1119,18 +1119,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

@@ -157,7 +157,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),
         buy_token: ByteArray(order.data.buy_token.0),
@@ -172,7 +172,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,
@@ -535,7 +535,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 {
@@ -545,7 +547,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)
@@ -563,12 +565,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,
@@ -641,7 +643,6 @@ mod tests {
                 SigningScheme as DbSigningScheme,
             },
         },
-        ethrpc::alloy::conversions::IntoAlloy,
         model::{
             interaction::InteractionData,
             order::{Order, OrderData, OrderMetadata, OrderStatus, OrderUid},
@@ -868,7 +869,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();
@@ -905,7 +906,7 @@ mod tests {
             .unwrap();
 
         let order_statuses = db
-            .user_orders(&owner.into_alloy(), 0, None)
+            .user_orders(&owner, 0, None)
             .await
             .unwrap()
             .iter()
@@ -934,7 +935,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();
@@ -1009,7 +1010,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,6 +13,7 @@ use {
     bigdecimal::ToPrimitive,
     chrono::Utc,
     database::order_events::OrderEventLabel,
+    ethrpc::alloy::conversions::IntoLegacy,
     model::{
         DomainSeparator,
         order::{
@@ -348,7 +349,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);
         };
 
@@ -378,7 +382,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);
         };
 
@@ -632,6 +636,7 @@ mod tests {
         super::*,
         crate::database::orders::MockOrderStoring,
         ethcontract::H160,
+        ethrpc::alloy::conversions::{IntoAlloy, IntoLegacy},
         mockall::predicate::eq,
         model::{
             order::{OrderData, OrderMetadata},
@@ -646,7 +651,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 {
@@ -674,7 +679,7 @@ mod tests {
                 Ok((
                     Order {
                         metadata: OrderMetadata {
-                            owner: creation.from.unwrap(),
+                            owner: creation.from.unwrap().into_alloy(),
                             uid: new_order_uid,
                             ..Default::default()
                         },
@@ -750,7 +755,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!(
@@ -769,7 +774,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!(

crates/shared/src/account_balances/mod.rs

@@ -6,7 +6,11 @@ use {
     alloy::sol_types::{SolCall, SolType, sol_data},
     contracts::alloy::{GPv2Settlement, support::Balances},
     ethcontract::state_overrides::StateOverrides,
-    ethrpc::{Web3, alloy::conversions::IntoAlloy, block_stream::CurrentBlockWatcher},
+    ethrpc::{
+        Web3,
+        alloy::conversions::{IntoAlloy, IntoLegacy},
+        block_stream::CurrentBlockWatcher,
+    },
     model::{
         interaction::InteractionData,
         order::{Order, SellTokenSource},
@@ -31,7 +35,7 @@ pub struct Query {
 impl Query {
     pub fn from_order(o: &Order) -> Self {
         Self {
-            owner: o.metadata.owner,
+            owner: o.metadata.owner.into_legacy(),
             token: o.data.sell_token,
             source: o.data.sell_token_balance,
             interactions: o.interactions.pre.clone(),

crates/shared/src/db_order_conversions.rs

@@ -57,7 +57,9 @@ pub fn full_order_into_model_order(order: database::orders::FullOrder) -> Result
     } 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 {
@@ -68,7 +70,7 @@ pub fn full_order_into_model_order(order: database::orders::FullOrder) -> Result
 
     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)
@@ -86,12 +88,12 @@ pub fn full_order_into_model_order(order: database::orders::FullOrder) -> Result
             .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,