ismp weight base fee handler (#474)

Co-authored-by: Seun Lanlege <seun@polytope.technology>

Author: dharjeezy

Cargo.lock

@@ -85,6 +85,7 @@ members = [
     # Utilities
     "modules/utils/subxt",
     "modules/utils/serde",
+    "modules/utils/crypto",
 
     # tesseract
     "tesseract/messaging/primitives",
@@ -148,6 +149,7 @@ strip = true
 polkadot-sdk = { version = "=2506.0.0", default-features = false }
 
 # crates that can't be used in polkadot-sdk
+sp-weights = { version = "32.0.0", default-features = false }
 sp-core = { version = "37.0.0", default-features = false }
 frame-benchmarking = { version = "41.0.0", default-features = false }
 sp-io = { version = "41.0.0", default-features = false }
@@ -213,6 +215,7 @@ ics23 = { version = "0.12.0", default-features = false }
 # published crates
 ismp = { version = "1.2.0", path = "./modules/ismp/core", default-features = false }
 serde-hex-utils = { version = "0.1.0", path = "modules/utils/serde", default-features = false }
+crypto-utils = { path = "modules/utils/crypto", default-features = false }
 grandpa-verifier-primitives = { version = "2.1.0", path = "./modules/consensus/grandpa/primitives", default-features = false }
 grandpa-verifier = { version = "2.1.0", path = "./modules/consensus/grandpa/verifier", default-features = false }
 ismp-grandpa = { version = "2506.0.0", path = "./modules/ismp/clients/grandpa", default-features = false }
@@ -365,4 +368,4 @@ features = ["derive"]
 
 [workspace.dependencies.reconnecting-jsonrpsee-ws-client]
 version = "0.5.0"
-default-features = false
+default-features = false

Cargo.toml

@@ -31,6 +31,7 @@ hex = { workspace = true, features = ["alloc"] }
 anyhow = { workspace = true, default-features = false }
 thiserror = { workspace = true }
 serde-hex-utils = { workspace = true, default-features = false }
+sp-weights = {workspace = true, default-features = false}
 
 [features]
 default = ["std"]
@@ -46,4 +47,5 @@ std = [
     "thiserror/std",
     "displaydoc/std",
     "anyhow/std",
-]
+    "sp-weights/std"
+]

modules/ismp/core/Cargo.toml

@@ -25,6 +25,7 @@ use crate::{
 use crate::{consensus::ConsensusStateId, module::DispatchResult};
 use alloc::{boxed::Box, vec::Vec};
 pub use consensus::create_client;
+use sp_weights::Weight;
 
 mod consensus;
 mod request;
@@ -46,12 +47,39 @@ pub enum MessageResult {
 	ConsensusMessage(Vec<Event>),
 	/// Result of freezing a consensus state.
 	FrozenClient(ConsensusStateId),
-	/// The [`DispatchResult`] for requests
-	Request(Vec<DispatchResult>),
-	/// The [`DispatchResult`] for responses
-	Response(Vec<DispatchResult>),
-	/// The [`DispatchResult`] for timeouts
-	Timeout(Vec<DispatchResult>),
+	/// The result of processing a batch of requests.
+	Request {
+		/// A Vec containing the results of each individual request dispatch.
+		events: Vec<DispatchResult>,
+		/// The total weight consumed by all module `on_accept` calls for this batch.
+		weight: Weight,
+	},
+	/// The result of processing a batch of responses.
+	Response {
+		/// A Vec containing the results of each individual response dispatch.
+		events: Vec<DispatchResult>,
+		/// The total weight consumed by all module `on_accept` calls for this batch.
+		weight: Weight,
+	},
+	/// The result of processing a timeouts.
+	Timeout {
+		/// A Vec containing the results of each individual response dispatch.
+		events: Vec<DispatchResult>,
+		/// The total weight consumed by all module `on_accept` calls for this batch.
+		weight: Weight,
+	},
+}
+
+impl MessageResult {
+	/// Returns the total weight consumed by this message
+	pub fn weight(&self) -> Weight {
+		match self {
+			MessageResult::Request { weight, .. } => *weight,
+			MessageResult::Response { weight, .. } => *weight,
+			MessageResult::Timeout { weight, .. } => *weight,
+			MessageResult::ConsensusMessage(_) | MessageResult::FrozenClient(_) => Weight::zero(),
+		}
+	}
 }
 
 /// This function serves as an entry point to handle the message types provided by the ISMP protocol

modules/ismp/core/src/handlers.rs

@@ -24,6 +24,7 @@ use crate::{
 	router::{Request, RequestResponse},
 };
 use alloc::vec::Vec;
+use sp_weights::Weight;
 
 /// Validate the state machine, verify the request message and dispatch the message to the modules
 pub fn handle<H>(host: &H, msg: RequestMessage) -> Result<MessageResult, anyhow::Error>
@@ -81,16 +82,19 @@ where
 		&msg.proof,
 	)?;
 
+	let mut total_weights = Weight::zero();
 	let result = msg
 		.requests
 		.into_iter()
 		.map(|request| {
 			let wrapped_req = Request::Post(request.clone());
-			let lambda = || {
+			let mut lambda = || {
 				let cb = router.module_for_id(request.to.clone())?;
 				// Store request receipt to prevent reentrancy attack
 				host.store_request_receipt(&wrapped_req, &msg.signer)?;
-				let res = cb.on_accept(request.clone()).map(|_| {
+				let res = cb.on_accept(request.clone()).map(|weight| {
+					total_weights.saturating_accrue(weight);
+
 					let commitment = hash_request::<H>(&wrapped_req);
 					Event::PostRequestHandled(RequestResponseHandled {
 						commitment,
@@ -109,5 +113,5 @@ where
 		})
 		.collect::<Vec<_>>();
 
-	Ok(MessageResult::Request(result))
+	Ok(MessageResult::Request { events: result, weight: total_weights })
 }

modules/ismp/core/src/handlers/request.rs

@@ -24,6 +24,7 @@ use crate::{
 	router::{GetResponse, Request, RequestResponse, Response, StorageValue},
 };
 use alloc::{vec, vec::Vec};
+use sp_weights::Weight;
 
 /// Validate the state machine, verify the response message and dispatch the message to the modules
 pub fn handle<H>(host: &H, msg: ResponseMessage) -> Result<MessageResult, anyhow::Error>
@@ -44,6 +45,7 @@ where
 			.is_none()
 	};
 
+	let mut total_weights = Weight::zero();
 	let result = match &msg.datagram {
 		RequestResponse::Response(responses) => {
 			for response in responses.iter() {
@@ -91,7 +93,8 @@ where
 					let cb = router.module_for_id(response.destination_module())?;
 					// Store response receipt to prevent reentrancy attack
 					host.store_response_receipt(&response, &msg.signer)?;
-					let res = cb.on_response(response.clone()).map(|_| {
+					let res = cb.on_response(response.clone()).map(|weight| {
+						total_weights.saturating_accrue(weight);
 						let commitment = hash_response::<H>(&response);
 						Event::PostResponseHandled(RequestResponseHandled {
 							commitment,
@@ -164,7 +167,8 @@ where
 					host.store_response_receipt(&response, &msg.signer)?;
 					let res = cb
 						.on_response(Response::Get(GetResponse { get: request.clone(), values }))
-						.map(|_| {
+						.map(|weight| {
+							total_weights.saturating_accrue(weight);
 							let commitment = hash_request::<H>(&wrapped_req);
 							Event::GetRequestHandled(RequestResponseHandled {
 								commitment,
@@ -181,5 +185,5 @@ where
 		},
 	};
 
-	Ok(MessageResult::Response(result))
+	Ok(MessageResult::Response { events: result, weight: total_weights })
 }

modules/ismp/core/src/handlers/response.rs

@@ -24,6 +24,7 @@ use crate::{
 	router::Response,
 };
 use alloc::vec::Vec;
+use sp_weights::Weight;
 
 /// This function handles timeouts
 pub fn handle<H>(host: &H, msg: TimeoutMessage) -> Result<MessageResult, anyhow::Error>
@@ -38,6 +39,7 @@ where
 			.find_map(|client| client.state_machine(state_machine).ok())
 			.is_none()
 	};
+	let mut total_module_weight = Weight::zero();
 
 	let results = match msg {
 		TimeoutMessage::Post { requests, timeout_proof } => {
@@ -90,7 +92,8 @@ where
 					if host.host_state_machine() != request.source_chain() {
 						signer = host.delete_request_receipt(&request).ok();
 					}
-					let res = cb.on_timeout(request.clone().into()).map(|_| {
+					let res = cb.on_timeout(request.clone().into()).map(|weight| {
+						total_module_weight.saturating_accrue(weight);
 						let commitment = hash_request::<H>(&request);
 						Event::PostRequestTimeoutHandled(TimeoutHandled {
 							commitment,
@@ -163,7 +166,8 @@ where
 						signer =
 							host.delete_response_receipt(&Response::Post(response.clone())).ok();
 					}
-					let res = cb.on_timeout(response.clone().into()).map(|_| {
+					let res = cb.on_timeout(response.clone().into()).map(|weight| {
+						total_module_weight.saturating_accrue(weight);
 						let commitment = hash_post_response::<H>(&response);
 						Event::PostResponseTimeoutHandled(TimeoutHandled {
 							commitment,
@@ -211,7 +215,8 @@ where
 					let cb = router.module_for_id(request.source_module())?;
 					// Delete commitment to prevent reentrancy
 					let meta = host.delete_request_commitment(&request)?;
-					let res = cb.on_timeout(request.clone().into()).map(|_| {
+					let res = cb.on_timeout(request.clone().into()).map(|weight| {
+						total_module_weight.saturating_accrue(weight);
 						let commitment = hash_request::<H>(&request);
 						Event::GetRequestTimeoutHandled(TimeoutHandled {
 							commitment,
@@ -229,5 +234,5 @@ where
 		},
 	};
 
-	Ok(MessageResult::Timeout(results))
+	Ok(MessageResult::Timeout { events: results, weight: total_module_weight })
 }

modules/ismp/core/src/handlers/timeout.rs

@@ -30,6 +30,7 @@ use crate::{
 };
 use alloc::{string::ToString, vec::Vec};
 use codec::{Decode, DecodeWithMemTracking, Encode};
+use sp_weights::Weight;
 use primitive_types::H256;
 
 /// A consensus message is used to update the state of a consensus client and its children state
@@ -234,6 +235,17 @@ pub enum Message {
 	Timeout(TimeoutMessage),
 }
 
+/// The ISMP Message with Weight consumed by the message
+#[derive(
+	Debug, Clone, Encode, Decode, DecodeWithMemTracking, scale_info::TypeInfo, PartialEq, Eq,
+)]
+pub struct MessageWithWeight {
+	/// The message itself
+	pub message: Message,
+	/// The weight consumed by the message
+	pub weight: Weight,
+}
+
 /// A trait that returns a 256 bit keccak has of some bytes
 pub trait Keccak256 {
 	/// Returns a keccak256 hash of a byte slice

modules/ismp/core/src/messaging.rs

@@ -20,7 +20,7 @@ use crate::{
 	router::{PostRequest, Response, Timeout},
 	Error,
 };
-
+use sp_weights::Weight;
 /// A type alias for dispatch results
 pub type DispatchResult = Result<Event, anyhow::Error>;
 
@@ -29,19 +29,19 @@ pub type DispatchResult = Result<Event, anyhow::Error>;
 pub trait IsmpModule {
 	/// Called by the message handler on a module, to notify module of a new POST request
 	/// the module may choose to respond immediately, or in a later block
-	fn on_accept(&self, _request: PostRequest) -> Result<(), anyhow::Error> {
+	fn on_accept(&self, _request: PostRequest) -> Result<Weight, anyhow::Error> {
 		Err(Error::CannotHandleMessage)?
 	}
 
 	/// Called by the message handler on a module, to notify module of a response to a previously
 	/// sent out request
-	fn on_response(&self, _response: Response) -> Result<(), anyhow::Error> {
+	fn on_response(&self, _response: Response) -> Result<Weight, anyhow::Error> {
 		Err(Error::CannotHandleMessage)?
 	}
 
 	/// Called by the message handler on a module, to notify module of requests that were previously
 	/// sent but have now timed-out
-	fn on_timeout(&self, _request: Timeout) -> Result<(), anyhow::Error> {
+	fn on_timeout(&self, _request: Timeout) -> Result<Weight, anyhow::Error> {
 		Err(Error::CannotHandleMessage)?
 	}
 }

modules/ismp/core/src/module.rs

@@ -1,5 +1,5 @@
 use codec::Encode;
-use polkadot_sdk::*;
+use polkadot_sdk::{sp_runtime::Weight, *};
 use primitive_types::H256;
 use std::{
 	cell::RefCell,
@@ -415,19 +415,23 @@ impl Keccak256 for Host {
 pub struct MockModule;
 
 impl IsmpModule for MockModule {
-	fn on_accept(&self, _request: PostRequest) -> Result<(), anyhow::Error> {
-		Ok(())
+	fn on_accept(&self, _request: PostRequest) -> Result<Weight, anyhow::Error> {
+		Ok(weight())
 	}
 
-	fn on_response(&self, _response: Response) -> Result<(), anyhow::Error> {
-		Ok(())
+	fn on_response(&self, _response: Response) -> Result<Weight, anyhow::Error> {
+		Ok(weight())
 	}
 
-	fn on_timeout(&self, _request: Timeout) -> Result<(), anyhow::Error> {
-		Ok(())
+	fn on_timeout(&self, _request: Timeout) -> Result<Weight, anyhow::Error> {
+		Ok(weight())
 	}
 }
 
+fn weight() -> Weight {
+	Weight::from_parts(0, 0)
+}
+
 pub struct MockRouter(pub Host);
 
 impl IsmpRouter for MockRouter {