add sovereign sdk integration

Author: ross-weir

rust/main/Cargo.lock

@@ -11,6 +11,7 @@ members = [
   "chains/hyperlane-fuel",
   "chains/hyperlane-radix",
   "chains/hyperlane-sealevel",
+  "chains/hyperlane-sovereign",
   "chains/hyperlane-starknet",
   "ethers-prometheus",
   "hyperlane-base",

rust/main/Cargo.toml

@@ -544,7 +544,24 @@ const DOMAINS: &[RawDomain] = &[
         chain_id: 9913375,
         is_test_net: true,
         is_deprecated: false,
-    }, // ---------- End: E2E tests chains ----------------
+    },
+    RawDomain {
+        name: "sovrollup0",
+        token: "SOV",
+        domain: 50001,
+        chain_id: 50001,
+        is_test_net: true,
+        is_deprecated: false,
+    },
+    RawDomain {
+        name: "sovrollup1",
+        token: "SOV",
+        domain: 50002,
+        chain_id: 50002,
+        is_test_net: true,
+        is_deprecated: false,
+    },
+    // ---------- End: E2E tests chains ----------------
 ];
 
 #[derive(DeriveMigrationName)]

rust/main/agents/scraper/migration/src/m20230309_000001_create_table_domain.rs

@@ -97,7 +97,7 @@ impl LatestCheckpointReorgReporter {
         origin: &HyperlaneDomain,
     ) -> Vec<(Url, ValidatorSettings)> {
         use ChainConnectionConf::{
-            Cosmos, CosmosNative, Ethereum, Fuel, Radix, Sealevel, Starknet,
+            Cosmos, CosmosNative, Ethereum, Fuel, Radix, Sealevel, Sovereign, Starknet,
         };
 
         let chain_conf = settings
@@ -149,6 +149,13 @@ impl LatestCheckpointReorgReporter {
                     Radix(updated_conn)
                 })
             }
+            Sovereign(conn) => {
+                Self::map_urls_to_connections(vec![conn.url.clone()], conn, |conn, url| {
+                    let mut updated_conn = conn.clone();
+                    updated_conn.url = url;
+                    Sovereign(updated_conn)
+                })
+            }
         };
 
         chain_conn_confs

rust/main/agents/validator/src/reorg_reporter.rs

@@ -0,0 +1,43 @@
+[package]
+name = "hyperlane-sovereign"
+version = "0.1.0"
+edition.workspace = true
+
+[dependencies]
+hyperlane-core = { path = "../../hyperlane-core", features = ["async"] }
+hyperlane-operation-verifier = { path = "../../applications/hyperlane-operation-verifier" }
+hyperlane-warp-route = { path = "../../applications/hyperlane-warp-route" }
+
+anyhow.workspace = true
+async-trait.workspace = true
+base64.workspace = true
+bech32.workspace = true
+bytes.workspace = true
+derive-new.workspace = true
+ethers.workspace = true
+futures.workspace = true
+k256.workspace = true
+reqwest.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+sha2.workspace = true
+sha3.workspace = true
+tokio = { workspace = true, features = ["fs", "macros"] }
+tracing.workspace = true
+url.workspace = true
+hex.workspace = true
+num-traits.workspace = true
+
+ed25519-dalek = "2.1.1"
+bs58 = { version = "0.5.1", default-features = false, features = [
+  "std",
+  "alloc",
+] }
+sov-universal-wallet = { git = "https://@github.com/Sovereign-Labs/sovereign-sdk.git", branch = "nightly", features = [
+  "serde",
+] }
+tokio-tungstenite = "0.23"
+tokio-retry = "0.3.0"
+
+[features]
+default = []

rust/main/chains/hyperlane-sovereign/Cargo.toml

