get the eth_NewFilter request compiling

core/src/environment.rs

@@ -2,7 +2,7 @@
 #![warn(unsafe_code)]
 
 use crossbeam_channel::{unbounded, Receiver, Sender};
-use ethers::providers::{JsonRpcClient, ProviderError};
+use ethers::{providers::{JsonRpcClient, ProviderError}, types::{Filter, H256}, prelude::k256::sha2::{Digest, Sha256}, utils::serialize};
 use revm::{
     db::{CacheDB, EmptyDB},
     primitives::{ExecutionResult, Log, TxEnv, U256},
@@ -12,7 +12,7 @@ use serde::{de::DeserializeOwned, Serialize};
 use std::{
     fmt::Debug,
     sync::{Arc, Mutex},
-    thread,
+    thread, collections::HashMap,
 };
 
 use crate::{utils::revm_logs_to_ethers_logs, agent::IsAttached};
@@ -52,6 +52,7 @@ pub struct RevmProvider {
     pub(crate) result_sender: crossbeam_channel::Sender<ExecutionResult>,
     pub(crate) result_receiver: crossbeam_channel::Receiver<ExecutionResult>,
     pub(crate) event_receiver: crossbeam_channel::Receiver<Vec<ethers::types::Log>>,
+    // pub(crate) filter_receivers: HashMap<ethers::types::U256, crossbeam_channel::Receiver<Vec<ethers::types::Log>>>, // TODO: Use this to replace event_receivers so we can look for updates in specific filters
 }
 
 impl Debug for RevmProvider {
@@ -71,13 +72,25 @@ impl JsonRpcClient for RevmProvider {
     ) -> Result<R, ProviderError> {
         match method {
             "eth_getFilterChanges" => {
+                // Store a Map of filters with their IDs as keys
                 let logs = self.event_receiver.recv().unwrap();
                 println!("logs: {:?}", logs);
                 let logs_str = serde_json::to_string(&logs).unwrap();
                 let logs_deserializeowned: R = serde_json::from_str(&logs_str)?;
                 return Ok(logs_deserializeowned);
                 // return Ok(serde::to_value(self.event_receiver.recv().ok()).unwrap())
             },
+            "eth_newFilter" => {
+                let filter_string = serde_json::to_string(&params).unwrap();
+                let filter: Filter = serde_json::from_str(&filter_string).unwrap();
+                let mut hasher = Sha256::new();
+                hasher.update(filter_string.as_bytes());
+                let hash = hasher.finalize();
+                let id = ethers::types::U256::from(ethers::types::H256::from_slice(&hash).as_bytes());
+                let id_str = serde_json::to_string(&id).unwrap();
+                let id_deserializeowned: R = serde_json::from_str(&id_str)?;
+                Ok(id_deserializeowned)
+            },
             _ => {
                 unimplemented!("We don't cover this case yet.")
             }

core/src/middleware.rs

@@ -5,6 +5,7 @@
 
 use ethers::prelude::pending_transaction::PendingTxState;
 use ethers::providers::{FilterKind, JsonRpcClient, JsonRpcError, PendingTransaction, Provider};
+use ethers::utils;
 use ethers::{
     prelude::k256::{
         ecdsa::SigningKey,
@@ -87,7 +88,7 @@ impl Middleware for RevmMiddleware {
     async fn send_transaction<T: Into<TypedTransaction> + Send + Sync>(
         &self,
         tx: T,
-        block: Option<BlockId>,
+        _block: Option<BlockId>,
     ) -> Result<PendingTransaction<'_, Self::Provider>, Self::Error> {
         let mut tx: TypedTransaction = tx.into();
         tx.set_from(self.wallet.address());
@@ -210,14 +211,13 @@ impl Middleware for RevmMiddleware {
         &self,
         filter: FilterKind<'_>,
     ) -> Result<ethers::types::U256, ProviderError> {
-        todo!()
-        // let (method, args) = match filter {
-        //     FilterKind::NewBlocks => unimplemented!("We will need to implement this."),
-        //     FilterKind::PendingTransactions => unimplemented!("Not sure if we need to implement this."),
-        //     FilterKind::Logs(filter) => ("eth_newFilter", vec![utils::serialize(&filter)]),
-        // };
-
-        // self.request(method, args).await
+        let (method, args) = match filter {
+            FilterKind::NewBlocks => unimplemented!("We will need to implement this."),
+            FilterKind::PendingTransactions => unimplemented!("Not sure if we need to implement this."),
+            FilterKind::Logs(filter) => ("eth_newFilter", vec![utils::serialize(&filter)]),
+        };
+
+        self.provider().request(method, args).await
     }
 
     async fn watch<'a>(

core/src/tests.rs

@@ -68,6 +68,7 @@ fn multiple_agent_addresses() {
     );
 }
 
+// TODO: Test to see that we prvent agents with the same name from being added.
 #[test]
 fn agent_name_collision() {
     todo!();
@@ -158,16 +159,17 @@ async fn transact() -> Result<()> {
 
 #[tokio::test]
 async fn filter_watcher() -> Result<()> {
-    // let mut environment = Environment::new(TEST_ENV_LABEL.to_string());
-    // environment.run();
-    // let agent = Agent::new_simulation_agent(TEST_AGENT_NAME.to_string(), environment.connection);
-    // let arbiter_token = deploy().await.unwrap();
-    // let filter = arbiter_token.approval_filter().filter;
-    // let mut filter_watcher = agent.client.watch(&filter).await?;
-    // let event = filter_watcher.next().await;
-    // println!("{:?}", event);
-    // Ok(())
+    let environment = &mut Environment::new(TEST_ENV_LABEL);
+    let agent = Agent::new(TEST_AGENT_NAME);
+    agent.attach_to_environment(environment);
+    environment.run();
+    let client = environment.agents[0].client.clone();
+    let arbiter_token = deploy().await.unwrap();
+    let filter = arbiter_token.approval_filter().filter;
+    let mut filter_watcher = client.watch(&filter).await?;
+    let event = filter_watcher.next().await;
+    println!("{:?}", event);
+    Ok(())
 
     // TODO: Test that we can filter out approvals and NOT transfers (or something like this)
-    todo!()
 }