refactor: restrict exports to contract and contract clients

contracts/axelar-gas-service/src/lib.rs

@@ -13,8 +13,8 @@ cfg_if::cfg_if! {
     } else {
         mod event;
         mod storage_types;
+        mod contract;
 
-        pub mod contract;
         pub use contract::{AxelarGasService, AxelarGasServiceClient};
     }
 }

contracts/axelar-gas-service/tests/test.rs

@@ -3,8 +3,8 @@ extern crate std;
 
 use std::format;
 
-use axelar_gas_service::contract::{AxelarGasService, AxelarGasServiceClient};
 use axelar_gas_service::error::ContractError;
+use axelar_gas_service::{AxelarGasService, AxelarGasServiceClient};
 use axelar_soroban_std::{
     assert_contract_err, assert_invoke_auth_err, assert_last_emitted_event, types::Token,
 };

contracts/axelar-gateway/src/lib.rs

@@ -26,8 +26,8 @@ cfg_if::cfg_if! {
         mod auth;
         mod event;
         mod storage_types;
+        mod contract;
 
-        pub mod contract;
         pub use contract::{AxelarGateway, AxelarGatewayClient};
     }
 }

contracts/axelar-operators/src/lib.rs

@@ -3,7 +3,7 @@
 mod event;
 mod storage_types;
 
-pub mod contract;
+mod contract;
 pub mod error;
 
-pub use contract::AxelarOperatorsClient;
+pub use contract::{AxelarOperators, AxelarOperatorsClient};

contracts/axelar-operators/tests/test.rs

@@ -7,7 +7,7 @@ use axelar_soroban_std::{
     testutils::assert_invocation,
 };
 
-use axelar_operators::contract::{AxelarOperators, AxelarOperatorsClient};
+use axelar_operators::{AxelarOperators, AxelarOperatorsClient};
 use soroban_sdk::{
     contract, contractimpl, symbol_short, testutils::Address as _, Address, Env, Symbol, Val, Vec,
 };

contracts/example/src/lib.rs

@@ -1,8 +1,7 @@
 #![no_std]
 
+mod contract;
 mod event;
 mod storage_types;
 
-pub mod contract;
-
-pub use contract::ExampleClient;
+pub use contract::{Example, ExampleClient};

contracts/example/tests/test.rs

@@ -1,14 +1,14 @@
 #![cfg(test)]
 extern crate std;
 
-use axelar_gas_service::contract::AxelarGasService;
+use axelar_gas_service::AxelarGasService;
 use axelar_gas_service::AxelarGasServiceClient;
 use axelar_gateway::testutils::{self, generate_proof, get_approve_hash, TestSignerSet};
 use axelar_gateway::types::Message;
 use axelar_gateway::AxelarGatewayClient;
 use axelar_soroban_std::types::Token;
 use axelar_soroban_std::{assert_last_emitted_event, auth_invocation};
-use example::contract::Example;
+use example::Example;
 use example::ExampleClient;
 use soroban_sdk::testutils::{AuthorizedFunction, AuthorizedInvocation};
 use soroban_sdk::token::StellarAssetClient;

contracts/interchain-token-service/src/abi.rs

