Introduce augmenting_std for re-exporting tokio, serde & async_trait

chaindexing-tests/src/factory/handlers.rs

@@ -5,7 +5,7 @@ pub struct NftState;
 
 pub struct TransferTestHandler;
 
-#[async_trait::async_trait]
+#[chaindexing::augmenting_std::async_trait::async_trait]
 impl EventHandler for TransferTestHandler {
     fn abi(&self) -> &'static str {
         "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
@@ -15,7 +15,7 @@ impl EventHandler for TransferTestHandler {
 
 pub struct ApprovalForAllTestHandler;
 
-#[async_trait::async_trait]
+#[chaindexing::augmenting_std::async_trait::async_trait]
 impl EventHandler for ApprovalForAllTestHandler {
     fn abi(&self) -> &'static str {
         "event ApprovalForAll(address indexed owner, address indexed operator, bool approved)"

chaindexing-tests/src/factory/providers.rs

@@ -7,7 +7,7 @@ use rand::seq::SliceRandom;
 pub fn empty_provider() -> impl IngesterProvider {
     #[derive(Clone)]
     struct Provider;
-    #[async_trait::async_trait]
+    #[chaindexing::augmenting_std::async_trait::async_trait]
     impl IngesterProvider for Provider {
         async fn get_block_number(&self) -> Result<U64, ProviderError> {
             Ok(U64::from(0))
@@ -79,7 +79,7 @@ macro_rules! provider_with_logs {
         struct Provider {
             contract_address: String,
         }
-        #[async_trait::async_trait]
+        #[chaindexing::augmenting_std::async_trait::async_trait]
         impl IngesterProvider for Provider {
             async fn get_block_number(&self) -> Result<U64, ProviderError> {
                 Ok(U64::from($current_block_number))
@@ -112,7 +112,7 @@ macro_rules! provider_with_filter_stubber {
 
         #[derive(Clone)]
         struct Provider;
-        #[async_trait::async_trait]
+        #[chaindexing::augmenting_std::async_trait::async_trait]
         impl IngesterProvider for Provider {
             async fn get_block_number(&self) -> Result<U64, ProviderError> {
                 Ok(U64::from(3))
@@ -147,7 +147,7 @@ macro_rules! provider_with_empty_logs {
 
         #[derive(Clone)]
         struct Provider;
-        #[async_trait::async_trait]
+        #[chaindexing::augmenting_std::async_trait::async_trait]
         impl IngesterProvider for Provider {
             async fn get_block_number(&self) -> Result<U64, ProviderError> {
                 Ok(U64::from(3))

chaindexing/src/augmenting_std.rs

@@ -0,0 +1,3 @@
+pub use async_trait;
+pub use serde;
+pub use tokio;

chaindexing/src/handlers/pure_handler.rs

@@ -10,7 +10,7 @@ use super::handler_context::HandlerContext;
 
 /// Pure handlers do not contain any side effects. They are simple reducers
 /// that derive or index states deterministically.
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 pub trait PureHandler: Send + Sync {
     /// The human-readable ABI of the event being handled.
     /// For example, Uniswap's PoolCreated event's abi is:

chaindexing/src/handlers/side_effect_handler.rs

@@ -8,14 +8,13 @@ use crate::{ChaindexingRepoTxnClient, EventParam};
 
 use super::handler_context::HandlerContext;
 
-#[async_trait::async_trait]
-
 /// SideEffectHandlers are event handlers that help handle side-effects for events.
 /// This is useful for handling events only ONCE and can rely on a non-deterministic
 /// shared state. Some use-cases are notifications, bridging etc. Chaindexing ensures
 /// that the side-effect handlers are called once immutably regardless of resets.
 /// However, one can dangerously reset including side effects with the `reset_including_side_effects`
 /// exposed in the Config API.
+#[crate::augmenting_std::async_trait::async_trait]
 pub trait SideEffectHandler: Send + Sync {
     type SharedState: Send + Sync + Clone + Debug;
 

chaindexing/src/ingester/provider.rs

@@ -13,7 +13,7 @@ use super::filters::Filter;
 
 pub type ProviderError = EthersProviderError;
 
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 pub trait Provider: Clone + Sync + Send {
     async fn get_block_number(&self) -> Result<U64, ProviderError>;
     async fn get_logs(&self, filter: &EthersFilter) -> Result<Vec<Log>, ProviderError>;
@@ -50,7 +50,7 @@ pub trait Provider: Clone + Sync + Send {
     }
 }
 
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 impl Provider for EthersProvider<Http> {
     async fn get_block_number(&self) -> Result<U64, ProviderError> {
         Middleware::get_block_number(&self).await

chaindexing/src/lib.rs

@@ -21,6 +21,9 @@ mod pruning;
 mod repos;
 mod root;
 
+/// Augmenting modules for standard library to support Chaindexing's asynchronous operations
+pub mod augmenting_std;
+
 pub use chains::{Chain, ChainId};
 pub use config::{Config, OptimizationConfig};
 pub use contracts::{Contract, ContractAddress, EventAbi};
@@ -207,7 +210,7 @@ fn get_tasks_runner<S: Sync + Send + Debug + Clone + 'static>(
     struct ChaindexingNodeTasksRunner<'a, S: Send + Sync + Clone + Debug + 'static> {
         config: &'a Config<S>,
     }
-    #[async_trait::async_trait]
+    #[crate::augmenting_std::async_trait::async_trait]
     impl<'a, S: Send + Sync + Clone + Debug + 'static> NodeTasksRunner
         for ChaindexingNodeTasksRunner<'a, S>
     {

chaindexing/src/nodes/node_tasks_runner.rs

@@ -1,6 +1,6 @@
 use super::node_task::NodeTask;
 
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 pub trait NodeTasksRunner {
     async fn run(&self) -> Vec<NodeTask>;
 }

chaindexing/src/repos/postgres_repo.rs

@@ -54,7 +54,7 @@ impl PostgresRepo {
     }
 }
 
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 impl Repo for PostgresRepo {
     type Conn<'a> = PgPooledConn<'a>;
     type Pool = bb8::Pool<AsyncDieselConnectionManager<AsyncPgConnection>>;

chaindexing/src/repos/postgres_repo/raw_queries.rs

@@ -10,7 +10,7 @@ use serde::de::DeserializeOwned;
 pub type PostgresRepoClient = Client;
 pub type PostgresRepoTxnClient<'a> = Transaction<'a>;
 
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 impl HasRawQueryClient for PostgresRepo {
     type RawQueryClient = Client;
     type RawQueryTxnClient<'a> = Transaction<'a>;
@@ -29,7 +29,7 @@ impl HasRawQueryClient for PostgresRepo {
     }
 }
 
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 impl ExecutesWithRawQuery for PostgresRepo {
     async fn execute(client: &Self::RawQueryClient, query: &str) {
         client.execute(query, &[] as &[&(dyn ToSql + Sync)]).await.unwrap();
@@ -206,7 +206,7 @@ impl ExecutesWithRawQuery for PostgresRepo {
     }
 }
 
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 impl LoadsDataWithRawQuery for PostgresRepo {
     async fn create_and_load_new_node(client: &Self::RawQueryClient) -> Node {
         Self::load_data(

chaindexing/src/repos/repo.rs

@@ -21,7 +21,7 @@ pub enum RepoError {
     Unknown(String),
 }
 
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 pub trait Repo:
     Sync + Send + Migratable + ExecutesWithRawQuery + LoadsDataWithRawQuery + Clone + Debug
 {
@@ -69,7 +69,7 @@ pub trait Repo:
     async fn keep_node_active<'a>(conn: &mut Self::Conn<'a>, node: &Node);
 }
 
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 pub trait HasRawQueryClient {
     type RawQueryClient: Send + Sync;
     type RawQueryTxnClient<'a>: Send + Sync;
@@ -80,7 +80,7 @@ pub trait HasRawQueryClient {
     ) -> Self::RawQueryTxnClient<'a>;
 }
 
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 pub trait ExecutesWithRawQuery: HasRawQueryClient {
     async fn execute(client: &Self::RawQueryClient, query: &str);
     async fn execute_in_txn<'a>(client: &Self::RawQueryTxnClient<'a>, query: &str);
@@ -127,7 +127,7 @@ pub trait ExecutesWithRawQuery: HasRawQueryClient {
     async fn prune_root_states(client: &Self::RawQueryClient, retain_size: u64);
 }
 
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 pub trait LoadsDataWithRawQuery: HasRawQueryClient {
     async fn create_and_load_new_node(client: &Self::RawQueryClient) -> Node;
     async fn load_last_root_state(client: &Self::RawQueryClient) -> Option<root::State>;
@@ -196,7 +196,7 @@ pub trait RepoMigrations: Migratable {
     }
 }
 
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 pub trait Migratable: ExecutesWithRawQuery + Sync + Send {
     async fn migrate(client: &Self::RawQueryClient, migrations: Vec<impl AsRef<str> + Send + Sync>)
     where

chaindexing/src/states/chain_state.rs

@@ -14,7 +14,7 @@ use serde::de::DeserializeOwned;
 use serde::Serialize;
 
 /// States derived from different contracts within a chain
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 pub trait ChainState: DeserializeOwned + Serialize + Clone + Debug + Sync + Send + 'static {
     /// Table of the state as specified in StateMigrations
     fn table_name() -> &'static str;

chaindexing/src/states/contract_state.rs

@@ -14,7 +14,7 @@ use serde::de::DeserializeOwned;
 use serde::Serialize;
 
 /// States derived from a contract
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 pub trait ContractState:
     DeserializeOwned + Serialize + Clone + Debug + Sync + Send + 'static
 {

chaindexing/src/states/multi_chain_state.rs

@@ -14,7 +14,7 @@ use serde::Serialize;
 
 /// States derived from different contracts across different chains
 /// N/B: Indexing MultiChainStates must be Order-Agnostic
-#[async_trait::async_trait]
+#[crate::augmenting_std::async_trait::async_trait]
 pub trait MultiChainState:
     DeserializeOwned + Serialize + Clone + Debug + Sync + Send + 'static
 {