fix(ampd): skip events from unknown contracts

ampd/src/handlers/evm_verify_msg.rs

@@ -41,8 +41,6 @@
 #[derive(Deserialize, Debug)]
 #[try_from("wasm-messages_poll_started")]
 struct PollStartedEvent {
-    #[serde(rename = "_contract_address")]
-    contract_address: TMAddress,
     poll_id: PollId,
     source_chain: connection_router::state::ChainName,
     source_gateway_address: EVMAddress,
@@ -150,8 +148,11 @@
     type Err = Error;
 
     async fn handle(&self, event: &events::Event) -> Result<()> {
+        if !event.is_from_contract(self.voting_verifier.as_ref()) {
+            return Ok(());
+        }
+
         let PollStartedEvent {
-            contract_address,
             poll_id,
             source_chain,
             source_gateway_address,
@@ -166,10 +167,6 @@
             event => event.change_context(DeserializeEvent)?,
         };
 
-        if self.voting_verifier != contract_address {
-            return Ok(());
-        }
-
         if self.chain != source_chain {
             return Ok(());
         }

ampd/src/handlers/evm_verify_worker_set.rs

@@ -41,8 +41,6 @@
 #[derive(Deserialize, Debug)]
 #[try_from("wasm-worker_set_poll_started")]
 struct PollStartedEvent {
-    #[serde(rename = "_contract_address")]
-    contract_address: TMAddress,
     worker_set: WorkerSetConfirmation,
     poll_id: PollId,
     source_chain: connection_router::state::ChainName,
@@ -146,8 +144,11 @@
     type Err = Error;
 
     async fn handle(&self, event: &events::Event) -> Result<()> {
+        if !event.is_from_contract(self.voting_verifier.as_ref()) {
+            return Ok(());
+        }
+
         let PollStartedEvent {
-            contract_address,
             poll_id,
             source_chain,
             source_gateway_address,
@@ -162,10 +163,6 @@
             event => event.change_context(Error::DeserializeEvent)?,
         };
 
-        if self.voting_verifier != contract_address {
-            return Ok(());
-        }
-
         if self.chain != source_chain {
             return Ok(());
         }

ampd/src/handlers/multisig.rs

@@ -28,8 +28,6 @@
 #[derive(Debug, Deserialize)]
 #[try_from("wasm-signing_started")]
 struct SigningStartedEvent {
-    #[serde(rename = "_contract_address")]
-    contract_address: TMAddress,
     session_id: u64,
     #[serde(deserialize_with = "deserialize_public_keys")]
     pub_keys: HashMap<TMAddress, PublicKey>,
@@ -132,8 +130,11 @@
     type Err = Error;
 
     async fn handle(&self, event: &events::Event) -> error_stack::Result<(), Error> {
+        if !event.is_from_contract(self.multisig.as_ref()) {
+            return Ok(());
+        }
+
         let SigningStartedEvent {
-            contract_address,
             session_id,
             pub_keys,
             msg,
@@ -145,10 +146,6 @@
             result => result.change_context(DeserializeEvent)?,
         };
 
-        if self.multisig != contract_address {
-            return Ok(());
-        }
-
         info!(
             session_id = session_id,
             msg = encode(&msg),
@@ -278,6 +275,38 @@
         .unwrap()
     }
 
+    // this returns an event that is named SigningStarted, but some expected fields are missing
+    fn signing_started_event_with_missing_fields(contract_address: &str) -> events::Event {
+        let pub_keys = (0..10)
+            .map(|_| (rand_account().to_string(), rand_public_key()))
+            .collect::<HashMap<String, PublicKey>>();
+
+        let poll_started = SigningStarted {
+            session_id: Uint64::one(),
+            worker_set_id: "worker_set_id".to_string(),
+            pub_keys,
+            msg: MsgToSign::unchecked(rand_message()),
+            chain_name: rand_chain_name(),
+            expires_at: 100u64,
+        };
+
+        let mut event: cosmwasm_std::Event = poll_started.into();
+        event.ty = format!("wasm-{}", event.ty);
+        event = event.add_attribute("_contract_address", contract_address);
+        event.attributes.retain(|attr| attr.key != "expires_at");
+
+        events::Event::try_from(abci::Event::new(
+            event.ty,
+            event
+                .attributes
+                .into_iter()
+                .map(|cosmwasm_std::Attribute { key, value }| {
+                    (STANDARD.encode(key), STANDARD.encode(value))
+                }),
+        ))
+        .unwrap()
+    }
+
     fn get_handler(
         worker: TMAddress,
         multisig: TMAddress,
@@ -292,7 +321,7 @@
         let (broadcaster, _) =
             QueuedBroadcaster::new(broadcaster, Gas::default(), 100, Duration::from_secs(5));
 
-        let (tx, rx) = watch::channel(latest_block_height);
+        let (_, rx) = watch::channel(latest_block_height);
 
         Handler::new(worker, multisig, broadcaster.client(), signer, rx)
     }
@@ -352,12 +381,45 @@
         assert!(event.is_ok());
     }
 
+    #[tokio::test]
+    async fn should_not_handle_event_with_missing_fields_if_multisig_address_does_not_match() {
+        let client = MockEcdsaClient::new();
+
+        let handler = get_handler(
+            rand_account(),
+            TMAddress::from(MULTISIG_ADDRESS.parse::<AccountId>().unwrap()),
+            SharableEcdsaClient::new(client),
+            100u64,
+        );
+
+        assert!(handler
+            .handle(&signing_started_event_with_missing_fields(
+                &rand_account().to_string()
+            ))
+            .await
+            .is_ok());
+    }
+
+    #[tokio::test]
+    async fn should_error_on_event_with_missing_fields_if_multisig_address_does_match() {
+        let client = MockEcdsaClient::new();
+
+        let handler = get_handler(
+            rand_account(),
+            TMAddress::from(MULTISIG_ADDRESS.parse::<AccountId>().unwrap()),
+            SharableEcdsaClient::new(client),
+            100u64,
+        );
+
+        assert!(handler
+            .handle(&signing_started_event_with_missing_fields(MULTISIG_ADDRESS))
+            .await
+            .is_err());
+    }
+
     #[tokio::test]
     async fn should_not_handle_event_if_multisig_address_does_not_match() {
-        let mut client = MockEcdsaClient::new();
-        client
-            .expect_sign()
-            .returning(move |_, _, _| Err(Report::from(tofnd::error::Error::SignFailed)));
+        let client = MockEcdsaClient::new();
 
         let handler = get_handler(
             rand_account(),

ampd/src/handlers/sui_verify_msg.rs

@@ -35,8 +35,6 @@ pub struct Message {
 #[derive(Deserialize, Debug)]
 #[try_from("wasm-messages_poll_started")]
 struct PollStartedEvent {
-    #[serde(rename = "_contract_address")]
-    contract_address: TMAddress,
     poll_id: PollId,
     source_gateway_address: SuiAddress,
     messages: Vec<Message>,
@@ -102,8 +100,11 @@ where
     type Err = Error;
 
     async fn handle(&self, event: &Event) -> Result<()> {
+        if !event.is_from_contract(self.voting_verifier.as_ref()) {
+            return Ok(());
+        }
+
         let PollStartedEvent {
-            contract_address,
             poll_id,
             source_gateway_address,
             messages,
@@ -117,10 +118,6 @@ where
             event => event.change_context(Error::DeserializeEvent)?,
         };
 
-        if self.voting_verifier != contract_address {
-            return Ok(());
-        }
-
         if !participants.contains(&self.worker) {
             return Ok(());
         }

ampd/src/handlers/sui_verify_worker_set.rs

@@ -40,8 +40,6 @@
 #[derive(Deserialize, Debug)]
 #[try_from("wasm-worker_set_poll_started")]
 struct PollStartedEvent {
-    #[serde(rename = "_contract_address")]
-    contract_address: TMAddress,
     poll_id: PollId,
     source_gateway_address: SuiAddress,
     worker_set: WorkerSetConfirmation,
@@ -110,8 +108,11 @@
     type Err = Error;
 
     async fn handle(&self, event: &Event) -> error_stack::Result<(), Error> {
+        if !event.is_from_contract(self.voting_verifier.as_ref()) {
+            return Ok(());
+        }
+
         let PollStartedEvent {
-            contract_address,
             poll_id,
             source_gateway_address,
             worker_set,
@@ -125,10 +126,6 @@
             event => event.change_context(Error::DeserializeEvent)?,
         };
 
-        if self.voting_verifier != contract_address {
-            return Ok(());
-        }
-
         if !participants.contains(&self.worker) {
             return Ok(());
         }

packages/events/Cargo.toml

@@ -8,6 +8,7 @@ edition = "2021"
 [dependencies]
 axelar-wasm-std = { workspace = true }
 base64 = "0.21.2"
+cosmrs = { version = "0.14.0", features = ["cosmwasm"] }
 error-stack = { workspace = true }
 serde_json = "1.0.105"
 # Need to switch to our own fork of tendermint and tendermint-rpc due to event attribute value being nullable.

packages/events/src/event.rs

@@ -9,6 +9,8 @@
 use crate::errors::DecodingError;
 use crate::Error;
 
+use cosmrs::AccountId;
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Event {
     BlockBegin(block::Height),
@@ -27,6 +29,25 @@
     pub fn block_end(height: impl Into<block::Height>) -> Self {
         Event::BlockEnd(height.into())
     }
+
+    pub fn is_from_contract(&self, from_address: &AccountId) -> bool {
+        match self.contract_address() {
+            Some(emitting_address) => &emitting_address == from_address,
+            _ => false,
+        }
+    }
+
+    fn contract_address(&self) -> Option<AccountId> {
+        match self {
+            Event::Abci {
+                event_type: _,
+                attributes,
+            } => attributes
+                .get("_contract_address")
+                .and_then(|address| serde_json::from_value::<AccountId>(address.clone()).ok()),
+            _ => None,
+        }
+    }
 }
 
 impl TryFrom<abci::Event> for Event {
@@ -71,3 +92,70 @@
 fn base64_to_utf8(base64_str: &str) -> std::result::Result<String, DecodingError> {
     Ok(STANDARD.decode(base64_str)?.then(String::from_utf8)?)
 }
+
+#[cfg(test)]
+mod test {
+    use std::str::FromStr;
+
+    use cosmrs::AccountId;
+
+    use crate::Event;
+
+    fn make_event_with_contract_address(contract_address: &AccountId) -> Event {
+        let mut attributes = serde_json::Map::new();
+        attributes.insert(
+            "_contract_address".to_string(),
+            contract_address.to_string().into(),
+        );
+        Event::Abci {
+            event_type: "some_event".to_string(),
+            attributes,
+        }
+    }
+
+    #[test]
+    fn should_get_contract_address_if_exists() {
+        let expected_contract_address =
+            AccountId::from_str("axelarvaloper1zh9wrak6ke4n6fclj5e8yk397czv430ygs5jz7").unwrap();
+
+        let event = make_event_with_contract_address(&expected_contract_address);
+
+        let contract_address = event.contract_address();
+        assert_eq!(contract_address, Some(expected_contract_address));
+    }
+
+    #[test]
+    fn should_not_get_contract_address_if_not_exists() {
+        let event = Event::Abci {
+            event_type: "some_event".to_string(),
+            attributes: serde_json::Map::new(),
+        };
+        let contract_address = event.contract_address();
+        assert!(contract_address.is_none());
+    }
+
+    #[test]
+    fn event_is_from_contract_should_return_true_iff_contract_address_matches() {
+        let contract_address =
+            AccountId::from_str("axelarvaloper1zh9wrak6ke4n6fclj5e8yk397czv430ygs5jz7").unwrap();
+        let event = make_event_with_contract_address(&contract_address);
+        assert!(event.is_from_contract(&contract_address));
+
+        let diff_contract_address =
+            AccountId::from_str("axelarvaloper1tee73c83k2vqky9gt59jd3ztwxhqjm27l588q6").unwrap();
+        assert!(!event.is_from_contract(&diff_contract_address));
+    }
+
+    #[test]
+    fn event_is_from_contract_should_return_false_if_contract_address_does_not_exist() {
+        let contract_address =
+            AccountId::from_str("axelarvaloper1zh9wrak6ke4n6fclj5e8yk397czv430ygs5jz7").unwrap();
+
+        let event_without_contract_address = Event::Abci {
+            event_type: "some_event".to_string(),
+            attributes: serde_json::Map::new(),
+        };
+
+        assert!(!event_without_contract_address.is_from_contract(&contract_address));
+    }
+}