refactor: async error handling and future tracking improvements

- Update async procedures to use explicit raises annotation
- Modify TrackedFutures to handle futures with no raised exceptions
- Replace `asyncSpawn` with explicit future tracking
- Update test suites to use `unittest2`
- Standardize error handling across network and async components
- Remove deprecated error handling patterns

This commit introduces a more robust approach to async error handling and future management, improving type safety and reducing potential runtime errors.

codex/blockexchange/engine/advertiser.nim

@@ -41,7 +41,7 @@ type Advertiser* = ref object of RootObj
   advertiserRunning*: bool # Indicates if discovery is running
   concurrentAdvReqs: int # Concurrent advertise requests
 
-  advertiseLocalStoreLoop*: Future[void] # Advertise loop task handle
+  advertiseLocalStoreLoop*: Future[void].Raising([]) # Advertise loop task handle
   advertiseQueue*: AsyncQueue[Cid] # Advertise queue
   trackedFutures*: TrackedFutures # Advertise tasks futures
 
@@ -82,8 +82,6 @@ proc advertiseLocalStoreLoop(b: Advertiser) {.async: (raises: []).} =
         trace "Advertiser iterating blocks finished."
 
       await sleepAsync(b.advertiseLocalStoreLoopSleep)
-    except CancelledError:
-      break # do not propagate as advertiseLocalStoreLoop was asyncSpawned
     except CatchableError as e:
       error "failed to advertise blocks in local store", error = e.msgDetail
 

codex/blockexchange/engine/discovery.nim

@@ -48,7 +48,7 @@ type DiscoveryEngine* = ref object of RootObj
   pendingBlocks*: PendingBlocksManager # Blocks we're awaiting to be resolved
   discEngineRunning*: bool # Indicates if discovery is running
   concurrentDiscReqs: int # Concurrent discovery requests
-  discoveryLoop*: Future[void] # Discovery loop task handle
+  discoveryLoop*: Future[void].Raising([]) # Discovery loop task handle
   discoveryQueue*: AsyncQueue[Cid] # Discovery queue
   trackedFutures*: TrackedFutures # Tracked Discovery tasks futures
   minPeersPerBlock*: int # Max number of peers with block

codex/blockexchange/engine/engine.nim

@@ -644,23 +644,29 @@ proc new*(
     network.switch.addPeerEventHandler(peerEventHandler, PeerEventKind.Joined)
     network.switch.addPeerEventHandler(peerEventHandler, PeerEventKind.Left)
 
-  proc blockWantListHandler(peer: PeerId, wantList: WantList): Future[void] {.gcsafe.} =
+  proc blockWantListHandler(
+      peer: PeerId, wantList: WantList
+  ): Future[void] {.async: (raises: []).} =
     self.wantListHandler(peer, wantList)
 
   proc blockPresenceHandler(
       peer: PeerId, presence: seq[BlockPresence]
-  ): Future[void] {.gcsafe.} =
+  ): Future[void] {.async: (raises: []).} =
     self.blockPresenceHandler(peer, presence)
 
   proc blocksDeliveryHandler(
       peer: PeerId, blocksDelivery: seq[BlockDelivery]
-  ): Future[void] {.gcsafe.} =
+  ): Future[void] {.async: (raises: []).} =
     self.blocksDeliveryHandler(peer, blocksDelivery)
 
-  proc accountHandler(peer: PeerId, account: Account): Future[void] {.gcsafe.} =
+  proc accountHandler(
+      peer: PeerId, account: Account
+  ): Future[void] {.async: (raises: []).} =
     self.accountHandler(peer, account)
 
-  proc paymentHandler(peer: PeerId, payment: SignedState): Future[void] {.gcsafe.} =
+  proc paymentHandler(
+      peer: PeerId, payment: SignedState
+  ): Future[void] {.async: (raises: []).} =
     self.paymentHandler(peer, payment)
 
   network.handlers = BlockExcHandlers(

codex/blockexchange/engine/payments.nim

@@ -7,6 +7,8 @@
 ## This file may not be copied, modified, or distributed except according to
 ## those terms.
 
+{.push raises: [].}
+
 import std/math
 import pkg/nitro
 import pkg/questionable/results
@@ -15,9 +17,6 @@ import ../peers
 export nitro
 export results
 
-push:
-  {.upraises: [].}
-
 const ChainId* = 0.u256 # invalid chain id for now
 const Asset* = EthAddress.zero # invalid ERC20 asset address for now
 const AmountPerChannel = (10'u64 ^ 18).u256 # 1 asset, ERC20 default is 18 decimals

codex/blockexchange/network/network.nim

@@ -35,13 +35,15 @@ const
   DefaultMaxInflight* = 100
 
 type
-  WantListHandler* = proc(peer: PeerId, wantList: WantList): Future[void] {.gcsafe.}
+  WantListHandler* =
+    proc(peer: PeerId, wantList: WantList) {.gcsafe, async: (raises: []).}
   BlocksDeliveryHandler* =
-    proc(peer: PeerId, blocks: seq[BlockDelivery]): Future[void] {.gcsafe.}
+    proc(peer: PeerId, blocks: seq[BlockDelivery]) {.gcsafe, async: (raises: []).}
   BlockPresenceHandler* =
-    proc(peer: PeerId, precense: seq[BlockPresence]): Future[void] {.gcsafe.}
-  AccountHandler* = proc(peer: PeerId, account: Account): Future[void] {.gcsafe.}
-  PaymentHandler* = proc(peer: PeerId, payment: SignedState): Future[void] {.gcsafe.}
+    proc(peer: PeerId, precense: seq[BlockPresence]) {.gcsafe, async: (raises: []).}
+  AccountHandler* = proc(peer: PeerId, account: Account) {.gcsafe, async: (raises: []).}
+  PaymentHandler* =
+    proc(peer: PeerId, payment: SignedState) {.gcsafe, async: (raises: []).}
 
   BlockExcHandlers* = object
     onWantList*: WantListHandler
@@ -58,15 +60,20 @@ type
     wantType: WantType = WantType.WantHave,
     full: bool = false,
     sendDontHave: bool = false,
-  ): Future[void] {.gcsafe.}
-  WantCancellationSender* =
-    proc(peer: PeerId, addresses: seq[BlockAddress]): Future[void] {.gcsafe.}
-  BlocksDeliverySender* =
-    proc(peer: PeerId, blocksDelivery: seq[BlockDelivery]): Future[void] {.gcsafe.}
-  PresenceSender* =
-    proc(peer: PeerId, presence: seq[BlockPresence]): Future[void] {.gcsafe.}
-  AccountSender* = proc(peer: PeerId, account: Account): Future[void] {.gcsafe.}
-  PaymentSender* = proc(peer: PeerId, payment: SignedState): Future[void] {.gcsafe.}
+  ) {.async: (raises: [CancelledError]).}
+  WantCancellationSender* = proc(peer: PeerId, addresses: seq[BlockAddress]) {.
+    async: (raises: [CancelledError])
+  .}
+  BlocksDeliverySender* = proc(peer: PeerId, blocksDelivery: seq[BlockDelivery]) {.
+    async: (raises: [CancelledError])
+  .}
+  PresenceSender* = proc(peer: PeerId, presence: seq[BlockPresence]) {.
+    async: (raises: [CancelledError])
+  .}
+  AccountSender* =
+    proc(peer: PeerId, account: Account) {.async: (raises: [CancelledError]).}
+  PaymentSender* =
+    proc(peer: PeerId, payment: SignedState) {.async: (raises: [CancelledError]).}
 
   BlockExcRequest* = object
     sendWantList*: WantListSender
@@ -98,7 +105,9 @@ proc isSelf*(b: BlockExcNetwork, peer: PeerId): bool =
 
   return b.peerId == peer
 
-proc send*(b: BlockExcNetwork, id: PeerId, msg: pb.Message) {.async.} =
+proc send*(
+    b: BlockExcNetwork, id: PeerId, msg: pb.Message
+) {.async: (raises: [CancelledError]).} =
   ## Send message to peer
   ##
 
