fix: dont use global variables

Author: richard-ramos

examples/poc_gossipsub.nim

@@ -43,17 +43,17 @@ proc setUpNodes(numNodes: int): seq[Switch] =
   # This is not actually GC-safe
   {.gcsafe.}:
     # Initialize mix nodes
-    discard initializeMixNodes(numNodes)
+    let mixNodes = initializeMixNodes(numNodes).valueOr:
+      error "Could not initialize mixnodes", err = error
+      return
 
     var nodes: seq[Switch] = @[]
 
     for index, node in enumerate(mixNodes):
       # Write public info of all mix nodes
-      let nodePubInfoRes = getMixPubInfoByIndex(index)
-      if nodePubInfoRes.isErr:
-        error "Get mix pub info by index error", err = nodePubInfoRes.error
+      let nodePubInfo = mixNodes.getMixPubInfoByIndex(index).valueOr:
+        error "Get mix pub info by index error", err = error
         continue
-      let nodePubInfo = nodePubInfoRes.get()
 
       let writePubRes = writeMixPubInfoToFile(nodePubInfo, index)
       if writePubRes.isErr:

examples/poc_gossipsub_repeated_runs.nim

@@ -43,17 +43,17 @@ proc setUpNodes(numNodes: int): seq[Switch] =
   # This is not actually GC-safe
   {.gcsafe.}:
     # Initialize mix nodes
-    discard initializeMixNodes(numNodes)
+    let mixNodes = initializeMixNodes(numNodes).valueOr:
+      error "Could not initialize mixnodes", err = error
+      return
 
     var nodes: seq[Switch] = @[]
 
     for index, node in enumerate(mixNodes):
       # Write public info of all mix nodes
-      let nodePubInfoRes = getMixPubInfoByIndex(index)
-      if nodePubInfoRes.isErr:
-        error "Get mix pub info by index error", err = nodePubInfoRes.error
+      let nodePubInfo = mixNodes.getMixPubInfoByIndex(index).valueOr:
+        error "Get mix pub info by index error", err = error
         continue
-      let nodePubInfo = nodePubInfoRes.get()
 
       let writePubRes = writeMixPubInfoToFile(nodePubInfo, index)
       if writePubRes.isErr:

examples/poc_noresp_ping.nim

@@ -30,17 +30,17 @@ proc setUpNodes(numNodes: int): seq[Switch] =
   # This is not actually GC-safe
   {.gcsafe.}:
     # Initialize mix nodes
-    discard initializeMixNodes(numNodes)
+    let mixNodes = initializeMixNodes(numNodes).valueOr:
+      error "Could not initialize mixnodes", err = error
+      return
 
     var nodes: seq[Switch] = @[]
 
     for index, node in enumerate(mixNodes):
       # Write public info of all mix nodes
-      let nodePubInfoRes = getMixPubInfoByIndex(index)
-      if nodePubInfoRes.isErr:
-        error "Get mix pub info by index error", err = nodePubInfoRes.error
+      let nodePubInfo = mixNodes.getMixPubInfoByIndex(index).valueOr:
+        error "Get mix pub info by index error", err = error
         continue
-      let nodePubInfo = nodePubInfoRes.get()
 
       let writePubRes = writeMixPubInfoToFile(nodePubInfo, index)
       if writePubRes.isErr:

examples/poc_resp_ping.nim

@@ -28,17 +28,17 @@ proc setUpNodes(numNodes: int): seq[Switch] =
   # This is not actually GC-safe
   {.gcsafe.}:
     # Initialize mix nodes
-    discard initializeMixNodes(numNodes)
+    let mixNodes = initializeMixNodes(numNodes).valueOr:
+      error "Could not initialize mixnodes", err = error
+      return
 
     var nodes: seq[Switch] = @[]
 
     for index, node in enumerate(mixNodes):
       # Write public info of all mix nodes
-      let nodePubInfoRes = getMixPubInfoByIndex(index)
-      if nodePubInfoRes.isErr:
-        error "Get mix pub info by index error", err = nodePubInfoRes.error
+      let nodePubInfo = mixNodes.getMixPubInfoByIndex(index).valueOr:
+        error "Get mix pub info by index error", err = error
         continue
-      let nodePubInfo = nodePubInfoRes.get()
 
       let writePubRes = writeMixPubInfoToFile(nodePubInfo, index)
       if writePubRes.isErr:
@@ -86,7 +86,7 @@ proc mixnetSimulation() {.async: (raises: [Exception]).} =
 
     # We'll fwd requests, so let's register how should the exit node will read responses
     proto.registerFwdReadBehavior(PingCodec, readExactly(32))
-    
+
     mixProto.add(proto)
 
     nodes[index].mount(pingProto[index])

mix.nim

@@ -8,24 +8,26 @@ export results
 export toConnection
 export MixProtocolID
 export MixProtocol
