feat: posting ECDSARegistry signature to s3 bucket for validators

.gitattributes

@@ -1,2 +1,4 @@
 typescript/sdk/src/cw-types/*.types.ts linguist-generated=true
 rust/chains/hyperlane-ethereum/abis/*.abi.json linguist-generated=true
+solidity/contracts/interfaces/avs/*.sol linguist-vendored=true
+solidity/contracts/avs/ECDSA*.sol linguist-vendored=true

rust/agents/validator/src/settings.rs

@@ -12,6 +12,7 @@ use hyperlane_base::{
     impl_loadable_from_settings,
     settings::{
         parser::{RawAgentConf, RawAgentSignerConf, ValueParser},
+        staking_config::StakingConf,
         CheckpointSyncerConf, Settings, SignerConf,
     },
 };
@@ -34,12 +35,18 @@ pub struct ValidatorSettings {
     pub origin_chain: HyperlaneDomain,
     /// The validator attestation signer
     pub validator: SignerConf,
+    /// The AVS domain to register the operator with ()
+    pub avs_domain: Option<u32>,
+    /// The optional signer for registering the AVS operator
+    pub avs_operator: Option<SignerConf>,
     /// The checkpoint syncer configuration
     pub checkpoint_syncer: CheckpointSyncerConf,
     /// The reorg_period in blocks
     pub reorg_period: u64,
     /// How frequently to check for new checkpoints
     pub interval: Duration,
+
+    pub staking_config: StakingConf,
 }
 
 #[derive(Debug, Deserialize)]
@@ -91,6 +98,27 @@ impl FromRawConf<RawValidatorSettings> for ValidatorSettings {
             )
             .end();
 
+        let avs_chain_name = p
+            .chain(&mut err)
+            .get_key("avsChainName")
+            .parse_string()
+            .end();
+
+        let avs_domain: Option<u32> = match avs_chain_name {
+            Some("ethereum") => Some(1),
+            Some("holesky") => Some(17000),
+            _ => None,
+        };
+
+        let avs_operator = p
+            .chain(&mut err)
+            .get_opt_key("avs_operator")
+            .parse_from_raw_config::<SignerConf, RawAgentSignerConf, NoFilter>(
+                (),
+                "Expected valid validator configuration",
+            )
+            .end();
+
         let db = p
             .chain(&mut err)
             .get_opt_key("db")
@@ -140,9 +168,12 @@ impl FromRawConf<RawValidatorSettings> for ValidatorSettings {
             db,
             origin_chain,
             validator,
+            avs_domain,
+            avs_operator,
             checkpoint_syncer,
             reorg_period,
             interval,
+            staking_config: StakingConf::default_staking_config(),
         })
     }
 }

rust/agents/validator/src/validator.rs

@@ -12,14 +12,15 @@ use tracing::{error, info, info_span, instrument::Instrumented, warn, Instrument
 use hyperlane_base::{
     db::{HyperlaneRocksDB, DB},
     metrics::AgentMetrics,
-    settings::ChainConf,
+    settings::{staking_config::StakingConf, ChainConf},
     BaseAgent, ChainMetrics, CheckpointSyncer, ContractSyncMetrics, ContractSyncer, CoreMetrics,
     HyperlaneAgentCore, MetricsUpdater, SequencedDataContractSync,
 };
 
 use hyperlane_core::{
-    Announcement, ChainResult, HyperlaneChain, HyperlaneContract, HyperlaneDomain, HyperlaneSigner,
-    HyperlaneSignerExt, Mailbox, MerkleTreeHook, MerkleTreeInsertion, TxOutcome, ValidatorAnnounce,
+    utils::operator_registration_signature_expiry, Announcement, ChainResult, HyperlaneChain,
+    HyperlaneContract, HyperlaneDomain, HyperlaneSigner, HyperlaneSignerExt, Mailbox,
+    MerkleTreeHook, MerkleTreeInsertion, OperatorRegistrationBuilder, TxOutcome, ValidatorAnnounce,
     H256, U256,
 };
 use hyperlane_ethereum::{SingletonSigner, SingletonSignerHandle};
@@ -44,12 +45,16 @@ pub struct Validator {
     signer: SingletonSignerHandle,
     // temporary holder until `run` is called
     signer_instance: Option<Box<SingletonSigner>>,
+    avs_domain: Option<u32>,
+    avs_signer: Option<SingletonSignerHandle>,
+    avs_signer_instance: Option<Box<SingletonSigner>>,
     reorg_period: u64,
     interval: Duration,
     checkpoint_syncer: Arc<dyn CheckpointSyncer>,
     core_metrics: Arc<CoreMetrics>,
     agent_metrics: AgentMetrics,
     chain_metrics: ChainMetrics,
+    staking_config: StakingConf,
 }
 
 #[async_trait]
@@ -73,6 +78,16 @@ impl BaseAgent for Validator {
         // Intentionally using hyperlane_ethereum for the validator's signer
         let (signer_instance, signer) = SingletonSigner::new(settings.validator.build().await?);
 
+        // If the AVS operator is provided, create a signer for it to write the announcement
+        let (avs_signer_instance, avs_signer) = match &settings.avs_operator {
+            Some(avs_operator) => {
+                let (avs_signer_instance, avs_signer) =
+                    SingletonSigner::new(avs_operator.build().await?);
+                (Some(avs_signer_instance), Some(avs_signer))
+            }
+            None => (None, None),
+        };
+
         let core = settings.build_hyperlane_core(metrics.clone());
         let checkpoint_syncer = settings.checkpoint_syncer.build(None).await?.into();
 
@@ -116,12 +131,16 @@ impl BaseAgent for Validator {
             validator_announce: validator_announce.into(),
             signer,
             signer_instance: Some(Box::new(signer_instance)),
+            avs_domain: settings.avs_domain,
+            avs_signer,
+            avs_signer_instance: avs_signer_instance.map(Box::new),
             reorg_period: settings.reorg_period,
             interval: settings.interval,
             checkpoint_syncer,
             agent_metrics,
             chain_metrics,
             core_metrics: metrics,
+            staking_config: settings.staking_config,
         })
     }
 
@@ -152,6 +171,15 @@ impl BaseAgent for Validator {
             );
         }
 
+        if let Some(avs_signer_instance) = self.avs_signer_instance.take() {
+            tasks.push(
+                tokio::spawn(async move {
+                    avs_signer_instance.run().await;
+                })
+                .instrument(info_span!("AvsSingletonSigner")),
+            );
+        }
+
         let metrics_updater = MetricsUpdater::new(
             &self.origin_chain_conf,
             self.core_metrics.clone(),
@@ -171,6 +199,10 @@ impl BaseAgent for Validator {
         // announce the validator after spawning the signer task
         self.announce().await.expect("Failed to announce validator");
 
+        self.write_operator_registration()
+            .await
+            .expect("Failed to announce to AVS");
+
         let reorg_period = NonZeroU64::new(self.reorg_period);
 
         // Ensure that the merkle tree hook has count > 0 before we begin indexing
@@ -286,6 +318,45 @@ impl Validator {
         }
     }
 
+    async fn write_operator_registration(&self) -> Result<()> {
+        if let Some(ref avs_signer) = &self.avs_signer {
+            let address = avs_signer.eth_address();
+            let registration_location = self.checkpoint_syncer.announcement_location();
+
+            println!(
+                "Announcing to AVS, location: {:?} for validator: {:?}",
+                registration_location, address
+            );
+
+            let avs_domain = self.avs_domain.unwrap();
+
+            let service_manager = match self.staking_config.service_managers.get(&avs_domain) {
+                Some(service_manager) => service_manager,
+                None => {
+                    info!("No service manager found for AVS domain {}", avs_domain);
+                    return Ok(());
+                }
+            };
+
+            let registration = OperatorRegistrationBuilder::default()
+                .domain(avs_domain)
+                .operator(address)
+                .service_manager_address(*service_manager) // Dereference the service_manager variable
+                .salt(H256::zero()) // TODO: is this ok?
+                .expiry(operator_registration_signature_expiry())
+                .build()
+                .unwrap();
+
+            let signed_registration = avs_signer.sign(registration.clone()).await?;
+            self.checkpoint_syncer
+                .write_operator_registration(&signed_registration)
+                .await?;
+        } else {
+            info!("No AVS signer configured, skipping AVS announcement");
+        }
+        Ok(())
+    }
+
     async fn announce(&self) -> Result<()> {
         let address = self.signer.eth_address();
         let announcement_location = self.checkpoint_syncer.announcement_location();

rust/chains/hyperlane-ethereum/src/signer/mod.rs

@@ -92,12 +92,25 @@ impl HyperlaneSigner for Signers {
     }
 
     async fn sign_hash(&self, hash: &H256) -> Result<HyperlaneSignature, HyperlaneSignerError> {
+        print!("non_sign_hash: {:?}", hash);
         let mut signature = Signer::sign_message(self, hash)
             .await
             .map_err(|err| HyperlaneSignerError::from(Box::new(err) as Box<_>))?;
         signature.v = 28 - (signature.v % 2);
         Ok(signature.into())
     }
+
+    async fn sign_hash_directly(
+        &self,
+        hash: &H256,
+    ) -> Result<HyperlaneSignature, HyperlaneSignerError> {
+        let mut signature = match self {
+            Signers::Local(signer) => signer.sign_hash(hash.into()),
+            Signers::Aws(_signer) => !unimplemented!(),
+        }; // TODO: map_err
+        signature.v = 28 - (signature.v % 2);
+        Ok(signature.into())
+    }
 }
 
 /// Error types for Signers

rust/chains/hyperlane-ethereum/src/signer/singleton.rs

@@ -61,6 +61,13 @@ impl HyperlaneSigner for SingletonSignerHandle {
             Err(err) => Err(SingletonSignerError::from(err).into()),
         }
     }
+
+    async fn sign_hash_directly(
+        &self,
+        hash: &H256,
+    ) -> Result<HyperlaneSignature, HyperlaneSignerError> {
+        self.sign_hash(hash).await
+    }
 }
 
 impl SingletonSigner {

rust/hyperlane-base/src/settings/mod.rs

@@ -92,6 +92,8 @@ mod trace;
 mod checkpoint_syncer;
 pub mod parser;
 
+pub mod staking_config;
+
 /// Declare that an agent can be constructed from settings.
 ///
 /// E.g.

rust/hyperlane-base/src/settings/staking_config.rs

@@ -0,0 +1,24 @@
+use hyperlane_core::H160;
+use std::{collections::HashMap, str::FromStr};
+
+#[derive(Clone, Debug, Default)]
+pub struct StakingConf {
+    /// Address of the HyperlaneServiceManager contract
+    pub service_managers: HashMap<u32, H160>,
+}
+
+impl StakingConf {
+    pub fn default_staking_config() -> StakingConf {
+        let mut service_managers = HashMap::new();
+        service_managers.insert(
+            1,
+            H160::from_str("0xa3aC2db78AC678D9609637e23020dc210110DAE4").unwrap(),
+        );
+        service_managers.insert(
+            17000,
+            H160::from_str("0x055733000064333CaDDbC92763c58BF0192fFeBf").unwrap(),
+        ); // holesky
+
+        StakingConf { service_managers }
+    }
+}

rust/hyperlane-base/src/traits/checkpoint_syncer.rs

@@ -3,7 +3,9 @@ use std::fmt::Debug;
 use async_trait::async_trait;
 use eyre::Result;
 
-use hyperlane_core::{SignedAnnouncement, SignedCheckpointWithMessageId};
+use hyperlane_core::{
+    SignedAnnouncement, SignedCheckpointWithMessageId, SignedOperatorRegistration,
+};
 
 /// A generic trait to read/write Checkpoints offchain
 #[async_trait]
@@ -29,6 +31,11 @@ pub trait CheckpointSyncer: Debug + Send + Sync {
     ) -> Result<()>;
     /// Write the signed announcement to this syncer
     async fn write_announcement(&self, signed_announcement: &SignedAnnouncement) -> Result<()>;
+    /// Write the signed announcement to this syncer
+    async fn write_operator_registration(
+        &self,
+        signed_operator_registration: &SignedOperatorRegistration,
+    ) -> Result<()>;
     /// Return the announcement storage location for this syncer
     fn announcement_location(&self) -> String;
 }

rust/hyperlane-base/src/types/gcs_storage.rs

@@ -2,7 +2,9 @@ use crate::CheckpointSyncer;
 use async_trait::async_trait;
 use derive_new::new;
 use eyre::{bail, Result};
-use hyperlane_core::{SignedAnnouncement, SignedCheckpointWithMessageId};
+use hyperlane_core::{
+    SignedAnnouncement, SignedCheckpointWithMessageId, SignedOperatorRegistration,
+};
 use std::fmt;
 use ya_gcp::{storage::StorageClient, AuthFlow, ClientBuilder, ClientBuilderConfig};
 
@@ -186,6 +188,13 @@ impl CheckpointSyncer for GcsStorageClient {
         Ok(())
     }
 
+    async fn write_operator_registration(
+        &self,
+        _signed_operator_registration: &SignedOperatorRegistration,
+    ) -> Result<()> {
+        unimplemented!()
+    }
+
     /// Return the announcement storage location for this syncer
     fn announcement_location(&self) -> String {
         format!("gs://{}/{}", &self.bucket, ANNOUNCEMENT_KEY)

rust/hyperlane-base/src/types/local_storage.rs

@@ -2,7 +2,9 @@ use std::path::PathBuf;
 
 use async_trait::async_trait;
 use eyre::{Context, Result};
-use hyperlane_core::{SignedAnnouncement, SignedCheckpointWithMessageId};
+use hyperlane_core::{
+    SignedAnnouncement, SignedCheckpointWithMessageId, SignedOperatorRegistration,
+};
 use prometheus::IntGauge;
 
 use crate::traits::CheckpointSyncer;
@@ -40,6 +42,10 @@ impl LocalStorage {
     fn announcement_file_path(&self) -> PathBuf {
         self.path.join("announcement.json")
     }
+
+    fn operator_registration_file_path(&self) -> PathBuf {
+        self.path.join("eigenlayer_operator_registration.json")
+    }
 }
 
 #[async_trait]
@@ -100,6 +106,19 @@ impl CheckpointSyncer for LocalStorage {
         Ok(())
     }
 
+    async fn write_operator_registration(
+        &self,
+        signed_operator_registration: &SignedOperatorRegistration,
+    ) -> Result<()> {
+        let serialized_operator_registration =
+            serde_json::to_string_pretty(signed_operator_registration)?;
+        let path = self.operator_registration_file_path();
+        tokio::fs::write(&path, &serialized_operator_registration)
+            .await
+            .with_context(|| format!("Writing operator registration to {path:?}"))?;
+        Ok(())
+    }
+
     fn announcement_location(&self) -> String {
         format!("file://{}", self.path.to_str().unwrap())
     }