@@ -106,8 +115,9 @@ proc send*(b: BlockExcNetwork, id: PeerId, msg: pb.Message) {.async.} =
     trace "Unable to send, peer not found", peerId = id
     return
 
-  let peer = b.peers[id]
   try:
+    let peer = b.peers[id]
+
     await b.inflightSema.acquire()
     await peer.send(msg)
   except CancelledError as error:
@@ -117,7 +127,9 @@ proc send*(b: BlockExcNetwork, id: PeerId, msg: pb.Message) {.async.} =
   finally:
     b.inflightSema.release()
 
-proc handleWantList(b: BlockExcNetwork, peer: NetworkPeer, list: WantList) {.async.} =
+proc handleWantList(
+    b: BlockExcNetwork, peer: NetworkPeer, list: WantList
+) {.async: (raises: []).} =
   ## Handle incoming want list
   ##
 
@@ -133,7 +145,7 @@ proc sendWantList*(
     wantType: WantType = WantType.WantHave,
     full: bool = false,
     sendDontHave: bool = false,
-): Future[void] =
+) {.async: (raw: true, raises: [CancelledError]).} =
   ## Send a want message to peer
   ##
 
@@ -154,14 +166,14 @@ proc sendWantList*(
 
 proc sendWantCancellations*(
     b: BlockExcNetwork, id: PeerId, addresses: seq[BlockAddress]
-): Future[void] {.async.} =
+): Future[void] {.async: (raises: [CancelledError]).} =
   ## Informs a remote peer that we're no longer interested in a set of blocks
   ##
   await b.sendWantList(id = id, addresses = addresses, cancel = true)
 
 proc handleBlocksDelivery(
     b: BlockExcNetwork, peer: NetworkPeer, blocksDelivery: seq[BlockDelivery]
-) {.async.} =
+) {.async: (raises: []).} =
   ## Handle incoming blocks
   ##
 
@@ -170,7 +182,7 @@ proc handleBlocksDelivery(
 
 proc sendBlocksDelivery*(
     b: BlockExcNetwork, id: PeerId, blocksDelivery: seq[BlockDelivery]
-): Future[void] =
+) {.async: (raw: true, raises: [CancelledError]).} =
   ## Send blocks to remote
   ##
 
@@ -178,7 +190,7 @@ proc sendBlocksDelivery*(
 
 proc handleBlockPresence(
     b: BlockExcNetwork, peer: NetworkPeer, presence: seq[BlockPresence]
-) {.async.} =
+) {.async: (raises: []).} =
   ## Handle block presence
   ##
 
@@ -187,7 +199,7 @@ proc handleBlockPresence(
 
 proc sendBlockPresence*(
     b: BlockExcNetwork, id: PeerId, presence: seq[BlockPresence]
-): Future[void] =
+) {.async: (raw: true, raises: [CancelledError]).} =
   ## Send presence to remote
   ##
 
@@ -195,20 +207,24 @@ proc sendBlockPresence*(
 
 proc handleAccount(
     network: BlockExcNetwork, peer: NetworkPeer, account: Account
-) {.async.} =
+) {.async: (raises: []).} =
   ## Handle account info
   ##
 
   if not network.handlers.onAccount.isNil:
     await network.handlers.onAccount(peer.id, account)
 
-proc sendAccount*(b: BlockExcNetwork, id: PeerId, account: Account): Future[void] =
+proc sendAccount*(
+    b: BlockExcNetwork, id: PeerId, account: Account
+) {.async: (raw: true, raises: [CancelledError]).} =
   ## Send account info to remote
   ##
 
   b.send(id, Message(account: AccountMessage.init(account)))
 
-proc sendPayment*(b: BlockExcNetwork, id: PeerId, payment: SignedState): Future[void] =
+proc sendPayment*(
+    b: BlockExcNetwork, id: PeerId, payment: SignedState
+) {.async: (raw: true, raises: [CancelledError]).} =
   ## Send payment to remote
   ##
 
@@ -216,7 +232,7 @@ proc sendPayment*(b: BlockExcNetwork, id: PeerId, payment: SignedState): Future[
 
 proc handlePayment(
     network: BlockExcNetwork, peer: NetworkPeer, payment: SignedState
-) {.async.} =
+) {.async: (raises: []).} =
   ## Handle payment
   ##
 
@@ -225,7 +241,7 @@ proc handlePayment(
 
 proc rpcHandler(
     b: BlockExcNetwork, peer: NetworkPeer, msg: Message
-) {.async: (raises: [CatchableError]).} =
+) {.async: (raises: []).} =
   ## handle rpc messages
   ##
   if msg.wantList.entries.len > 0:
@@ -250,7 +266,9 @@ proc getOrCreatePeer(b: BlockExcNetwork, peer: PeerId): NetworkPeer =
   if peer in b.peers:
     return b.peers.getOrDefault(peer, nil)
 
-  var getConn: ConnProvider = proc(): Future[Connection] {.async, gcsafe, closure.} =
+  var getConn: ConnProvider = proc(): Future[Connection] {.
+      async: (raises: [CancelledError])
+  .} =
     try:
       trace "Getting new connection stream", peer
       return await b.switch.dial(peer, Codec)
@@ -262,9 +280,7 @@ proc getOrCreatePeer(b: BlockExcNetwork, peer: PeerId): NetworkPeer =
   if not isNil(b.getConn):
     getConn = b.getConn
 
-  let rpcHandler = proc(
-      p: NetworkPeer, msg: Message
-  ) {.async: (raises: [CatchableError]).} =
+  let rpcHandler = proc(p: NetworkPeer, msg: Message) {.async: (raises: []).} =
     await b.rpcHandler(p, msg)
 
   # create new pubsub peer
@@ -353,26 +369,32 @@ proc new*(
       wantType: WantType = WantType.WantHave,
       full: bool = false,
       sendDontHave: bool = false,
-  ): Future[void] {.gcsafe.} =
+  ): Future[void] {.async: (raw: true, raises: [CancelledError]).} =
     self.sendWantList(id, cids, priority, cancel, wantType, full, sendDontHave)
 
   proc sendWantCancellations(
       id: PeerId, addresses: seq[BlockAddress]
-  ): Future[void] {.gcsafe.} =
+  ): Future[void] {.async: (raw: true, raises: [CancelledError]).} =
     self.sendWantCancellations(id, addresses)
 
   proc sendBlocksDelivery(
       id: PeerId, blocksDelivery: seq[BlockDelivery]
-  ): Future[void] {.gcsafe.} =
+  ): Future[void] {.async: (raw: true, raises: [CancelledError]).} =
     self.sendBlocksDelivery(id, blocksDelivery)
 
-  proc sendPresence(id: PeerId, presence: seq[BlockPresence]): Future[void] {.gcsafe.} =
+  proc sendPresence(
+      id: PeerId, presence: seq[BlockPresence]
+  ): Future[void] {.async: (raw: true, raises: [CancelledError]).} =
     self.sendBlockPresence(id, presence)
 
-  proc sendAccount(id: PeerId, account: Account): Future[void] {.gcsafe.} =
+  proc sendAccount(
+      id: PeerId, account: Account
+  ): Future[void] {.async: (raw: true, raises: [CancelledError]).} =
     self.sendAccount(id, account)
 