@@ -0,0 +1,69 @@
+use std::io::Cursor;
+
+use async_trait::async_trait;
+use derive_new::new;
+use hyperlane_core::{Decode, HyperlaneMessage, H256, U256};
+use hyperlane_operation_verifier::{
+    ApplicationOperationVerifier, ApplicationOperationVerifierReport,
+};
+use hyperlane_warp_route::TokenMessage;
+
+use crate::signers::sovereign::SOV_HEX_ADDRESS_LEADING_ZEROS;
+
+const WARP_ROUTE_MARKER: &str = "/";
+
+/// Application operation verifier for Sovereign
+#[derive(new)]
+pub struct SovereignApplicationOperationVerifier {}
+
+#[async_trait]
+impl ApplicationOperationVerifier for SovereignApplicationOperationVerifier {
+    async fn verify(
+        &self,
+        app_context: &Option<String>,
+        message: &HyperlaneMessage,
+    ) -> Option<ApplicationOperationVerifierReport> {
+        use ApplicationOperationVerifierReport::{MalformedMessage, ZeroAmount};
+        tracing::trace!(
+            ?app_context,
+            ?message,
+            "Sovereign application operation verifier",
+        );
+
+        let context = match app_context {
+            Some(c) => c,
+            None => return None,
+        };
+
+        if !context.contains(WARP_ROUTE_MARKER) {
+            return None;
+        }
+
+        // Starting from this point we assume that we are in a warp route context
+
+        let mut reader = Cursor::new(message.body.as_slice());
+        let token_message = match TokenMessage::read_from(&mut reader) {
+            Ok(m) => m,
+            Err(_) => return Some(MalformedMessage(message.clone())),
+        };
+
+        if !has_enough_leading_zeroes(token_message.recipient()) {
+            return Some(MalformedMessage(message.clone()));
+        }
+
+        if token_message.amount() == U256::zero() {
+            return Some(ZeroAmount);
+        }
+
+        None
+    }
+}
+
+// this uses the ed25519 addresses check as it has less leading zeros
+fn has_enough_leading_zeroes(address: H256) -> bool {
+    address
+        .as_bytes()
+        .iter()
+        .take(SOV_HEX_ADDRESS_LEADING_ZEROS)
+        .all(|b| *b == 0)
+}

rust/main/chains/hyperlane-sovereign/src/application/mod.rs