+
 export initializeMixNodes
 export getMixPubInfoByIndex
 export writeMixPubInfoToFile
 export writeMixNodeInfoToFile
-export mixNodes
 export getMixNodeInfo
 export `new`
 export getMaxMessageSizeForCodec
 export deleteNodeInfoFolder
 export deletePubInfoFolder
-export initMixMultiAddrByIndex
+
 export Destination
 export DestinationType
 export forwardToAddr
 export mixNode
+
 export MixParameters
 export fwdReadBehaviorCb
 export registerFwdReadBehavior
+export MixNodes
 
 proc readLp*(maxSize: int): fwdReadBehaviorCb =
   return proc(

mix/entry_connection.nim

@@ -170,7 +170,7 @@ method readLp*(
   if length == 0:
     return
 
-  var res = newSeqUninit[byte](length)
+  var res = newSeqUninitialized[byte](length)
   await s.readExactly(addr res[0], res.len)
   res
 

mix/mix_node.nim

@@ -14,8 +14,6 @@ type MixNodeInfo* = object
   libp2pPubKey: SkPublicKey
   libp2pPrivKey: SkPrivateKey
 
-var mixNodes*: seq[MixNodeInfo] = @[] # TODO: global variable?
-
 proc initMixNodeInfo*(
     multiAddr: string,
     mixPubKey, mixPrivKey: FieldElement,
@@ -243,20 +241,20 @@ proc deletePubInfoFolder*(pubInfoFolderPath: string = "./pubInfo") =
   if dirExists(pubInfoFolderPath):
     removeDir(pubInfoFolderPath)
 
-proc getMixPubInfoByIndex*(index: int): Result[MixPubInfo, string] =
-  if index < 0 or index >= mixNodes.len:
-    return err("Index must be between 0 and " & $(mixNodes.len))
+type MixNodes* = seq[MixNodeInfo]
+
+proc getMixPubInfoByIndex*(self: MixNodes, index: int): Result[MixPubInfo, string] =
+  if index < 0 or index >= self.len:
+    return err("Index must be between 0 and " & $(self.len))
   ok(
     MixPubInfo(
-      multiAddr: mixNodes[index].multiAddr,
-      mixPubKey: mixNodes[index].mixPubKey,
-      libp2pPubKey: mixNodes[index].libp2pPubKey,
+      multiAddr: self[index].multiAddr,
+      mixPubKey: self[index].mixPubKey,
+      libp2pPubKey: self[index].libp2pPubKey,
     )
   )
 
-proc generateMixNodes(
-    count: int, basePort: int = 4242
-): Result[seq[MixNodeInfo], string] =
+proc generateMixNodes(count: int, basePort: int = 4242): Result[MixNodes, string] =
   var nodes = newSeq[MixNodeInfo](count)
   for i in 0 ..< count:
     let keyPairResult = generateKeyPair()
@@ -283,31 +281,21 @@ proc generateMixNodes(
 
   ok(nodes)
 
-proc initializeMixNodes*(count: int, basePort: int = 4242): Result[void, string] =
-  mixNodes = generateMixNodes(count, basePort).valueOr:
+proc initializeMixNodes*(count: int, basePort: int = 4242): Result[MixNodes, string] =
+  let mixNodes = generateMixNodes(count, basePort).valueOr:
     return err("Mix node initialization error: " & error)
+  return ok(mixNodes)
 
 proc getPeerIdFromMultiAddr*(multiAddr: string): Result[PeerId, string] =
   let parts = multiAddr.split("/")
   if parts.len != 7:
     return err("Invalid multiaddress format")
   ok(PeerId.init(parts[6]).get())
 
-proc findMixNodeByPeerId*(peerId: PeerId): Result[MixNodeInfo, string] =
-  for node in mixNodes:
+proc findByPeerId*(self: MixNodes, peerId: PeerId): Result[MixNodeInfo, string] =
+  for node in self:
     let peerIdRes = getPeerIdFromMultiAddr(node.multiAddr).valueOr:
       return err("Failed to get peer id from multiAddress")
     if peerIdRes == peerId:
       return ok(node)
   return err("No node with peer id: " & $peerId)
-
-proc getMixNodeByIndex*(index: int): Result[MixNodeInfo, string] =
-  if index < 0 or index >= mixNodes.len:
-    return err("Index must be between 0 and " & $(mixNodes.len))
-  ok(mixNodes[index])
-
-proc initMixMultiAddrByIndex*(index: int, multiAddr: string): Result[void, string] =
-  if index < 0 or index >= mixNodes.len:
-    return err("Index must be between 0 and " & $(mixNodes.len))
-  mixNodes[index].multiAddr = multiAddr
-  ok()

mix/mix_protocol.nim

@@ -170,7 +170,7 @@ proc handleMixNodeConnection(
         await connCred.incoming.put(deserialized.message)
       else:
         error "could not process reply", id = processedSP.id
-    except KeyError as ex:
+    except KeyError:
       doAssert false, "checked with hasKey"
   of Intermediate:
     trace "# Intermediate: ", multiAddr = multiAddr

tests/test_mix_node.nim

@@ -5,9 +5,16 @@ import libp2p/[crypto/crypto, crypto/secp, multiaddress, peerid]
 import ../mix/[curve25519, mix_node]
 
 suite "Mix Node Tests":
+  var mixNodes {.threadvar.}: MixNodes
+
   setup:
     var count = 5
-    discard initializeMixNodes(count)
+    let mixNodesRes = initializeMixNodes(count)
+    if mixNodesRes.isErr():
+      error "could not generate mix nodes"
+      fail()
+    mixNodes = mixNodesRes.value()
+
     deleteNodeInfoFolder()
     deletePubInfoFolder()
 
@@ -21,12 +28,7 @@ suite "Mix Node Tests":
       fail()
 
     for i in 0 ..< count:
-      let nodeRes = getMixNodeByIndex(i)
-      if nodeRes.isErr:
-        error "Get mix node by index error", err = nodeRes.error
-        fail()
-      let node = nodeRes.get()
-
+      let node = mixNodes[i]
       let
         (multiAddr, mixPubKey, mixPrivKey, libp2pPubKey, libp2pPrivKey) =
           getMixNodeInfo(node)
@@ -73,11 +75,7 @@ suite "Mix Node Tests":
 
   test "find_mix_node_by_peer_id":
     for i in 0 ..< count:
-      let nodeRes = getMixNodeByIndex(i)
-      if nodeRes.isErr:
-        error "Get mix node by index error", err = nodeRes.error
-        fail()
-      let node = nodeRes.get()
+      let node = mixNodes[i]
 
       let (multiAddr, mixPubKey, mixPrivKey, libp2pPubKey, libp2pPrivKey) =
         getMixNodeInfo(node)
@@ -88,7 +86,7 @@ suite "Mix Node Tests":
         fail()
       let peerId = peerIdRes.get()
 
-      let foundNodeRes = findMixNodeByPeerId(peerId)
+      let foundNodeRes = mixNodes.findByPeerId(peerId)
       if foundNodeRes.isErr:
         error "Find mix node error", err = foundNodeRes.error
         fail()
@@ -133,17 +131,13 @@ suite "Mix Node Tests":
       fail()
     let peerId = peerIdRes.get()
 
-    let foundNodeRes = findMixNodeByPeerId(peerId)
+    let foundNodeRes = mixNodes.findByPeerId(peerId)
     if foundNodeRes.isOk:
       fail()
 
   test "write_and_read_mix_node_info":
     for i in 0 ..< count:
-      let nodeRes = getMixNodeByIndex(i)
-      if nodeRes.isErr:
-        error "Get mix node by index error", err = nodeRes.error
-        fail()
-      let node = nodeRes.get()
+      let node = mixNodes[i]
 
       let (multiAddr, mixPubKey, mixPrivKey, libp2pPubKey, libp2pPrivKey) =
         getMixNodeInfo(node)
@@ -189,15 +183,15 @@ suite "Mix Node Tests":
 
   test "write_and_read_mix_pub_info":
     for i in 0 ..< count:
-      let nodeRes = getMixPubInfoByIndex(i)
-      if nodeRes.isErr:
-        error "Get mix node by index error", err = nodeRes.error
+      let mixPubInfoRes = mixNodes.getMixPubInfoByIndex(i)
+      if mixPubInfoRes.isErr:
+        error "Get mix pubinfo by index error", err = mixPubInfoRes.error
         fail()
-      let node = nodeRes.get()
+      let mixPubInfo = mixPubInfoRes.get()
 
-      let (multiAddr, mixPubKey, libp2pPubKey) = getMixPubInfo(node)
+      let (multiAddr, mixPubKey, libp2pPubKey) = getMixPubInfo(mixPubInfo)
 
-      let writeNodeRes = writeMixPubInfoToFile(node, i)
+      let writeNodeRes = writeMixPubInfoToFile(mixPubInfo, i)
       if writeNodeRes.isErr:
         error "File write error", index = i
         fail()
@@ -234,14 +228,13 @@ suite "Mix Node Tests":
   test "generate_mix_nodes_with_different_ports":
     count = 3
     let basePort = 5000
-    discard initializeMixNodes(count, basePort)
+    let mixNodesRes2 = initializeMixNodes(count, basePort)
+    if mixNodesRes2.isErr:
+      error "could not generate mixnodes", err = mixNodesRes2.error()
+    let mixNodes = mixNodesRes2.value()
 
     for i in 0 ..< count:
-      let nodeRes = getMixNodeByIndex(i)
-      if nodeRes.isErr:
-        error "Get mix node by index error", err = nodeRes.error
-        fail()
-      let node = nodeRes.get()
+      let node = mixNodes[i]
 
       let (multiAddr, _, _, _, _) = getMixNodeInfo(node)