chore: disallow casts with possible truncations (axelarnetwork#463)

Cargo.toml

@@ -45,6 +45,7 @@ tokio-util = "0.7.11"
 
 [workspace.lints.clippy]
 arithmetic_side_effects = "deny"
+cast_possible_truncation = "deny"
 
 [profile.release]
 opt-level = 3

ampd/src/block_height_monitor.rs

@@ -89,6 +89,7 @@ mod tests {
     use async_trait::async_trait;
 
     #[test]
+    #[allow(clippy::cast_possible_truncation)]
     async fn latest_block_height_should_work() {
         let block: tendermint::Block =
             serde_json::from_str(include_str!("tests/axelar_block.json")).unwrap();

ampd/src/event_sub.rs

@@ -244,6 +244,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cast_possible_truncation)]
     async fn start_from_should_work() {
         let block_count = 10;
         let block: tendermint::Block =
@@ -424,6 +425,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cast_possible_truncation)]
     async fn stream_should_work() {
         let block_count = 10;
         let block: tendermint::Block =

contracts/gateway/tests/contract.rs

@@ -334,15 +334,15 @@ fn test_cases_for_duplicate_msgs() -> (
 }
 
 fn generate_msgs_with_all_statuses(
-    count_per_status: i32,
+    count_per_status: u8,
 ) -> HashMap<VerificationStatus, Vec<Message>> {
     all_statuses()
         .into_iter()
         .map(|status| (status, generate_msgs(status, count_per_status)))
         .collect::<HashMap<VerificationStatus, Vec<Message>>>()
 }
 
-fn generate_msgs(namespace: impl Debug, count: i32) -> Vec<Message> {
+fn generate_msgs(namespace: impl Debug, count: u8) -> Vec<Message> {
     (0..count)
         .map(|i| Message {
             cc_id: CrossChainId {
@@ -352,7 +352,7 @@ fn generate_msgs(namespace: impl Debug, count: i32) -> Vec<Message> {
             destination_address: "idc".parse().unwrap(),
             destination_chain: "mock-chain-2".parse().unwrap(),
             source_address: "idc".parse().unwrap(),
-            payload_hash: [i as u8; 32],
+            payload_hash: [i; 32],
         })
         .collect()
 }

contracts/rewards/src/contract/execute.rs

@@ -913,7 +913,7 @@ mod test {
         let rewards_claimed = distribute_rewards(
             mock_deps.as_mut().storage,
             pool_id,
-            block_height_started + epoch_duration * (epoch_count + 2) as u64,
+            block_height_started + epoch_duration * (epoch_count as u64 + 2),
             None,
         )
         .unwrap();

contracts/router/src/contract.rs

@@ -196,7 +196,7 @@ mod test {
         .unwrap();
     }
 
-    #[allow(clippy::arithmetic_side_effects)]
+    #[allow(clippy::arithmetic_side_effects, clippy::cast_possible_truncation)]
     fn generate_messages(
         src_chain: &Chain,
         dest_chain: &Chain,

contracts/service-registry/src/contract.rs

@@ -1763,6 +1763,7 @@ mod test {
     }
 
     #[test]
+    #[allow(clippy::cast_possible_truncation)]
     fn get_active_verifiers_should_not_return_less_than_min() {
         let mut deps = setup();
 

contracts/voting-verifier/src/contract.rs

@@ -207,27 +207,27 @@ mod test {
         deps
     }
 
-    fn message_id(id: &str, index: u64, msg_id_format: &MessageIdFormat) -> nonempty::String {
+    fn message_id(id: &str, index: u32, msg_id_format: &MessageIdFormat) -> nonempty::String {
         let tx_hash = Keccak256::digest(id.as_bytes()).into();
         match msg_id_format {
             MessageIdFormat::HexTxHashAndEventIndex => HexTxHashAndEventIndex {
                 tx_hash,
-                event_index: index as u32,
+                event_index: index,
             }
             .to_string()
             .parse()
             .unwrap(),
             MessageIdFormat::Base58TxDigestAndEventIndex => Base58TxDigestAndEventIndex {
                 tx_digest: tx_hash,
-                event_index: index as u32,
+                event_index: index,
             }
             .to_string()
             .parse()
             .unwrap(),
         }
     }
 
-    fn messages(len: u64, msg_id_format: &MessageIdFormat) -> Vec<Message> {
+    fn messages(len: u32, msg_id_format: &MessageIdFormat) -> Vec<Message> {
         (0..len)
             .map(|i| Message {
                 cc_id: CrossChainId {
@@ -362,7 +362,7 @@ mod test {
         let mut deps = setup(verifiers.clone(), &msg_id_format);
         let messages_count = 5;
         let messages_in_progress = 3;
-        let messages = messages(messages_count as u64, &msg_id_format);
+        let messages = messages(messages_count as u32, &msg_id_format);
 
         execute(
             deps.as_mut(),
@@ -1157,7 +1157,7 @@ mod test {
 
         // simulate a majority of verifiers voting for succeeded on chain
         verifiers.iter().enumerate().for_each(|(i, verifier)| {
-            if i >= majority as usize {
+            if i as u64 >= majority {
                 return;
             }
             let msg = ExecuteMsg::Vote {
@@ -1266,7 +1266,7 @@ mod test {
         // which is one less than the updated majority. The messages
         // should not receive enough votes to be considered verified
         verifiers.iter().enumerate().for_each(|(i, verifier)| {
-            if i >= old_majority as usize {
+            if i as u64 >= old_majority {
                 return;
             }
             let msg = ExecuteMsg::Vote {

contracts/voting-verifier/src/execute.rs

@@ -231,14 +231,17 @@ pub fn vote(
 
     let results_after_voting = get_poll_results(&poll);
 
-    let quorum_events = (results_after_voting.difference(results_before_voting))
+    let quorum_events = results_after_voting
+        .difference(results_before_voting)
         .expect("failed to substract poll results")
         .0
         .into_iter()
         .enumerate()
         .filter_map(|(idx, vote)| vote.map(|vote| (idx, vote)))
         .map(|(index_in_poll, vote)| {
-            make_quorum_event(&vote, index_in_poll as u32, &poll_id, &poll, &deps)
+            let idx = u32::try_from(index_in_poll)
+                .expect("the amount of votes should never overflow u32");
+            make_quorum_event(&vote, idx, &poll_id, &poll, &deps)
         })
         .collect::<Result<Vec<Event>, _>>()?;
 

contracts/voting-verifier/src/query.rs

@@ -219,13 +219,13 @@ mod tests {
         );
     }
 
-    fn message(id: u64) -> Message {
+    fn message(id: u32) -> Message {
         Message {
             cc_id: CrossChainId {
                 chain: "source-chain".parse().unwrap(),
                 id: HexTxHashAndEventIndex {
                     tx_hash: [0; 32],
-                    event_index: id as u32,
+                    event_index: id,
                 }
                 .to_string()
                 .try_into()

packages/axelar-wasm-std/src/voting.rs

@@ -365,7 +365,7 @@ impl WeightedPoll {
             return Err(Error::PollExpired);
         }
 
-        if votes.len() != self.poll_size as usize {
+        if votes.len() as u64 != self.poll_size {
             return Err(Error::InvalidVoteSize);
         }