Pallet ISMP

#[pallet::config]
pub trait Config: frame_system::Config {
	/// The overarching event type.
	type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 
	/// Admin origin for privileged actions such as adding new consensus clients as well as
	/// modifying existing consensus clients (eg. challenge period, unbonding period)
	type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>;
 
	/// Timestamp interface [`UnixTime`] for querying the current timestamp. This is used within
	/// the various ISMP sub-protocols.
	type TimestampProvider: UnixTime;
 
	/// The balance of an account.
	type Balance: Parameter
		+ Member
		+ AtLeast32BitUnsigned
		+ Codec
		+ Default
		+ Copy
		+ MaybeSerializeDeserialize
		+ Debug
		+ MaxEncodedLen
		+ TypeInfo
		+ FixedPointOperand;
 
	/// The currency that is offered to relayers as payment for request delivery
	/// and execution. This should ideally be a stablecoin of some kind to guarantee
	/// predictable and stable revenue for relayers.
	///
	/// This can also be used with pallet-assets through the
	/// [ItemOf](frame_support::traits::tokens::fungible::ItemOf) implementation
	type Currency: Mutate<Self::AccountId, Balance = Self::Balance>;
 
	/// The state machine identifier for the host chain. This is the identifier that will be
	/// used to accept requests that are addressed to this state machine. Remote chains
	/// will also use this identifier to accept requests originating from this state
	/// machine.
	type HostStateMachine: Get<StateMachine>;
 
	/// The coprocessor is a state machine which proxies requests on our behalf. The coprocessor
	/// does this by performing the costly consensus and state proof verification needed to
	/// verify requests/responses that are addressed to this host state machine.
	///
	/// The ISMP framework permits the coprocessor to aggregate messages from potentially
	/// multiple state machines. Finally producing much cheaper proofs of consensus and state
	/// needed to verify the legitimacy of the messages.
	type Coprocessor: Get<Option<StateMachine>>;
 
	/// [`IsmpRouter`] implementation for routing requests & responses to their appropriate
	/// modules.
	type Router: IsmpRouter + Default;
 
	/// This should provide a list of [`ConsenusClient`](ismp::consensus::ConsensusClient)s
	/// which should be used to validate incoming requests or responses. There should be
	/// at least one consensus client present to allow messages be processed by the ISMP
	/// subsystems.
	type ConsensusClients: ConsensusClientProvider;
 
	/// This implementation should provide the weight consumed by `IsmpModule` callbacks from
	/// their benchmarks.
	type WeightProvider: WeightProvider;
 
	/// Merkle mountain range overlay tree implementation. Outgoing requests and responses are
	/// inserted in this "overlay tree" to enable cheap proofs for messages.
	///
	/// State machines that do not need this can simply use the `NoOpMmrTree`
	type Mmr: MerkleMountainRangeTree<Leaf = Leaf>;
}

parameter_types! {
    // The hyperbridge parachain on Polkadot
    pub const Coprocessor: Option<StateMachine> = Some(StateMachine::Polkadot(3367));
    // The host state machine of this pallet
    pub const HostStateMachine: StateMachine = StateMachine::Polkadot(1000); // your paraId here
}
 
impl pallet_ismp::Config for Runtime {
    // configure the runtime event
    type RuntimeEvent = RuntimeEvent;
    // Permissioned origin who can create or update consensus clients
    type AdminOrigin = EnsureRoot<AccountId>;
    // The state machine identifier for this state machine
    type HostStateMachine = HostStateMachine;
    // The pallet_timestamp pallet
    type TimestampProvider = Timestamp;
    // The currency implementation that is offered to relayers
    type Currency = Balances;
    // The balance type for the currency implementation
    type Balance = Balance;
    // Router implementation for routing requests/responses to their respective modules
    type Router = Router;
    // Optional coprocessor for incoming requests/responses
    type Coprocessor = Coprocessor;
    // Supported consensus clients
    type ConsensusClients = (
        // as an example, the parachain consensus client
        ismp_parachain::ParachainConsensusClient<Runtime, IsmpParachain>,
    );
    // Optional merkle mountain range overlay tree, for cheaper outgoing request proofs.
    // You most likely don't need it, just use the `NoOpMmrTree`
    type Mmr = NoOpMmrTree<Runtime>;
    // Weight provider for local modules
    type WeightProvider = ();
}
 
