Migrate alerter to alloy

Author: jmg-duarte

Cargo.lock

@@ -6,14 +6,14 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+alloy = { workspace = true }
 anyhow = { workspace = true }
 clap = { workspace = true }
 humantime = { workspace = true }
 observe = { workspace = true }
 mimalloc = { workspace = true }
 model = { workspace = true }
 number = { workspace = true }
-primitive-types = { workspace = true }
 prometheus = { workspace = true }
 reqwest = { workspace = true, features = ["json"] }
 serde_with = { workspace = true }

crates/alerter/Cargo.toml

@@ -4,11 +4,11 @@
 // price api (0x). If this is the case it alerts.
 
 use {
+    alloy::primitives::{Address, U256, address},
     anyhow::{Context, Result},
     clap::Parser,
     model::order::{BUY_ETH_ADDRESS, OrderClass, OrderKind, OrderStatus, OrderUid},
     number::serialization::HexOrDecimalU256,
-    primitive_types::{H160, U256},
     prometheus::IntGauge,
     reqwest::Client,
     serde_with::serde_as,
@@ -24,10 +24,10 @@ use {
 #[serde(rename_all = "camelCase")]
 struct Order {
     kind: OrderKind,
-    buy_token: H160,
+    buy_token: Address,
     #[serde_as(as = "HexOrDecimalU256")]
     buy_amount: U256,
-    sell_token: H160,
+    sell_token: Address,
     #[serde_as(as = "HexOrDecimalU256")]
     sell_amount: U256,
     uid: OrderUid,
@@ -90,12 +90,10 @@ impl OrderBookApi {
 
 // Converts the eth placeholder address to weth. Leaves other addresses
 // untouched.
-fn convert_eth_to_weth(token: H160) -> H160 {
-    let weth: H160 = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
-        .parse()
-        .unwrap();
-    if token == BUY_ETH_ADDRESS {
-        weth
+fn convert_eth_to_weth(token: Address) -> Address {
+    const WETH: Address = address!("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2");
+    if token == Address::from_slice(&BUY_ETH_ADDRESS.0) {
+        WETH
     } else {
         token
     }

crates/alerter/src/lib.rs

@@ -5,14 +5,43 @@ use {
     std::fmt,
 };
 
+/// (De)serialization structure able to deserialize decimal and hexadecimal
+/// numbers, serializes as decimal.
 pub struct HexOrDecimalU256;
 
-impl<'de> DeserializeAs<'de, U256> for HexOrDecimalU256 {
-    fn deserialize_as<D>(deserializer: D) -> Result<U256, D::Error>
+impl<'de> DeserializeAs<'de, alloy::primitives::U256> for HexOrDecimalU256 {
+    fn deserialize_as<D>(deserializer: D) -> Result<alloy::primitives::U256, D::Error>
     where
         D: Deserializer<'de>,
     {
-        deserialize(deserializer)
+        struct Visitor {}
+        impl de::Visitor<'_> for Visitor {
+            type Value = alloy::primitives::U256;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                write!(
+                    formatter,
+                    "a u256 encoded either as 0x hex prefixed or decimal encoded string"
+                )
+            }
+
+            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                if s.trim().starts_with("0x") {
+                    alloy::primitives::U256::from_str_radix(s, 16).map_err(|err| {
+                        de::Error::custom(format!("failed to decode {s:?} as hex u256: {err}"))
+                    })
+                } else {
+                    alloy::primitives::U256::from_str_radix(s, 10).map_err(|err| {
+                        de::Error::custom(format!("failed to decode {s:?} as decimal u256: {err}"))
+                    })
+                }
+            }
+        }
+
+        deserializer.deserialize_str(Visitor {})
     }
 }
 
@@ -25,6 +54,24 @@ impl SerializeAs<U256> for HexOrDecimalU256 {
     }
 }
 
+impl<'de> DeserializeAs<'de, U256> for HexOrDecimalU256 {
+    fn deserialize_as<D>(deserializer: D) -> Result<U256, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserialize(deserializer)
+    }
+}
+
+impl SerializeAs<alloy::primitives::U256> for HexOrDecimalU256 {
+    fn serialize_as<S>(source: &alloy::primitives::U256, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&source.to_string())
+    }
+}
+
 pub fn serialize<S>(value: &U256, serializer: S) -> Result<S::Ok, S::Error>
 where
     S: Serializer,