chore: fix "unsuported fork" typo in whole repo

crates/networking/rpc/engine/blobs.rs

@@ -162,7 +162,7 @@ async fn get_blobs_and_proof(
             .is_osaka_activated(current_block_header.timestamp)
     {
         // validation requested in https://github.com/ethereum/execution-apis/blob/a1d95fb555cd91efb3e0d6555e4ab556d9f5dd06/src/engine/osaka.md?plain=1#L130
-        return Err(RpcErr::UnsuportedFork(format!(
+        return Err(RpcErr::UnsupportedFork(format!(
             "getBlobsV{} engine only supported for Osaka",
             version
         )));
@@ -303,7 +303,7 @@ mod tests {
         };
 
         let err = request.handle(context).await.unwrap_err();
-        assert!(matches!(err, RpcErr::UnsuportedFork(_)));
+        assert!(matches!(err, RpcErr::UnsupportedFork(_)));
     }
 
     #[tokio::test]

crates/networking/rpc/engine/fork_choice.rs

@@ -41,7 +41,7 @@ impl RpcHandler for ForkChoiceUpdatedV1 {
         if let (Some(head_block), Some(attributes)) = (head_block_opt, &self.payload_attributes) {
             let chain_config = context.storage.get_chain_config();
             if chain_config.is_cancun_activated(attributes.timestamp) {
-                return Err(RpcErr::UnsuportedFork(
+                return Err(RpcErr::UnsupportedFork(
                     "forkChoiceV1 used to build Cancun payload".to_string(),
                 ));
             }
@@ -74,7 +74,7 @@ impl RpcHandler for ForkChoiceUpdatedV2 {
         if let (Some(head_block), Some(attributes)) = (head_block_opt, &self.payload_attributes) {
             let chain_config = context.storage.get_chain_config();
             if chain_config.is_cancun_activated(attributes.timestamp) {
-                return Err(RpcErr::UnsuportedFork(
+                return Err(RpcErr::UnsupportedFork(
                     "forkChoiceV2 used to build Cancun payload".to_string(),
                 ));
             } else if chain_config.is_shanghai_activated(attributes.timestamp) {
@@ -396,7 +396,7 @@ fn validate_attributes_v3(
         ));
     }
     if !chain_config.is_cancun_activated(attributes.timestamp) {
-        return Err(RpcErr::UnsuportedFork(
+        return Err(RpcErr::UnsupportedFork(
             "forkChoiceV3 used to build pre-Cancun payload".to_string(),
         ));
     }

crates/networking/rpc/engine/payload.rs

@@ -211,7 +211,7 @@ impl RpcHandler for NewPayloadV4Request {
         let chain_config = context.storage.get_chain_config();
 
         if !chain_config.is_prague_activated(block.header.timestamp) {
-            return Err(RpcErr::UnsuportedFork(format!(
+            return Err(RpcErr::UnsupportedFork(format!(
                 "{:?}",
                 chain_config.get_fork(block.header.timestamp)
             )));
@@ -301,7 +301,7 @@ impl RpcHandler for NewPayloadV5Request {
         let chain_config = context.storage.get_chain_config();
 
         if !chain_config.is_amsterdam_activated(block.header.timestamp) {
-            return Err(RpcErr::UnsuportedFork(format!(
+            return Err(RpcErr::UnsupportedFork(format!(
                 "{:?}",
                 chain_config.get_fork(block.header.timestamp)
             )));
@@ -430,13 +430,13 @@ impl RpcHandler for GetPayloadV4Request {
         let chain_config = &context.storage.get_chain_config();
 
         if !chain_config.is_prague_activated(payload_bundle.block.header.timestamp) {
-            return Err(RpcErr::UnsuportedFork(format!(
+            return Err(RpcErr::UnsupportedFork(format!(
                 "{:?}",
                 chain_config.get_fork(payload_bundle.block.header.timestamp)
             )));
         }
         if chain_config.is_osaka_activated(payload_bundle.block.header.timestamp) {
-            return Err(RpcErr::UnsuportedFork(format!("{:?}", Fork::Osaka)));
+            return Err(RpcErr::UnsupportedFork(format!("{:?}", Fork::Osaka)));
         }
 
         // V4 doesn't support BAL (Prague fork, pre-EIP-7928)
@@ -483,7 +483,7 @@ impl RpcHandler for GetPayloadV5Request {
         let chain_config = &context.storage.get_chain_config();
 
         if !chain_config.is_osaka_activated(payload_bundle.block.header.timestamp) {
-            return Err(RpcErr::UnsuportedFork(format!(
+            return Err(RpcErr::UnsupportedFork(format!(
                 "{:?}",
                 chain_config.get_fork(payload_bundle.block.header.timestamp)
             )));
@@ -771,7 +771,7 @@ fn validate_execution_payload_v4(payload: &ExecutionPayload) -> Result<(), RpcEr
 fn validate_payload_v1_v2(block: &Block, context: &RpcApiContext) -> Result<(), RpcErr> {
     let chain_config = &context.storage.get_chain_config();
     if chain_config.is_cancun_activated(block.header.timestamp) {
-        return Err(RpcErr::UnsuportedFork(
+        return Err(RpcErr::UnsupportedFork(
             "Cancun payload received".to_string(),
         ));
     }
@@ -1044,7 +1044,7 @@ fn validate_fork(block: &Block, fork: Fork, context: &RpcApiContext) -> Result<(
     let current_fork = chain_config.get_fork(block.header.timestamp);
 
     if current_fork != fork {
-        return Err(RpcErr::UnsuportedFork(format!("{current_fork:?}")));
+        return Err(RpcErr::UnsupportedFork(format!("{current_fork:?}")));
     }
     Ok(())
 }

crates/networking/rpc/eth/client.rs

@@ -113,7 +113,7 @@ impl RpcHandler for Config {
         let current_fork = chain_config.get_fork(latest_block_timestamp);
 
         if current_fork < Fork::Paris {
-            return Err(RpcErr::UnsuportedFork(
+            return Err(RpcErr::UnsupportedFork(
                 "eth-config is not supported for forks prior to Paris".to_string(),
             ));
         }

crates/networking/rpc/rpc.rs

@@ -356,7 +356,7 @@ fn get_error_kind(err: &RpcErr) -> &'static str {
         RpcErr::MissingParam(_) => "MissingParam",
         RpcErr::TooLargeRequest => "TooLargeRequest",
         RpcErr::BadHexFormat(_) => "BadHexFormat",
-        RpcErr::UnsuportedFork(_) => "UnsuportedFork",
+        RpcErr::UnsupportedFork(_) => "UnsupportedFork",
         RpcErr::Internal(_) => "Internal",
         RpcErr::Vm(_) => "Vm",
         RpcErr::Revert { .. } => "Revert",

crates/networking/rpc/utils.rs

@@ -39,7 +39,7 @@ pub enum RpcErr {
     #[error("Bad hex format: {0}")]
     BadHexFormat(u64),
     #[error("Unsupported fork: {0}")]
-    UnsuportedFork(String),
+    UnsupportedFork(String),
     #[error("Internal Error: {0}")]
     Internal(String),
     #[error("Vm execution error: {0}")]
@@ -86,7 +86,7 @@ impl From<RpcErr> for RpcErrorMetadata {
                 data: None,
                 message: "Too large request".to_string(),
             },
-            RpcErr::UnsuportedFork(context) => RpcErrorMetadata {
+            RpcErr::UnsupportedFork(context) => RpcErrorMetadata {
                 code: -38005,
                 data: None,
                 message: format!("Unsupported fork: {context}"),