Use blocks to determine other environment settlements

crates/autopilot/src/boundary/mod.rs

@@ -17,6 +17,7 @@ pub use {
             SellTokenSource,
         },
         signature::{EcdsaSignature, Signature, SigningScheme},
+        solver_competition::SolverCompetitionDB,
         DomainSeparator,
     },
     shared::order_validation::{is_order_outside_market_price, Amounts},

crates/autopilot/src/database/competition.rs

@@ -10,10 +10,9 @@ use {
         Address,
     },
     derivative::Derivative,
-    model::solver_competition::{SolverCompetitionAPI, SolverCompetitionDB},
+    model::solver_competition::SolverCompetitionDB,
     number::conversions::u256_to_big_decimal,
-    primitive_types::{H160, H256, U256},
-    sqlx::{types::JsonValue, PgConnection},
+    primitive_types::{H160, U256},
     std::collections::{BTreeMap, HashSet},
 };
 
@@ -137,35 +136,4 @@ impl super::Postgres {
 
         Ok(())
     }
-
-    pub async fn find_competition(
-        auction_id: AuctionId,
-        ex: &mut PgConnection,
-    ) -> anyhow::Result<Option<SolverCompetitionAPI>> {
-        database::solver_competition::load_by_id(ex, auction_id)
-            .await
-            .context("solver_competition::load_by_id")?
-            .map(|row| {
-                deserialize_solver_competition(
-                    row.json,
-                    row.id,
-                    row.tx_hashes.iter().map(|hash| H256(hash.0)).collect(),
-                )
-            })
-            .transpose()
-    }
-}
-
-fn deserialize_solver_competition(
-    json: JsonValue,
-    auction_id: model::auction::AuctionId,
-    transaction_hashes: Vec<H256>,
-) -> anyhow::Result<SolverCompetitionAPI> {
-    let common: SolverCompetitionDB =
-        serde_json::from_value(json).context("deserialize SolverCompetitionDB")?;
-    Ok(SolverCompetitionAPI {
-        auction_id,
-        transaction_hashes,
-        common,
-    })
 }

crates/autopilot/src/domain/eth/chain.rs

