middleware to inject missing block hash/number

.gitignore

@@ -4,3 +4,4 @@
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
+.idea

config.yml

@@ -15,41 +15,41 @@ rpcs:
 
     - method: chain_getBlockHash
       cache: true
-      with_block_number: true
+      with_block_number: 0
 
     - method: chain_getHeader
       cache: true
-      with_block_hash: true
+      with_block_hash: 0
 
     - method: chain_getBlock
       cache: true
-      with_block_hash: true
+      with_block_hash: 0
 
     - method: chain_getFinalizedHead
 
     - method: state_getRuntimeVersion
       cache: true
-      with_block_hash: true
+      with_block_hash: 0
 
     - method: state_getMetadata
       cache: true
-      with_block_hash: true
+      with_block_hash: 0
 
     - method: state_getStorage
       cache: true
-      with_block_hash: true
+      with_block_hash: 1
 
     - method: state_getKeysPaged
       cache: true
-      with_block_hash: true
+      with_block_hash: 3
 
     - method: state_queryStorageAt
       cache: true
-      with_block_hash: true
+      with_block_hash: 1
 
     - method: state_call
       cache: true
-      with_block_hash: true
+      with_block_hash: 2
 
     - method: system_chain
       cache: true
@@ -70,7 +70,7 @@ rpcs:
 
     - method: system_dryRun
       cache: true
-      with_block_hash: true
+      with_block_hash: 1
 
     - method: system_accountNextIndex
 

src/api.rs

@@ -11,6 +11,24 @@ pub struct Api {
     finalized_head: Arc<RwLock<Option<(JsonValue, u64)>>>,
 }
 
+impl Api {
+    pub async fn get_block_number(&self) -> Option<JsonValue> {
+        self.head
+            .read()
+            .await
+            .as_ref()
+            .map(|(_, number)| JsonValue::from(*number))
+    }
+
+    pub async fn get_block_hash(&self) -> Option<JsonValue> {
+        self.head
+            .read()
+            .await
+            .as_ref()
+            .map(|(hash, _)| hash.clone())
+    }
+}
+
 impl Api {
     pub fn new(client: Arc<Client>) -> Self {
         let this = Self {

src/config.rs

@@ -31,11 +31,8 @@ pub struct RpcMethod {
     #[serde(default)]
     pub cache: bool,
 
-    #[serde(default)]
-    pub with_block_hash: bool,
-
-    #[serde(default)]
-    pub with_block_number: bool,
+    pub with_block_hash: Option<usize>,
+    pub with_block_number: Option<usize>,
 }
 
 #[derive(Deserialize, Debug)]

src/middleware/inject_params.rs

@@ -0,0 +1,65 @@
+use async_trait::async_trait;
+use jsonrpsee::{
+    core::{Error, JsonValue, __reexports::serde_json},
+    types::Params,
+};
+use std::sync::Arc;
+
+use super::{Middleware, NextFn};
+use crate::{api::Api, middleware::call::CallRequest};
+
+pub enum Inject {
+    BlockHashAt(usize),
+    BlockNumberAt(usize),
+}
+
+pub struct InjectParamsMiddleware {
+    api: Arc<Api>,
+    inject: Inject,
+}
+
+impl InjectParamsMiddleware {
+    pub fn new(api: Arc<Api>, inject: Inject) -> Self {
+        Self { api, inject }
+    }
+
+    async fn needs_to_inject(&self, params_len: usize) -> Option<JsonValue> {
+        match self.inject {
+            Inject::BlockHashAt(hash_index) => {
+                if params_len == hash_index {
+                    // block hash is missing
+                    return self.api.get_block_hash().await;
+                }
+            }
+            Inject::BlockNumberAt(number_index) => {
+                if params_len == number_index {
+                    // block number is missing
+                    return self.api.get_block_number().await;
+                }
+            }
+        }
+        None
+    }
+}
+
+#[async_trait]
+impl Middleware<CallRequest, Result<JsonValue, Error>> for InjectParamsMiddleware {
+    async fn call(
+        &self,
+        mut request: CallRequest,
+        next: NextFn<CallRequest, Result<JsonValue, Error>>,
+    ) -> Result<JsonValue, Error> {
+        let params = request.params.parse::<JsonValue>()?;
+
+        if let Some(params) = params.to_owned().as_array_mut() {
+            if let Some(param) = self.needs_to_inject(params.len()).await {
+                log::debug!("Injected param {} to method {}", &param, request.method);
+                params.push(param);
+                request.params =
+                    Params::new(Some(serde_json::to_string(&params)?.as_str())).into_owned();
+            }
+        }
+
+        next(request).await
+    }
+}

src/middleware/mod.rs

@@ -4,6 +4,7 @@ use async_trait::async_trait;
 use futures::{future::BoxFuture, FutureExt};
 
 pub mod call;
+pub mod inject_params;
 pub mod subscription;
 
 type NextFn<Request, Result> = Box<dyn FnOnce(Request) -> BoxFuture<'static, Result> + Send + Sync>;

src/server.rs

@@ -10,8 +10,9 @@ use crate::{
     config::Config,
     middleware::{
         call::{self, CallRequest},
+        inject_params::{Inject, InjectParamsMiddleware},
         subscription::{self, SubscriptionRequest},
-        Middlewares,
+        Middleware, Middlewares,
     },
 };
 
@@ -36,13 +37,30 @@ pub async fn start_server(
     let mut module = RpcModule::new(());
 
     let client = Arc::new(client);
-    let _api = Api::new(client.clone());
+    let api = Arc::new(Api::new(client.clone()));
 
     let upstream = Arc::new(call::UpstreamMiddleware::new(client.clone()));
 
     for method in &config.rpcs.methods {
+        let mut list: Vec<Arc<dyn Middleware<_, _>>> = vec![];
+
+        if let Some(hash_index) = method.with_block_hash {
+            list.push(Arc::new(InjectParamsMiddleware::new(
+                api.clone(),
+                Inject::BlockHashAt(hash_index),
+            )));
+        }
+        if let Some(number_index) = method.with_block_number {
+            list.push(Arc::new(InjectParamsMiddleware::new(
+                api.clone(),
+                Inject::BlockNumberAt(number_index),
+            )));
+        }
+
+        list.push(upstream.clone());
+
         let middlewares = Arc::new(Middlewares::new(
-            vec![upstream.clone()],
+            list,
             Arc::new(|_| {
                 async {
                     Err(