Automatically wrap comments

Author: alcuadrado

crates/edr/src/config.rs

@@ -14,7 +14,8 @@ pub use super::NodeArgs;
 mod number;
 pub use number::{u256_number, u64_number, Number};
 
-/// struct representing the deserialized conifguration file, eg hardhat.config.json
+/// struct representing the deserialized conifguration file, eg
+/// hardhat.config.json
 #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
 #[serde(default)]
 pub struct ConfigFile {
@@ -143,8 +144,8 @@ mod tests {
         assert_eq!(config_file, deserialized);
     }
 
-    /// test that specifying a non-default value for one field still allows the other fields to
-    /// take their default values.
+    /// test that specifying a non-default value for one field still allows the
+    /// other fields to take their default values.
     #[test]
     fn test_config_file_mixed_defaults() {
         let original = "chain_id = 999";

crates/edr/src/config/number.rs

@@ -58,7 +58,8 @@ where
     }
 }
 
-/// deserialize a [`Number`] but always as a [`Number::U64`], panicking if the value overflows.
+/// deserialize a [`Number`] but always as a [`Number::U64`], panicking if the
+/// value overflows.
 pub fn u64_number<'de, D>(deserializer: D) -> Result<Number, D::Error>
 where
     D: serde::Deserializer<'de>,

crates/edr/src/lib.rs

