Make our traits object safe and implement the ReviveDevNodePolkaVMResolc target. (#159)

* Generate schema for the metadata file

* Groundwork for dyn traits

* Make the ethereum node trait object compatible

* Allow for compilers to be created in the dyn trait

* Add more identifiers to the platform

* Implement the dyn compiler trait for compilers

* Support the dyn compiler in the builder pattern

* Introduce a geth platform

* Provide a common node implementation for substrate chains

* Add all of the platforms that we support

* Add a way to convert platform identifier into a platform

* Replace infra with the dyn infra

* Remoe all references to leader and follower

* Remove the old traits

* Remove an un-needed dependency

* Update the default values for the platforms

* Final set of renames

* Update the default values of the cli

* Update tests

crates/node-interaction/src/lib.rs

@@ -1,35 +1,53 @@
 //! This crate implements all node interactions.
 
-use alloy::primitives::{Address, StorageKey, U256};
+use std::pin::Pin;
+use std::sync::Arc;
+
+use alloy::primitives::{Address, StorageKey, TxHash, U256};
 use alloy::rpc::types::trace::geth::{DiffMode, GethDebugTracingOptions, GethTrace};
 use alloy::rpc::types::{EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest};
 use anyhow::Result;
 
+use revive_common::EVMVersion;
+use revive_dt_format::traits::ResolverApi;
+
 /// An interface for all interactions with Ethereum compatible nodes.
+#[allow(clippy::type_complexity)]
 pub trait EthereumNode {
+    fn id(&self) -> usize;
+
+    /// Returns the nodes connection string.
+    fn connection_string(&self) -> &str;
+
     /// Execute the [TransactionRequest] and return a [TransactionReceipt].
     fn execute_transaction(
         &self,
         transaction: TransactionRequest,
-    ) -> impl Future<Output = Result<TransactionReceipt>>;
+    ) -> Pin<Box<dyn Future<Output = Result<TransactionReceipt>> + '_>>;
 
     /// Trace the transaction in the [TransactionReceipt] and return a [GethTrace].
     fn trace_transaction(
         &self,
-        receipt: &TransactionReceipt,
+        tx_hash: TxHash,
         trace_options: GethDebugTracingOptions,
-    ) -> impl Future<Output = Result<GethTrace>>;
+    ) -> Pin<Box<dyn Future<Output = Result<GethTrace>> + '_>>;
 
     /// Returns the state diff of the transaction hash in the [TransactionReceipt].
-    fn state_diff(&self, receipt: &TransactionReceipt) -> impl Future<Output = Result<DiffMode>>;
+    fn state_diff(&self, tx_hash: TxHash) -> Pin<Box<dyn Future<Output = Result<DiffMode>> + '_>>;
 
     /// Returns the balance of the provided [`Address`] back.
-    fn balance_of(&self, address: Address) -> impl Future<Output = Result<U256>>;
+    fn balance_of(&self, address: Address) -> Pin<Box<dyn Future<Output = Result<U256>> + '_>>;
 
     /// Returns the latest storage proof of the provided [`Address`]
     fn latest_state_proof(
         &self,
         address: Address,
         keys: Vec<StorageKey>,
-    ) -> impl Future<Output = Result<EIP1186AccountProofResponse>>;
+    ) -> Pin<Box<dyn Future<Output = Result<EIP1186AccountProofResponse>> + '_>>;
+
+    /// Returns the resolver that is to use with this ethereum node.
+    fn resolver(&self) -> Pin<Box<dyn Future<Output = Result<Arc<dyn ResolverApi + '_>>> + '_>>;
+
+    /// Returns the EVM version of the node.
+    fn evm_version(&self) -> EVMVersion;
 }