fix(audit-sweep): batch A — trivial bug-hunt fixes (process.exit, error leaks, missing try/catch)

src/index.ts

@@ -269,13 +269,12 @@ async function digestArguments() {
 async function isPortAvailable(port: number): Promise<boolean> {
     return new Promise((resolve, reject) => {
         const server = net.createServer()
-        server.once("error", err => {
+        server.once("error", (err: NodeJS.ErrnoException) => {
             server.close()
-            if (err["code"] == "EADDRINUSE") {
+            if (err.code === "EADDRINUSE") {
                 resolve(false)
             } else {
-                resolve(false) // or throw error!!
-                // reject(err);
+                reject(err)
             }
         })
 

src/libs/blockchain/chainBlocks.ts

@@ -3,7 +3,6 @@ import log from "src/utilities/logger"
 import Block from "./block"
 import Mempool from "./mempool"
 import Transaction, { toTransactionsEntity } from "./transaction"
-import Transaction, { toTransactionsEntity } from "./transaction"
 import Datasource from "src/model/datasource"
 import { Blocks } from "src/model/entities/Blocks"
 import { Transactions } from "src/model/entities/Transactions"
@@ -27,21 +26,6 @@ import {
 } from "@/forks/migrations/gasFeeSeparation"
 import { isForkActive } from "@/forks/forkGates"
 import { isForkMachineryDisabled } from "@/forks/loadForkConfig"
-import tallyUpgradeVotes from "./routines/tallyUpgradeVotes"
-import applyNetworkUpgrade from "./routines/applyNetworkUpgrade"
-import { loadNetworkParameters } from "./routines/loadNetworkParameters"
-import { NetworkUpgrade } from "@/model/entities/NetworkUpgrade"
-import { NetworkUpgradeVote } from "@/model/entities/NetworkUpgradeVote"
-import {
-    isOsDenominationMigrationApplied,
-    runOsDenominationMigration,
-} from "@/forks/migrations/osDenomination"
-import {
-    isGasFeeSeparationMigrationApplied,
-    runGasFeeSeparationMigration,
-} from "@/forks/migrations/gasFeeSeparation"
-import { isForkActive } from "@/forks/forkGates"
-import { isForkMachineryDisabled } from "@/forks/loadForkConfig"
 import type { FindManyOptions } from "typeorm"
 
 export function isGenesis(block: Block): boolean {

src/libs/blockchain/mempool.ts

@@ -149,8 +149,7 @@ export default class Mempool {
         hashes: string[],
         transactionalEntityManager?: EntityManager,
     ) {
-        // REVIEW: CRITICAL FIX - Support transactional entity manager for atomic operations
-        // When called within a transaction, use the transactional manager to ensure atomicity
+        // Use transactional EM for atomicity if provided by caller
         const repo = transactionalEntityManager
             ? transactionalEntityManager.getRepository(this.repo.target)
             : this.repo

src/libs/communications/broadcastManager.ts

@@ -3,7 +3,7 @@ import Block from "../blockchain/block"
 import Chain from "../blockchain/chain"
 import { Peer, PeerManager } from "../peer"
 import { syncBlock } from "../blockchain/routines/Sync"
-import { RPCRequest } from "@kynesyslabs/demosdk/types"
+import { RPCRequest, RPCResponse } from "@kynesyslabs/demosdk/types"
 import { Waiter } from "@/utilities/waiter"
 import { getSharedState } from "@/utilities/sharedState"
 import SecretaryManager from "../consensus/v2/types/secretaryManager"
@@ -47,10 +47,15 @@ export class BroadcastManager {
             }
         })
 
-        const responses = await Promise.all(promises)
+        type BroadcastResult = { pubkey: string; result: RPCResponse }
+        const settled = await Promise.allSettled(promises)
+        const responses = settled
+            .filter((r): r is PromiseFulfilledResult<BroadcastResult> => r.status === "fulfilled")
+            .map(r => r.value)
         const successful = responses.filter(res => res.result.result === 200)
 
         for (const res of responses) {
+            if (res.result.result !== 200) continue
             await this.handleUpdatePeerSyncData(
                 res.pubkey,
                 res.result.response.syncData,
@@ -194,7 +199,11 @@ export class BroadcastManager {
             }
         })
 
-        const responses = await Promise.all(promises)
+        type SyncResult = { pubkey: string; result: RPCResponse }
+        const settled = await Promise.allSettled(promises)
+        const responses = settled
+            .filter((r): r is PromiseFulfilledResult<SyncResult> => r.status === "fulfilled")
+            .map(r => r.value)
         const successful = responses.filter(res => res.result.result === 200)
 
         for (const res of responses) {

src/libs/consensus/v2/PoRBFT.ts

@@ -193,9 +193,7 @@ export async function consensusRoutine(): Promise<void> {
                 //  Prune the mempool of the failed txs
                 // NOTE The mempool should now be updated with only the successful txs
                 const pruneStart = Date.now()
-                for (const tx of failedTxs) {
-                    await Mempool.removeTransactionsByHashes([tx])
-                }
+                await Mempool.removeTransactionsByHashes(failedTxs)
                 const pruneEnd = Date.now()
                 log.only(
                     `[consensusRoutine] Prune took ${pruneEnd - pruneStart}ms with ${failedTxs.length} failed txs`,

src/libs/network/bunServer.ts

@@ -1,6 +1,7 @@
 import { Server } from "bun"
 import { Headers } from "node-fetch"
 import log from "@/utilities/logger"
+import { handleError } from "src/errors"
 
 export type BunRequest = Request & { params: Record<string, string> }
 export type Handler = (req: BunRequest) => Promise<Response> | Response
@@ -126,7 +127,12 @@
         }
 
         // Execute the complete chain
-        return await handler()
+        try {
+            return await handler()
+        } catch (err) {
+            handleError(err, "NETWORK", { source: "bunServer.handleRequest", path: (req as Request).url })
+            return jsonResponse({ error: "Internal error" }, 500)
+        }
     }
 
     start(): Server {
@@ -136,6 +142,10 @@
             fetch: async (req, server) => {
                 return await this.handleRequest(req, server)
             },
+            error(err) {
+                handleError(err, "NETWORK", { source: "bun_serve" })
+                return new Response(JSON.stringify({ error: "Internal error" }), { status: 500, headers: { "content-type": "application/json" } })
+            },
         })
         return this.server
     }

src/libs/network/handlers/blockHandlers.ts

@@ -74,18 +74,36 @@
 
     getLastBlockNumber: async (_data, response) => {
         log.debug("[SERVER] Received getLastBlockNumber")
-        response.response = await Chain.getLastBlockNumber()
-        log.debug("[CHAIN] Received reply from the database")
+        try {
+            response.response = await Chain.getLastBlockNumber()
+            log.debug("[CHAIN] Received reply from the database")
+        } catch (e) {
+            response.result = 503
+            response.response = "STATE_NOT_READY"
+            response.extra = { message: e instanceof Error ? e.message : String(e) }
+        }
         return response
     },
 
     getLastBlock: async (_data, response) => {
-        response.response = await Chain.getLastBlock()
+        try {
+            response.response = await Chain.getLastBlock()
+        } catch (e) {
+            response.result = 503
+            response.response = "STATE_NOT_READY"
+            response.extra = { message: e instanceof Error ? e.message : String(e) }
+        }
         return response
     },
 
     getLastBlockHash: async (_data, response) => {
-        response.response = await Chain.getLastBlockHash()
+        try {
+            response.response = await Chain.getLastBlockHash()
+        } catch (e) {
+            response.result = 503
+            response.response = "STATE_NOT_READY"
+            response.extra = { message: e instanceof Error ? e.message : String(e) }
+        }
         return response
     },
 
@@ -115,7 +133,7 @@
         } catch (e) {
             response.response = null
             response.result = 400
-            response.extra = e
+            response.extra = { message: e instanceof Error ? e.message : String(e) }
         }
         return response
     },
@@ -126,7 +144,13 @@
             response.response = "No block hash specified"
             return response
         }
-        response.response = await Chain.getBlockTransactions(data.blockHash)
+        try {
+            response.response = await Chain.getBlockTransactions(data.blockHash)
+        } catch (e) {
+            response.result = 503
+            response.response = "STATE_NOT_READY"
+            response.extra = { message: e instanceof Error ? e.message : String(e) }
+        }
         return response
     },
 }

src/libs/network/handlers/identityHandlers.ts

@@ -21,7 +21,7 @@
         } catch (error) {
             response.result = 400
             response.response = "error"
-            response.extra = error
+            response.extra = { message: error instanceof Error ? error.message : String(error) }
         }
         return response
     },