@@ -250,7 +250,6 @@ mod tests {
     use super::*;
     use alloc::vec;
     use axelar_soroban_std::assert_ok;
-    use core::u128;
     use soroban_sdk::{Bytes, BytesN, Env, String};
     use std::vec::Vec;
 
@@ -264,28 +263,28 @@ mod tests {
         let env = Env::default();
 
         let plain_string = "hello world";
-        let plain_string_soroban = String::from_str(&env, &plain_string);
+        let plain_string_soroban = String::from_str(&env, plain_string);
         assert_eq!(
             to_std_string(plain_string_soroban).unwrap(),
             StdString::from(plain_string)
         );
 
         let var_length_chars = "🎉中🚀π🌈€";
-        let var_length_chars_soroban = String::from_str(&env, &var_length_chars);
+        let var_length_chars_soroban = String::from_str(&env, var_length_chars);
         assert_eq!(
             to_std_string(var_length_chars_soroban).unwrap(),
             StdString::from(var_length_chars)
         );
 
         let null_bytes = "Hello\x00World";
-        let null_bytes_soroban = String::from_str(&env, &null_bytes);
+        let null_bytes_soroban = String::from_str(&env, null_bytes);
         assert_eq!(
             to_std_string(null_bytes_soroban).unwrap(),
             StdString::from(null_bytes)
         );
 
         let escape_char = "Hello\tWorld";
-        let escape_char_soroban = String::from_str(&env, &escape_char);
+        let escape_char_soroban = String::from_str(&env, escape_char);
         assert_eq!(
             to_std_string(escape_char_soroban).unwrap(),
             StdString::from(escape_char)
@@ -297,11 +296,11 @@ mod tests {
         let env = Env::default();
 
         let invalid_sequences = vec![
-            String::from_bytes(&env, &vec![0xF5, 0x90, 0x80]), // not valid utf-8
-            String::from_bytes(&env, &vec![0x00, 0x01, 0x02, 0xC0]), // valid ASCII characters followed by an invalid UTF-8 starting byte
-            String::from_bytes(&env, &vec![0xC0, 0x80, 0xF5, 0x90]), // invalid UTF-8 starting byte followed by valid UTF-8 sequences
-            String::from_bytes(&env, &vec![0xF0, 0x90, 0x80, 0xDF, 0xFB, 0xBF]), // surrogate pairs with invalid charaters "\uD800\uDDFF"
-            String::from_bytes(&env, &vec![0xF4, 0x90, 0x80, 0x80]), // outside the Basic Multilingual Plane
+            String::from_bytes(&env, &[0xF5, 0x90, 0x80]), // not valid utf-8
+            String::from_bytes(&env, &[0x00, 0x01, 0x02, 0xC0]), // valid ASCII characters followed by an invalid UTF-8 starting byte
+            String::from_bytes(&env, &[0xC0, 0x80, 0xF5, 0x90]), // invalid UTF-8 starting byte followed by valid UTF-8 sequences
+            String::from_bytes(&env, &[0xF0, 0x90, 0x80, 0xDF, 0xFB, 0xBF]), // surrogate pairs with invalid charaters "\uD800\uDDFF"
+            String::from_bytes(&env, &[0xF4, 0x90, 0x80, 0x80]), // outside the Basic Multilingual Plane
         ];
 
         for sequence in invalid_sequences {
@@ -358,7 +357,7 @@ mod tests {
     #[test]
     fn interchain_transfer_encode_decode() {
         let env = Env::default();
-        let remote_chain = String::from_str(&env, &"chain");
+        let remote_chain = String::from_str(&env, "chain");
 
         let cases = vec![
             types::HubMessage::SendToHub {
@@ -367,10 +366,9 @@ mod tests {
                     token_id: BytesN::from_array(&env, &[0u8; 32]),
                     source_address: bytes_from_hex(&env, "00"),
                     destination_address: bytes_from_hex(&env, "00"),
-                    amount: 1u64.try_into().unwrap(),
+                    amount: 1u64.into(),
                     data: None,
-                })
-                .into(),
+                }),
             },
             types::HubMessage::SendToHub {
                 destination_chain: remote_chain.clone(),
@@ -386,22 +384,20 @@ mod tests {
                     ),
                     amount: i128::MAX,
                     data: Some(bytes_from_hex(&env, "abcd")),
-                })
-                .into(),
+                }),
             },
             types::HubMessage::ReceiveFromHub {
                 source_chain: remote_chain.clone(),
                 message: types::Message::InterchainTransfer(types::InterchainTransfer {
                     token_id: BytesN::from_array(&env, &[0u8; 32]),
                     source_address: bytes_from_hex(&env, "00"),
                     destination_address: bytes_from_hex(&env, "00"),
-                    amount: 1u64.try_into().unwrap(),
+                    amount: 1u64.into(),
                     data: None,
-                })
-                .into(),
+                }),
             },
             types::HubMessage::ReceiveFromHub {
-                source_chain: remote_chain.clone(),
+                source_chain: remote_chain,
                 message: types::Message::InterchainTransfer(types::InterchainTransfer {
                     token_id: BytesN::from_array(&env, &[255u8; 32]),
                     source_address: bytes_from_hex(
@@ -414,8 +410,7 @@ mod tests {
                     ),
                     amount: i128::MAX,
                     data: Some(bytes_from_hex(&env, "abcd")),
-                })
-                .into(),
+                }),
             },
         ];
 
