Merge pull request #8 from crodriguezvega/carlos/fix-check-linter

fix: cargo check and linter

contracts/pallet-ibc/src/light_clients.rs

@@ -6,8 +6,7 @@ use frame_support::{
 use ibc::core::{
 	ics02_client,
 	ics02_client::{
-		client_consensus::ConsensusState, client_message::ClientMessage,
-		client_state::ClientState,
+		client_consensus::ConsensusState, client_message::ClientMessage, client_state::ClientState,
 	},
 };
 use ibc_derive::{ClientDef, ClientMessage, ClientState, ConsensusState, Protobuf};
@@ -22,10 +21,8 @@ use ics07_tendermint::{
 	consensus_state::TENDERMINT_CONSENSUS_STATE_TYPE_URL,
 };
 use ics08_wasm::{
-	client_message::WASM_CLIENT_MESSAGE_TYPE_URL,
-	client_state::WASM_CLIENT_STATE_TYPE_URL,
-	consensus_state::WASM_CONSENSUS_STATE_TYPE_URL,
-	Bytes,
+	client_message::WASM_CLIENT_MESSAGE_TYPE_URL, client_state::WASM_CLIENT_STATE_TYPE_URL,
+	consensus_state::WASM_CONSENSUS_STATE_TYPE_URL, Bytes,
 };
 use ics10_grandpa::{
 	client_message::{
@@ -329,18 +326,15 @@ pub enum AnyClientMessage {
 
 impl AnyClientMessage {
 	pub fn wasm(inner: Self) -> Result<Self, tendermint_proto::Error> {
-		Ok(Self::Wasm(
-			ics08_wasm::client_message::ClientMessage {
-				data: inner.encode_to_vec()?,
-				inner: Box::new(inner),
-			}
-		))
+		Ok(Self::Wasm(ics08_wasm::client_message::ClientMessage {
+			data: inner.encode_to_vec()?,
+			inner: Box::new(inner),
+		}))
 	}
 
 	pub fn unpack_recursive_into(self) -> Self {
 		match self {
-			Self::Wasm(ics08_wasm::client_message::ClientMessage{inner, data}) =>
-				*inner,
+			Self::Wasm(ics08_wasm::client_message::ClientMessage { inner, data }) => *inner,
 			_ => self,
 		}
 	}
@@ -400,7 +394,7 @@ impl From<AnyClientMessage> for Any {
 		match client_msg {
 			AnyClientMessage::Wasm(msg) => Any {
 				type_url: WASM_CLIENT_MESSAGE_TYPE_URL.to_string(),
-				value: msg.encode_vec().expect("encode_vec failed")
+				value: msg.encode_vec().expect("encode_vec failed"),
 			},
 			AnyClientMessage::Grandpa(msg) => match msg {
 				ics10_grandpa::client_message::ClientMessage::Header(h) => Any {

light-clients/ics07-tendermint-cw/src/connection.rs

@@ -50,4 +50,4 @@ impl<'a, H: HostFunctionsProvider> ConnectionReader for Context<'a, H> {
 			"'connection_counter' is unavailable from the client".to_string(),
 		))
 	}
-}
+}

light-clients/ics07-tendermint-cw/src/context.rs

@@ -75,7 +75,7 @@ impl<'a, H> Context<'a, H> {
 	pub fn log(&self, msg: &str) {
 		match &self.deps_mut {
 			Some(deps_mut) => deps_mut.api.debug(msg),
-			None => unimplemented!()
+			None => unimplemented!(),
 		}
 	}
 
@@ -84,15 +84,15 @@ impl<'a, H> Context<'a, H> {
 			Some(deps_mut) => deps_mut.storage,
 			None => match &self.deps {
 				Some(deps) => deps.storage,
-				None => unimplemented!()
-			}
+				None => unimplemented!(),
+			},
 		}
 	}
 
 	pub fn storage_mut(&mut self) -> &mut dyn Storage {
 		match &mut self.deps_mut {
 			Some(deps_mut) => deps_mut.storage,
-			None => unimplemented!()
+			None => unimplemented!(),
 		}
 	}
 }
@@ -168,11 +168,10 @@ where
 		let client_states = ReadonlyClientStates::new(self.storage());
 		let checksum = match self.checksum.clone() {
 			None => {
-				let encoded_wasm_client_state = client_states.get_prefixed(prefix).ok_or_else(|| {
-					ContractError::Tendermint(
-						Error::client_not_found(client_id).to_string(),
-					)
-				})?;
+				let encoded_wasm_client_state =
+					client_states.get_prefixed(prefix).ok_or_else(|| {
+						ContractError::Tendermint(Error::client_not_found(client_id).to_string())
+					})?;
 				let any = Any::decode(&*encoded_wasm_client_state)
 					.map_err(Error::decode)
 					.map_err(|e| ContractError::Tendermint(e.to_string()))?;

light-clients/ics07-tendermint-cw/src/contract.rs

@@ -22,10 +22,9 @@ use crate::{
 	},
 	ics23::ReadonlyProcessedStates,
 	msg::{
-		CheckForMisbehaviourMsg, ContractResult, ExportMetadataMsg, QueryMsg,
-		QueryResponse, StatusMsg, SudoMsg, UpdateStateMsg, UpdateStateOnMisbehaviourMsg,
-		VerifyClientMessage, VerifyMembershipMsg, VerifyNonMembershipMsg,
-		VerifyUpgradeAndUpdateStateMsg,
+		CheckForMisbehaviourMsg, ContractResult, ExportMetadataMsg, QueryMsg, QueryResponse,
+		StatusMsg, SudoMsg, UpdateStateMsg, UpdateStateOnMisbehaviourMsg, VerifyClientMessage,
+		VerifyMembershipMsg, VerifyNonMembershipMsg, VerifyUpgradeAndUpdateStateMsg,
 	},
 	state::{get_client_state, get_consensus_state},
 };
@@ -169,11 +168,7 @@ pub fn instantiate(
 	Ok(response)
 }
 #[cfg_attr(not(feature = "library"), entry_point)]
-pub fn sudo(
-	deps: DepsMut,
-	env: Env,
-	msg: SudoMsg,
-) -> Result<Response, ContractError> {
+pub fn sudo(deps: DepsMut, env: Env, msg: SudoMsg) -> Result<Response, ContractError> {
 	let client = TendermintClient::<HostFunctions>::default();
 	let client_id = ClientId::from_str(env.contract.address.as_str()).expect("client id is valid");
 	let mut ctx = Context::<HostFunctions>::new(deps, env);
@@ -267,7 +262,7 @@ fn process_message(
 				msg.value,
 			)
 			.map_err(|e| ContractError::Tendermint(e.to_string()))
-		  .map(|_| to_binary(&ContractResult::success()))
+			.map(|_| to_binary(&ContractResult::success()))
 		},
 		SudoMsg::VerifyNonMembership(msg) => {
 			let client_state = ctx
@@ -357,7 +352,9 @@ pub fn query(deps: Deps, env: Env, msg: QueryMsg) -> StdResult<Binary> {
 						let tp = client_state.trusting_period.as_secs();
 						let now = env.block.time.seconds();
 						if (last_update + tp) < now {
-							return to_binary(&QueryResponse::success().status("Expired".to_string()))
+							return to_binary(
+								&QueryResponse::success().status("Expired".to_string()),
+							)
 						}
 						to_binary(&QueryResponse::success().status("Active".to_string()))
 					},
@@ -370,7 +367,11 @@ pub fn query(deps: Deps, env: Env, msg: QueryMsg) -> StdResult<Binary> {
 			let consensus_state = ctx
 				.consensus_state(&client_id, msg.height)
 				.map_err(|e| ContractError::Tendermint(e.to_string()))?;
-			to_binary(&QueryResponse::success().timestamp(consensus_state.timestamp.unix_timestamp_nanos().unsigned_abs() as u64))
+			to_binary(
+				&QueryResponse::success().timestamp(
+					consensus_state.timestamp.unix_timestamp_nanos().unsigned_abs() as u64,
+				),
+			)
 		},
 		QueryMsg::VerifyClientMessage(msg) => {
 			let ctx = Context::<HostFunctions>::new_ro(deps, env);

light-clients/ics07-tendermint-cw/src/error.rs

@@ -60,4 +60,4 @@ impl From<ContractError> for StdError {
 	fn from(e: ContractError) -> Self {
 		StdError::GenericErr { msg: e.to_string() }
 	}
-}
+}

light-clients/ics07-tendermint-cw/src/msg.rs

@@ -27,7 +27,10 @@ use ibc::{
 };
 use ibc_proto::{google::protobuf::Any, ibc::core::client::v1::Height as HeightRaw};
 use ics07_tendermint::{
-	client_message::{ClientMessage, Header, Misbehaviour, TENDERMINT_HEADER_TYPE_URL, TENDERMINT_MISBEHAVIOUR_TYPE_URL},
+	client_message::{
+		ClientMessage, Header, Misbehaviour, TENDERMINT_HEADER_TYPE_URL,
+		TENDERMINT_MISBEHAVIOUR_TYPE_URL,
+	},
 	client_state::ClientState,
 	consensus_state::ConsensusState,
 };
@@ -67,7 +70,13 @@ pub struct QueryResponse {
 
 impl QueryResponse {
 	pub fn success() -> Self {
-		Self { is_valid: true, status: None, genesis_metadata: None, found_misbehaviour: None, timestamp: None }
+		Self {
+			is_valid: true,
+			status: None,
+			genesis_metadata: None,
+			found_misbehaviour: None,
+			timestamp: None,
+		}
 	}
 
 	pub fn status(mut self, status: String) -> Self {
@@ -79,7 +88,7 @@ impl QueryResponse {
 		self.genesis_metadata = genesis_metadata;
 		self
 	}
-	
+
 	pub fn misbehaviour(mut self, found_misbehavior: bool) -> Self {
 		self.found_misbehaviour = Some(found_misbehavior);
 		self
@@ -176,7 +185,8 @@ impl VerifyClientMessage {
 		let any = Any::decode(&mut raw.as_slice())?;
 		let client_message = match &*any.type_url {
 			TENDERMINT_HEADER_TYPE_URL => ClientMessage::Header(Header::decode_vec(&any.value)?),
-			TENDERMINT_MISBEHAVIOUR_TYPE_URL => ClientMessage::Misbehaviour(Misbehaviour::decode_vec(&any.value)?),
+			TENDERMINT_MISBEHAVIOUR_TYPE_URL =>
+				ClientMessage::Misbehaviour(Misbehaviour::decode_vec(&any.value)?),
 			_ => return Err(ContractError::Tendermint("unknown client message type".to_string())),
 		};
 		Ok(client_message)
@@ -361,7 +371,7 @@ impl<H: Clone> TryFrom<VerifyUpgradeAndUpdateStateMsgRaw> for VerifyUpgradeAndUp
 		let any = Any::decode(&mut raw.upgrade_client_state.as_slice())?;
 		let upgrade_client_state = ClientState::decode_vec(&any.value)?;
 		let any = Any::decode(&mut raw.upgrade_consensus_state.as_slice())?;
-		let upgrade_consensus_state =	ConsensusState::decode_vec(&any.value)?;
+		let upgrade_consensus_state = ConsensusState::decode_vec(&any.value)?;
 		if upgrade_client_state.trust_level != TrustThreshold::ZERO ||
 			upgrade_client_state.trusting_period != Duration::ZERO ||
 			upgrade_client_state.max_clock_drift != Duration::ZERO ||
@@ -373,8 +383,8 @@ impl<H: Clone> TryFrom<VerifyUpgradeAndUpdateStateMsgRaw> for VerifyUpgradeAndUp
 		}
 
 		Ok(VerifyUpgradeAndUpdateStateMsg {
-			upgrade_client_state: upgrade_client_state,
-			upgrade_consensus_state: upgrade_consensus_state,
+			upgrade_client_state,
+			upgrade_consensus_state,
 			proof_upgrade_client: CommitmentProofBytes::try_from(raw.proof_upgrade_client)?,
 			proof_upgrade_consensus_state: CommitmentProofBytes::try_from(
 				raw.proof_upgrade_consensus_state,

light-clients/ics07-tendermint-cw/src/state.rs

@@ -25,7 +25,10 @@ use ics07_tendermint::{client_state::ClientState, consensus_state::ConsensusStat
 use prost::Message;
 
 /// Retrieves raw bytes from storage and deserializes them into [`ClientState`]
-pub fn get_client_state<H: Clone>(deps: Deps, client_id: ClientId) -> Result<ClientState<H>, Error> {
+pub fn get_client_state<H: Clone>(
+	deps: Deps,
+	client_id: ClientId,
+) -> Result<ClientState<H>, Error> {
 	deps.storage
 		.get(&"clientState".to_string().into_bytes())
 		.ok_or_else(|| Error::unknown_client_state_type(client_id.to_string()))

light-clients/ics08-wasm/src/client_def.rs

@@ -77,12 +77,8 @@ where
 		client_state: Self::ClientState,
 		client_msg: Self::ClientMessage,
 	) -> Result<(), Error> {
-		self.inner.verify_client_message(
-			ctx,
-			client_id,
-			*client_state.inner,
-			*client_msg.inner,
-		)
+		self.inner
+			.verify_client_message(ctx, client_id, *client_state.inner, *client_msg.inner)
 	}
 
 	fn update_state<Ctx: ReaderContext>(
@@ -92,12 +88,9 @@ where
 		client_state: Self::ClientState,
 		client_msg: Self::ClientMessage,
 	) -> Result<(Self::ClientState, ConsensusUpdateResult<Ctx>), Error> {
-		let (inner_client_state, inner_consensus_update_result) = self.inner.update_state(
-			ctx,
-			client_id,
-			*client_state.inner,
-			*client_msg.inner,
-		)?;
+		let (inner_client_state, inner_consensus_update_result) =
+			self.inner
+				.update_state(ctx, client_id, *client_state.inner, *client_msg.inner)?;
 		let client_state = ClientState {
 			data: client_state.data.clone(),
 			checksum: client_state.checksum.clone(),
@@ -132,12 +125,8 @@ where
 		client_state: Self::ClientState,
 		client_msg: Self::ClientMessage,
 	) -> Result<bool, Error> {
-		self.inner.check_for_misbehaviour(
-			ctx,
-			client_id,
-			*client_state.inner,
-			*client_msg.inner,
-		)
+		self.inner
+			.check_for_misbehaviour(ctx, client_id, *client_state.inner, *client_msg.inner)
 	}
 
 	fn verify_upgrade_and_update_state<Ctx: ReaderContext>(

light-clients/ics08-wasm/src/client_message.rs

@@ -24,11 +24,11 @@ use core::fmt::Display;
 #[cfg(feature = "cosmwasm")]
 use cosmwasm_schema::cw_serde;
 use ibc::{
-	core::ics02_client::client_message::ClientMessage as IbcClientMessage,
-	protobuf::Protobuf,
+	core::ics02_client::client_message::ClientMessage as IbcClientMessage, protobuf::Protobuf,
+};
+use ibc_proto::{
+	google::protobuf::Any, ibc::lightclients::wasm::v1::ClientMessage as RawClientMessage,
 };
-use ibc_proto::google::protobuf::Any;
-use ibc_proto::ibc::lightclients::wasm::v1::ClientMessage as RawClientMessage;
 use prost::Message;
 
 pub const WASM_CLIENT_MESSAGE_TYPE_URL: &str = "/ibc.lightclients.wasm.v1.ClientMessage";
@@ -81,12 +81,10 @@ where
 	fn try_from(raw: RawClientMessage) -> Result<Self, Self::Error> {
 		let any = Any::decode(&mut &raw.data[..])
 			.map_err(|e| format!("failed to decode ClientMessage::data into Any: {}", e))?;
-		let inner = AnyClientMessage::try_from(any).map_err(
-			|e| {
-				format!("failed to decode ClientMessage::data into ClientMessage: {}", e)
-			})?;
-		Ok(Self { data: raw.data, inner: Box::new(inner)})
-
+		let inner = AnyClientMessage::try_from(any).map_err(|e| {
+			format!("failed to decode ClientMessage::data into ClientMessage: {}", e)
+		})?;
+		Ok(Self { data: raw.data, inner: Box::new(inner) })
 	}
 }
 

light-clients/ics08-wasm/src/consensus_state.rs

@@ -30,8 +30,7 @@ use cosmwasm_schema::cw_serde;
 use ibc::{
 	core::{
 		ics02_client::client_consensus::{
-			ConsensusState as IcsConsensusState,
-			ConsensusState as IbcConsensusState,
+			ConsensusState as IcsConsensusState, ConsensusState as IbcConsensusState,
 		},
 		ics23_commitment::commitment::CommitmentRoot,
 	},

light-clients/ics08-wasm/src/instantiate.rs

@@ -1,19 +1,18 @@
-use crate::Bytes;
-use crate::msg::Base64;
+use crate::{msg::Base64, Bytes};
 #[cfg(feature = "cosmwasm")]
 use cosmwasm_schema::cw_serde;
 
 #[cfg_attr(feature = "cosmwasm", cw_serde)]
 #[cfg_attr(not(feature = "cosmwasm"), derive(Clone, Debug, PartialEq))]
 #[derive(Eq)]
 pub struct InstantiateMessage {
-	#[schemars(with = "String")]
-	#[serde(with = "Base64", default)]
+	#[cfg_attr(feature = "cosmwasm", schemars(with = "String"))]
+	#[cfg_attr(feature = "cosmwasm", serde(with = "Base64", default))]
 	pub client_state: Bytes,
-	#[schemars(with = "String")]
-	#[serde(with = "Base64", default)]
+	#[cfg_attr(feature = "cosmwasm", schemars(with = "String"))]
+	#[cfg_attr(feature = "cosmwasm", serde(with = "Base64", default))]
 	pub consensus_state: Bytes,
-	#[schemars(with = "String")]
-	#[serde(with = "Base64", default)]
-	pub checksum: Bytes
+	#[cfg_attr(feature = "cosmwasm", schemars(with = "String"))]
+	#[cfg_attr(feature = "cosmwasm", serde(with = "Base64", default))]
+	pub checksum: Bytes,
 }

light-clients/ics10-grandpa-cw/src/client.rs

@@ -70,9 +70,7 @@ impl<'a, H: HostFunctions<Header = RelayChainHeader>> ClientReader for Context<'
 		})?;
 		match ClientType::from_str(&data) {
 			Err(_err) => Err(Error::unknown_client_type(data.to_string())),
-			Ok(val) => {
-				Ok(val)
-			},
+			Ok(val) => Ok(val),
 		}
 	}
 
@@ -88,7 +86,6 @@ impl<'a, H: HostFunctions<Header = RelayChainHeader>> ClientReader for Context<'
 		client_id: &ClientId,
 		height: Height,
 	) -> Result<ConsensusState, Error> {
-
 		let consensus_states = ReadonlyConsensusStates::new(self.storage());
 		let value = consensus_states
 			.get(height)