wip

Signed-off-by: poonai <[email protected]>

node/src/bin/manager.rs

@@ -427,6 +427,29 @@ pub enum ChainCommand {
         #[clap(long, short)]
         force: bool,
     },
+
+    /// Execute operations on call cache.
+    CallCache {
+        #[clap(subcommand)]
+        method: CallCacheCommand,
+        /// Chain name (must be an existing chain, see 'chain list')
+        #[clap(empty_values = false)]
+        chain_name: String,
+    },
+}
+
+#[derive(Clone, Debug, Subcommand)]
+pub enum CallCacheCommand {
+    /// Remove call cache of a specified chain
+    ///
+    /// If block pointers of from and to is not mentioned, then all the call cache will be
+    /// removed.
+    Remove {
+        /// Starting block pointer
+        from: Option<i32>,
+        /// Ending block pointer
+        to: Option<i32>,
+    },
 }
 
 #[derive(Clone, Debug, Subcommand)]
@@ -1088,6 +1111,7 @@ async fn main() -> anyhow::Result<()> {
                     let chain_store = ctx.chain_store(&chain_name)?;
                     truncate(chain_store, force)
                 }
+                CallCache { method, chain_name } => {}
             }
         }
         Stats(cmd) => {

node/src/manager/commands/chain.rs

@@ -129,3 +129,6 @@ pub fn remove(primary: ConnectionPool, store: Arc<BlockStore>, name: String) ->
 
     Ok(())
 }
+
+
+pub async fn call_cache_remove(){}

store/postgres/src/chain_store.rs

@@ -1028,6 +1028,32 @@ mod data {
                 .collect())
         }
 
+        pub(super) fn clear_call_cache(
+            &self,
+            conn: &PgConnection,
+            from: Option<i32>,
+            to: Option<i32>,
+        ) -> Result<(), Error> {
+            match self {
+                Storage::Shared => {
+                    use public::eth_call_cache as cache;
+
+                    let stmt = cache::table.select((cache::id, cache::return_value, cache::contract_address));
+                    if let Some(from) = from{
+                         stmt.filter(cache::block_number.ge(from));
+                    }
+                    if let Some(to) = to  {
+                        stmt.filter(cache::block_number.le(to));
+                    }
+
+                },
+                Storage::Private(Schema{call_cache, ..}) => {
+
+                }
+            }
+            Ok(())
+        }
+
         pub(super) fn update_accessed_at(
             &self,
             conn: &PgConnection,