scheme height

Author: mina86

light-clients/cf-guest-cw/src/contract.rs

@@ -89,8 +89,7 @@ fn query(deps: Deps, env: Env, msg: msg::QueryMsg) -> StdResult<Binary> {
 		},
 		msg::QueryMsg::Status(msg::StatusMsg {}) => to_json_binary(&query_status(ctx)?),
 		msg::QueryMsg::TimestampAtHeight(msg) => {
-			let height = msg.height.try_into()?;
-			let state = ctx.consensus_state(height)?;
+			let state = ctx.consensus_state(msg.height)?;
 			to_json_binary(&Uint64::from(state.timestamp_ns.get()))
 		},
 		msg::QueryMsg::ExportMetadata(msg::ExportMetadataMsg {}) => {
@@ -101,8 +100,7 @@ fn query(deps: Deps, env: Env, msg: msg::QueryMsg) -> StdResult<Binary> {
 }
 
 fn query_verify_state_proof(ctx: context::Context, msg: msg::VerifyStateProofMsg) -> StdResult<()> {
-	let height = msg.height.try_into()?;
-	let consensus_state = ctx.consensus_state(height)?;
+	let consensus_state = ctx.consensus_state(msg.height)?;
 	cf_guest::proof::verify(
 		&ibc::CommitmentPrefix::default(),
 		&msg.proof,

light-clients/cf-guest-cw/src/msg.rs

@@ -18,15 +18,15 @@ use cosmwasm_std::Uint64;
 
 use crate::{
 	ibc,
-	serialisation::{AsStr, Base64, OptBase64},
+	serialisation,
 	state,
 };
 
 #[cw_serde]
 pub struct InstantiateMsg {
-	#[serde(with = "Base64")]
+	#[serde(with = "serialisation::Base64")]
 	pub client_state: state::ClientState,
-	#[serde(with = "Base64")]
+	#[serde(with = "serialisation::Base64")]
 	pub consensus_state: state::ConsensusState,
 }
 
@@ -43,25 +43,25 @@ pub enum SudoMsg {
 
 #[cw_serde]
 pub struct UpdateStateMsg {
-	#[serde(with = "Base64")]
+	#[serde(with = "serialisation::Base64")]
 	pub header: state::Header,
 }
 
 #[cw_serde]
 pub struct UpdateStateOnMisbehaviourMsg {
-	#[serde(with = "Base64")]
+	#[serde(with = "serialisation::Base64")]
 	pub misbehaviour_message: state::Misbehaviour,
 }
 
 // #[cw_serde]
 // pub struct VerifyUpgradeAndUpdateStateMsg {
-// 	#[serde(with = "Base64")]
+// 	#[serde(with = "serialisation::Base64")]
 // 	pub upgrade_client_state: state::ClientState,
-// 	#[serde(with = "Base64")]
+// 	#[serde(with = "serialisation::Base64")]
 // 	pub upgrade_consensus_state: state::ConsensusState,
-// 	#[serde(with = "Base64")]
+// 	#[serde(with = "serialisation::Base64")]
 // 	pub proof_upgrade_client: ibc::CommitmentProofBytes,
-// 	#[serde(with = "Base64")]
+// 	#[serde(with = "serialisation::Base64")]
 // 	pub proof_upgrade_consensus_state: ibc::CommitmentProofBytes,
 // }
 
@@ -101,25 +101,26 @@ pub enum QueryMsg {
 
 #[cw_serde]
 pub struct VerifyClientMessageMsg {
-	#[serde(with = "Base64")]
+	#[serde(with = "serialisation::Base64")]
 	pub client_message: Vec<u8>,
 }
 
 #[cw_serde]
 pub struct CheckForMisbehaviourMsg {
-	#[serde(with = "Base64")]
+	#[serde(with = "serialisation::Base64")]
 	pub client_message: Vec<u8>,
 }
 
 #[cw_serde]
 pub struct VerifyStateProofMsg {
-	#[serde(with = "Base64")]
+	#[serde(with = "serialisation::Base64")]
 	pub proof: ibc::CommitmentProofBytes,
-	#[serde(with = "AsStr")]
+	#[serde(with = "serialisation::AsStr")]
 	pub path: ibc::path::Path,
-	#[serde(with = "OptBase64", default, skip_serializing_if = "Option::is_none")]
+	#[serde(with = "serialisation::OptBase64", default, skip_serializing_if = "Option::is_none")]
 	pub value: Option<Vec<u8>>,
-	pub height: Height,
+	#[serde(with = "serialisation::Height")]
+	pub height: ibc::Height,
 }
 
 #[cw_serde]
@@ -137,71 +138,17 @@ pub struct GetLatestHeightsMsg {}
 
 #[cw_serde]
 pub struct TimestampAtHeightMsg {
-	pub height: Height,
+	#[serde(with = "serialisation::Height")]
+	pub height: ibc::Height,
 }
 
 #[cw_serde]
 pub struct ExportMetadataMsg {}
 
 #[cw_serde]
 pub struct ConsensusStateMetadata {
-	pub height: Height,
+	#[serde(with = "serialisation::Height")]
+	pub height: ibc::Height,
 	pub host_timestamp_ns: Uint64,
 	pub host_height: Uint64,
 }
-
-fn is_zero(num: &Uint64) -> bool {
-	u64::from(*num) == 0
-}
-
-/// IBC height.
-///
-/// This is essentially a copy of [`ibc::Height`] which we have so that we can
-/// implement `JsonSchema` on it without having to enable `schema` feature on
-/// `ibc` which pulls in `std` which we don’t want.
-#[derive(
-	Copy,
-	Clone,
-	PartialEq,
-	Eq,
-	derive_more::Display,
-	serde::Serialize,
-	serde::Deserialize,
-	schemars::JsonSchema,
-)]
-#[display(fmt = "{}-{}", revision_number, revision_height)]
-pub struct Height {
-	/// Previously known as "epoch"
-	#[serde(default, skip_serializing_if = "is_zero")]
-	pub revision_number: Uint64,
-
-	/// The height of a block
-	pub revision_height: Uint64,
-}
-
-impl TryFrom<Height> for ibc::Height {
-	type Error = cosmwasm_std::StdError;
-	fn try_from(height: Height) -> Result<Self, Self::Error> {
-		ibc::Height::new(height.revision_number.into(), height.revision_height.into()).map_err(
-			|_| cosmwasm_std::StdError::ParseErr {
-				target_type: "Height".into(),
-				msg: "unexpected zero height".into(),
-			},
-		)
-	}
-}
-
-impl From<ibc::Height> for Height {
-	fn from(height: ibc::Height) -> Self {
-		Self {
-			revision_number: height.revision_number().into(),
-			revision_height: height.revision_height().into(),
-		}
-	}
-}
-
-impl core::fmt::Debug for Height {
-	fn fmt(&self, fmtr: &mut core::fmt::Formatter) -> core::fmt::Result {
-		core::fmt::Display::fmt(self, fmtr)
-	}
-}

light-clients/cf-guest-cw/src/serialisation.rs

@@ -19,6 +19,16 @@ pub struct OptBase64;
 /// `Display` and deserialises using `FromStr`.
 pub struct AsStr;
 
+/// A Serde serialisation implementation for [`ibc::Height`].
+///
+/// We need it because we the type to implement `JsonSchema`.  ibc-rs does
+/// support schema with a `schema` feature however that brings in `std` and we
+/// don’t want that.  So, we need to define our own serialisation for height
+/// IBC height.
+pub struct Height;
+
+// ==================== Base64 =================================================
+
 impl Base64 {
 	pub fn serialize<T: BytesConv, S: Serializer>(obj: &T, ser: S) -> Result<S::Ok, S::Error> {
 		let bytes = obj.to_bytes()?;
@@ -110,6 +120,32 @@ conv_via_any!(state::ConsensusState);
 conv_via_any!(state::Header);
 conv_via_any!(state::Misbehaviour);
 
+impl schemars::JsonSchema for Base64 {
+	fn schema_name() -> alloc::string::String {
+		"Base64".into()
+	}
+	fn schema_id() -> alloc::borrow::Cow<'static, str> {
+		alloc::borrow::Cow::Borrowed("cf_guest::Base64")
+	}
+	fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+		String::json_schema(gen)
+	}
+}
+
+impl schemars::JsonSchema for OptBase64 {
+	fn schema_name() -> alloc::string::String {
+		"Nullable_Base64".into()
+	}
+	fn schema_id() -> alloc::borrow::Cow<'static, str> {
+		alloc::borrow::Cow::Borrowed("Option<cf_guest::Base64>")
+	}
+	fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+		<Option<String>>::json_schema(gen)
+	}
+}
+
+// ==================== As String ==============================================
+
 impl AsStr {
 	pub fn serialize<T: fmt::Display, S: Serializer>(obj: &T, ser: S) -> Result<S::Ok, S::Error> {
 		ser.serialize_str(&obj.to_string())
@@ -149,38 +185,82 @@ where
 	}
 }
 
-impl schemars::JsonSchema for Base64 {
+impl schemars::JsonSchema for AsStr {
 	fn schema_name() -> alloc::string::String {
-		"Base64".into()
+		String::schema_name()
 	}
 	fn schema_id() -> alloc::borrow::Cow<'static, str> {
-		alloc::borrow::Cow::Borrowed("cf_guest::Base64")
+		String::schema_id()
 	}
 	fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
 		String::json_schema(gen)
 	}
 }
 