-  proc sendPayment(id: PeerId, payment: SignedState): Future[void] {.gcsafe.} =
+  proc sendPayment(
+      id: PeerId, payment: SignedState
+  ): Future[void] {.async: (raw: true, raises: [CancelledError]).} =
     self.sendPayment(id, payment)
 
   self.request = BlockExcRequest(

codex/blockexchange/network/networkpeer.nim

@@ -7,9 +7,7 @@
 ## This file may not be copied, modified, or distributed except according to
 ## those terms.
 
-import pkg/upraises
-push:
-  {.upraises: [].}
+{.push raises: [].}
 
 import pkg/chronos
 import pkg/libp2p
@@ -18,6 +16,7 @@ import ../protobuf/blockexc
 import ../protobuf/message
 import ../../errors
 import ../../logutils
+import ../../utils/trackedfutures
 
 logScope:
   topics = "codex blockexcnetworkpeer"
@@ -25,11 +24,10 @@ logScope:
 const DefaultYieldInterval = 50.millis
 
 type
-  ConnProvider* = proc(): Future[Connection] {.gcsafe, closure.}
+  ConnProvider* =
+    proc(): Future[Connection] {.gcsafe, async: (raises: [CancelledError]).}
 
-  RPCHandler* = proc(
-    peer: NetworkPeer, msg: Message
-  ): Future[void].Raising(CatchableError) {.gcsafe.}
+  RPCHandler* = proc(peer: NetworkPeer, msg: Message) {.gcsafe, async: (raises: []).}
 
   NetworkPeer* = ref object of RootObj
     id*: PeerId
@@ -37,55 +35,60 @@ type
     sendConn: Connection
     getConn: ConnProvider
     yieldInterval*: Duration = DefaultYieldInterval
+    trackedFutures: TrackedFutures
 
-proc connected*(b: NetworkPeer): bool =
-  not (isNil(b.sendConn)) and not (b.sendConn.closed or b.sendConn.atEof)
+proc connected*(self: NetworkPeer): bool =
+  not (isNil(self.sendConn)) and not (self.sendConn.closed or self.sendConn.atEof)
 
-proc readLoop*(b: NetworkPeer, conn: Connection) {.async.} =
+proc readLoop*(self: NetworkPeer, conn: Connection) {.async: (raises: []).} =
   if isNil(conn):
-    trace "No connection to read from", peer = b.id
+    trace "No connection to read from", peer = self.id
     return
 
-  trace "Attaching read loop", peer = b.id, connId = conn.oid
+  trace "Attaching read loop", peer = self.id, connId = conn.oid
   try:
-    var nextYield = Moment.now() + b.yieldInterval
+    var nextYield = Moment.now() + self.yieldInterval
     while not conn.atEof or not conn.closed:
       if Moment.now() > nextYield:
-        nextYield = Moment.now() + b.yieldInterval
+        nextYield = Moment.now() + self.yieldInterval
         trace "Yielding in read loop",
-          peer = b.id, nextYield = nextYield, interval = b.yieldInterval
+          peer = self.id, nextYield = nextYield, interval = self.yieldInterval
         await sleepAsync(10.millis)
 
       let
         data = await conn.readLp(MaxMessageSize.int)
         msg = Message.protobufDecode(data).mapFailure().tryGet()
-      trace "Received message", peer = b.id, connId = conn.oid
-      await b.handler(b, msg)
+      trace "Received message", peer = self.id, connId = conn.oid
+      await self.handler(self, msg)
   except CancelledError:
     trace "Read loop cancelled"
   except CatchableError as err:
     warn "Exception in blockexc read loop", msg = err.msg
   finally:
-    trace "Detaching read loop", peer = b.id, connId = conn.oid
+    trace "Detaching read loop", peer = self.id, connId = conn.oid
     await conn.close()
 
-proc connect*(b: NetworkPeer): Future[Connection] {.async.} =
-  if b.connected:
-    trace "Already connected", peer = b.id, connId = b.sendConn.oid
-    return b.sendConn
+proc connect*(
+    self: NetworkPeer
+): Future[Connection] {.async: (raises: [CancelledError]).} =
+  if self.connected:
+    trace "Already connected", peer = self.id, connId = self.sendConn.oid
+    return self.sendConn
 
-  b.sendConn = await b.getConn()
-  asyncSpawn b.readLoop(b.sendConn)
-  return b.sendConn
+  self.sendConn = await self.getConn()
+  self.trackedFutures.track(self.readLoop(self.sendConn))
+  return self.sendConn
 
-proc send*(b: NetworkPeer, msg: Message) {.async.} =
-  let conn = await b.connect()
+proc send*(
+    self: NetworkPeer, msg: Message
+) {.async: (raises: [CancelledError, LPStreamError]).} =
+  let conn = await self.connect()
 
   if isNil(conn):
-    warn "Unable to get send connection for peer message not sent", peer = b.id
+    warn "Unable to get send connection for peer message not sent", peer = self.id
     return
 
-  trace "Sending message", peer = b.id, connId = conn.oid
+  trace "Sending message", peer = self.id, connId = conn.oid
   await conn.writeLp(protobufEncode(msg))
 
 func new*(
@@ -96,4 +99,9 @@ func new*(
 ): NetworkPeer =
   doAssert(not isNil(connProvider), "should supply connection provider")
 
-  NetworkPeer(id: peer, getConn: connProvider, handler: rpcHandler)
+  NetworkPeer(
+    id: peer,
+    getConn: connProvider,
+    handler: rpcHandler,
+    trackedFutures: TrackedFutures(),
+  )

codex/blockexchange/peers/peerctxstore.nim

@@ -7,16 +7,13 @@
 ## This file may not be copied, modified, or distributed except according to
 ## those terms.
 
+{.push raises: [].}
+
 import std/sequtils
 import std/tables
 import std/algorithm
 import std/sequtils
 
-import pkg/upraises
-
-push:
-  {.upraises: [].}
-
 import pkg/chronos
 import pkg/libp2p
 

codex/blockexchange/protobuf/payments.nim

@@ -1,8 +1,9 @@
+{.push raises: [].}
+
 import pkg/stew/byteutils
 import pkg/stint
 import pkg/nitro
 import pkg/questionable
-import pkg/upraises
 import ./blockexc
 
 export AccountMessage
@@ -11,9 +12,6 @@ export StateChannelUpdate
 export stint
 export nitro
 
-push:
-  {.upraises: [].}
-
 type Account* = object
   address*: EthAddress
 

codex/blockexchange/protobuf/presence.nim

@@ -1,8 +1,9 @@
+{.push raises: [].}
+
 import libp2p
 import pkg/stint
 import pkg/questionable
 import pkg/questionable/results
-import pkg/upraises
 import ./blockexc
 
 import ../../blocktype
@@ -11,9 +12,6 @@ export questionable
 export stint
 export BlockPresenceType
 
-upraises.push:
-  {.upraises: [].}
-
 type
   PresenceMessage* = blockexc.BlockPresence
   Presence* = object

codex/node.nim

@@ -223,36 +223,27 @@ proc streamSingleBlock(self: CodexNodeRef, cid: Cid): Future[?!LPStream] {.async
   without blk =? (await self.networkStore.getBlock(BlockAddress.init(cid))), err:
     return failure(err)
 
-  proc streamOneBlock(): Future[void] {.async.} =
+  proc streamOneBlock(): Future[void] {.async: (raises: []).} =
     try:
+      defer:
+        await stream.pushEof()
       await stream.pushData(blk.data)
     except CatchableError as exc:
       trace "Unable to send block", cid, exc = exc.msg
-      discard
-    finally:
-      await stream.pushEof()
 
   self.trackedFutures.track(streamOneBlock())
   LPStream(stream).success
 
 proc streamEntireDataset(
-    self: CodexNodeRef,
-    manifest: Manifest,
-    manifestCid: Cid,
-    prefetchBatch = DefaultFetchBatch,
+    self: CodexNodeRef, manifest: Manifest, manifestCid: Cid
 ): Future[?!LPStream] {.async.} =
   ## Streams the contents of the entire dataset described by the manifest.
-  ## Background jobs (erasure decoding and prefetching) will be cancelled when
-  ## the stream is closed.
   ##
   trace "Retrieving blocks from manifest", manifestCid
 
-  let stream = LPStream(StoreStream.new(self.networkStore, manifest, pad = false))
-  var jobs: seq[Future[void]]
-
   if manifest.protected:
     # Retrieve, decode and save to the local store all EС groups
-    proc erasureJob(): Future[void] {.async.} =
+    proc erasureJob(): Future[void] {.async: (raises: []).} =
       try:
         # Spawn an erasure decoding job
         let erasure = Erasure.new(
@@ -260,36 +251,25 @@ proc streamEntireDataset(
         )
         without _ =? (await erasure.decode(manifest)), error:
           error "Unable to erasure decode manifest", manifestCid, exc = error.msg
-      except CancelledError:
-        trace "Erasure job cancelled", manifestCid
       except CatchableError as exc:
         trace "Error erasure decoding manifest", manifestCid, exc = exc.msg
 
-    jobs.add(erasureJob())
+    self.trackedFutures.track(erasureJob())
 
-  proc prefetch(): Future[void] {.async.} =
+  proc prefetch() {.async: (raises: []).} =
     try:
-      if err =?
-          (await self.fetchBatched(manifest, prefetchBatch, fetchLocal = false)).errorOption:
+      if err =? (
+        await self.fetchBatched(manifest, DefaultFetchBatch, fetchLocal = false)
+      ).errorOption:
         error "Unable to fetch blocks", err = err.msg
-    except CancelledError:
-      trace "Prefetch job cancelled"
     except CatchableError as exc:
       error "Error fetching blocks", exc = exc.msg
 
-  jobs.add(prefetch())
-
-  # Monitor stream completion and cancel background jobs when done
-  proc monitorStream() {.async.} =
-    try:
-      await stream.join()
-    finally:
-      await allFutures(jobs.mapIt(it.cancelAndWait))
-
-  self.trackedFutures.track(monitorStream())
+  self.trackedFutures.track(prefetch())
 
+  # Retrieve all blocks of the dataset sequentially from the local store or network
   trace "Creating store stream for manifest", manifestCid
-  stream.success
+  LPStream(StoreStream.new(self.networkStore, manifest, pad = false)).success
 
 proc retrieve*(
     self: CodexNodeRef, cid: Cid, local: bool = true

codex/sales.nim

@@ -488,7 +488,9 @@ proc startSlotQueue(sales: Sales) =
   let slotQueue = sales.context.slotQueue
   let reservations = sales.context.reservations
 
-  slotQueue.onProcessSlot = proc(item: SlotQueueItem, done: Future[void]) {.async.} =
+  slotQueue.onProcessSlot = proc(
+      item: SlotQueueItem, done: Future[void]
+  ) {.async: (raises: []).} =
     trace "processing slot queue item", reqId = item.requestId, slotIdx = item.slotIndex
     sales.processSlot(item, done)
 

codex/sales/slotqueue.nim

@@ -3,7 +3,6 @@ import std/tables
 import pkg/chronos
 import pkg/questionable
 import pkg/questionable/results
-import pkg/upraises
 import ../errors
 import ../clock
 import ../logutils
@@ -17,8 +16,9 @@ logScope:
   topics = "marketplace slotqueue"
 
 type
-  OnProcessSlot* =
-    proc(item: SlotQueueItem, done: Future[void]): Future[void] {.gcsafe, upraises: [].}
+  OnProcessSlot* = proc(item: SlotQueueItem, done: Future[void]): Future[void] {.
+    gcsafe, async: (raises: [])
+  .}
 
   # Non-ref obj copies value when assigned, preventing accidental modification
   # of values which could cause an incorrect order (eg
@@ -26,7 +26,7 @@ type
   # but the heap invariant would no longer be honoured. When non-ref, the
   # compiler can ensure that statement will fail).
   SlotQueueWorker = object
-    doneProcessing*: Future[void]
+    doneProcessing*: Future[void].Raising([])
 
   SlotQueueItem* = object
     requestId: RequestId
@@ -129,7 +129,17 @@ proc new*(
   # `newAsyncQueue` procedure
 
 proc init(_: type SlotQueueWorker): SlotQueueWorker =
-  SlotQueueWorker(doneProcessing: newFuture[void]("slotqueue.worker.processing"))
+  let workerFut = Future[void].Raising([]).init(
+      "slotqueue.worker.processing", {FutureFlag.OwnCancelSchedule}
+    )
+
+  workerFut.cancelCallback = proc(data: pointer) {.raises: [].} =
+    # this is equivalent to try: ... except CatchableError: ...
+    if not workerFut.finished:
+      workerFut.complete()
+    trace "Cancelling `SlotQueue` worker processing future"
+
+  SlotQueueWorker(doneProcessing: workerFut)
 
 proc init*(
     _: type SlotQueueItem,
@@ -430,7 +440,6 @@ proc run(self: SlotQueue) {.async: (raises: []).} =
 
       let fut = self.dispatch(worker, item)
       self.trackedFutures.track(fut)
-      asyncSpawn fut
 
       await sleepAsync(1.millis) # poll
     except CancelledError:
@@ -458,7 +467,6 @@ proc start*(self: SlotQueue) =
 
   let fut = self.run()
   self.trackedFutures.track(fut)
-  asyncSpawn fut
 
 proc stop*(self: SlotQueue) {.async.} =
   if not self.running:

codex/utils/trackedfutures.nim

@@ -5,9 +5,11 @@ import ../logutils
 
 {.push raises: [].}
 
-type TrackedFutures* = ref object
-  futures: Table[uint, FutureBase]
-  cancelling: bool
+type
+  TrackedFuture = Future[void].Raising([])
+  TrackedFutures* = ref object
+    futures: Table[uint, TrackedFuture]
+    cancelling: bool
 
 logScope:
   topics = "trackable futures"
@@ -15,15 +17,15 @@ logScope:
 proc len*(self: TrackedFutures): int =
   self.futures.len
 
-proc removeFuture(self: TrackedFutures, future: FutureBase) =
+proc removeFuture(self: TrackedFutures, future: TrackedFuture) =
   if not self.cancelling and not future.isNil:
     self.futures.del(future.id)
 
-proc track*[T](self: TrackedFutures, fut: Future[T]) =
+proc track*(self: TrackedFutures, fut: TrackedFuture) =
   if self.cancelling:
     return
 
-  self.futures[fut.id] = FutureBase(fut)
+  self.futures[fut.id] = fut
 
   proc cb(udata: pointer) =
     self.removeFuture(fut)
@@ -33,13 +35,8 @@ proc track*[T](self: TrackedFutures, fut: Future[T]) =
 proc cancelTracked*(self: TrackedFutures) {.async: (raises: []).} =
   self.cancelling = true
 
-  trace "cancelling tracked futures"
-
-  var cancellations: seq[FutureBase]
-  for future in self.futures.values:
-    if not future.isNil and not future.finished:
-      cancellations.add future.cancelAndWait()
-
+  trace "cancelling tracked futures", len = self.futures.len
+  let cancellations = self.futures.values.toSeq.mapIt(it.cancelAndWait())
   await noCancel allFutures cancellations
 
   self.futures.clear()

tests/asynctest.nim

@@ -1,3 +1,3 @@
-import pkg/asynctest/chronos/unittest
+import pkg/asynctest/chronos/unittest2
 
-export unittest
+export unittest2

tests/codex/blockexchange/engine/testengine.nim

@@ -22,7 +22,7 @@ import ../../examples
 
 const NopSendWantCancellationsProc = proc(
     id: PeerId, addresses: seq[BlockAddress]
-) {.gcsafe, async.} =
+) {.async: (raises: [CancelledError]).} =
   discard
 
 asyncchecksuite "NetworkStore engine basic":
@@ -66,20 +66,17 @@ asyncchecksuite "NetworkStore engine basic":
         wantType: WantType = WantType.WantHave,
         full: bool = false,
         sendDontHave: bool = false,
-    ) {.gcsafe, async.} =
+    ) {.async: (raises: [CancelledError]).} =
       check addresses.mapIt($it.cidOrTreeCid).sorted == blocks.mapIt($it.cid).sorted
       done.complete()
 
     let
       network = BlockExcNetwork(request: BlockExcRequest(sendWantList: sendWantList))
-
       localStore = CacheStore.new(blocks.mapIt(it))
       discovery = DiscoveryEngine.new(
         localStore, peerStore, network, blockDiscovery, pendingBlocks
       )
-
       advertiser = Advertiser.new(localStore, blockDiscovery)
-
       engine = BlockExcEngine.new(
         localStore, wallet, network, discovery, advertiser, peerStore, pendingBlocks
       )
@@ -93,7 +90,9 @@ asyncchecksuite "NetworkStore engine basic":
   test "Should send account to new peers":
     let pricing = Pricing.example
 
-    proc sendAccount(peer: PeerId, account: Account) {.gcsafe, async.} =
+    proc sendAccount(
+        peer: PeerId, account: Account
+    ) {.async: (raises: [CancelledError]).} =
       check account.address == pricing.address
       done.complete()
 
@@ -186,7 +185,9 @@ asyncchecksuite "NetworkStore engine handlers":
       done = newFuture[void]()
       wantList = makeWantList(blocks.mapIt(it.cid))
 
-    proc sendPresence(peerId: PeerId, presence: seq[BlockPresence]) {.gcsafe, async.} =
+    proc sendPresence(
+        peerId: PeerId, presence: seq[BlockPresence]
+    ) {.async: (raises: [CancelledError]).} =
       check presence.mapIt(it.address) == wantList.entries.mapIt(it.address)
       done.complete()
 
@@ -203,7 +204,9 @@ asyncchecksuite "NetworkStore engine handlers":
       done = newFuture[void]()
       wantList = makeWantList(blocks.mapIt(it.cid), sendDontHave = true)
 
-    proc sendPresence(peerId: PeerId, presence: seq[BlockPresence]) {.gcsafe, async.} =
+    proc sendPresence(
+        peerId: PeerId, presence: seq[BlockPresence]
+    ) {.async: (raises: [CancelledError]).} =
       check presence.mapIt(it.address) == wantList.entries.mapIt(it.address)
       for p in presence:
         check:
@@ -222,7 +225,9 @@ asyncchecksuite "NetworkStore engine handlers":
       done = newFuture[void]()
       wantList = makeWantList(blocks.mapIt(it.cid), sendDontHave = true)
 
-    proc sendPresence(peerId: PeerId, presence: seq[BlockPresence]) {.gcsafe, async.} =
+    proc sendPresence(
+        peerId: PeerId, presence: seq[BlockPresence]
+    ) {.async: (raises: [CancelledError]).} =
       for p in presence:
         if p.address.cidOrTreeCid != blocks[0].cid and
             p.address.cidOrTreeCid != blocks[1].cid:
@@ -271,14 +276,22 @@ asyncchecksuite "NetworkStore engine handlers":
 
     engine.network = BlockExcNetwork(
       request: BlockExcRequest(
-        sendPayment: proc(receiver: PeerId, payment: SignedState) {.gcsafe, async.} =
+        sendPayment: proc(
+            receiver: PeerId, payment: SignedState
+        ) {.async: (raises: [CancelledError]).} =
           let
-            amount = blocks.mapIt(peerContext.blocks[it.address].price).foldl(a + b)
+            amount = blocks
+              .mapIt(
+                (peerContext.blocks[it.address].catch.expect("address should exist")).price
+              )
+              .foldl(a + b)
 
             balances = !payment.state.outcome.balances(Asset)
 
           check receiver == peerId
-          check balances[account.address.toDestination] == amount
+          check balances[account.address.toDestination].catch.expect(
+            "toDestination address should exist"
+          ) == amount
           done.complete(),
 
         # Install NOP for want list cancellations so they don't cause a crash
@@ -303,7 +316,7 @@ asyncchecksuite "NetworkStore engine handlers":
         wantType: WantType = WantType.WantHave,
         full: bool = false,
         sendDontHave: bool = false,
-    ) {.gcsafe, async.} =
+    ) {.async: (raises: [CancelledError]).} =
       engine.pendingBlocks.resolve(
         blocks.filterIt(it.address in addresses).mapIt(
           BlockDelivery(blk: it, address: it.address)
@@ -340,9 +353,9 @@ asyncchecksuite "NetworkStore engine handlers":
 
     proc sendWantCancellations(
         id: PeerId, addresses: seq[BlockAddress]
-    ) {.gcsafe, async.} =
+    ) {.async: (raises: [CancelledError]).} =
       for address in addresses:
-        cancellations[address].complete()
+        cancellations[address].catch.expect("address should exist").complete()
 
     engine.network = BlockExcNetwork(
       request: BlockExcRequest(sendWantCancellations: sendWantCancellations)
@@ -416,7 +429,7 @@ asyncchecksuite "Block Download":
         wantType: WantType = WantType.WantHave,
         full: bool = false,
         sendDontHave: bool = false,
-    ) {.gcsafe, async.} =
+    ) {.async: (raises: [CancelledError]).} =
       check wantType == WantHave
       check not engine.pendingBlocks.isInFlight(address)
       check engine.pendingBlocks.retries(address) == retries
@@ -433,7 +446,7 @@ asyncchecksuite "Block Download":
       discard (await pending).tryGet()
 
   test "Should retry block request":
-    let
+    var
       address = BlockAddress.init(blocks[0].cid)
       steps = newAsyncEvent()
 
@@ -445,7 +458,7 @@ asyncchecksuite "Block Download":
         wantType: WantType = WantType.WantHave,
         full: bool = false,
         sendDontHave: bool = false,
-    ) {.gcsafe, async.} =
+    ) {.async: (raises: [CancelledError]).} =
       case wantType
       of WantHave:
         check engine.pendingBlocks.isInFlight(address) == false
@@ -467,7 +480,7 @@ asyncchecksuite "Block Download":
     let pending = engine.requestBlock(address)
     await steps.wait()
 
-    # add blocks presence
+    # add blocks precense
     peerCtx.blocks = blocks.mapIt(
       (it.address, Presence(address: it.address, have: true, price: UInt256.example))
     ).toTable
@@ -493,7 +506,7 @@ asyncchecksuite "Block Download":
         wantType: WantType = WantType.WantHave,
         full: bool = false,
         sendDontHave: bool = false,
-    ) {.gcsafe, async.} =
+    ) {.async: (raises: [CancelledError]).} =
       done.complete()
 
     engine.pendingBlocks.blockRetries = 10