@@ -442,74 +437,68 @@ mod tests {
     #[test]
     fn deploy_interchain_token_encode_decode() {
         let env = Env::default();
-        let remote_chain = String::from_str(&env, &"chain");
+        let remote_chain = String::from_str(&env, "chain");
 
         let cases = vec![
             types::HubMessage::SendToHub {
                 destination_chain: remote_chain.clone(),
                 message: types::Message::DeployInterchainToken(types::DeployInterchainToken {
                     token_id: BytesN::from_array(&env, &[0u8; 32]),
-                    name: String::from_str(&env, &"t"),
-                    symbol: String::from_str(&env, &"T"),
+                    name: String::from_str(&env, "t"),
+                    symbol: String::from_str(&env, "T"),
                     decimals: 0,
                     minter: None,
-                })
-                .into(),
+                }),
             },
             types::HubMessage::SendToHub {
                 destination_chain: remote_chain.clone(),
                 message: types::Message::DeployInterchainToken(types::DeployInterchainToken {
                     token_id: BytesN::from_array(&env, &[1u8; 32]),
-                    name: String::from_str(&env, &"Test Token"),
-                    symbol: String::from_str(&env, &"TST"),
+                    name: String::from_str(&env, "Test Token"),
+                    symbol: String::from_str(&env, "TST"),
                     decimals: 18,
                     minter: Some(bytes_from_hex(&env, "1234")),
-                })
-                .into(),
+                }),
             },
             types::HubMessage::SendToHub {
                 destination_chain: remote_chain.clone(),
                 message: types::Message::DeployInterchainToken(types::DeployInterchainToken {
                     token_id: BytesN::from_array(&env, &[0u8; 32]),
-                    name: String::from_str(&env, &"Unicode Token 🪙"),
-                    symbol: String::from_str(&env, &"UNI🔣"),
+                    name: String::from_str(&env, "Unicode Token 🪙"),
+                    symbol: String::from_str(&env, "UNI🔣"),
                     decimals: 255,
                     minter: Some(bytes_from_hex(&env, "abcd")),
-                })
-                .into(),
+                }),
             },
             types::HubMessage::ReceiveFromHub {
                 source_chain: remote_chain.clone(),
                 message: types::Message::DeployInterchainToken(types::DeployInterchainToken {
                     token_id: BytesN::from_array(&env, &[0u8; 32]),
-                    name: String::from_str(&env, &"t"),
-                    symbol: String::from_str(&env, &"T"),
+                    name: String::from_str(&env, "t"),
+                    symbol: String::from_str(&env, "T"),
                     decimals: 0,
                     minter: None,
-                })
-                .into(),
+                }),
             },
             types::HubMessage::ReceiveFromHub {
                 source_chain: remote_chain.clone(),
                 message: types::Message::DeployInterchainToken(types::DeployInterchainToken {
                     token_id: BytesN::from_array(&env, &[1u8; 32]),
-                    name: String::from_str(&env, &"Test Token"),
-                    symbol: String::from_str(&env, &"TST"),
+                    name: String::from_str(&env, "Test Token"),
+                    symbol: String::from_str(&env, "TST"),
                     decimals: 18,
                     minter: Some(bytes_from_hex(&env, "1234")),
-                })
-                .into(),
+                }),
             },
             types::HubMessage::ReceiveFromHub {
-                source_chain: remote_chain.clone(),
+                source_chain: remote_chain,
                 message: types::Message::DeployInterchainToken(types::DeployInterchainToken {
                     token_id: BytesN::from_array(&env, &[0u8; 32]),
-                    name: String::from_str(&env, &"Unicode Token 🪙"),
-                    symbol: String::from_str(&env, &"UNI🔣"),
+                    name: String::from_str(&env, "Unicode Token 🪙"),
+                    symbol: String::from_str(&env, "UNI🔣"),
                     decimals: 255,
                     minter: Some(bytes_from_hex(&env, "abcd")),
-                })
-                .into(),
+                }),
             },
         ];
 
@@ -547,7 +536,7 @@ mod tests {
                 token_id: BytesN::from_array(&env, &[0u8; 32]),
                 source_address: bytes_from_hex(&env, "00"),
                 destination_address: bytes_from_hex(&env, "00"),
-                amount: 1u64.try_into().unwrap(),
+                amount: 1u64.into(),
                 data: None,
             }
         )

contracts/interchain-token-service/src/interface.rs