-impl schemars::JsonSchema for OptBase64 {
-	fn schema_name() -> alloc::string::String {
-		"Nullable_Base64".into()
+// ==================== IBC Height =============================================
+
+impl Height {
+	pub fn serialize<S: Serializer>(height: &ibc::Height, ser: S) -> Result<S::Ok, S::Error> {
+		RawHeight::from(*height).serialize(ser)
 	}
-	fn schema_id() -> alloc::borrow::Cow<'static, str> {
-		alloc::borrow::Cow::Borrowed("Option<cf_guest::Base64>")
+
+	pub fn deserialize<'de, D: Deserializer<'de>>(de: D) -> Result<ibc::Height, D::Error> {
+		use serde::de::Error;
+		let height = <RawHeight as Deserialize>::deserialize(de)?;
+		ibc::Height::try_from(height).map_err(|_| {
+			D::Error::invalid_value(
+				serde::de::Unexpected::Unsigned(0),
+				&"height with non-zero revision_height",
+			)
+		})
 	}
-	fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
-		<Option<String>>::json_schema(gen)
+}
+
+/// The core IBC height type, which represents the height of a chain, which
+/// typically is the number of blocks since genesis (or more generally, since
+/// the last revision/hard upgrade).
+#[derive(
+	serde::Serialize,
+	serde::Deserialize,
+	schemars::JsonSchema,
+)]
+pub struct RawHeight {
+	/// Previously known as "epoch"
+	#[serde(default, skip_serializing_if = "is_zero")]
+	pub revision_number: cosmwasm_std::Uint64,
+
+	/// The height of a block
+	pub revision_height: cosmwasm_std::Uint64,
+}
+
+impl TryFrom<RawHeight> for ibc::Height {
+	type Error = ibc::ClientError;
+	fn try_from(height: RawHeight) -> Result<Self, Self::Error> {
+		Self::new(height.revision_number.into(), height.revision_height.into())
 	}
 }
 