@@ -573,7 +586,7 @@ asyncchecksuite "Task Handler":
   test "Should send want-blocks in priority order":
     proc sendBlocksDelivery(
         id: PeerId, blocksDelivery: seq[BlockDelivery]
-    ) {.gcsafe, async.} =
+    ) {.async: (raises: [CancelledError]).} =
       check blocksDelivery.len == 2
       check:
         blocksDelivery[1].address == blocks[0].address
@@ -610,7 +623,7 @@ asyncchecksuite "Task Handler":
   test "Should set in-flight for outgoing blocks":
     proc sendBlocksDelivery(
         id: PeerId, blocksDelivery: seq[BlockDelivery]
-    ) {.gcsafe, async.} =
+    ) {.async: (raises: [CancelledError]).} =
       check peersCtx[0].peerWants[0].inFlight
 
     for blk in blocks:
@@ -649,7 +662,9 @@ asyncchecksuite "Task Handler":
     let missing = @[Block.new("missing".toBytes).tryGet()]
     let price = (!engine.pricing).price
 
-    proc sendPresence(id: PeerId, presence: seq[BlockPresence]) {.gcsafe, async.} =
+    proc sendPresence(
+        id: PeerId, presence: seq[BlockPresence]
+    ) {.async: (raises: [CancelledError]).} =
       check presence.mapIt(!Presence.init(it)) ==
         @[
           Presence(address: present[0].address, have: true, price: price),

tests/codex/blockexchange/engine/testpayments.nim

@@ -1,10 +1,10 @@
-import std/unittest
+import pkg/unittest2
 
 import pkg/codex/stores
 import ../../examples
 import ../../helpers
 
-checksuite "engine payments":
+suite "engine payments":
   let address = EthAddress.example
   let amount = 42.u256
 

tests/codex/blockexchange/protobuf/testpayments.nim

@@ -6,7 +6,7 @@ import ../../../asynctest
 import ../../examples
 import ../../helpers
 
-checksuite "account protobuf messages":
+suite "account protobuf messages":
   let account = Account(address: EthAddress.example)
   let message = AccountMessage.init(account)
 
@@ -21,7 +21,7 @@ checksuite "account protobuf messages":
     incorrect.address.del(0)
     check Account.init(incorrect).isNone
 
-checksuite "channel update messages":
+suite "channel update messages":
   let state = SignedState.example
   let update = StateChannelUpdate.init(state)
 

tests/codex/blockexchange/protobuf/testpresence.nim

@@ -6,7 +6,7 @@ import ../../../asynctest
 import ../../examples
 import ../../helpers
 
-checksuite "block presence protobuf messages":
+suite "block presence protobuf messages":
   let
     cid = Cid.example
     address = BlockAddress(leaf: false, cid: cid)

tests/codex/blockexchange/testnetwork.nim

@@ -26,7 +26,7 @@ asyncchecksuite "Network - Handlers":
     blocks: seq[bt.Block]
     done: Future[void]
 
-  proc getConn(): Future[Connection] {.async.} =
+  proc getConn(): Future[Connection] {.async: (raises: [CancelledError]).} =
     return Connection(buffer)
 
   setup:
@@ -45,7 +45,7 @@ asyncchecksuite "Network - Handlers":
     discard await networkPeer.connect()
 
   test "Want List handler":
-    proc wantListHandler(peer: PeerId, wantList: WantList) {.gcsafe, async.} =
+    proc wantListHandler(peer: PeerId, wantList: WantList) {.async: (raises: []).} =
       # check that we got the correct amount of entries
       check wantList.entries.len == 4
 
@@ -72,7 +72,7 @@ asyncchecksuite "Network - Handlers":
   test "Blocks Handler":
     proc blocksDeliveryHandler(
         peer: PeerId, blocksDelivery: seq[BlockDelivery]
-    ) {.gcsafe, async.} =
+    ) {.async: (raises: []).} =
       check blocks == blocksDelivery.mapIt(it.blk)
       done.complete()
 