@@ -0,0 +1,43 @@
+use primitive_types::U256;
+
+/// A supported Ethereum Chain ID.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Id {
+    Mainnet = 1,
+    Gnosis = 100,
+    Sepolia = 11155111,
+    ArbitrumOne = 42161,
+}
+
+impl Id {
+    pub fn new(value: U256) -> Result<Self, UnsupportedChain> {
+        // Check to avoid panics for large `U256` values, as there is no checked
+        // conversion API available and we don't support chains with IDs greater
+        // than `u64::MAX` anyway.
+        if value > U256::from(u64::MAX) {
+            return Err(UnsupportedChain);
+        }
+
+        match value.as_u64() {
+            1 => Ok(Self::Mainnet),
+            100 => Ok(Self::Gnosis),
+            11155111 => Ok(Self::Sepolia),
+            42161 => Ok(Self::ArbitrumOne),
+            _ => Err(UnsupportedChain),
+        }
+    }
+
+    /// Returns the network ID for the chain.
+    pub fn network_id(self) -> &'static str {
+        match self {
+            Id::Mainnet => "1",
+            Id::Gnosis => "100",
+            Id::Sepolia => "11155111",
+            Id::ArbitrumOne => "42161",
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("unsupported chain")]
+pub struct UnsupportedChain;

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

@@ -4,6 +4,8 @@ use {
     derive_more::{Display, From, Into},
 };
 
+pub mod chain;
+
 /// An address. Can be an EOA or a smart contract address.
 #[derive(
     Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, From, Into, Display,
@@ -14,6 +16,15 @@ pub struct Address(pub H160);
 #[derive(Debug, Copy, Clone, From, PartialEq, PartialOrd, Default)]
 pub struct BlockNo(pub u64);
 
+/// Adding blocks to a block number.
+impl std::ops::Add<u64> for BlockNo {
+    type Output = BlockNo;
+
+    fn add(self, rhs: u64) -> Self::Output {
+        Self(self.0 + rhs)
+    }
+}
+
 /// A transaction ID, AKA transaction hash.
 #[derive(Debug, Copy, Clone, From, Default)]
 pub struct TxId(pub H256);

crates/autopilot/src/domain/settlement/auction.rs

@@ -8,6 +8,8 @@ use {
 #[derive(Debug)]
 pub struct Auction {
     pub id: domain::auction::Id,
+    /// The block on top of which the auction was created.
+    pub block: domain::eth::BlockNo,
     /// All orders from a competition auction. Some of them may contain fee
     /// policies.
     pub orders: HashMap<domain::OrderUid, Vec<domain::fee::Policy>>,

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

@@ -4,7 +4,10 @@
 //! a form of settlement transaction.
 
 use {
-    crate::{domain, domain::eth, infra},
+    crate::{
+        domain::{self, eth},
+        infra,
+    },
     std::collections::HashMap,
 };
 
@@ -103,19 +106,21 @@ impl Settlement {
     pub async fn new(
         settled: Transaction,
         persistence: &infra::Persistence,
+        chain: &eth::chain::Id,
     ) -> Result<Self, Error> {
-        if persistence
-            .auction_has_settlement(settled.auction_id)
-            .await?
-        {
-            // This settlement has already been processed by another environment.
+        let auction = persistence.get_auction(settled.auction_id).await?;
+
+        if settled.block > auction.block + max_settlement_age(chain) {
+            // A settled transaction references a VERY old auction.
+            //
+            // A hacky way to detect processing of production settlements in the staging
+            // environment, as production is lagging with auction ids by ~270 days on
+            // Ethereum mainnet.
             //
             // TODO: remove once https://github.com/cowprotocol/services/issues/2848 is resolved and ~270 days are passed since bumping.
             return Err(Error::WrongEnvironment);
         }
 
-        let auction = persistence.get_auction(settled.auction_id).await?;
-
         let trades = settled
             .trades
             .into_iter()
@@ -133,6 +138,19 @@ impl Settlement {
     }
 }
 
+/// How old (in terms of blocks) a settlement should be, to be considered as a
+/// settlement from another environment.
+///
+/// Currently set to ~6h
+fn max_settlement_age(chain: &eth::chain::Id) -> u64 {
+    match chain {
+        eth::chain::Id::Mainnet => 2000,
+        eth::chain::Id::Gnosis => 4000,
+        eth::chain::Id::Sepolia => 2000,
+        eth::chain::Id::ArbitrumOne => 100_000,
+    }
+}
+
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
     #[error("failed communication with the database: {0}")]
@@ -286,6 +304,7 @@ mod tests {
         let order_uid = transaction.trades[0].uid;
 
         let auction = super::Auction {
+            block: eth::BlockNo(0),
             // prices read from https://solver-instances.s3.eu-central-1.amazonaws.com/prod/mainnet/legacy/8655372.json
             prices: auction::Prices::from([
                 (
@@ -436,6 +455,7 @@ mod tests {
 
         let order_uid = transaction.trades[0].uid;
         let auction = super::Auction {
+            block: eth::BlockNo(0),
             prices,
             surplus_capturing_jit_order_owners: Default::default(),
             id: 0,
@@ -599,6 +619,7 @@ mod tests {
         ]);
 
         let auction = super::Auction {
+            block: eth::BlockNo(0),
             prices,
             surplus_capturing_jit_order_owners: HashSet::from([eth::Address(
                 eth::H160::from_slice(&hex!("f08d4dea369c456d26a3168ff0024b904f2d8b91")),
@@ -777,6 +798,7 @@ mod tests {
         ]);
 
         let auction = super::Auction {
+            block: eth::BlockNo(0),
             prices,
             surplus_capturing_jit_order_owners: Default::default(),
             id: 0,

crates/autopilot/src/domain/settlement/observer.rs

@@ -78,8 +78,12 @@ impl Observer {
         let (auction_id, settlement) = match transaction {
             Ok(transaction) => {
                 let auction_id = transaction.auction_id;
-                let settlement = match settlement::Settlement::new(transaction, &self.persistence)
-                    .await
+                let settlement = match settlement::Settlement::new(
+                    transaction,
+                    &self.persistence,
+                    self.eth.network(),
+                )
+                .await
                 {
                     Ok(settlement) => Some(settlement),
                     Err(err) if retryable(&err) => return Err(err.into()),

crates/autopilot/src/infra/blockchain/authenticator.rs

@@ -1,10 +1,7 @@
 use {
     crate::{
         domain::{self, eth},
-        infra::blockchain::{
-            contracts::{deployment_address, Contracts},
-            ChainId,
-        },
+        infra::blockchain::contracts::{deployment_address, Contracts},
     },
     ethcontract::{dyns::DynWeb3, GasPrice},
 };
@@ -25,7 +22,7 @@ impl Manager {
     /// Creates an authenticator which can remove solvers from the allow-list
     pub async fn new(
         web3: DynWeb3,
-        chain: ChainId,
+        chain: eth::chain::Id,
         contracts: Contracts,
         authenticator_pk: eth::H256,
     ) -> Self {

crates/autopilot/src/infra/blockchain/contracts.rs

@@ -1,4 +1,4 @@
-use {super::ChainId, crate::domain, ethcontract::dyns::DynWeb3, primitive_types::H160};
+use {crate::domain, ethcontract::dyns::DynWeb3, primitive_types::H160};
 
 #[derive(Debug, Clone)]
 pub struct Contracts {
@@ -20,7 +20,7 @@ pub struct Addresses {
 }
 
 impl Contracts {
-    pub async fn new(web3: &DynWeb3, chain: &ChainId, addresses: Addresses) -> Self {
+    pub async fn new(web3: &DynWeb3, chain: &domain::eth::chain::Id, addresses: Addresses) -> Self {
         let address_for = |contract: &ethcontract::Contract, address: Option<H160>| {
             address
                 .or_else(|| deployment_address(contract, chain))
@@ -92,6 +92,9 @@ impl Contracts {
 
 /// Returns the address of a contract for the specified network, or `None` if
 /// there is no known deployment for the contract on that network.
-pub fn deployment_address(contract: &ethcontract::Contract, chain: &ChainId) -> Option<H160> {
-    Some(contract.networks.get(&chain.to_string())?.address)
+pub fn deployment_address(
+    contract: &ethcontract::Contract,
+    chain: &domain::eth::chain::Id,
+) -> Option<H160> {
+    Some(contract.networks.get(chain.network_id())?.address)
 }

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

@@ -12,28 +12,10 @@ use {
 pub mod authenticator;
 pub mod contracts;
 
-/// Chain ID as defined by EIP-155.
-///
-/// https://eips.ethereum.org/EIPS/eip-155
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub struct ChainId(pub U256);
-
-impl std::fmt::Display for ChainId {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl From<U256> for ChainId {
-    fn from(value: U256) -> Self {
-        Self(value)
-    }
-}
-
 /// An Ethereum RPC connection.
 pub struct Rpc {
     web3: DynWeb3,
-    chain: ChainId,
+    chain: eth::chain::Id,
     url: Url,
 }
 
@@ -45,7 +27,8 @@ impl Rpc {
         ethrpc_args: &shared::ethrpc::Arguments,
     ) -> Result<Self, Error> {
         let web3 = boundary::web3_client(url, ethrpc_args);
-        let chain = web3.eth().chain_id().await?.into();
+        let chain = eth::chain::Id::new(web3.eth().chain_id().await?)
+            .map_err(|_| Error::UnsupportedChain)?;
 
         Ok(Self {
             web3,
@@ -55,7 +38,7 @@ impl Rpc {
     }
 
     /// Returns the chain id for the RPC connection.
-    pub fn chain(&self) -> ChainId {
+    pub fn chain(&self) -> eth::chain::Id {
         self.chain
     }
 
@@ -74,7 +57,7 @@ impl Rpc {
 #[derive(Clone)]
 pub struct Ethereum {
     web3: DynWeb3,
-    chain: ChainId,
+    chain: eth::chain::Id,
     current_block: CurrentBlockWatcher,
     contracts: Contracts,
 }
@@ -88,7 +71,7 @@ impl Ethereum {
     /// any initialization error.
     pub async fn new(
         web3: DynWeb3,
-        chain: ChainId,
+        chain: eth::chain::Id,
         url: Url,
         addresses: contracts::Addresses,
         poll_interval: Duration,
@@ -105,7 +88,7 @@ impl Ethereum {
         }
     }
 
-    pub fn network(&self) -> &ChainId {
+    pub fn network(&self) -> &eth::chain::Id {
         &self.chain
     }
 
@@ -179,4 +162,6 @@ pub enum Error {
     IncompleteTransactionData(anyhow::Error),
     #[error("transaction not found")]
     TransactionNotFound,
+    #[error("unsupported chain")]
+    UnsupportedChain,
 }