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

@@ -2,35 +2,73 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use hyperlane_core::{
-    Announcement, ChainResult, ContractLocator, HyperlaneChain, HyperlaneContract, HyperlaneDomain,
-    SignedType, TxOutcome, ValidatorAnnounce, H160, H256, H512, U256,
+    Announcement, ChainCommunicationError, ChainResult, ContractLocator, HyperlaneChain,
+    HyperlaneContract, HyperlaneDomain, SignedType, TxOutcome, ValidatorAnnounce, H160, H256, U256,
 };
 use hyperlane_sealevel_validator_announce::{
-    accounts::ValidatorStorageLocationsAccount, validator_storage_locations_pda_seeds,
+    accounts::ValidatorStorageLocationsAccount,
+    instruction::{AnnounceInstruction, Instruction as ValidatorAnnounceInstruction},
+    replay_protection_pda_seeds, validator_announce_pda_seeds,
+    validator_storage_locations_pda_seeds,
 };
-use solana_sdk::pubkey::Pubkey;
-use tracing::{info, instrument, warn};
+use solana_sdk::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+    signer::Signer as _,
+    system_program,
+};
+use tracing::{info, instrument};
 
-use crate::SealevelProvider;
+use crate::{ConnectionConf, SealevelKeypair, SealevelProvider, TransactionSubmitter};
 
 /// A reference to a ValidatorAnnounce contract on some Sealevel chain
-#[derive(Debug)]
 pub struct SealevelValidatorAnnounce {
     provider: Arc<SealevelProvider>,
+    tx_submitter: Arc<dyn TransactionSubmitter>,
     program_id: Pubkey,
     domain: HyperlaneDomain,
+    conn: ConnectionConf,
+    signer: Option<SealevelKeypair>,
+}
+
+impl std::fmt::Debug for SealevelValidatorAnnounce {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SealevelValidatorAnnounce")
+            .field("provider", &self.provider)
+            .field("tx_submitter", &"Arc<dyn TransactionSubmitter>")
+            .field("program_id", &self.program_id)
+            .field("domain", &self.domain)
+            .field("conn", &self.conn)
+            .field("signer", &self.signer)
+            .finish()
+    }
 }
 
 impl SealevelValidatorAnnounce {
     /// Create a new Sealevel ValidatorAnnounce
-    pub fn new(provider: Arc<SealevelProvider>, locator: &ContractLocator) -> Self {
+    pub fn new(
+        provider: Arc<SealevelProvider>,
+        tx_submitter: Arc<dyn TransactionSubmitter>,
+        conn: ConnectionConf,
+        locator: &ContractLocator,
+        signer: Option<SealevelKeypair>,
+    ) -> Self {
         let program_id = Pubkey::from(<[u8; 32]>::from(locator.address));
         Self {
             program_id,
             domain: locator.domain.clone(),
             provider,
+            tx_submitter,
+            conn,
+            signer,
         }
     }
+
+    fn get_signer(&self) -> ChainResult<&SealevelKeypair> {
+        self.signer
+            .as_ref()
+            .ok_or_else(|| ChainCommunicationError::SignerUnavailable)
+    }
 }
 
 impl HyperlaneContract for SealevelValidatorAnnounce {
@@ -112,13 +150,77 @@ impl ValidatorAnnounce for SealevelValidatorAnnounce {
 
     #[instrument(err, ret, skip(self))]
     #[allow(clippy::blocks_in_conditions)] // TODO: `rustc` 1.80.1 clippy issue
-    async fn announce(&self, _announcement: SignedType<Announcement>) -> ChainResult<TxOutcome> {
-        warn!(
-            "Announcing validator storage locations within the agents is not supported on Sealevel"
-        );
+    async fn announce(&self, announcement: SignedType<Announcement>) -> ChainResult<TxOutcome> {
+        let payer = self.get_signer()?;
+
+        let announce_instruction = AnnounceInstruction {
+            validator: announcement.value.validator,
+            storage_location: announcement.value.storage_location.clone(),
+            signature: announcement.signature.to_vec(),
+        };
+
+        let (validator_announce_account, _validator_announce_bump) =
+            Pubkey::find_program_address(validator_announce_pda_seeds!(), &self.program_id);
+
+        let (validator_storage_locations_key, _validator_storage_locations_bump_seed) =
+            Pubkey::find_program_address(
+                validator_storage_locations_pda_seeds!(announce_instruction.validator),
+                &self.program_id,
+            );
+
+        let replay_id = announce_instruction.replay_id();
+        let (replay_protection_pda_key, _replay_protection_bump_seed) =
+            Pubkey::find_program_address(replay_protection_pda_seeds!(replay_id), &self.program_id);
+
+        let ixn = ValidatorAnnounceInstruction::Announce(announce_instruction);
+
+        // Accounts:
+        // 0. [signer] The payer.
+        // 1. [executable] The system program.
+        // 2. [] The ValidatorAnnounce PDA account.
+        // 3. [writeable] The validator-specific ValidatorStorageLocationsAccount PDA account.
+        // 4. [writeable] The ReplayProtection PDA account specific to the announcement being made.
+        let accounts = vec![
+            AccountMeta::new_readonly(payer.pubkey(), true),
+            AccountMeta::new_readonly(system_program::id(), false),
+            AccountMeta::new_readonly(validator_announce_account, false),
+            AccountMeta::new(validator_storage_locations_key, false),
+            AccountMeta::new(replay_protection_pda_key, false),
+        ];
+
+        let instruction = Instruction {
+            program_id: self.program_id,
+            data: ixn.into_instruction_data().unwrap(),
+            accounts,
+        };
+
+        info!(?instruction, "Created validator announce instruction");
+
+        let tx = self
+            .provider
+            .build_estimated_tx_for_instruction(
+                instruction,
+                payer,
+                self.tx_submitter.clone(),
+                self.conn.priority_fee_oracle.create_oracle(),
+            )
+            .await?;
+
+        info!(?tx, "Built transaction for validator announcement");
+
+        let signature = self.tx_submitter.send_transaction(&tx, true).await?;
+
+        info!(?signature, "Sent validator announcement transaction");
+
+        self.tx_submitter
+            .wait_for_transaction_confirmation(&tx)
+            .await?;
+
+        info!(?signature, "Validator announcement transaction confirmed");
+
         Ok(TxOutcome {
-            transaction_id: H512::zero(),
-            executed: false,
+            transaction_id: signature.into(),
+            executed: true,
             gas_used: U256::zero(),
             gas_price: U256::zero().try_into()?,
         })

rust/main/chains/hyperlane-sealevel/src/validator_announce.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)
+}