@@ -85,7 +85,9 @@ asyncchecksuite "Network - Handlers":
     await done.wait(500.millis)
 
   test "Presence Handler":
-    proc presenceHandler(peer: PeerId, presence: seq[BlockPresence]) {.gcsafe, async.} =
+    proc presenceHandler(
+        peer: PeerId, presence: seq[BlockPresence]
+    ) {.async: (raises: []).} =
       for b in blocks:
         check:
           b.address in presence
@@ -105,7 +107,7 @@ asyncchecksuite "Network - Handlers":
   test "Handles account messages":
     let account = Account(address: EthAddress.example)
 
-    proc handleAccount(peer: PeerId, received: Account) {.gcsafe, async.} =
+    proc handleAccount(peer: PeerId, received: Account) {.async: (raises: []).} =
       check received == account
       done.complete()
 
@@ -119,7 +121,7 @@ asyncchecksuite "Network - Handlers":
   test "Handles payment messages":
     let payment = SignedState.example
 
-    proc handlePayment(peer: PeerId, received: SignedState) {.gcsafe, async.} =
+    proc handlePayment(peer: PeerId, received: SignedState) {.async: (raises: []).} =
       check received == payment
       done.complete()
 
@@ -165,7 +167,7 @@ asyncchecksuite "Network - Senders":
     await allFuturesThrowing(switch1.stop(), switch2.stop())
 
   test "Send want list":
