Fix spelling

book/src/dev/rfcs/0003-inventory-tracking.md

@@ -192,7 +192,7 @@ specific inventory request is ready, because until we get the request, we
 can't determine which peers might be required to process it.
 
 We could attempt to ensure that the peer set would be ready to process a
-specific inventory request would be to pre-emptively "reserve" a peer as soon
+specific inventory request would be to preemptively "reserve" a peer as soon
 as it advertises an inventory item. But this doesn't actually work to ensure
 readiness, because a peer could advertise two inventory items, and only be
 able to service one request at a time. It also potentially locks the peer

book/src/dev/rfcs/0006-contextual-difficulty.md

@@ -753,10 +753,10 @@ would be a security issue.
 # Future possibilities
 [future-possibilities]: #future-possibilities
 
-## Re-using the relevant chain API in other contextual checks
+## Reusing the relevant chain API in other contextual checks
 [relevant-chain-api-reuse]: #relevant-chain-api-reuse
 
-The relevant chain iterator can be re-used to implement other contextual
+The relevant chain iterator can be reused to implement other contextual
 validation checks.
 
 For example, responding to peer requests for block locators, which means

book/src/dev/rfcs/drafts/0005-treestate.md

@@ -126,7 +126,7 @@ finished validating everything that can be validated without the context of
 their anchor's finalization state.
 
 So for each transaction, for both `Spend` descriptions and `JoinSplit`s, we can
-pre-emptively try to do our consensus check by looking up the anchors in our
+preemptively try to do our consensus check by looking up the anchors in our
 finalized set first. For `Spend`s, we then trigger the remaining validation and
 when that finishes we are full done with those. For `JoinSplit`s, the anchor
 state check may pass early if it's a previous block Sprout `NoteCommitment` tree

zebra-chain/src/error.rs

@@ -65,7 +65,7 @@ pub enum Error {
 
     /// Zebra's type could not be converted to its librustzcash equivalent.
     #[error("Zebra's type could not be converted to its librustzcash equivalent: ")]
-    Convertion(#[from] io::Error),
+    Conversion(#[from] io::Error),
 
     /// The transaction is missing a network upgrade.
     #[error("the transaction is missing a network upgrade")]

zebra-chain/src/serialization/error.rs

@@ -56,7 +56,7 @@ impl From<crate::Error> for SerializationError {
     fn from(value: crate::Error) -> Self {
         match value {
             crate::Error::InvalidConsensusBranchId => Self::Parse("invalid consensus branch id"),
-            crate::Error::Convertion(e) => Self::Io(e),
+            crate::Error::Conversion(e) => Self::Io(e),
             crate::Error::MissingNetworkUpgrade => Self::Parse("missing network upgrade"),
         }
     }

zebra-network/src/peer_set/initialize/tests/vectors.rs

@@ -1575,7 +1575,7 @@ where
     let nil_peer_set = service_fn(move |req| async move {
         let rsp = match req {
             // Return the correct response variant for Peers requests,
-            // re-using one of the peers we already provided.
+            // reusing one of the peers we already provided.
             Request::Peers => Response::Peers(vec![fake_peer.unwrap()]),
             _ => unreachable!("unexpected request: {:?}", req),
         };

zebra-test/src/net.rs

@@ -58,7 +58,7 @@ pub fn zebra_skip_ipv6_tests() -> bool {
 /// to - it has a small risk of port conflicts.
 ///
 /// Use this function when you need to use the same random port multiple
-/// times. For example: setting up both ends of a connection, or re-using
+/// times. For example: setting up both ends of a connection, or reusing
 /// the same port multiple times.
 pub fn random_known_port() -> u16 {
     use rand::Rng;
@@ -99,7 +99,7 @@ pub fn random_known_port() -> u16 {
 /// between this fn call and binding the tcp listener.
 ///
 /// Use this function when you need to use the same random port multiple
-/// times. For example: setting up both ends of a connection, or re-using
+/// times. For example: setting up both ends of a connection, or reusing
 /// the same port multiple times.
 ///
 /// ## Panics

zebrad/src/commands/copy_state.rs

@@ -280,7 +280,7 @@ impl CopyStateCmd {
             // then deserializes bytes into new `Block` structs when reading.
             // So these checks are sufficient to detect block data corruption.
             //
-            // If Zebra starts re-using cached `Block` structs after writing them,
+            // If Zebra starts reusing cached `Block` structs after writing them,
             // we'll also need to check `Block` structs created from the actual database bytes.
             if source_block_hash != target_block_commit_hash
                 || source_block_hash != target_block_data_hash

zebrad/src/components/sync.rs

@@ -463,7 +463,7 @@ where
         // The Hedge middleware is the outermost layer, hedging requests
         // between two retry-wrapped networks.  The innermost timeout
         // layer is relatively unimportant, because slow requests will
-        // probably be pre-emptively hedged.
+        // probably be preemptively hedged.
         //
         // The Hedge goes outside the Retry, because the Retry layer
         // abstracts away spurious failures from individual peers

zebrad/tests/common/test_type.rs

@@ -200,7 +200,7 @@ impl TestType {
         if !use_internet_connection {
             config.network.initial_mainnet_peers = IndexSet::new();
             config.network.initial_testnet_peers = IndexSet::new();
-            // Avoid re-using cached peers from disk when we're supposed to be a disconnected instance
+            // Avoid reusing cached peers from disk when we're supposed to be a disconnected instance
             config.network.cache_dir = CacheDir::disabled();
 
             // Activate the mempool immediately by default