@@ -4,6 +4,7 @@ use soroban_sdk::{contractclient, Address, Bytes, BytesN, Env, String};
 
 use crate::error::ContractError;
 
+#[allow(dead_code)]
 #[contractclient(name = "InterchainTokenServiceClient")]
 pub trait InterchainTokenServiceInterface: AxelarExecutableInterface {
     fn trusted_address(env: &Env, chain: String) -> Option<String>;

contracts/interchain-token-service/src/lib.rs

@@ -1,15 +1,14 @@
 #![no_std]
 
 mod abi;
+mod contract;
 pub mod error;
 mod event;
 mod interface;
 mod storage_types;
 mod types;
 
-pub mod contract;
-
 #[cfg(test)]
 extern crate std;
 
-pub use contract::InterchainTokenServiceClient;
+pub use contract::{InterchainTokenService, InterchainTokenServiceClient};

contracts/interchain-token-service/tests/test.rs

@@ -1,8 +1,8 @@
 use axelar_gas_service::{AxelarGasService, AxelarGasServiceClient};
 use axelar_gateway::testutils;
 use axelar_gateway::AxelarGatewayClient;
-use interchain_token_service::contract::{InterchainTokenService, InterchainTokenServiceClient};
 use interchain_token_service::error::ContractError;
+use interchain_token_service::{InterchainTokenService, InterchainTokenServiceClient};
 
 use axelar_soroban_std::{assert_contract_err, assert_invoke_auth_err, assert_last_emitted_event};
 
@@ -16,7 +16,7 @@ fn setup_gateway<'a>(env: &Env) -> AxelarGatewayClient<'a> {
 
 fn setup_gas_service<'a>(env: &Env) -> AxelarGasServiceClient<'a> {
     let owner: Address = Address::generate(env);
-    let gas_collector: Address = Address::generate(&env);
+    let gas_collector: Address = Address::generate(env);
     let gas_service_id = env.register(AxelarGasService, (&owner, &gas_collector));
     let gas_service_client = AxelarGasServiceClient::new(env, &gas_service_id);
 

contracts/interchain-token/src/interface.rs

@@ -2,6 +2,7 @@ use soroban_sdk::{contractclient, token, Address, BytesN, Env};
 
 use crate::error::ContractError;
 
+#[allow(dead_code)]
 #[contractclient(name = "InterchainTokenClient")]
 pub trait InterchainTokenInterface: token::Interface {
     fn token_id(env: &Env) -> BytesN<32>;

contracts/interchain-token/src/lib.rs

@@ -10,8 +10,8 @@ cfg_if::cfg_if! {
     } else {
         mod event;
         mod storage_types;
+        mod contract;
 
-        pub mod contract;
         pub use contract::{InterchainToken, InterchainTokenClient};
     }
 }

contracts/interchain-token/tests/test.rs

@@ -5,18 +5,18 @@ use axelar_soroban_std::{
     assert_invoke_auth_err, assert_invoke_auth_ok, assert_last_emitted_event,
 };
 
-use interchain_token::contract::{InterchainToken, InterchainTokenClient};
+use interchain_token::{InterchainToken, InterchainTokenClient};
 use soroban_sdk::{
     testutils::{Address as _, BytesN as _},
     Address, BytesN, Env, IntoVal as _, Symbol,
 };
 use soroban_token_sdk::metadata::TokenMetadata;
 
 fn setup_token<'a>(env: &Env) -> (InterchainTokenClient<'a>, Address, Address) {
-    let owner = Address::generate(&env);
-    let minter = Address::generate(&env);
-    let interchain_token_service = Address::generate(&env);
-    let token_id: BytesN<32> = BytesN::<32>::random(&env);
+    let owner = Address::generate(env);
+    let minter = Address::generate(env);
+    let interchain_token_service = Address::generate(env);
+    let token_id: BytesN<32> = BytesN::<32>::random(env);
     let token_meta_data = TokenMetadata {
         decimal: 6,
         name: "name".into_val(env),
@@ -123,8 +123,8 @@ fn register_interchain_token() {
     let (token, owner, minter) = setup_token(&env);
 
     assert_eq!(token.owner(), owner);
-    assert_eq!(token.is_minter(&owner), false);
-    assert_eq!(token.is_minter(&minter), true);
+    assert!(!token.is_minter(&owner));
+    assert!(token.is_minter(&minter));
 }
 
 #[test]