-    proc wantListHandler(peer: PeerId, wantList: WantList) {.gcsafe, async.} =
+    proc wantListHandler(peer: PeerId, wantList: WantList) {.async: (raises: []).} =
       # check that we got the correct amount of entries
       check wantList.entries.len == 4
 
@@ -195,7 +197,7 @@ asyncchecksuite "Network - Senders":
   test "send blocks":
     proc blocksDeliveryHandler(
         peer: PeerId, blocksDelivery: seq[BlockDelivery]
-    ) {.gcsafe, async.} =
+    ) {.async: (raises: []).} =
       check blocks == blocksDelivery.mapIt(it.blk)
       done.complete()
 
@@ -207,7 +209,9 @@ asyncchecksuite "Network - Senders":
     await done.wait(500.millis)
 
   test "send presence":
-    proc presenceHandler(peer: PeerId, precense: seq[BlockPresence]) {.gcsafe, async.} =
+    proc presenceHandler(
+        peer: PeerId, precense: seq[BlockPresence]
+    ) {.async: (raises: []).} =
       for b in blocks:
         check:
           b.address in precense
@@ -226,7 +230,7 @@ asyncchecksuite "Network - Senders":
   test "send account":
     let account = Account(address: EthAddress.example)
 
-    proc handleAccount(peer: PeerId, received: Account) {.gcsafe, async.} =
+    proc handleAccount(peer: PeerId, received: Account) {.async: (raises: []).} =
       check received == account
       done.complete()
 
@@ -238,7 +242,7 @@ asyncchecksuite "Network - Senders":
   test "send payment":
     let payment = SignedState.example
 
-    proc handlePayment(peer: PeerId, received: SignedState) {.gcsafe, async.} =
+    proc handlePayment(peer: PeerId, received: SignedState) {.async: (raises: []).} =
       check received == payment
       done.complete()
 
