Merge branch 'main' into feat/bcs-msg-to-sign

.github/workflows/codecov.yaml

@@ -4,8 +4,8 @@ on:
   pull_request:
   push:
     branches:
-      - 'main'
-      - 'releases/**'
+      - main
+      - releases/**
 
 jobs:
   coverage:
@@ -35,6 +35,9 @@ jobs:
 
       - name: Generate code coverage
         run: cargo llvm-cov --workspace --lcov --output-path lcov.info
+        env:
+          RUSTFLAGS: --cfg tracing_unstable
+          RUST_BACKTRACE: 1
 
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v3

ampd/src/evm/mod.rs

@@ -16,8 +16,8 @@ pub enum ChainName {
     Other(String),
 }
 
-impl PartialEq<connection_router::types::ChainName> for ChainName {
-    fn eq(&self, other: &connection_router::types::ChainName) -> bool {
+impl PartialEq<connection_router::state::ChainName> for ChainName {
+    fn eq(&self, other: &connection_router::state::ChainName) -> bool {
         self.to_string().eq_ignore_ascii_case(&other.to_string())
     }
 }
@@ -44,28 +44,26 @@ impl ChainName {
 
 #[cfg(test)]
 mod tests {
+    use crate::evm;
+    use connection_router::state::ChainName;
     use std::str::FromStr;
 
-    use crate::evm::ChainName;
-
     #[test]
     fn chain_name_partial_eq() {
-        let chain_name = ChainName::Ethereum;
+        let chain_name = evm::ChainName::Ethereum;
 
-        assert!(chain_name == connection_router::types::ChainName::from_str("Ethereum").unwrap());
-        assert!(chain_name == connection_router::types::ChainName::from_str("ETHEREUM").unwrap());
-        assert!(chain_name == connection_router::types::ChainName::from_str("ethereum").unwrap());
-        assert!(chain_name == connection_router::types::ChainName::from_str("ethEReum").unwrap());
-        assert!(chain_name != connection_router::types::ChainName::from_str("Ethereum-1").unwrap());
+        assert_eq!(chain_name, ChainName::from_str("Ethereum").unwrap());
+        assert_eq!(chain_name, ChainName::from_str("ETHEREUM").unwrap());
+        assert_eq!(chain_name, ChainName::from_str("ethereum").unwrap());
+        assert_eq!(chain_name, ChainName::from_str("ethEReum").unwrap());
+        assert_ne!(chain_name, ChainName::from_str("Ethereum-1").unwrap());
 
-        let chain_name = ChainName::Other("avalanche".into());
+        let chain_name = evm::ChainName::Other("avalanche".into());
 
-        assert!(chain_name == connection_router::types::ChainName::from_str("Avalanche").unwrap());
-        assert!(chain_name == connection_router::types::ChainName::from_str("AVALANCHE").unwrap());
-        assert!(chain_name == connection_router::types::ChainName::from_str("avalanche").unwrap());
-        assert!(chain_name == connection_router::types::ChainName::from_str("avaLAnche").unwrap());
-        assert!(
-            chain_name != connection_router::types::ChainName::from_str("Avalanche-2").unwrap()
-        );
+        assert_eq!(chain_name, ChainName::from_str("Avalanche").unwrap());
+        assert_eq!(chain_name, ChainName::from_str("AVALANCHE").unwrap());
+        assert_eq!(chain_name, ChainName::from_str("avalanche").unwrap());
+        assert_eq!(chain_name, ChainName::from_str("avaLAnche").unwrap());
+        assert_ne!(chain_name, ChainName::from_str("Avalanche-2").unwrap());
     }
 }

ampd/src/handlers/evm_verify_msg.rs

@@ -11,7 +11,7 @@ use tracing::{info, info_span};
 use valuable::Valuable;
 
 use axelar_wasm_std::voting::PollID;
-use connection_router::types::ID_SEPARATOR;
+use connection_router::state::ID_SEPARATOR;
 use events::Error::EventTypeMismatch;
 use events_derive::try_from;
 use voting_verifier::msg::ExecuteMsg;
@@ -32,7 +32,7 @@ pub struct Message {
     pub tx_id: Hash,
     pub event_index: u64,
     pub destination_address: String,
-    pub destination_chain: connection_router::types::ChainName,
+    pub destination_chain: connection_router::state::ChainName,
     pub source_address: EVMAddress,
     pub payload_hash: Hash,
 }
@@ -43,7 +43,7 @@ struct PollStartedEvent {
     #[serde(rename = "_contract_address")]
     contract_address: TMAddress,
     poll_id: PollID,
-    source_chain: connection_router::types::ChainName,
+    source_chain: connection_router::state::ChainName,
     source_gateway_address: EVMAddress,
     confirmation_height: u64,
     messages: Vec<Message>,
@@ -233,7 +233,7 @@ mod tests {
 
     use events::Error::{DeserializationFailed, EventTypeMismatch};
     use events::Event;
-    use voting_verifier::events::{MessageByTxEvent, PollMetadata, PollStarted};
+    use voting_verifier::events::{PollMetadata, PollStarted, TxEventConfirmation};
 
     use crate::types::{EVMAddress, Hash};
 
@@ -244,7 +244,9 @@ mod tests {
             metadata: PollMetadata {
                 poll_id: "100".parse().unwrap(),
                 source_chain: "ethereum".parse().unwrap(),
-                source_gateway_address: "0x4f4495243837681061c4743b74eedf548d5686a5".into(),
+                source_gateway_address: "0x4f4495243837681061c4743b74eedf548d5686a5"
+                    .parse()
+                    .unwrap(),
                 confirmation_height: 15,
                 expires_at: 100,
                 participants: vec![
@@ -260,28 +262,28 @@ mod tests {
                 ],
             },
             messages: vec![
-                MessageByTxEvent {
-                    tx_id: format!("0x{:x}", Hash::random()),
+                TxEventConfirmation {
+                    tx_id: format!("0x{:x}", Hash::random()).parse().unwrap(),
                     event_index: 0,
-                    source_address: format!("0x{:x}", EVMAddress::random()),
+                    source_address: format!("0x{:x}", EVMAddress::random()).parse().unwrap(),
                     destination_chain: "ethereum".parse().unwrap(),
-                    destination_address: format!("0x{:x}", EVMAddress::random()),
+                    destination_address: format!("0x{:x}", EVMAddress::random()).parse().unwrap(),
                     payload_hash: HexBinary::from(Hash::random().as_bytes()),
                 },
-                MessageByTxEvent {
-                    tx_id: format!("0x{:x}", Hash::random()),
+                TxEventConfirmation {
+                    tx_id: format!("0x{:x}", Hash::random()).parse().unwrap(),
                     event_index: 1,
-                    source_address: format!("0x{:x}", EVMAddress::random()),
+                    source_address: format!("0x{:x}", EVMAddress::random()).parse().unwrap(),
                     destination_chain: "ethereum".parse().unwrap(),
-                    destination_address: format!("0x{:x}", EVMAddress::random()),
+                    destination_address: format!("0x{:x}", EVMAddress::random()).parse().unwrap(),
                     payload_hash: HexBinary::from(Hash::random().as_bytes()),
                 },
-                MessageByTxEvent {
-                    tx_id: format!("0x{:x}", Hash::random()),
+                TxEventConfirmation {
+                    tx_id: format!("0x{:x}", Hash::random()).parse().unwrap(),
                     event_index: 10,
-                    source_address: format!("0x{:x}", EVMAddress::random()),
+                    source_address: format!("0x{:x}", EVMAddress::random()).parse().unwrap(),
                     destination_chain: "ethereum".parse().unwrap(),
-                    destination_address: format!("0x{:x}", EVMAddress::random()),
+                    destination_address: format!("0x{:x}", EVMAddress::random()).parse().unwrap(),
                     payload_hash: HexBinary::from(Hash::random().as_bytes()),
                 },
             ],

ampd/src/handlers/evm_verify_worker_set.rs

@@ -11,7 +11,7 @@ use events::Error::EventTypeMismatch;
 use events_derive::try_from;
 
 use axelar_wasm_std::voting::PollID;
-use connection_router::types::ID_SEPARATOR;
+use connection_router::state::ID_SEPARATOR;
 use voting_verifier::msg::ExecuteMsg;
 
 use crate::event_processor::EventHandler;
@@ -43,7 +43,7 @@ struct PollStartedEvent {
     contract_address: TMAddress,
     worker_set: WorkerSetConfirmation,
     poll_id: PollID,
-    source_chain: connection_router::types::ChainName,
+    source_chain: connection_router::state::ChainName,
     source_gateway_address: EVMAddress,
     confirmation_height: u64,
     participants: Vec<TMAddress>,
@@ -216,7 +216,7 @@ mod tests {
     fn get_poll_started_event() -> Event {
         let poll_started = PollStarted::WorkerSet {
             worker_set: WorkerSetConfirmation {
-                tx_id: format!("0x{:x}", Hash::random()),
+                tx_id: format!("0x{:x}", Hash::random()).parse().unwrap(),
                 event_index: 100,
                 operators: Operators {
                     threshold: 40u64.into(),
@@ -239,7 +239,9 @@ mod tests {
             metadata: PollMetadata {
                 poll_id: "100".parse().unwrap(),
                 source_chain: "ethereum".parse().unwrap(),
-                source_gateway_address: "0x4f4495243837681061c4743b74eedf548d5686a5".into(),
+                source_gateway_address: "0x4f4495243837681061c4743b74eedf548d5686a5"
+                    .parse()
+                    .unwrap(),
                 confirmation_height: 15,
                 expires_at: 100,
                 participants: vec![

contracts/aggregate-verifier/Cargo.toml

@@ -43,6 +43,7 @@ schemars = "0.8.10"
 serde = { version = "1.0.145", default-features = false, features = ["derive"] }
 serde_json = "1.0.89"
 thiserror = { workspace = true }
+voting-verifier = { workspace = true, features = ["library"] }
 
 [dev-dependencies]
 cw-multi-test = "0.15.1"

contracts/aggregate-verifier/src/contract.rs

@@ -1,3 +1,4 @@
+use connection_router::state::CrossChainId;
 #[cfg(not(feature = "library"))]
 use cosmwasm_std::entry_point;
 use cosmwasm_std::{
@@ -6,15 +7,14 @@ use cosmwasm_std::{
 };
 use cw_utils::{parse_reply_execute_data, MsgExecuteContractResponse};
 
+use voting_verifier::msg as voting_msg;
+
 use crate::{
     error::ContractError,
     msg::{ExecuteMsg, InstantiateMsg, QueryMsg},
     state::{Config, CONFIG},
 };
 
-use connection_router::msg;
-use connection_router::state;
-
 use self::execute::verify_messages;
 
 #[cfg_attr(not(feature = "library"), entry_point)]
@@ -38,28 +38,21 @@ pub fn execute(
     msg: ExecuteMsg,
 ) -> Result<Response, axelar_wasm_std::ContractError> {
     match msg {
-        ExecuteMsg::VerifyMessages { messages } => {
-            // todo: this conversion can go away once the message types are merged
-            let msgs = messages
-                .into_iter()
-                .map(state::Message::try_from)
-                .collect::<Result<Vec<state::Message>, _>>()?;
-
-            verify_messages(deps, msgs)
-        }
+        ExecuteMsg::VerifyMessages { messages } => verify_messages(deps, messages),
     }
     .map_err(axelar_wasm_std::ContractError::from)
 }
 
 pub mod execute {
-
     use cosmwasm_std::{to_binary, SubMsg, WasmMsg};
 
+    use connection_router::state::NewMessage;
+
     use super::*;
 
     pub fn verify_messages(
         deps: DepsMut,
-        msgs: Vec<state::Message>,
+        msgs: Vec<NewMessage>,
     ) -> Result<Response, ContractError> {
         // Simply pass through to a single verifier for now. If there are multiple verification
         // methods in the future, as well as support for a callback when a message is actually
@@ -68,9 +61,7 @@ pub mod execute {
         Ok(Response::new().add_submessage(SubMsg::reply_on_success(
             WasmMsg::Execute {
                 contract_addr: verifier.to_string(),
-                msg: to_binary(&ExecuteMsg::VerifyMessages {
-                    messages: msgs.into_iter().map(msg::Message::from).collect(),
-                })?,
+                msg: to_binary(&voting_msg::ExecuteMsg::VerifyMessages { messages: msgs })?,
                 funds: vec![],
             },
             VERIFY_REPLY,
@@ -90,7 +81,7 @@ pub fn reply(
     match parse_reply_execute_data(reply) {
         Ok(MsgExecuteContractResponse { data: Some(data) }) => {
             // check format of data
-            let _: Vec<(String, bool)> = from_binary(&data)?;
+            let _: Vec<(CrossChainId, bool)> = from_binary(&data)?;
 
             // only one verifier, so just return the response as is
             Ok(Response::new().set_data(data))
@@ -109,11 +100,11 @@ pub fn reply(
 #[cfg_attr(not(feature = "library"), entry_point)]
 pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult<Binary> {
     match msg {
-        QueryMsg::IsVerified { messages: _ } => {
+        QueryMsg::IsVerified { messages } => {
             let verifier = CONFIG.load(deps.storage)?.verifier;
             deps.querier.query(&QueryRequest::Wasm(WasmQuery::Smart {
                 contract_addr: verifier.to_string(),
-                msg: to_binary(&msg)?,
+                msg: to_binary(&voting_msg::QueryMsg::IsVerified { messages })?,
             }))
         }
     }

contracts/aggregate-verifier/src/msg.rs

@@ -1,4 +1,4 @@
-use connection_router::msg::Message;
+use connection_router::state::NewMessage;
 use cosmwasm_schema::cw_serde;
 
 #[cw_serde]
@@ -8,12 +8,11 @@ pub struct InstantiateMsg {
 
 #[cw_serde]
 pub enum ExecuteMsg {
-    // Returns a vector of (String,bool) tuples for each passed in message, consisting of message ID and current verification status
     // Permissionless
-    VerifyMessages { messages: Vec<Message> },
+    VerifyMessages { messages: Vec<NewMessage> },
 }
 
 #[cw_serde]
 pub enum QueryMsg {
-    IsVerified { messages: Vec<Message> },
+    IsVerified { messages: Vec<NewMessage> },
 }

contracts/aggregate-verifier/tests/mock.rs

@@ -1,16 +1,16 @@
 use aggregate_verifier::error::ContractError;
-use connection_router::msg::Message;
+use connection_router::state::{CrossChainId, NewMessage};
 use cosmwasm_schema::cw_serde;
 use cosmwasm_std::{to_binary, Addr, DepsMut, Env, MessageInfo, Response};
 use cw_multi_test::{App, ContractWrapper, Executor};
 use cw_storage_plus::Map;
 
-const MOCK_VOTING_VERIFIER_MESSAGES: Map<String, bool> = Map::new("voting_verifier_messages");
+const MOCK_VOTING_VERIFIER_MESSAGES: Map<CrossChainId, bool> = Map::new("voting_verifier_messages");
 
 #[cw_serde]
 pub enum MockVotingVerifierExecuteMsg {
-    VerifyMessages { messages: Vec<Message> },
-    MessagesVerified { messages: Vec<Message> },
+    VerifyMessages { messages: Vec<NewMessage> },
+    MessagesVerified { messages: Vec<NewMessage> },
 }
 
 #[cw_serde]
@@ -26,18 +26,16 @@ pub fn mock_verifier_execute(
         MockVotingVerifierExecuteMsg::VerifyMessages { messages } => {
             let mut res = vec![];
             for m in messages {
-                let m = connection_router::state::Message::try_from(m).unwrap();
-                match MOCK_VOTING_VERIFIER_MESSAGES.may_load(deps.storage, m.id.to_string())? {
-                    Some(b) => res.push((m.id.to_string(), b)),
-                    None => res.push((m.id.to_string(), false)),
+                match MOCK_VOTING_VERIFIER_MESSAGES.may_load(deps.storage, m.cc_id.clone())? {
+                    Some(b) => res.push((m.cc_id, b)),
+                    None => res.push((m.cc_id, false)),
                 }
             }
             Ok(Response::new().set_data(to_binary(&res)?))
         }
         MockVotingVerifierExecuteMsg::MessagesVerified { messages } => {
             for m in messages {
-                let m = connection_router::state::Message::try_from(m).unwrap();
-                MOCK_VOTING_VERIFIER_MESSAGES.save(deps.storage, m.id.to_string(), &true)?;
+                MOCK_VOTING_VERIFIER_MESSAGES.save(deps.storage, m.cc_id, &true)?;
             }
             Ok(Response::new())
         }
@@ -47,7 +45,7 @@ pub fn mock_verifier_execute(
 pub fn mark_messages_as_verified(
     app: &mut App,
     voting_verifier_address: Addr,
-    msgs: Vec<connection_router::msg::Message>,
+    msgs: Vec<NewMessage>,
 ) {
     app.execute_contract(
         Addr::unchecked("relayer"),