Chore/update nim version

Makefile

@@ -15,8 +15,8 @@
 #
 # If NIM_COMMIT is set to "nimbusbuild", this will use the
 # version pinned by nimbus-build-system.
-PINNED_NIM_VERSION := 38640664088251bbc88917b4bacfd86ec53014b8 # 1.6.21
-
+#PINNED_NIM_VERSION := 38640664088251bbc88917b4bacfd86ec53014b8 # 1.6.21
+PINNED_NIM_VERSION := v2.0.12
 ifeq ($(NIM_COMMIT),)
 NIM_COMMIT := $(PINNED_NIM_VERSION)
 else ifeq ($(NIM_COMMIT),pinned)

codex.nim

@@ -48,18 +48,18 @@ when isMainModule:
   let config = CodexConf.load(
     version = codexFullVersion,
     envVarsPrefix = "codex",
-    secondarySources = proc (config: CodexConf, sources: auto) =
+    secondarySources = proc (config: CodexConf, sources: auto) {.gcsafe, raises: [ConfigurationError].} =
             if configFile =? config.configFile:
               sources.addConfigFile(Toml, configFile)
   )
   config.setupLogging()
   config.setupMetrics()
 
-  if config.nat == ValidIpAddress.init(IPv4_any()):
+  if config.nat == IPv4_any():
     error "`--nat` cannot be set to the any (`0.0.0.0`) address"
     quit QuitFailure
 
-  if config.nat == ValidIpAddress.init("127.0.0.1"):
+  if config.nat == static parseIpAddress("127.0.0.1"):
     warn "`--nat` is set to loopback, your node wont properly announce over the DHT"
 
   if not(checkAndCreateDataDir((config.dataDir).string)):

codex/clock.nim

@@ -8,7 +8,7 @@ type
   SecondsSince1970* = int64
   Timeout* = object of CatchableError
 
-method now*(clock: Clock): SecondsSince1970 {.base, upraises: [].} =
+method now*(clock: Clock): SecondsSince1970 {.base, gcsafe, upraises: [].} =
   raiseAssert "not implemented"
 
 method waitUntil*(clock: Clock, time: SecondsSince1970) {.base, async.} =

codex/codex.nim

@@ -11,7 +11,6 @@ import std/sequtils
 import std/strutils
 import std/os
 import std/tables
-import std/cpuinfo
 
 import pkg/chronos
 import pkg/presto
@@ -24,7 +23,6 @@ import pkg/stew/shims/net as stewnet
 import pkg/datastore
 import pkg/ethers except Rng
 import pkg/stew/io2
-import pkg/taskpools
 
 import ./node
 import ./conf
@@ -55,7 +53,6 @@ type
     codexNode: CodexNodeRef
     repoStore: RepoStore
     maintenance: BlockMaintainer
-    taskpool: Taskpool
 
   CodexPrivateKey* = libp2p.PrivateKey # alias
   EthWallet = ethers.Wallet
@@ -190,10 +187,6 @@ proc start*(s: CodexServer) {.async.} =
 proc stop*(s: CodexServer) {.async.} =
   notice "Stopping codex node"
 
