Support other matterlabs variables (#43)

* Introduce a custom kitchensink network

* fix formatting

* Added `--dev` to `substrate-node` arguments.

This commit adds the `--dev` argument to the `substrate-node` to allow
the chain to keep advancing as time goes own. We have found that if this
option is not added then the chain won't advance forward.

* fix clippy warning

* fix clippy warning

* Fix function selector and argument encoding

* Avoid extra buffer allocation

* Remove reliance on the web3 crate

* Update the async runtime with syntactic sugar.

* Fix tests

* Fix doc test

* Give nodes a standard way to get their alloy provider

* Add ability to get the chain_id from node

* Get kitchensink provider to use kitchensink network

* Use provider method in tests

* Add support for getting the gas limit from the node

* Add a way to get the coinbase address

* Add a way to get the block difficulty from the node

* Add a way to get block info from the node

* Expose APIs for getting the info of a specific block

* Add resolution logic for other matterlabs variables

* Fix tests

* Add comment on alternative solutions

* Change kitchensink gas limit assertion

* Remove un-needed profile config

crates/node-interaction/src/blocking_executor.rs

@@ -144,7 +144,6 @@ impl BlockingExecutor {
         }
     }
 }
-
 /// Represents the state of the async runtime. This runtime is designed to be a singleton runtime
 /// which means that in the current running program there's just a single thread that has an async
 /// runtime.

crates/node-interaction/src/lib.rs

@@ -1,8 +1,10 @@
 //! This crate implements all node interactions.
 
-use alloy::primitives::Address;
+use alloy::eips::BlockNumberOrTag;
+use alloy::primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, ChainId, U256};
 use alloy::rpc::types::trace::geth::{DiffMode, GethTrace};
 use alloy::rpc::types::{TransactionReceipt, TransactionRequest};
+use anyhow::Result;
 
 mod blocking_executor;
 pub use blocking_executor::*;
@@ -10,17 +12,37 @@ pub use blocking_executor::*;
 /// An interface for all interactions with Ethereum compatible nodes.
 pub trait EthereumNode {
     /// Execute the [TransactionRequest] and return a [TransactionReceipt].
-    fn execute_transaction(
-        &self,
-        transaction: TransactionRequest,
-    ) -> anyhow::Result<TransactionReceipt>;
+    fn execute_transaction(&self, transaction: TransactionRequest) -> Result<TransactionReceipt>;
 
     /// Trace the transaction in the [TransactionReceipt] and return a [GethTrace].
-    fn trace_transaction(&self, transaction: TransactionReceipt) -> anyhow::Result<GethTrace>;
+    fn trace_transaction(&self, transaction: TransactionReceipt) -> Result<GethTrace>;
 
     /// Returns the state diff of the transaction hash in the [TransactionReceipt].
-    fn state_diff(&self, transaction: TransactionReceipt) -> anyhow::Result<DiffMode>;
+    fn state_diff(&self, transaction: TransactionReceipt) -> Result<DiffMode>;
 
     /// Returns the next available nonce for the given [Address].
-    fn fetch_add_nonce(&self, address: Address) -> anyhow::Result<u64>;
+    fn fetch_add_nonce(&self, address: Address) -> Result<u64>;
+
+    /// Returns the ID of the chain that the node is on.
+    fn chain_id(&self) -> Result<ChainId>;
+
+    // TODO: This is currently a u128 due to Kitchensink needing more than 64 bits for its gas limit
+    // when we implement the changes to the gas we need to adjust this to be a u64.
+    /// Returns the gas limit of the specified block.
+    fn block_gas_limit(&self, number: BlockNumberOrTag) -> Result<u128>;
+
+    /// Returns the coinbase of the specified block.
+    fn block_coinbase(&self, number: BlockNumberOrTag) -> Result<Address>;
+
+    /// Returns the difficulty of the specified block.
+    fn block_difficulty(&self, number: BlockNumberOrTag) -> Result<U256>;
+
+    /// Returns the hash of the specified block.
+    fn block_hash(&self, number: BlockNumberOrTag) -> Result<BlockHash>;
+
+    /// Returns the timestamp of the specified block,
+    fn block_timestamp(&self, number: BlockNumberOrTag) -> Result<BlockTimestamp>;
+
+    /// Returns the number of the last block.
+    fn last_block_number(&self) -> Result<BlockNumber>;
 }