-impl schemars::JsonSchema for AsStr {
+impl From<ibc::Height> for RawHeight {
+	fn from(height: ibc::Height) -> Self {
+		Self {
+			revision_number: height.revision_number().into(),
+			revision_height: height.revision_height().into(),
+		}
+	}
+}
+
+impl schemars::JsonSchema for Height {
 	fn schema_name() -> alloc::string::String {
-		String::schema_name()
+		"Height".into()
 	}
 	fn schema_id() -> alloc::borrow::Cow<'static, str> {
-		String::schema_id()
+		alloc::borrow::Cow::Borrowed("cf_guest::IbcHeight")
 	}
 	fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
-		String::json_schema(gen)
+		<RawHeight>::json_schema(gen)
 	}
 }
+
+fn is_zero(num: &cosmwasm_std::Uint64) -> bool {
+	num.u64() == 0
+}

light-clients/cf-guest-cw/src/state.rs

@@ -149,11 +149,10 @@ impl ConsensusStates {
 		for record in self.all() {
 			let (key, _state, metadata) = record?;
 			let key = &key[key.len() - 16..];
+			let revision_number = u64::from_be_bytes(key[..8].try_into().unwrap());
+			let revision_height = u64::from_be_bytes(key[8..].try_into().unwrap());
 			records.push(crate::msg::ConsensusStateMetadata {
-				height: crate::msg::Height {
-					revision_number: u64::from_be_bytes(key[..8].try_into().unwrap()).into(),
-					revision_height: u64::from_be_bytes(key[8..].try_into().unwrap()).into(),
-				},
+				height: ibc::Height::new(revision_number, revision_height).unwrap(),
 				host_timestamp_ns: metadata.host_timestamp_ns.into(),
 				host_height: metadata.host_height.into(),
 			})