@@ -25,9 +25,11 @@ struct Cli {
 #[derive(Subcommand)]
 #[allow(clippy::large_enum_variant)]
 enum Command {
-    /// Start the local Ethereum development node to serve JSON-RPC requests over HTTP.
+    /// Start the local Ethereum development node to serve JSON-RPC requests
+    /// over HTTP.
     Node(NodeArgs),
-    /// Write default configuration values to edr.toml, overwriting any existing file.
+    /// Write default configuration values to edr.toml, overwriting any existing
+    /// file.
     InitConfigFile,
 }
 

crates/edr/tests/cli.rs

@@ -22,13 +22,14 @@ use edr_rpc_server::{HardhatMethodInvocation, MethodInvocation};
 async fn node() -> Result<(), Box<dyn std::error::Error>> {
     let address = secret_key_to_address(edr_defaults::SECRET_KEYS[0]).unwrap();
 
-    // the order of operations is a little weird in this test, because we spawn a separate process
-    // for the server, and we want to make sure that we end that process gracefully. more
-    // specifically, once the server is started, we avoid the ? operator until the server has been
-    // stopped.
+    // the order of operations is a little weird in this test, because we spawn a
+    // separate process for the server, and we want to make sure that we end
+    // that process gracefully. more specifically, once the server is started,
+    // we avoid the ? operator until the server has been stopped.
 
-    // hold method invocations separately from requests so that we can easily iterate over them in
-    // order to check for corresponding log entries in the server output:
+    // hold method invocations separately from requests so that we can easily
+    // iterate over them in order to check for corresponding log entries in the
+    // server output:
     let method_invocations = [
         MethodInvocation::Eth(EthMethodInvocation::Accounts()),
         MethodInvocation::Eth(EthMethodInvocation::BlockNumber()),
@@ -93,7 +94,8 @@ async fn node() -> Result<(), Box<dyn std::error::Error>> {
         MethodInvocation::Hardhat(HardhatMethodInvocation::StopImpersonatingAccount(address)),
     ];
 
-    // prepare request body before even spawning the server because serialization could fail:
+    // prepare request body before even spawning the server because serialization
+    // could fail:
     let request_body: String = serde_json::to_string(
         &method_invocations
             .iter()
@@ -121,12 +123,12 @@ async fn node() -> Result<(), Box<dyn std::error::Error>> {
         .stdout(Stdio::piped())
         .spawn()?;
 
-    // (required for CI runs on MacOS) sleep a moment to make sure the server comes up before we
-    // start sending requests:
+    // (required for CI runs on MacOS) sleep a moment to make sure the server comes
+    // up before we start sending requests:
     std::thread::sleep(std::time::Duration::from_secs(1));
 
-    // query the server, but don't check the Result yet, because returning early would prevent us
-    // from gracefully terminating the server:
+    // query the server, but don't check the Result yet, because returning early
+    // would prevent us from gracefully terminating the server:
     let send_result = reqwest::Client::new()
         .post("http://127.0.0.1:8549/")
         .header(reqwest::header::CONTENT_TYPE, "application/json")
@@ -143,7 +145,8 @@ async fn node() -> Result<(), Box<dyn std::error::Error>> {
     // validate query Result:
     send_result?.text().await?;
 
-    // assert that the standard output of the server process contains the expected log entries:
+    // assert that the standard output of the server process contains the expected
+    // log entries:
     Assert::new(output.clone()).stdout(contains("Listening on 127.0.0.1:8549"));
     for (i, default_secret_key) in edr_defaults::SECRET_KEYS.to_vec().iter().enumerate() {
         Assert::new(output.clone())

crates/edr_defaults/src/lib.rs

@@ -23,9 +23,10 @@ pub const SECRET_KEYS: [&str; 20] = [
     "df57089febbacf7ba0bc227dafbffa9fc08a93fdc68e1e42411a14efcf23656e",
 ];
 
-/// The default cache directory. Cache dirs for specific subsystems such as the RPC Client are
-/// subdirectories of this directory.
+/// The default cache directory. Cache dirs for specific subsystems such as the
+/// RPC Client are subdirectories of this directory.
 pub const CACHE_DIR: &str = "./edr-cache";
 
-/// Maximum concurrent requests to a remote blockchain node to avoid getting rate limited.
+/// Maximum concurrent requests to a remote blockchain node to avoid getting
+/// rate limited.
 pub const MAX_CONCURRENT_REQUESTS: usize = 5;

crates/edr_eth/src/access_list.rs

@@ -1,4 +1,5 @@
-// Part of this code was adapted from ethers-rs and is distributed under their licenss:
+// Part of this code was adapted from ethers-rs and is distributed under their
+// licenss:
 // - https://github.com/gakonst/ethers-rs/blob/cba6f071aedafb766e82e4c2f469ed5e4638337d/LICENSE-APACHE
 // - https://github.com/gakonst/ethers-rs/blob/cba6f071aedafb766e82e4c2f469ed5e4638337d/LICENSE-MIT
 // For the original context see: https://github.com/gakonst/ethers-rs/blob/3d9c3290d42b77c510e5b5d0b6f7a2f72913bfff/ethers-core/src/types/transaction/eip2930.rs

crates/edr_eth/src/account.rs

@@ -1,4 +1,5 @@
-// Part of this code was adapted from foundry and is distributed under their licenss:
+// Part of this code was adapted from foundry and is distributed under their
+// licenss:
 // - https://github.com/foundry-rs/foundry/blob/01b16238ff87dc7ca8ee3f5f13e389888c2a2ee4/LICENSE-APACHE
 // - https://github.com/foundry-rs/foundry/blob/01b16238ff87dc7ca8ee3f5f13e389888c2a2ee4/LICENSE-MIT
 // For the original context see: https://github.com/foundry-rs/foundry/blob/01b16238ff87dc7ca8ee3f5f13e389888c2a2ee4/anvil/core/src/eth/proof.rs

crates/edr_eth/src/block.rs

@@ -1,4 +1,5 @@
-// Part of this code was adapted from foundry and is distributed under their licenss:
+// Part of this code was adapted from foundry and is distributed under their
+// licenss:
 // - https://github.com/foundry-rs/foundry/blob/01b16238ff87dc7ca8ee3f5f13e389888c2a2ee4/LICENSE-APACHE
 // - https://github.com/foundry-rs/foundry/blob/01b16238ff87dc7ca8ee3f5f13e389888c2a2ee4/LICENSE-MIT
 // For the original context see: https://github.com/foundry-rs/foundry/blob/01b16238ff87dc7ca8ee3f5f13e389888c2a2ee4/anvil/core/src/eth/block.rs
@@ -54,7 +55,8 @@ pub struct Block {
 }
 
 impl Block {
-    /// Constructs a new block from the provided partial header, transactions, and ommers.
+    /// Constructs a new block from the provided partial header, transactions,
+    /// and ommers.
     pub fn new(
         mut partial_header: PartialHeader,
         transactions: Vec<SignedTransaction>,
@@ -138,7 +140,8 @@ pub struct Header {
     /// Blob gas was added by EIP-4844 and is ignored in older headers.
     #[cfg_attr(feature = "serde", serde(flatten))]
     pub blob_gas: Option<BlobGas>,
-    /// The hash tree root of the parent beacon block for the given execution block (EIP-4788).
+    /// The hash tree root of the parent beacon block for the given execution
+    /// block (EIP-4788).
     pub parent_beacon_block_root: Option<B256>,
 }
 
@@ -159,16 +162,19 @@ impl From<B64Def> for B64 {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
 pub struct BlobGas {
-    /// The total amount of blob gas consumed by the transactions within the block.
+    /// The total amount of blob gas consumed by the transactions within the
+    /// block.
     pub gas_used: u64,
     /// The running total of blob gas consumed in excess of the target, prior to
-    /// the block. Blocks with above-target blob gas consumption increase this value,
-    /// blocks with below-target blob gas consumption decrease it (bounded at 0).
+    /// the block. Blocks with above-target blob gas consumption increase this
+    /// value, blocks with below-target blob gas consumption decrease it
+    /// (bounded at 0).
     pub excess_gas: u64,
 }
 
 impl Header {
-    /// Constructs a header from the provided [`PartialHeader`], ommers' root hash, transactions' root hash, and withdrawals' root hash.
+    /// Constructs a header from the provided [`PartialHeader`], ommers' root
+    /// hash, transactions' root hash, and withdrawals' root hash.
     pub fn new(partial_header: PartialHeader, ommers_hash: B256, transactions_root: B256) -> Self {
         Self {
             parent_hash: partial_header.parent_hash,
@@ -341,12 +347,14 @@ pub struct PartialHeader {
     pub withdrawals_root: Option<B256>,
     /// Blob gas was added by EIP-4844 and is ignored in older headers.
     pub blob_gas: Option<BlobGas>,
-    /// The hash tree root of the parent beacon block for the given execution block (EIP-4788).
+    /// The hash tree root of the parent beacon block for the given execution
+    /// block (EIP-4788).
     pub parent_beacon_block_root: Option<B256>,
 }
 
 impl PartialHeader {
-    /// Constructs a new instance based on the provided [`BlockOptions`] and parent [`Header`] for the given [`SpecId`].
+    /// Constructs a new instance based on the provided [`BlockOptions`] and
+    /// parent [`Header`] for the given [`SpecId`].
     pub fn new(spec_id: SpecId, options: BlockOptions, parent: Option<&Header>) -> Self {
         let timestamp = options.timestamp.unwrap_or_default();
         let number = options.number.unwrap_or({
@@ -403,7 +411,8 @@ impl PartialHeader {
             }),
             blob_gas: if spec_id >= SpecId::CANCUN {
                 let excess_gas = parent.and_then(|parent| parent.blob_gas.as_ref()).map_or(
-                    // For the first (post-fork) block, both parent.blob_gas_used and parent.excess_blob_gas are evaluated as 0.
+                    // For the first (post-fork) block, both parent.blob_gas_used and
+                    // parent.excess_blob_gas are evaluated as 0.
                     0,
                     |BlobGas {
                          gas_used,

crates/edr_eth/src/block/options.rs

@@ -31,6 +31,7 @@ pub struct BlockOptions {
     pub base_fee: Option<U256>,
     /// The block's withdrawals root
     pub withdrawals_root: Option<B256>,
-    /// The hash tree root of the parent beacon block for the given execution block (EIP-4788).
+    /// The hash tree root of the parent beacon block for the given execution
+    /// block (EIP-4788).
     pub parent_beacon_block_root: Option<B256>,
 }

crates/edr_eth/src/block/reorg.rs

@@ -1,13 +1,15 @@
 use std::time::Duration;
 
-/// The default depth of blocks to consider safe from a reorg and thus cacheable.
+/// The default depth of blocks to consider safe from a reorg and thus
+/// cacheable.
 const DEFAULT_SAFE_BLOCK_DEPTH: u64 = 128;
 
-/// The default delay between blocks. Should be the lowest possible to stay on the safe side.
+/// The default delay between blocks. Should be the lowest possible to stay on
+/// the safe side.
 const DEFAULT_SAFE_BLOCK_TIME: Duration = Duration::from_secs(1);
 
-/// Test whether a block number is safe from a reorg for a specific chain based on the latest block
-/// number.
+/// Test whether a block number is safe from a reorg for a specific chain based
+/// on the latest block number.
 pub fn is_safe_block_number(args: IsSafeBlockNumberArgs) -> bool {
     let safe_block_number = largest_safe_block_number((&args).into());
     args.block_number <= safe_block_number
@@ -33,8 +35,8 @@ impl<'a> From<&'a IsSafeBlockNumberArgs> for LargestSafeBlockNumberArgs {
     }
 }
 
-/// The largest block number that is safe from a reorg for a specific chain based on the latest
-/// block number.
+/// The largest block number that is safe from a reorg for a specific chain
+/// based on the latest block number.
 pub fn largest_safe_block_number(args: LargestSafeBlockNumberArgs) -> u64 {
     args.latest_block_number
         .saturating_sub(safe_block_depth(args.chain_id))

crates/edr_eth/src/lib.rs

@@ -2,7 +2,8 @@
 
 //! Ethereum types
 //!
-//! Ethereum types as needed by EDR. In particular, they are based on the same primitive types as `revm`.
+//! Ethereum types as needed by EDR. In particular, they are based on the same
+//! primitive types as `revm`.
 
 /// Ethereum access list types
 pub mod access_list;

crates/edr_eth/src/receipt.rs

@@ -1,4 +1,5 @@
-// Part of this code was adapted from foundry and is distributed under their licenss:
+// Part of this code was adapted from foundry and is distributed under their
+// licenss:
 // - https://github.com/foundry-rs/foundry/blob/01b16238ff87dc7ca8ee3f5f13e389888c2a2ee4/LICENSE-APACHE
 // - https://github.com/foundry-rs/foundry/blob/01b16238ff87dc7ca8ee3f5f13e389888c2a2ee4/LICENSE-MIT
 // For the original context see: https://github.com/foundry-rs/foundry/blob/01b16238ff87dc7ca8ee3f5f13e389888c2a2ee4/anvil/core/src/eth/receipt.rs
@@ -404,8 +405,8 @@ mod tests {
             let deserialized: TypedReceipt<Log> = serde_json::from_str(&serialized).unwrap();
             assert_eq!(receipt, deserialized);
 
-            // This is necessary to ensure that the deser implementation doesn't expect a &str
-            // where a String can be passed.
+            // This is necessary to ensure that the deser implementation doesn't expect a
+            // &str where a String can be passed.
             let serialized = serde_json::to_value(&receipt).unwrap();
             let deserialized: TypedReceipt<Log> = serde_json::from_value(serialized).unwrap();
 

crates/edr_eth/src/receipt/transaction.rs

@@ -19,15 +19,18 @@ pub struct TransactionReceipt<L> {
     pub transaction_index: u64,
     /// Address of the sender
     pub from: Address,
-    /// Address of the receiver. `None` when it's a contract creation transaction.
+    /// Address of the receiver. `None` when it's a contract creation
+    /// transaction.
     pub to: Option<Address>,
-    /// The contract address created, if the transaction was a contract creation, otherwise `None`.
+    /// The contract address created, if the transaction was a contract
+    /// creation, otherwise `None`.
     pub contract_address: Option<Address>,
     /// Gas used by this transaction alone.
     pub gas_used: U256,
-    /// The actual value per gas deducted from the senders account. Before EIP-1559, this is equal
-    /// to the transaction's gas price. After, it is equal to baseFeePerGas + min(maxFeePerGas -
-    /// baseFeePerGas, maxPriorityFeePerGas).
+    /// The actual value per gas deducted from the senders account. Before
+    /// EIP-1559, this is equal to the transaction's gas price. After, it is
+    /// equal to baseFeePerGas + min(maxFeePerGas - baseFeePerGas,
+    /// maxPriorityFeePerGas).
     pub effective_gas_price: U256,
 }
 

crates/edr_eth/src/remote.rs

@@ -32,8 +32,8 @@ pub enum Eip1898BlockSpec {
     Hash {
         /// the block hash
         block_hash: B256,
-        /// whether the server should additionally raise a JSON-RPC error if the block is not in
-        /// the canonical chain
+        /// whether the server should additionally raise a JSON-RPC error if the
+        /// block is not in the canonical chain
         require_canonical: Option<bool>,
     },
     /// to represent the Object { blockNumber } in EIP-1898