-
-  s.taskpool.syncAll()
-  s.taskpool.shutdown()
-
   await allFuturesThrowing(
     s.restServer.stop(),
     s.codexNode.switch.stop(),
@@ -283,15 +276,12 @@ proc new*(
     else:
       none Prover
 
-    taskpool = Taskpool.new(num_threads = countProcessors())
-
     codexNode = CodexNodeRef.new(
       switch = switch,
       networkStore = store,
       engine = engine,
-      prover = prover,
       discovery = discovery,
-      taskpool = taskpool)
+      prover = prover)
 
     restServer = RestServerRef.new(
       codexNode.initRestApi(config, repoStore, config.apiCorsAllowedOrigin),
@@ -306,6 +296,4 @@ proc new*(
     config: config,
     codexNode: codexNode,
     restServer: restServer,
-    repoStore: repoStore,
-    maintenance: maintenance,
-    taskpool: taskpool)
+    repoStore: repoStore)

codex/conf.nim

@@ -114,9 +114,9 @@ type
 
     metricsAddress* {.
       desc: "Listening address of the metrics server"
-      defaultValue: ValidIpAddress.init("127.0.0.1")
+      defaultValue: defaultAddress(config)
       defaultValueDesc: "127.0.0.1"
-      name: "metrics-address" }: ValidIpAddress
+      name: "metrics-address" }: IpAddress
 
     metricsPort* {.
       desc: "Listening HTTP port of the metrics server"
@@ -142,17 +142,17 @@ type
     # TODO: change this once we integrate nat support
     nat* {.
       desc: "IP Addresses to announce behind a NAT"
-      defaultValue: ValidIpAddress.init("127.0.0.1")
+      defaultValue: defaultAddress(config)
       defaultValueDesc: "127.0.0.1"
       abbr: "a"
-      name: "nat" }: ValidIpAddress
+      name: "nat" }: IpAddress
 
     discoveryIp* {.
       desc: "Discovery listen address"
-      defaultValue: ValidIpAddress.init(IPv4_any())
+      defaultValue: IPv4_any()
       defaultValueDesc: "0.0.0.0"
       abbr: "e"
-      name: "disc-ip" }: ValidIpAddress
+      name: "disc-ip" }: IpAddress
 
     discoveryPort* {.
       desc: "Discovery (UDP) port"
@@ -413,6 +413,9 @@ type
 logutils.formatIt(LogFormat.textLines, EthAddress): it.short0xHexLog
 logutils.formatIt(LogFormat.json, EthAddress): %it
 
+func defaultAddress*(conf: CodexConf): IpAddress =
+  result = static parseIpAddress("127.0.0.1")
+
 func persistence*(self: CodexConf): bool =
   self.cmd == StartUpCmd.persistence
 
@@ -445,13 +448,17 @@ const
 
 proc parseCmdArg*(T: typedesc[MultiAddress],
                   input: string): MultiAddress
-                 {.upraises: [ValueError, LPError].} =
+                 {.upraises: [ValueError] .} =
   var ma: MultiAddress
-  let res = MultiAddress.init(input)
-  if res.isOk:
-    ma = res.get()
-  else:
-    warn "Invalid MultiAddress", input=input, error = res.error()
+  try:
+    let res = MultiAddress.init(input)
+    if res.isOk:
+      ma = res.get()
+    else:
+      warn "Invalid MultiAddress", input=input, error = res.error()
+      quit QuitFailure
+  except LPError as exc:
+    warn "Invalid MultiAddress uri", uri = input, error = exc.msg
     quit QuitFailure
   ma
 
@@ -461,6 +468,9 @@ proc parseCmdArg*(T: type SignedPeerRecord, uri: string): T =
     if not res.fromURI(uri):
       warn "Invalid SignedPeerRecord uri", uri = uri
       quit QuitFailure
+  except LPError as exc:
+    warn "Invalid SignedPeerRecord uri", uri = uri, error = exc.msg
+    quit QuitFailure
   except CatchableError as exc:
     warn "Invalid SignedPeerRecord uri", uri = uri, error = exc.msg
     quit QuitFailure
@@ -494,7 +504,11 @@ proc readValue*(r: var TomlReader, val: var SignedPeerRecord) =
     error "invalid SignedPeerRecord configuration value", error = err.msg
     quit QuitFailure
 
-  val = SignedPeerRecord.parseCmdArg(uri)
+  try:
+    val = SignedPeerRecord.parseCmdArg(uri)
+  except LPError as err:
+    warn "Invalid SignedPeerRecord uri", uri = uri, error = err.msg
+    quit QuitFailure
 
 proc readValue*(r: var TomlReader, val: var MultiAddress) =
   without input =? r.readValue(string).catch, err:

codex/contracts/clock.nim

@@ -45,7 +45,7 @@ method start*(clock: OnChainClock) {.async.} =
   if clock.started:
     return
 
-  proc onBlock(_: Block) =
+  proc onBlock(_: ?!Block) =
     # ignore block parameter; hardhat may call this with pending blocks
     asyncSpawn clock.update()
 

codex/contracts/market.nim

@@ -277,10 +277,14 @@ method canReserveSlot*(
 method subscribeRequests*(market: OnChainMarket,
                          callback: OnRequest):
                         Future[MarketSubscription] {.async.} =
-  proc onEvent(event: StorageRequested) {.upraises:[].} =
-    callback(event.requestId,
-             event.ask,
-             event.expiry)
+  proc onEvent(event: ?!StorageRequested) {.upraises:[].} =
+    without value =? event:
+      error "The event object is not defined"
+      return
+
+    callback(value.requestId,
+             value.ask,
+             value.expiry)
 
   convertEthersError:
     let subscription = await market.contract.subscribe(StorageRequested, onEvent)
@@ -289,8 +293,12 @@ method subscribeRequests*(market: OnChainMarket,
 method subscribeSlotFilled*(market: OnChainMarket,
                             callback: OnSlotFilled):
                            Future[MarketSubscription] {.async.} =
-  proc onEvent(event: SlotFilled) {.upraises:[].} =
-    callback(event.requestId, event.slotIndex)
+  proc onEvent(event: ?!SlotFilled) {.upraises:[].} =
+    without value =? event:
+      error "The event object is not defined"
+      return
+
+    callback(value.requestId, value.slotIndex)
 
   convertEthersError:
     let subscription = await market.contract.subscribe(SlotFilled, onEvent)
@@ -311,8 +319,12 @@ method subscribeSlotFilled*(market: OnChainMarket,
 method subscribeSlotFreed*(market: OnChainMarket,
                            callback: OnSlotFreed):
                           Future[MarketSubscription] {.async.} =
-  proc onEvent(event: SlotFreed) {.upraises:[].} =
-    callback(event.requestId, event.slotIndex)
+  proc onEvent(event: ?!SlotFreed) {.upraises:[].} =
+    without value =? event:
+      error "The event object is not defined"
+      return
+
+    callback(value.requestId, value.slotIndex)
 
   convertEthersError:
     let subscription = await market.contract.subscribe(SlotFreed, onEvent)
@@ -322,8 +334,12 @@ method subscribeSlotReservationsFull*(
   market: OnChainMarket,
   callback: OnSlotReservationsFull): Future[MarketSubscription] {.async.} =
 
-  proc onEvent(event: SlotReservationsFull) {.upraises:[].} =
-    callback(event.requestId, event.slotIndex)
+  proc onEvent(event: ?!SlotReservationsFull) {.upraises:[].} =
+    without value =? event:
+      error "The event object is not defined"
+      return
+
+    callback(value.requestId, value.slotIndex)
 
   convertEthersError:
     let subscription = await market.contract.subscribe(SlotReservationsFull, onEvent)
@@ -332,8 +348,12 @@ method subscribeSlotReservationsFull*(
 method subscribeFulfillment(market: OnChainMarket,
                             callback: OnFulfillment):
                            Future[MarketSubscription] {.async.} =
-  proc onEvent(event: RequestFulfilled) {.upraises:[].} =
-    callback(event.requestId)
+  proc onEvent(event: ?!RequestFulfilled) {.upraises:[].} =
+    without value =? event:
+      error "The event object is not defined"
+      return
+
+    callback(value.requestId)
 
   convertEthersError:
     let subscription = await market.contract.subscribe(RequestFulfilled, onEvent)
@@ -343,9 +363,13 @@ method subscribeFulfillment(market: OnChainMarket,
                             requestId: RequestId,
                             callback: OnFulfillment):
                            Future[MarketSubscription] {.async.} =
-  proc onEvent(event: RequestFulfilled) {.upraises:[].} =
-    if event.requestId == requestId:
-      callback(event.requestId)
+  proc onEvent(event: ?!RequestFulfilled) {.upraises:[].} =
+    without value =? event:
+      error "The event object is not defined"
+      return
+
+    if value.requestId == requestId:
+      callback(value.requestId)
 
   convertEthersError:
     let subscription = await market.contract.subscribe(RequestFulfilled, onEvent)
@@ -354,8 +378,12 @@ method subscribeFulfillment(market: OnChainMarket,
 method subscribeRequestCancelled*(market: OnChainMarket,
                                   callback: OnRequestCancelled):
                                 Future[MarketSubscription] {.async.} =
-  proc onEvent(event: RequestCancelled) {.upraises:[].} =
-    callback(event.requestId)
+  proc onEvent(event: ?!RequestCancelled) {.upraises:[].} =
+    without value =? event:
+      error "The event object is not defined"
+      return
+
+    callback(value.requestId)
 
   convertEthersError:
     let subscription = await market.contract.subscribe(RequestCancelled, onEvent)
@@ -365,9 +393,13 @@ method subscribeRequestCancelled*(market: OnChainMarket,
                                   requestId: RequestId,
                                   callback: OnRequestCancelled):
                                 Future[MarketSubscription] {.async.} =
-  proc onEvent(event: RequestCancelled) {.upraises:[].} =
-    if event.requestId == requestId:
-      callback(event.requestId)
+  proc onEvent(event: ?!RequestCancelled) {.upraises:[].} =
+    without value =? event:
+      error "The event object is not defined"
+      return
+
+    if value.requestId == requestId:
+      callback(value.requestId)
 
   convertEthersError:
     let subscription = await market.contract.subscribe(RequestCancelled, onEvent)
@@ -376,8 +408,12 @@ method subscribeRequestCancelled*(market: OnChainMarket,
 method subscribeRequestFailed*(market: OnChainMarket,
                               callback: OnRequestFailed):
                             Future[MarketSubscription] {.async.} =
-  proc onEvent(event: RequestFailed) {.upraises:[]} =
-    callback(event.requestId)
+  proc onEvent(event: ?!RequestFailed) {.upraises:[]} =
+    without value =? event:
+      error "The event object is not defined"
+      return
+
+    callback(value.requestId)
 
   convertEthersError:
     let subscription = await market.contract.subscribe(RequestFailed, onEvent)
@@ -387,9 +423,13 @@ method subscribeRequestFailed*(market: OnChainMarket,
                               requestId: RequestId,
                               callback: OnRequestFailed):
                             Future[MarketSubscription] {.async.} =
-  proc onEvent(event: RequestFailed) {.upraises:[]} =
-    if event.requestId == requestId:
-      callback(event.requestId)
+  proc onEvent(event: ?!RequestFailed) {.upraises:[]} =
+    without value =? event:
+      error "The event object is not defined"
+      return
+
+    if value.requestId == requestId:
+      callback(value.requestId)
 
   convertEthersError:
     let subscription = await market.contract.subscribe(RequestFailed, onEvent)
@@ -398,8 +438,12 @@ method subscribeRequestFailed*(market: OnChainMarket,
 method subscribeProofSubmission*(market: OnChainMarket,
                                  callback: OnProofSubmitted):
                                 Future[MarketSubscription] {.async.} =
-  proc onEvent(event: ProofSubmitted) {.upraises: [].} =
-    callback(event.id)
+  proc onEvent(event: ?!ProofSubmitted) {.upraises: [].} =
+    without value =? event:
+      error "The event object is not defined"
+      return
+
+    callback(value.id)
 
   convertEthersError:
     let subscription = await market.contract.subscribe(ProofSubmitted, onEvent)