src/libs/network/manageP2P.ts

@@ -21,7 +21,7 @@
 // Multiton class to manage P2P connections and sessions
 export default class DemosP2P {
 
-    private static instances: Map<string, DemosP2P>
+    private static instances: Map<string, DemosP2P> = new Map()
 
     // SECTION Properties and constructor
 
@@ -33,6 +33,7 @@
     constructor(partecipants: [string, string]) {
         this.partecipants = partecipants
         this.sessionId = DemosP2P.getSessionId(partecipants[0], partecipants[1])
+        this.messages = new Map()
     }
 
     // SECTION Static methods
@@ -65,12 +66,13 @@
     // Relay a message to the other partecipant
     public relayMessage(message: Message): void {
         // ! TODO Signature verification
-        this.messages.get(message.publicKey).push(message)
+        if (!this.messages.has(message.publicKey)) this.messages.set(message.publicKey, [])
+        this.messages.get(message.publicKey)!.push(message)
     }
 
     // Get the messages for the partecipant and mark them as read
     public getMessagesForPartecipant(publicKey: string): Message[] {
-        const messages = this.messages.get(publicKey)
+        const messages = this.messages.get(publicKey) ?? []
         for (const message of messages) {
             message.read = true
         }

src/libs/network/middleware/rateLimiter.ts

@@ -274,7 +274,7 @@
             15 * 60 * 1000,
         )
 
-        this.loadIPs()
+        void this.loadIPs()
     }
 
     /**
@@ -375,12 +375,12 @@
         }
     }
 
-    private loadIPs(): void {
+    private async loadIPs(): Promise<void> {
         const filePath = "blocked_ips.json"
 
         try {
             const data: Record<string, RateLimitData> = JSON.parse(
-                fs.readFileSync(filePath, "utf8"),
+                await fs.promises.readFile(filePath, "utf8"),
             )
 
             // load each IP and its RateLimitData to this.ipRequests

src/libs/network/routines/normalizeWebBuffers.ts

@@ -25,6 +25,6 @@
             return [Buffer.from(bufferized.data), null]
         }
     } catch (e) {
-        return [null, e["message"]]
+        return [null, e instanceof Error ? e.message : String(e)]
     }
 }

src/libs/network/rpcDispatch.ts

@@ -62,7 +62,7 @@
     )
 }
 
 export async function processPayload(
     payload: RPCRequest,
     sender: string,
 ): Promise<RPCResponse> {
@@ -131,7 +131,7 @@
                     response: "Error in nodeCall: ",
                     require_reply: false,
                     extra: {
-                        error: error.toString(),
+                        error: error instanceof Error ? error.message : String(error),
                     },
                 }
             }

src/libs/network/server_rpc.ts

@@ -75,7 +75,7 @@
         })
     })
 
     server.get("/health", async () => {
         // PR #797 contract — preserve every field so SDK probes do not
         // break. New blocks are additive (Epic 13 T7):
         //   - `status`: ok | degraded | dormant | failing
@@ -96,7 +96,7 @@
         try {
             mempoolSize = await Mempool.count()
         } catch (err) {
-            log.error("[/health] Mempool.count() failed:", err)
+            log.error("[/health] Mempool.count() failed: " + (err instanceof Error ? err.message : String(err)))
         }
 
         const subsystems = snapshotSubsystems(getSharedState.subsystems)
@@ -237,14 +237,22 @@
     })
 
     server.get("/genesis", async () => {
-        const genesisBlock = await Chain.getGenesisBlock()
-        let genesisData = genesisBlock.content.extra?.genesisData || null
+        try {
+            const genesisBlock = await Chain.getGenesisBlock()
+            let genesisData = genesisBlock.content.extra?.genesisData || null
+
+            if (typeof genesisData === "string") {
+                try {
+                    genesisData = JSON.parse(genesisData)
+                } catch (_e) {
+                    return jsonResponse({ result: 503, response: "STATE_NOT_READY", extra: { message: "Corrupt genesis data" } }, 503)
+                }
+            }
 
-        if (typeof genesisData === "string") {
-            genesisData = JSON.parse(genesisData)
+            return jsonResponse(genesisData)
+        } catch (e) {
+            return jsonResponse({ result: 503, response: "STATE_NOT_READY", extra: { message: e instanceof Error ? e.message : String(e) } }, 503)
         }
-
-        return jsonResponse(genesisData)
     })
 
     server.get("/rate-limit/stats", () => {

src/libs/omniprotocol/transport/ConnectionPool.ts

@@ -758,8 +758,7 @@ export class ConnectionPool extends EventEmitter {
         }
 
         if (!this.instance && !rateLimiter) {
-            log.error("Connection Pool not initialized")
-            process.exit(1)
+            throw new Error("ConnectionPool not initialised: must call getInstance(rateLimiter) before getInstance()")
         }
 
         return this.instance

src/libs/omniprotocol/transport/PeerConnection.ts

@@ -784,7 +784,7 @@
      * Handle an incoming request from peer
      * Performs authentication, rate limiting, and dispatches to appropriate handler
      */
     private async handleIncomingRequest(
         header: OmniMessageHeader,
         payload: Buffer,
         auth: AuthBlock | null,
@@ -885,9 +885,10 @@
                 `[PeerConnection] ${this._peerIdentity} handler error: ${error}`,
             )
 
+            handleError(error, "NETWORK", { source: "PeerConnection.handler" })
             // Send error response
             const errorPayload = Buffer.from(
-                JSON.stringify({ error: String(error) }),
+                JSON.stringify({ error: error instanceof Error ? error.message : String(error) }),
             )
             await this.sendResponse(header.sequence, errorPayload)
         }

src/libs/peer/Peer.ts

@@ -268,7 +268,7 @@
     }
 
     // Single HTTP call (no retry logic - use longCall for retries)
     async httpCall(
         request: RPCRequest,
         isAuthenticated = true,
     ): Promise<RPCResponse> {
@@ -382,7 +382,7 @@
 
             return {
                 result: 500,
-                response: error,
+                response: error instanceof Error ? error.message : String(error),
                 require_reply: false,
                 extra: null,
             }
@@ -400,8 +400,12 @@
         }
         const url = this.connection.string + "/" + endpoint
         log.info("[Fetch] Making fetch call to: " + url)
-        const response = await axios.get(url)
-        return response.data
+        try {
+            const response = await axios.get(url)
+            return response.data
+        } catch (e) {
+            return { status: 0, error: e instanceof Error ? e.message : String(e) }
+        }
     }
 
     async getInfo(): Promise<any> {