Migrate settlement part 2 (#3834)

# Description
Follow up to #3830
completely migrating the settlement contract to alloy

Author: MartinquaXD

crates/autopilot/src/boundary/events/settlement.rs

@@ -1,12 +1,36 @@
 use {
     crate::{database::Postgres, domain::settlement},
+    alloy::{
+        primitives::Address,
+        rpc::types::{Filter, Log},
+    },
     anyhow::Result,
-    ethrpc::block_stream::RangeInclusive,
-    shared::{event_handling::EventStoring, impl_event_retrieving},
+    contracts::alloy::GPv2Settlement::GPv2Settlement::GPv2SettlementEvents,
+    ethrpc::{AlloyProvider, block_stream::RangeInclusive},
+    shared::event_handling::{AlloyEventRetrieving, EventStoring},
 };
 
-impl_event_retrieving! {
-    pub GPv2SettlementContract for contracts::gpv2_settlement
+pub struct GPv2SettlementContract {
+    provider: AlloyProvider,
+    address: Address,
+}
+
+impl GPv2SettlementContract {
+    pub fn new(provider: AlloyProvider, address: Address) -> Self {
+        Self { provider, address }
+    }
+}
+
+impl AlloyEventRetrieving for GPv2SettlementContract {
+    type Event = GPv2SettlementEvents;
+
+    fn filter(&self) -> alloy::rpc::types::Filter {
+        Filter::new().address(self.address)
+    }
+
+    fn provider(&self) -> &contracts::alloy::Provider {
+        &self.provider
+    }
 }
 
 pub struct Indexer {
@@ -29,7 +53,7 @@ impl Indexer {
 pub(crate) const INDEX_NAME: &str = "settlements";
 
 #[async_trait::async_trait]
-impl EventStoring<ethcontract::Event<contracts::gpv2_settlement::Event>> for Indexer {
+impl EventStoring<(GPv2SettlementEvents, Log)> for Indexer {
     async fn last_event_block(&self) -> Result<u64> {
         super::read_last_block_from_db(&self.db.pool, INDEX_NAME)
             .await
@@ -42,7 +66,7 @@ impl EventStoring<ethcontract::Event<contracts::gpv2_settlement::Event>> for Ind
 
     async fn replace_events(
         &mut self,
-        events: Vec<ethcontract::Event<contracts::gpv2_settlement::Event>>,
+        events: Vec<(GPv2SettlementEvents, Log)>,
         range: RangeInclusive<u64>,
     ) -> Result<()> {
         let mut transaction = self.db.pool.begin().await?;
@@ -55,10 +79,7 @@ impl EventStoring<ethcontract::Event<contracts::gpv2_settlement::Event>> for Ind
         Ok(())
     }
 
-    async fn append_events(
-        &mut self,
-        events: Vec<ethcontract::Event<contracts::gpv2_settlement::Event>>,
-    ) -> Result<()> {
+    async fn append_events(&mut self, events: Vec<(GPv2SettlementEvents, Log)>) -> Result<()> {
         let mut transaction = self.db.pool.begin().await?;
         crate::database::events::append_events(&mut transaction, events).await?;
         transaction.commit().await?;

crates/autopilot/src/database/events.rs

@@ -1,51 +1,86 @@
 use {
     alloy::rpc::types::Log,
-    anyhow::{Context, Result, anyhow},
-    contracts::gpv2_settlement::{
-        Event as ContractEvent,
-        event_data::{
-            OrderInvalidated as ContractInvalidation,
-            PreSignature as ContractPreSignature,
-            Settlement as ContractSettlement,
-            Trade as ContractTrade,
-        },
-    },
+    anyhow::{Context, Result},
+    contracts::alloy::GPv2Settlement::GPv2Settlement::{self, GPv2SettlementEvents},
     database::{
         OrderUid,
         PgTransaction,
+        TransactionHash,
         byte_array::ByteArray,
         events::{Event, EventIndex, Invalidation, PreSignature, Settlement, Trade},
     },
-    ethcontract::{Event as EthContractEvent, EventMetadata},
+    ethcontract::EventMetadata,
+    ethrpc::alloy::conversions::IntoLegacy,
     number::conversions::u256_to_big_decimal,
     std::convert::TryInto,
 };
 
 pub fn contract_to_db_events(
-    contract_events: Vec<EthContractEvent<ContractEvent>>,
+    contract_events: Vec<(GPv2SettlementEvents, Log)>,
 ) -> Result<Vec<(EventIndex, Event)>> {
     contract_events
         .into_iter()
-        .filter_map(|EthContractEvent { data, meta }| {
-            let meta = match meta {
-                Some(meta) => meta,
-                None => return Some(Err(anyhow!("event without metadata"))),
-            };
-            match data {
-                ContractEvent::Trade(event) => Some(convert_trade(&event, &meta)),
-                ContractEvent::Settlement(event) => Some(Ok(convert_settlement(&event, &meta))),
-                ContractEvent::OrderInvalidated(event) => Some(convert_invalidation(&event, &meta)),
-                ContractEvent::PreSignature(event) => Some(convert_presignature(&event, &meta)),
+        .filter_map(|(event, log)| {
+            let log = ValidatedLog::try_from(log).ok()?;
+            match event {
+                GPv2SettlementEvents::Trade(event) => Some(convert_trade(&event, log)),
+                GPv2SettlementEvents::Settlement(event) => {
+                    Some(Ok(convert_settlement(&event, log)))
+                }
+                GPv2SettlementEvents::OrderInvalidated(event) => {
+                    Some(convert_invalidation(&event, log))
+                }
+                GPv2SettlementEvents::PreSignature(event) => {
+                    Some(convert_presignature(&event, log))
+                }
                 // TODO: handle new events
-                ContractEvent::Interaction(_) => None,
+                GPv2SettlementEvents::Interaction(_) => None,
             }
         })
         .collect::<Result<Vec<_>>>()
 }
 
+struct ValidatedLog {
+    block: i64,
+    tx_hash: TransactionHash,
+    log_index: i64,
+}
+
+impl TryFrom<Log> for ValidatedLog {
+    type Error = anyhow::Error;
+
+    fn try_from(log: Log) -> std::result::Result<Self, Self::Error> {
+        Ok(Self {
+            block: log
+                .block_number
+                .context("missing block_number")?
+                .try_into()
+                .context("could not convert block number to i64")?,
+            tx_hash: log
+                .transaction_hash
+                .map(|hash| ByteArray(hash.0))
+                .context("missing transaction_hash")?,
+            log_index: log
+                .log_index
+                .context("missing log_index")?
+                .try_into()
+                .context("could not convert log index to i64")?,
+        })
+    }
+}
+
+impl From<ValidatedLog> for EventIndex {
+    fn from(value: ValidatedLog) -> Self {
+        Self {
+            block_number: value.block,
+            log_index: value.log_index,
+        }
+    }
+}
+
 pub async fn append_events(
     transaction: &mut PgTransaction<'_>,
-    events: Vec<EthContractEvent<ContractEvent>>,
+    events: Vec<(GPv2SettlementEvents, Log)>,
 ) -> Result<()> {
     let _timer = super::Metrics::get()
         .database_queries
@@ -61,7 +96,7 @@ pub async fn append_events(
 
 pub async fn replace_events(
     transaction: &mut PgTransaction<'_>,
-    events: Vec<EthContractEvent<ContractEvent>>,
+    events: Vec<(GPv2SettlementEvents, Log)>,
     from_block: u64,
 ) -> Result<()> {
     let _timer = super::Metrics::get()
@@ -100,52 +135,45 @@ pub fn bytes_to_order_uid(bytes: &[u8]) -> Result<OrderUid> {
         .map(ByteArray)
 }
 
-fn convert_trade(trade: &ContractTrade, meta: &EventMetadata) -> Result<(EventIndex, Event)> {
+fn convert_trade(trade: &GPv2Settlement::Trade, log: ValidatedLog) -> Result<(EventIndex, Event)> {
     let event = Trade {
-        order_uid: bytes_to_order_uid(&trade.order_uid.0)?,
-        sell_amount_including_fee: u256_to_big_decimal(&trade.sell_amount),
-        buy_amount: u256_to_big_decimal(&trade.buy_amount),
-        fee_amount: u256_to_big_decimal(&trade.fee_amount),
+        order_uid: bytes_to_order_uid(&trade.orderUid.0)?,
+        sell_amount_including_fee: u256_to_big_decimal(&trade.sellAmount.into_legacy()),
+        buy_amount: u256_to_big_decimal(&trade.buyAmount.into_legacy()),
+        fee_amount: u256_to_big_decimal(&trade.feeAmount.into_legacy()),
     };
-    Ok((meta_to_event_index(meta), Event::Trade(event)))
+    Ok((log.into(), Event::Trade(event)))
 }
 
 fn convert_settlement(
-    settlement: &ContractSettlement,
-    meta: &EventMetadata,
+    settlement: &GPv2Settlement::Settlement,
+    log: ValidatedLog,
 ) -> (EventIndex, Event) {
     let event = Settlement {
-        solver: ByteArray(settlement.solver.0),
-        transaction_hash: ByteArray(meta.transaction_hash.0),
+        solver: ByteArray(settlement.solver.into()),
+        transaction_hash: log.tx_hash,
     };
-    (meta_to_event_index(meta), Event::Settlement(event))
+    (log.into(), Event::Settlement(event))
 }
 
 fn convert_invalidation(
-    invalidation: &ContractInvalidation,
-    meta: &EventMetadata,
+    invalidation: &GPv2Settlement::OrderInvalidated,
+    log: ValidatedLog,
 ) -> Result<(EventIndex, Event)> {
     let event = Invalidation {
-        order_uid: bytes_to_order_uid(&invalidation.order_uid.0)?,
+        order_uid: bytes_to_order_uid(invalidation.orderUid.as_ref())?,
     };
-    Ok((meta_to_event_index(meta), Event::Invalidation(event)))
+    Ok((log.into(), Event::Invalidation(event)))
 }
 
 fn convert_presignature(
-    presignature: &ContractPreSignature,
-    meta: &EventMetadata,
+    presignature: &GPv2Settlement::PreSignature,
+    log: ValidatedLog,
 ) -> Result<(EventIndex, Event)> {
     let event = PreSignature {
-        owner: ByteArray(presignature.owner.0),
-        order_uid: ByteArray(
-            presignature
-                .order_uid
-                .0
-                .as_slice()
-                .try_into()
-                .context("trade event order_uid has wrong number of bytes")?,
-        ),
+        owner: ByteArray(presignature.owner.into()),
+        order_uid: bytes_to_order_uid(presignature.orderUid.as_ref())?,
         signed: presignature.signed,
     };
-    Ok((meta_to_event_index(meta), Event::PreSignature(event)))
+    Ok((log.into(), Event::PreSignature(event)))
 }

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

@@ -3,13 +3,12 @@ use {
     crate::database::events::log_to_event_index,
     alloy::rpc::types::Log,
     anyhow::{Context, Result, anyhow},
-    contracts::{
-        GPv2Settlement,
-        alloy::CoWSwapOnchainOrders::CoWSwapOnchainOrders::{
+    contracts::alloy::{
+        CoWSwapOnchainOrders::CoWSwapOnchainOrders::{
             CoWSwapOnchainOrdersEvents as ContractEvent,
             OrderPlacement as ContractOrderPlacement,
         },
-        deployment_block,
+        GPv2Settlement,
     },
     database::{
         PgTransaction,
@@ -150,7 +149,8 @@ async fn settlement_deployment_block_number_hash(
     web3: &Web3,
     chain_id: u64,
 ) -> Result<BlockNumberHash> {
-    let block_number = deployment_block(GPv2Settlement::raw_contract(), chain_id)?;
+    let block_number =
+        GPv2Settlement::deployment_block(&chain_id).context("no deployment block configured")?;
     block_number_to_block_number_hash(web3, U64::from(block_number).into())
         .await
         .context("Deployment block not found")