construct_runtime! {
    // ...
    Ismp: pallet_ismp
}

#[derive(Default)]
struct Router;
 
impl IsmpRouter for Router {
    fn module_for_id(&self, id: Vec<u8>) -> Result<Box<dyn IsmpModule>, Error> {
        let module = match id.as_slice() {
           YOUR_MODULE_ID => Box::new(YourModule::default()),
           // ... other modules
            _ => Err(Error::ModuleNotFound(id))?
        };
        Ok(module)
    }
}
 
/// Some custom module capable of processing some incoming/request or response.
/// This could also be a pallet itself.
#[derive(Default)]
struct YourModule;
 
impl IsmpModule for YourModule {
    /// Called by the ISMP hanlder, 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: Post) -> Result<(), Error> {
        // do something useful with the request
        Ok(())
    }
 
    /// Called by the ISMP hanlder, to notify module of a response to a previously
    /// sent out request
    fn on_response(&self, response: Response) -> Result<(), Error> {
         // do something useful with the response
         Ok(())
    }
 
     /// Called by the ISMP hanlder, to notify module of requests that were previously
     /// sent but have now timed-out
 	fn on_timeout(&self, request: Timeout) -> Result<(), Error> {
        // revert any state changes that were made prior to dispatching the request
        Ok(())
    }
}

struct YourModuleBenchmarks;
 
impl pallet_ismp::weights::IsmpModuleWeight for YourModuleBenchmarks {
    /// Should return the weight used in processing this request
	   fn on_accept(&self, request: &Post) -> Weight {
        todo!("Return benchmark weight")
    }
	   /// Should return the weight used in processing this timeout
	   fn on_timeout(&self, request: &Timeout) -> Weight {
        todo!("Return benchmark weight")
    }
	   /// Should return the weight used in processing this response
	   fn on_response(&self, response: &Response) -> Weight {
        todo!("Return benchmark weight")
    }
}
 
struct ModuleWeightProvider
 
impl pallet_ismp::WeightProvider for ModuleWeightProvider {
	fn module_callback(dest_module: ModuleId) -> Option<Box<dyn IsmpModuleWeight>> {
		match dest_module.to_bytes().as_slice() {
            YOUR_MODULE_ID => {
                Some(Box::new(YourModuleBenchmarks::default()))
            }
            // ... other modules
            _ => None
        }
	}
}

impl pallet_ismp_runtime_api::IsmpRuntimeApi<Block, <Block as BlockT>::Hash> for Runtime {
		fn host_state_machine() -> StateMachine {
			<Runtime as pallet_ismp::Config>::HostStateMachine::get()
		}
 
		fn challenge_period(consensus_state_id: [u8; 4]) -> Option<u64> {
			Ismp::challenge_period(consensus_state_id)
		}
 
		/// Generate a proof for the provided leaf indices
		fn generate_proof(
			keys: ProofKeys
		) -> Result<(Vec<Leaf>, Proof<<Block as BlockT>::Hash>), sp_mmr_primitives::Error> {
			Ismp::generate_proof(keys)
		}
 
		/// Fetch all ISMP events in the block, should only be called from runtime-api.
		fn block_events() -> Vec<::ismp::events::Event> {
			Ismp::block_events()
		}
 
		/// Fetch all ISMP events and their extrinsic metadata, should only be called from runtime-api.
		fn block_events_with_metadata() -> Vec<(::ismp::events::Event, Option<u32>)> {
			Ismp::block_events_with_metadata()
		}
 
		/// Return the scale encoded consensus state
		fn consensus_state(id: ConsensusClientId) -> Option<Vec<u8>> {
			Ismp::consensus_states(id)
		}
 
		/// Return the timestamp this client was last updated in seconds
		fn consensus_update_time(id: ConsensusClientId) -> Option<u64> {
			Ismp::consensus_update_time(id)
		}
 
		/// Return the latest height of the state machine
		fn latest_state_machine_height(id: StateMachineId) -> Option<u64> {
			Ismp::latest_state_machine_height(id)
		}
 
 
		/// Get actual requests
		fn requests(commitments: Vec<H256>) -> Vec<Request> {
			Ismp::requests(commitments)
		}
 
		/// Get actual requests
		fn responses(commitments: Vec<H256>) -> Vec<Response> {
			Ismp::responses(commitments)
		}
	}