refactor: static code analysis checks

Signed-off-by: Rob Walworth <[email protected]>

Author: rwalworth

Sources/Hiero/Client/NetworkUpdateTask.swift

@@ -23,7 +23,7 @@ import NIOCore
 /// - `ConsensusNetwork` - The network being updated
 /// - `MirrorNetwork` - Source of address book data
 /// - `NodeAddressBookQuery` - Fetches address book from network
-internal actor NetworkUpdateTask: Sendable {
+internal actor NetworkUpdateTask {
     // MARK: - Constants
 
     /// Delay before the first network update after initialization
@@ -71,13 +71,15 @@ internal actor NetworkUpdateTask: Sendable {
 
         if let updatePeriod {
             updateTask = Self.makeTask(
-                eventLoop,
-                consensusNetwork,
-                mirrorNetwork,
-                Self.networkFirstUpdateDelay,
-                updatePeriod,
-                shard,
-                realm
+                config: UpdateConfig(
+                    eventLoop: eventLoop,
+                    consensusNetwork: consensusNetwork,
+                    mirrorNetwork: mirrorNetwork,
+                    startDelay: Self.networkFirstUpdateDelay,
+                    updatePeriod: updatePeriod,
+                    shard: shard,
+                    realm: realm
+                )
             )
         }
     }
@@ -94,25 +96,63 @@ internal actor NetworkUpdateTask: Sendable {
         self.updateTask?.cancel()
 
         if let updatePeriod = duration {
-            self.updateTask = Self.makeTask(eventLoop, consensusNetwork, mirrorNetwork, nil, updatePeriod, shard, realm)
+            self.updateTask = Self.makeTask(
+                config: UpdateConfig(
+                    eventLoop: eventLoop,
+                    consensusNetwork: consensusNetwork,
+                    mirrorNetwork: mirrorNetwork,
+                    startDelay: nil,
+                    updatePeriod: updatePeriod,
+                    shard: shard,
+                    realm: realm
+                )
+            )
         }
     }
 
+    // MARK: - Private Types
+
+    /// Configuration parameters for creating a network update task.
+    ///
+    /// This struct groups all parameters needed to configure and run the periodic
+    /// network update loop, avoiding the need for functions with many parameters.
+    private struct UpdateConfig {
+        /// Event loop for network operations
+        internal let eventLoop: NIOCore.EventLoopGroup
+
+        /// Atomic reference to the consensus network being updated
+        internal let consensusNetwork: ManagedAtomic<ConsensusNetwork>
+
+        /// Atomic reference to the mirror network for queries
+        internal let mirrorNetwork: ManagedAtomic<MirrorNetwork>
+
+        /// Optional delay before the first update (nil for immediate start)
+        internal let startDelay: Duration?
+
+        /// Interval between updates in nanoseconds
+        internal let updatePeriod: UInt64
+
+        /// Shard number for address book file ID
+        internal let shard: UInt64
+
+        /// Realm number for address book file ID
+        internal let realm: UInt64
+    }
+
     // MARK: - Private Methods
 
     /// Creates the background task that performs periodic network updates.
-    private static func makeTask(
-        _ eventLoop: NIOCore.EventLoopGroup,
-        _ consensusNetwork: ManagedAtomic<ConsensusNetwork>,
-        _ mirrorNetwork: ManagedAtomic<MirrorNetwork>,
-        _ startDelay: Duration?,
-        _ updatePeriod: UInt64,
-        _ shard: UInt64,
-        _ realm: UInt64
-    ) -> Task<(), Error> {
+    ///
+    /// The task runs an infinite loop that fetches the network address book from the
+    /// mirror network and atomically updates the consensus network. Errors are logged
+    /// but don't terminate the loop.
+    ///
+    /// - Parameter config: Configuration containing all necessary parameters for updates
+    /// - Returns: A Task that can be canceled to stop the update loop
+    private static func makeTask(config: UpdateConfig) -> Task<(), Error> {
         Task {
             // Initial delay before first update
-            if let startDelay {
+            if let startDelay = config.startDelay {
                 let delayNanos = startDelay.seconds * Self.nanosecondsPerSecond
                 try await Task.sleep(nanoseconds: delayNanos)
             }
@@ -123,14 +163,14 @@ internal actor NetworkUpdateTask: Sendable {
 
                 do {
                     // Fetch address book from mirror network
-                    let mirror = mirrorNetwork.load(ordering: .relaxed)
+                    let mirror = config.mirrorNetwork.load(ordering: .relaxed)
                     let addressBook = try await NodeAddressBookQuery(
-                        FileId.getAddressBookFileIdFor(shard: shard, realm: realm)
+                        FileId.getAddressBookFileIdFor(shard: config.shard, realm: config.realm)
                     ).executeChannel(mirror.channel)
 
                     // Apply updates to consensus network atomically
-                    let newNetwork = consensusNetwork.readCopyUpdate {
-                        ConsensusNetwork.withAddressBook($0, eventLoop: eventLoop.next(), addressBook)
+                    let newNetwork = config.consensusNetwork.readCopyUpdate { old in
+                        ConsensusNetwork.withAddressBook(old, eventLoop: config.eventLoop.next(), addressBook)
                     }
 
                     // Log successful update with structured format
@@ -152,8 +192,8 @@ internal actor NetworkUpdateTask: Sendable {
 
                 // Wait for the remainder of the update period
                 let elapsed = (Timestamp.now - start).seconds * Self.nanosecondsPerSecond
-                if elapsed < updatePeriod {
-                    try await Task.sleep(nanoseconds: updatePeriod - elapsed)
+                if elapsed < config.updatePeriod {
+                    try await Task.sleep(nanoseconds: config.updatePeriod - elapsed)
                 }
             }
         }

Sources/Hiero/Execute.swift

@@ -289,7 +289,7 @@ private func executeAnyInner<E: Execute>(
     }
 }
 
-// MARK: - Execution Result Type
+// MARK: - Helper Types
 
 /// Result of attempting to execute a request on a node.
 private enum ExecutionResult<Response> {
@@ -306,6 +306,33 @@ private enum ExecutionResult<Response> {
     case regenerateTransactionAndRetry(HError)
 }
 
+/// Parameters for pre-check status handling.
+///
+/// This struct groups all parameters needed for handling pre-check status responses,
+/// avoiding the need for functions with many parameters and improving code clarity.
+private struct PrecheckParameters<E: Execute> {
+    /// The parsed pre-check status code from the response
+    internal let status: Status
+
+    /// The full GRPC response from the node
+    internal let response: E.GrpcResponse
+
+    /// Context data from request creation
+    internal let context: E.Context
+
+    /// Account ID of the node that processed the request
+    internal let nodeAccountId: AccountId
+
+    /// Transaction ID used for the request (if applicable)
+    internal let transactionId: TransactionId?
+
+    /// The transaction or query being executed
+    internal let executable: E
+
+    /// Execution context with network and backoff configuration
+    internal let ctx: ExecuteContext
+}
+
 // MARK: - Transaction ID Management
 
 /// Generates the initial transaction ID for a request.
@@ -392,13 +419,15 @@ private func executeOnNode<E: Execute>(
     let precheckStatus = Status(rawValue: rawPrecheckStatus)
 
     return try handlePrecheckStatus(
-        precheckStatus,
-        response: response,
-        context: context,
-        nodeAccountId: nodeAccountId,
-        transactionId: transactionId,
-        executable: executable,
-        ctx: ctx
+        params: PrecheckParameters(
+            status: precheckStatus,
+            response: response,
+            context: context,
+            nodeAccountId: nodeAccountId,
+            transactionId: transactionId,
+            executable: executable,
+            ctx: ctx
+        )
     )
 }
 
@@ -443,50 +472,37 @@ private func handleGrpcError<Response>(
 /// - Custom retry statuses: Retry with backoff
 /// - Everything else: Throw error
 ///
-/// - Parameters:
-///   - status: Parsed pre-check status
-///   - response: GRPC response containing the status
-///   - context: Context data from request creation
-///   - nodeAccountId: Account ID of the node
-///   - transactionId: Transaction ID used for the request
-///   - executable: The transaction or query being executed
-///   - ctx: Execution context
+/// - Parameter params: Parameters containing status, response, context, and execution state
 /// - Returns: Execution result indicating success or retry strategy
 /// - Throws: HError for unrecoverable status codes
-private func handlePrecheckStatus<E: Execute>(
-    _ status: Status,
-    response: E.GrpcResponse,
-    context: E.Context,
-    nodeAccountId: AccountId,
-    transactionId: TransactionId?,
-    executable: E,
-    ctx: ExecuteContext
-) throws -> ExecutionResult<E.Response> {
-    switch status {
-    case .ok where executable.shouldRetry(forResponse: response):
-        return .retryWithBackoff(executable.makeErrorPrecheck(status, transactionId))
+private func handlePrecheckStatus<E: Execute>(params: PrecheckParameters<E>) throws -> ExecutionResult<E.Response> {
+    switch params.status {
+    case .ok where params.executable.shouldRetry(forResponse: params.response):
+        return .retryWithBackoff(params.executable.makeErrorPrecheck(params.status, params.transactionId))
 
     case .ok:
-        let response = try executable.makeResponse(response, context, nodeAccountId, transactionId)
+        let response = try params.executable.makeResponse(
+            params.response, params.context, params.nodeAccountId, params.transactionId)
         return .success(response)
 
     case .busy, .platformNotActive:
-        return .retryImmediately(executable.makeErrorPrecheck(status, transactionId))
+        return .retryImmediately(params.executable.makeErrorPrecheck(params.status, params.transactionId))
 
-    case .transactionExpired where executable.explicitTransactionId == nil && ctx.operatorAccountId != nil:
-        return .regenerateTransactionAndRetry(executable.makeErrorPrecheck(status, transactionId))
+    case .transactionExpired
+    where params.executable.explicitTransactionId == nil && params.ctx.operatorAccountId != nil:
+        return .regenerateTransactionAndRetry(params.executable.makeErrorPrecheck(params.status, params.transactionId))
 
     case .unrecognized(let value):
         throw HError(
             kind: .responseStatusUnrecognized,
             description: "response status \(value) unrecognized"
         )
 
-    case let status where executable.shouldRetryPrecheck(forStatus: status):
-        return .retryWithBackoff(executable.makeErrorPrecheck(status, transactionId))
+    case let status where params.executable.shouldRetryPrecheck(forStatus: status):
+        return .retryWithBackoff(params.executable.makeErrorPrecheck(status, params.transactionId))
 
     default:
-        throw executable.makeErrorPrecheck(status, transactionId)
+        throw params.executable.makeErrorPrecheck(params.status, params.transactionId)
     }
 }