@@ -276,7 +280,7 @@ asyncchecksuite "Network - Test Limits":
     let account = Account(address: EthAddress.example)
     network2.handlers.onAccount = proc(
         peer: PeerId, received: Account
-    ) {.gcsafe, async.} =
+    ) {.async: (raises: []).} =
       check false
 
     let fut = network1.send(

tests/codex/blockexchange/testpeerctxstore.nim

@@ -1,7 +1,7 @@
 import std/sugar
 import std/sequtils
-import std/unittest
 
+import pkg/unittest2
 import pkg/libp2p
 
 import pkg/codex/blockexchange/peers
@@ -11,7 +11,7 @@ import pkg/codex/blockexchange/protobuf/presence
 import ../helpers
 import ../examples
 
-checksuite "Peer Context Store":
+suite "Peer Context Store":
   var
     store: PeerCtxStore
     peerCtx: BlockExcPeerCtx
@@ -31,7 +31,7 @@ checksuite "Peer Context Store":
   test "Should get peer":
     check store.get(peerCtx.id) == peerCtx
 
-checksuite "Peer Context Store Peer Selection":
+suite "Peer Context Store Peer Selection":
   var
     store: PeerCtxStore
     peerCtxs: seq[BlockExcPeerCtx]

tests/codex/blockexchange/testpendingblocks.nim

@@ -10,7 +10,7 @@ import pkg/codex/blockexchange
 import ../helpers
 import ../../asynctest
 
-checksuite "Pending Blocks":
+suite "Pending Blocks":
   test "Should add want handle":
     let
       pendingBlocks = PendingBlocksManager.new()

tests/codex/merkletree/generictreetests.nim

@@ -1,4 +1,4 @@
-import std/unittest
+import pkg/unittest2
 
 import pkg/codex/merkletree
 

tests/codex/merkletree/testcodexcoders.nim

@@ -1,4 +1,4 @@
-import std/unittest
+import pkg/unittest2
 
 import pkg/questionable/results
 import pkg/stew/byteutils
@@ -18,7 +18,7 @@ const data = [
   "00000000000000000000000000000009".toBytes, "00000000000000000000000000000010".toBytes,
 ]
 
-checksuite "merkletree - coders":
+suite "merkletree - coders":
   test "encoding and decoding a tree yields the same tree":
     let
       tree = CodexTree.init(Sha256HashCodec, data).tryGet()

tests/codex/merkletree/testcodextree.nim

@@ -1,6 +1,6 @@
-import std/unittest
 import std/sequtils
 
+import pkg/unittest2
 import pkg/questionable/results
 import pkg/stew/byteutils
 import pkg/libp2p

tests/codex/merkletree/testmerkledigest.nim

@@ -1,7 +1,7 @@
-import std/unittest
 import std/sequtils
 import std/random
 
+import pkg/unittest2
 import pkg/poseidon2
 import pkg/poseidon2/sponge
 

tests/codex/merkletree/testposeidon2tree.nim

@@ -1,6 +1,6 @@
-import std/unittest
 import std/sequtils
 
+import pkg/unittest2
 import pkg/poseidon2
 import pkg/poseidon2/io
 import pkg/questionable/results

tests/codex/sales/states/testdownloading.nim

@@ -1,4 +1,4 @@
-import std/unittest
+import pkg/unittest2
 import pkg/questionable
 import pkg/codex/contracts/requests
 import pkg/codex/sales/states/cancelled
@@ -8,7 +8,7 @@ import pkg/codex/sales/states/filled
 import ../../examples
 import ../../helpers
 
-checksuite "sales state 'downloading'":
+suite "sales state 'downloading'":
   let request = StorageRequest.example
   let slotIndex = request.ask.slots div 2
   var state: SaleDownloading

tests/codex/sales/states/testfilled.nim

@@ -14,7 +14,7 @@ import ../../helpers/mockmarket
 import ../../examples
 import ../../helpers
 
-checksuite "sales state 'filled'":
+suite "sales state 'filled'":
   let request = StorageRequest.example
   let slotIndex = request.ask.slots div 2
 

tests/codex/sales/states/testfilling.nim

@@ -1,4 +1,4 @@
-import std/unittest
+import pkg/unittest2
 import pkg/questionable
 import pkg/codex/contracts/requests
 import pkg/codex/sales/states/filling
@@ -7,7 +7,7 @@ import pkg/codex/sales/states/failed
 import ../../examples
 import ../../helpers
 
-checksuite "sales state 'filling'":
+suite "sales state 'filling'":
   let request = StorageRequest.example
   let slotIndex = request.ask.slots div 2
   var state: SaleFilling

tests/codex/sales/states/testunknown.nim

@@ -14,7 +14,7 @@ import ../../helpers/mockmarket
 import ../../examples
 import ../../helpers
 
-checksuite "sales state 'unknown'":
+suite "sales state 'unknown'":
   let request = StorageRequest.example
   let slotIndex = request.ask.slots div 2
   let slotId = slotId(request.id, slotIndex)

tests/codex/sales/testsales.nim

@@ -236,10 +236,17 @@ asyncchecksuite "Sales":
     return true
 
   proc addRequestToSaturatedQueue(): Future[StorageRequest] {.async.} =
-    queue.onProcessSlot = proc(item: SlotQueueItem, done: Future[void]) {.async.} =
-      await sleepAsync(10.millis)
-      itemsProcessed.add item
-      done.complete()
+    queue.onProcessSlot = proc(
+        item: SlotQueueItem, done: Future[void]
+    ) {.async: (raises: []).} =
+      try:
+        await sleepAsync(10.millis)
+        itemsProcessed.add item
+      except CancelledError as exc:
+        checkpoint(exc.msg)
+      finally:
+        if not done.finished:
+          done.complete()
 
     var request1 = StorageRequest.example
     request1.ask.collateralPerByte = request.ask.collateralPerByte + 1
@@ -261,9 +268,12 @@ asyncchecksuite "Sales":
     waitFor run()
 
   test "processes all request's slots once StorageRequested emitted":
-    queue.onProcessSlot = proc(item: SlotQueueItem, done: Future[void]) {.async.} =
+    queue.onProcessSlot = proc(
+        item: SlotQueueItem, done: Future[void]
+    ) {.async: (raises: []).} =
       itemsProcessed.add item
-      done.complete()
+      if not done.finished:
+        done.complete()
     createAvailability()
     await market.requestStorage(request)
     let items = SlotQueueItem.init(request)
@@ -297,9 +307,12 @@ asyncchecksuite "Sales":
     check always (not itemsProcessed.contains(expected))
 
   test "adds slot index to slot queue once SlotFreed emitted":
-    queue.onProcessSlot = proc(item: SlotQueueItem, done: Future[void]) {.async.} =
+    queue.onProcessSlot = proc(
+        item: SlotQueueItem, done: Future[void]
+    ) {.async: (raises: []).} =
       itemsProcessed.add item
-      done.complete()
+      if not done.finished:
+        done.complete()
 
     createAvailability()
     market.requested.add request # "contract" must be able to return request

tests/codex/sales/testslotqueue.nim

@@ -50,12 +50,19 @@ suite "Slot queue start/stop":
 suite "Slot queue workers":
   var queue: SlotQueue
 
-  proc onProcessSlot(item: SlotQueueItem, doneProcessing: Future[void]) {.async.} =
-    await sleepAsync(1000.millis)
+  proc onProcessSlot(
+      item: SlotQueueItem, doneProcessing: Future[void]
+  ) {.async: (raises: []).} =
     # this is not illustrative of the realistic scenario as the
     # `doneProcessing` future would be passed to another context before being
     # completed and therefore is not as simple as making the callback async
-    doneProcessing.complete()
+    try:
+      await sleepAsync(1000.millis)
+    except CatchableError as exc:
+      checkpoint(exc.msg)
+    finally:
+      if not doneProcessing.finished:
+        doneProcessing.complete()
 
   setup:
     let request = StorageRequest.example
@@ -89,9 +96,14 @@ suite "Slot queue workers":
     check eventually queue.activeWorkers == 3
 
   test "discards workers once processing completed":
-    proc processSlot(item: SlotQueueItem, done: Future[void]) {.async.} =
-      await sleepAsync(1.millis)
-      done.complete()
+    proc processSlot(item: SlotQueueItem, done: Future[void]) {.async: (raises: []).} =
+      try:
+        await sleepAsync(1.millis)
+      except CatchableError as exc:
+        checkpoint(exc.msg)
+      finally:
+        if not done.finished:
+          done.complete()
 
     queue.onProcessSlot = processSlot
 
@@ -114,11 +126,19 @@ suite "Slot queue":
 
   proc newSlotQueue(maxSize, maxWorkers: int, processSlotDelay = 1.millis) =
     queue = SlotQueue.new(maxWorkers, maxSize.uint16)
-    queue.onProcessSlot = proc(item: SlotQueueItem, done: Future[void]) {.async.} =
-      await sleepAsync(processSlotDelay)
-      onProcessSlotCalled = true
-      onProcessSlotCalledWith.add (item.requestId, item.slotIndex)
-      done.complete()
+    queue.onProcessSlot = proc(
+        item: SlotQueueItem, done: Future[void]
+    ) {.async: (raises: []).} =
+      try:
+        await sleepAsync(processSlotDelay)
+      except CatchableError as exc:
+        checkpoint(exc.msg)
+      finally:
+        onProcessSlotCalled = true
+        onProcessSlotCalledWith.add (item.requestId, item.slotIndex)
+        if not done.finished:
+          done.complete()
+
     queue.start()
 
   setup:

tests/codex/stores/repostore/testcoders.nim

@@ -1,6 +1,6 @@
-import std/unittest
 import std/random
 
+import pkg/unittest2
 import pkg/stew/objects
 import pkg/questionable
 import pkg/questionable/results
@@ -11,7 +11,7 @@ import pkg/codex/stores/repostore/coders
 
 import ../../helpers
 
-checksuite "Test coders":
+suite "Test coders":
   proc rand(T: type NBytes): T =
     rand(Natural).NBytes
 

tests/codex/stores/testcachestore.nim

@@ -11,7 +11,7 @@ import ./commonstoretests
 import ../../asynctest
 import ../helpers
 
-checksuite "Cache Store":
+suite "Cache Store":
   var
     newBlock, newBlock1, newBlock2, newBlock3: Block
     store: CacheStore

tests/codex/stores/testkeyutils.nim

@@ -36,7 +36,7 @@ proc createManifestCid(): ?!Cid =
   let cid = ?Cid.init(version, codec, hash).mapFailure
   return success cid
 
-checksuite "KeyUtils":
+suite "KeyUtils":
   test "makePrefixKey should create block key":
     let length = 6
     let cid = Cid.example

tests/codex/stores/testmaintenance.nim

@@ -21,7 +21,7 @@ import ../examples
 
 import codex/stores/maintenance
 
-checksuite "BlockMaintainer":
+suite "BlockMaintainer":
   var mockRepoStore: MockRepoStore
   var interval: Duration
   var mockTimer: MockTimer

tests/codex/stores/testrepostore.nim

@@ -24,7 +24,7 @@ import ../helpers/mockclock
 import ../examples
 import ./commonstoretests
 
-checksuite "Test RepoStore start/stop":
+suite "Test RepoStore start/stop":
   var
     repoDs: Datastore
     metaDs: Datastore

tests/codex/testasyncheapqueue.nim

@@ -22,7 +22,7 @@ proc toSortedSeq[T](h: AsyncHeapQueue[T], queueType = QueueType.Min): seq[T] =
   while tmp.len > 0:
     result.add(popNoWait(tmp).tryGet())
 
-checksuite "Synchronous tests":
+suite "Synchronous tests":
   test "Test pushNoWait - Min":
     var heap = newAsyncHeapQueue[int]()
     let data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]

