feat: introduce starknet verify, verifier set

Cargo.toml

@@ -86,6 +86,11 @@ tokio-stream = "0.1.11"
 tokio-util = "0.7.11"
 voting-verifier = { version = "^1.1.0", path = "contracts/voting-verifier" }
 axelar-core-std = { version = "^1.0.0", path = "packages/axelar-core-std" }
+# Async
+futures-concurrency = "7.4"
+futures-util = "0.3"
+futures = "0.3"
+async-trait = "0"
 
 [workspace.lints.clippy]
 arithmetic_side_effects = "deny"

ampd/src/handlers/mod.rs

@@ -6,6 +6,7 @@ pub mod multisig;
 pub mod mvx_verify_msg;
 pub mod mvx_verify_verifier_set;
 pub mod starknet_verify_msg;
+pub mod starknet_verify_verifier_set;
 pub(crate) mod stellar_verify_msg;
 pub(crate) mod stellar_verify_verifier_set;
 pub mod sui_verify_msg;

ampd/src/handlers/starknet_verify_verifier_set.rs

@@ -0,0 +1,161 @@
+//! Module responsible for handling verification of verifier set changes.
+//! It processes events related to verifier set, verifies them against the Starknet chain,
+//! and manages the voting process for confirming these changes.
+
+use std::convert::TryInto;
+
+use async_trait::async_trait;
+use axelar_wasm_std::msg_id::HexTxHashAndEventIndex;
+use axelar_wasm_std::voting::{PollId, Vote};
+use cosmrs::cosmwasm::MsgExecuteContract;
+use cosmrs::tx::Msg;
+use cosmrs::Any;
+use error_stack::ResultExt;
+use events::Error::EventTypeMismatch;
+use events::Event;
+use events_derive::try_from;
+use multisig::verifier_set::VerifierSet;
+use serde::Deserialize;
+use starknet_core::types::Felt;
+use tokio::sync::watch::Receiver;
+use tracing::{info, info_span};
+use valuable::Valuable;
+use voting_verifier::msg::ExecuteMsg;
+
+use crate::event_processor::EventHandler;
+use crate::handlers::errors::Error;
+use crate::starknet::json_rpc::StarknetClient;
+use crate::starknet::verifier::verify_verifier_set;
+use crate::types::TMAddress;
+
+#[derive(Deserialize, Debug)]
+pub struct VerifierSetConfirmation {
+    pub message_id: HexTxHashAndEventIndex, // FIXME: in the future replace by FieldElementAndEventIndex
+    pub verifier_set: VerifierSet,
+}
+
+#[derive(Deserialize, Debug)]
+#[try_from("wasm-verifier_set_poll_started")]
+struct PollStartedEvent {
+    poll_id: PollId,
+    source_gateway_address: String,
+    verifier_set: VerifierSetConfirmation,
+    participants: Vec<TMAddress>,
+    expires_at: u64,
+}
+
+pub struct Handler<C>
+where
+    C: StarknetClient + Send + Sync,
+{
+    verifier: TMAddress,
+    voting_verifier_contract: TMAddress,
+    rpc_client: C,
+    latest_block_height: Receiver<u64>,
+}
+
+impl<C> Handler<C>
+where
+    C: StarknetClient + Send + Sync,
+{
+    /// Handler for verifying verifier set updates from Starknet
+    ///
+    /// # Type Parameters
+    /// * `C` - A Starknet client type that implements the [`StarknetClient`] trait
+    #[allow(dead_code)]
+    pub fn new(
+        verifier: TMAddress,
+        voting_verifier_contract: TMAddress,
+        rpc_client: C,
+        latest_block_height: Receiver<u64>,
+    ) -> Self {
+        Self {
+            verifier,
+            voting_verifier_contract,
+            rpc_client,
+            latest_block_height,
+        }
+    }
+
+    fn vote_msg(&self, poll_id: PollId, vote: Vote) -> MsgExecuteContract {
+        MsgExecuteContract {
+            sender: self.verifier.as_ref().clone(),
+            contract: self.voting_verifier_contract.as_ref().clone(),
+            msg: serde_json::to_vec(&ExecuteMsg::Vote {
+                poll_id,
+                votes: vec![vote],
+            })
+            .expect("vote msg should serialize"),
+            funds: vec![],
+        }
+    }
+}
+
+#[async_trait]
+impl<C> EventHandler for Handler<C>
+where
+    C: StarknetClient + Send + Sync + 'static,
+{
+    type Err = Error;
+
+    async fn handle(&self, event: &Event) -> error_stack::Result<Vec<Any>, Self::Err> {
+        if !event.is_from_contract(self.voting_verifier_contract.as_ref()) {
+            return Ok(vec![]);
+        }
+
+        let PollStartedEvent {
+            poll_id,
+            source_gateway_address,
+            verifier_set,
+            expires_at,
+            participants,
+        } = match event.try_into() as error_stack::Result<_, _> {
+            Err(report) if matches!(report.current_context(), EventTypeMismatch(_)) => {
+                return Ok(vec![])
+            }
+            event => event.change_context(Error::DeserializeEvent)?,
+        };
+
+        if !participants.contains(&self.verifier) {
+            return Ok(vec![]);
+        }
+
+        if *self.latest_block_height.borrow() >= expires_at {
+            info!(poll_id = poll_id.to_string(), "skipping expired poll");
+            return Ok(vec![]);
+        }
+
+        let transaction_response = self
+            .rpc_client
+            .get_event_by_hash_signers_rotated(Felt::from_bytes_be(
+                &verifier_set.message_id.tx_hash,
+            ))
+            .await
+            .unwrap();
+
+        let vote = info_span!(
+            "verify a new verifier set",
+            poll_id = poll_id.to_string(),
+            message_id = verifier_set.message_id.to_string(),
+        )
+        .in_scope(|| {
+            info!("ready to verify verifier set in poll",);
+
+            let vote = transaction_response.map_or(Vote::NotFound, |tx_receipt| {
+                verify_verifier_set(&tx_receipt.1, &verifier_set, &source_gateway_address)
+            });
+
+            info!(
+                vote = vote.as_value(),
+                "ready to vote for a new verifier set in poll"
+            );
+
+            vote
+        });
+
+        Ok(vec![self
+            .vote_msg(poll_id, vote)
+            .into_any()
+            .expect("vote msg should serialize")])
+    }
+}