@@ -0,0 +1,78 @@
+use std::{ops::RangeInclusive, str::FromStr};
+
+use async_trait::async_trait;
+use hyperlane_core::{ChainResult, Indexed, Indexer, LogMeta, SequenceAwareIndexer, H256, H512};
+use serde::Deserialize;
+
+use crate::{indexer::SovIndexer, types::TxEvent, SovereignProvider};
+
+/// Struct that retrieves delivery event data for a Sovereign Mailbox.
+#[derive(Debug, Clone)]
+pub struct SovereignDeliveryIndexer {
+    provider: SovereignProvider,
+}
+
+impl SovereignDeliveryIndexer {
+    /// Create a new `SovereignDeliveryIndexer`.
+    pub fn new(provider: SovereignProvider) -> ChainResult<Self> {
+        Ok(SovereignDeliveryIndexer { provider })
+    }
+}
+
+#[derive(Debug, Clone, Deserialize)]
+struct ProcessEvent {
+    process_id: ProcessEventInner,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+struct ProcessEventInner {
+    id: String,
+}
+
+#[async_trait]
+impl crate::indexer::SovIndexer<H256> for SovereignDeliveryIndexer {
+    const EVENT_KEY: &'static str = "Mailbox/ProcessId";
+
+    fn provider(&self) -> &SovereignProvider {
+        &self.provider
+    }
+
+    async fn latest_sequence(&self, at_slot: Option<u64>) -> ChainResult<Option<u32>> {
+        let sequence = self.provider().get_count(at_slot).await?;
+        Ok(Some(sequence))
+    }
+
+    fn decode_event(&self, event: &TxEvent) -> ChainResult<H256> {
+        let evt: ProcessEvent = serde_json::from_value(event.value.clone())?;
+        Ok(H256::from_str(&evt.process_id.id)?)
+    }
+}
+
+#[async_trait]
+impl SequenceAwareIndexer<H256> for SovereignDeliveryIndexer {
+    async fn latest_sequence_count_and_tip(&self) -> ChainResult<(Option<u32>, u32)> {
+        <Self as SovIndexer<H256>>::latest_sequence_count_and_tip(self).await
+    }
+}
+
+#[async_trait]
+impl Indexer<H256> for SovereignDeliveryIndexer {
+    async fn fetch_logs_in_range(
+        &self,
+        range: RangeInclusive<u32>,
+    ) -> ChainResult<Vec<(Indexed<H256>, LogMeta)>> {
+        <Self as SovIndexer<H256>>::fetch_logs_in_range(self, range).await
+    }
+
+    async fn get_finalized_block_number(&self) -> ChainResult<u32> {
+        <Self as SovIndexer<H256>>::get_finalized_block_number(self).await
+    }
+
+    async fn fetch_logs_by_tx_hash(
+        &self,
+        tx_hash: H512,
+    ) -> ChainResult<Vec<(Indexed<H256>, LogMeta)>> {
+        <Self as SovIndexer<H256>>::fetch_logs_by_tx_hash(self, tx_hash).await
+    }
+}
+

rust/main/chains/hyperlane-sovereign/src/delivery.rs

@@ -0,0 +1,125 @@
+use std::fmt::Debug;
+use std::ops::RangeInclusive;
+
+use async_trait::async_trait;
+use futures::stream::{self, FuturesOrdered, TryStreamExt};
+use hyperlane_core::{ChainResult, Indexed, Indexer, LogMeta, SequenceAwareIndexer, H256, H512};
+
+use crate::types::{Tx, TxEvent};
+use crate::SovereignProvider;
+
+// SovIndexer is a trait that contains default implementations for indexing
+// various different event types on the Sovereign chain to reduce code duplication in
+// e.g. SovereignMailboxIndexer, SovereignInterchainGasPaymasterIndexer, etc.
+#[async_trait]
+pub trait SovIndexer<T>: Indexer<T> + SequenceAwareIndexer<T>
+where
+    T: Into<Indexed<T>> + Debug + Clone + Send,
+{
+    const EVENT_KEY: &'static str;
+
+    fn provider(&self) -> &SovereignProvider;
+
+    fn decode_event(&self, event: &TxEvent) -> ChainResult<T>;
+
+    async fn latest_sequence(&self, at_slot: Option<u64>) -> ChainResult<Option<u32>>;
+
+    // Default implementation of Indexer<T>
+    async fn fetch_logs_in_range(
+        &self,
+        range: RangeInclusive<u32>,
+    ) -> ChainResult<Vec<(Indexed<T>, LogMeta)>> {
+        let logs = range
+            .map(|slot_num| async move {
+                let slot = self.provider().get_specified_slot(slot_num.into()).await?;
+                ChainResult::Ok(stream::iter(
+                    slot.batches
+                        .into_iter()
+                        .flat_map(|batch| batch.txs)
+                        .map(move |tx| self.process_tx(&tx, slot.number, slot.hash)),
+                ))
+            })
+            .collect::<FuturesOrdered<_>>()
+            .try_flatten()
+            .try_collect::<Vec<_>>()
+            .await?
+            .concat();
+
+        Ok(logs)
+    }
+
+    async fn get_finalized_block_number(&self) -> ChainResult<u32> {
+        let latest_slot = self.provider().get_finalized_slot().await?;
+        Ok(latest_slot.try_into().expect("Slot number overflowed u32"))
+    }
+
+    /// Get the transaction by hash. Sovereign Tx hashes are represented as H256,
+    /// so the input needs to be padded with 0's
+    async fn fetch_logs_by_tx_hash(
+        &self,
+        tx_hash: H512,
+    ) -> ChainResult<Vec<(Indexed<T>, LogMeta)>> {
+        if tx_hash.0[0..32] != [0; 32] {
+            return Err(custom_err!(
+                "Invalid sovereign transaction id, should have 32 bytes: {tx_hash:?}"
+            ));
+        }
+        let tx_hash = H256(tx_hash[32..].try_into().expect("Must be 32 bytes"));
+
+        let provider = self.provider();
+        let tx = provider.get_tx_by_hash(tx_hash).await?;
+        let batch = provider.get_batch(tx.batch_number).await?;
+        let slot = provider.get_specified_slot(batch.slot_number).await?;
+
+        self.process_tx(&tx, slot.number, slot.hash)
+    }
+
+    // Default implementation of SequenceAwareIndexer<T>
+    async fn latest_sequence_count_and_tip(&self) -> ChainResult<(Option<u32>, u32)> {
+        let finalized_slot = self.provider().get_finalized_slot().await?;
+        let sequence = self.latest_sequence(Some(finalized_slot)).await?;
+
+        Ok((
+            sequence,
+            finalized_slot
+                .try_into()
+                .map_err(|_| custom_err!("Slot number overflowed"))?,
+        ))
+    }
+
+    // Helper function to process a single transaction
+    fn process_tx(&self, tx: &Tx, slot_num: u64, slot_hash: H256) -> ChainResult<Vec<(Indexed<T>, LogMeta)>> {
+        tx.events
+            .iter()
+            .filter(|ev| ev.key == Self::EVENT_KEY)
+            .map(|ev| self.process_event(tx, ev, slot_num, slot_hash))
+            .collect()
+    }
+
+    // Helper function to process a single event
+    fn process_event(
+        &self,
+        tx: &Tx,
+        event: &TxEvent,
+        slot_num: u64,
+        slot_hash: H256,
+    ) -> ChainResult<(Indexed<T>, LogMeta)> {
+        let decoded_event = self.decode_event(event)?;
+
+        let meta = LogMeta {
+            // NOTE: sovereign logs are emitted by modules, not contracts, so we use a dummy address
+            address: H256::default(),
+            block_number: slot_num,
+            block_hash: slot_hash,
+            transaction_id: tx.hash.into(),
+            // NOTE: this diverges from the Ethereum behavior, as for sovereign, those numbers are
+            // global, and for Ethereum, they are block local. However, deducing block-local numbers
+            // for transactions fetched by hash would require pulling the whole slot data, which means
+            // a lot of overhead
+            transaction_index: tx.number,
+            log_index: event.number.into(),
+        };
+
+        Ok((decoded_event.into(), meta))
+    }
+}