tests/codex/testclock.nim

@@ -1,9 +1,9 @@
-import std/unittest
+import pkg/unittest2
 
 import codex/clock
 import ./helpers
 
-checksuite "Clock":
+suite "Clock":
   proc testConversion(seconds: SecondsSince1970) =
     let asBytes = seconds.toBytes
 

tests/codex/testlogutils.nim

@@ -1,6 +1,7 @@
 import std/options
 import std/strutils
-import std/unittest
+
+import pkg/unittest2
 import pkg/codex/blocktype
 import pkg/codex/conf
 import pkg/codex/contracts/requests

tests/codex/testmanifest.nim

@@ -13,7 +13,7 @@ import ../asynctest
 import ./helpers
 import ./examples
 
-checksuite "Manifest":
+suite "Manifest":
   let
     manifest =
       Manifest.new(treeCid = Cid.example, blockSize = 1.MiBs, datasetSize = 100.MiBs)

tests/codex/testpurchasing.nim

@@ -116,7 +116,7 @@ asyncchecksuite "Purchasing":
       await purchase.wait()
     check market.withdrawn == @[request.id]
 
-checksuite "Purchasing state machine":
+suite "Purchasing state machine":
   var purchasing: Purchasing
   var market: MockMarket
   var clock: MockClock

tests/codex/testsystemclock.nim

@@ -1,10 +1,10 @@
 import std/times
-import std/unittest
 
-import codex/systemclock
+import pkg/unittest2
+import pkg/codex/systemclock
 import ./helpers
 
-checksuite "SystemClock":
+suite "SystemClock":
   test "Should get now":
     let clock = SystemClock.new()
 

tests/codex/utils/testiter.nim

@@ -7,7 +7,7 @@ import pkg/codex/utils/iter
 import ../../asynctest
 import ../helpers
 
-checksuite "Test Iter":
+suite "Test Iter":
   test "Should be finished":
     let iter = Iter[int].empty()
 

tests/codex/utils/testkeyutils.nim

@@ -1,12 +1,14 @@
-import std/unittest
 import std/os
-import codex/utils/keyutils
+
+import pkg/unittest2
+import pkg/codex/utils/keyutils
+
 import ../helpers
 
 when defined(windows):
   import stew/windows/acl
 
-checksuite "keyutils":
+suite "keyutils":
   let path = getTempDir() / "CodexTest"
 
   setup:

tests/codex/utils/testoptions.nim

@@ -1,8 +1,9 @@
-import std/unittest
-import codex/utils/options
+import pkg/unittest2
+import pkg/codex/utils/options
+
 import ../helpers
 
-checksuite "optional casts":
+suite "optional casts":
   test "casting value to same type works":
     check 42 as int == some 42
 
@@ -31,7 +32,7 @@ checksuite "optional casts":
     check 42.some as string == string.none
     check int.none as int == int.none
 
-checksuite "Optionalize":
+suite "Optionalize":
   test "does not except non-object types":
     static:
       doAssert not compiles(Optionalize(int))

tests/codex/utils/testtrackedfutures.nim

@@ -17,44 +17,60 @@ asyncchecksuite "tracked futures":
     check module.trackedFutures.len == 0
 
   test "tracks unfinished futures":
-    let fut = newFuture[void]("test")
+    let fut = Future[void].Raising([]).init("test", {FutureFlag.OwnCancelSchedule})
     module.trackedFutures.track(fut)
     check module.trackedFutures.len == 1
 
   test "does not track completed futures":
-    let fut = newFuture[void]("test")
+    let fut = Future[void].Raising([]).init("test", {FutureFlag.OwnCancelSchedule})
     fut.complete()
     module.trackedFutures.track(fut)
     check eventually module.trackedFutures.len == 0
 
-  test "does not track failed futures":
-    let fut = newFuture[void]("test")
-    fut.fail((ref CatchableError)(msg: "some error"))
-    module.trackedFutures.track(fut)
-    check eventually module.trackedFutures.len == 0
+  # test "does not track failed futures":
+  #   let fut = Future[void].Raising([]).init("test", {FutureFlag.OwnCancelSchedule})
+  #   # fut.fail((ref CatchableError)(msg: "some error"))
+  #   fut.fail(some error)
+  #   module.trackedFutures.track(fut)
+  #   check eventually module.trackedFutures.len == 0
 
   test "does not track cancelled futures":
-    let fut = newFuture[void]("test")
+    let fut = Future[void].Raising([]).init("test", {FutureFlag.OwnCancelSchedule})
+    fut.cancelCallback = proc(data: pointer) =
+      fut.cancelAndSchedule() # manually schedule the cancel
+
     await fut.cancelAndWait()
     module.trackedFutures.track(fut)
     check eventually module.trackedFutures.len == 0
 
   test "removes tracked future when finished":
-    let fut = newFuture[void]("test")
+    let fut = Future[void].Raising([]).init("test", {FutureFlag.OwnCancelSchedule})
     module.trackedFutures.track(fut)
     fut.complete()
     check eventually module.trackedFutures.len == 0
 
   test "removes tracked future when cancelled":
-    let fut = newFuture[void]("test")
+    let fut = Future[void].Raising([]).init("test", {FutureFlag.OwnCancelSchedule})
+    fut.cancelCallback = proc(data: pointer) =
+      fut.cancelAndSchedule() # manually schedule the cancel
+
     module.trackedFutures.track(fut)
     await fut.cancelAndWait()
     check eventually module.trackedFutures.len == 0
 
   test "cancels and removes all tracked futures":
-    let fut1 = newFuture[void]("test1")
-    let fut2 = newFuture[void]("test2")
-    let fut3 = newFuture[void]("test3")
+    let fut1 = Future[void].Raising([]).init("test1", {FutureFlag.OwnCancelSchedule})
+    fut1.cancelCallback = proc(data: pointer) =
+      fut1.cancelAndSchedule() # manually schedule the cancel
+
+    let fut2 = Future[void].Raising([]).init("test2", {FutureFlag.OwnCancelSchedule})
+    fut2.cancelCallback = proc(data: pointer) =
+      fut2.cancelAndSchedule() # manually schedule the cancel
+
+    let fut3 = Future[void].Raising([]).init("test3", {FutureFlag.OwnCancelSchedule})
+    fut3.cancelCallback = proc(data: pointer) =
+      fut3.cancelAndSchedule() # manually schedule the cancel
+
     module.trackedFutures.track(fut1)
     module.trackedFutures.track(fut2)
     module.trackedFutures.track(fut3)

tests/codex/utils/testutils.nim

@@ -1,4 +1,4 @@
-import std/unittest
+import pkg/unittest2
 
 import pkg/codex/utils
 

tests/helpers/trackers.nim

@@ -1,5 +1,5 @@
 import pkg/codex/streams/storestream
-import std/unittest
+import pkg/unittest2
 
 # From lip2p/tests/helpers
 const trackerNames = [StoreStreamTrackerName]