contracts: cancelled event is no longer emitted

codex/contracts/market.nim

@@ -435,35 +435,6 @@ method subscribeFulfillment(
     let subscription = await market.contract.subscribe(RequestFulfilled, onEvent)
     return OnChainMarketSubscription(eventSubscription: subscription)
 
-method subscribeRequestCancelled*(
-    market: OnChainMarket, callback: OnRequestCancelled
-): Future[MarketSubscription] {.async.} =
-  proc onEvent(eventResult: ?!RequestCancelled) {.upraises: [].} =
-    without event =? eventResult, eventErr:
-      error "There was an error in RequestCancelled subscription", msg = eventErr.msg
-      return
-
-    callback(event.requestId)
-
-  convertEthersError("Failed to subscribe to RequestCancelled events"):
-    let subscription = await market.contract.subscribe(RequestCancelled, onEvent)
-    return OnChainMarketSubscription(eventSubscription: subscription)
-
-method subscribeRequestCancelled*(
-    market: OnChainMarket, requestId: RequestId, callback: OnRequestCancelled
-): Future[MarketSubscription] {.async.} =
-  proc onEvent(eventResult: ?!RequestCancelled) {.upraises: [].} =
-    without event =? eventResult, eventErr:
-      error "There was an error in RequestCancelled subscription", msg = eventErr.msg
-      return
-
-    if event.requestId == requestId:
-      callback(event.requestId)
-
-  convertEthersError("Failed to subscribe to RequestCancelled events"):
-    let subscription = await market.contract.subscribe(RequestCancelled, onEvent)
-    return OnChainMarketSubscription(eventSubscription: subscription)
-
 method subscribeRequestFailed*(
     market: OnChainMarket, callback: OnRequestFailed
 ): Future[MarketSubscription] {.async.} =

codex/market.nim

@@ -28,7 +28,6 @@ type
   OnSlotFreed* = proc(requestId: RequestId, slotIndex: uint64) {.gcsafe, upraises: [].}
   OnSlotReservationsFull* =
     proc(requestId: RequestId, slotIndex: uint64) {.gcsafe, upraises: [].}
-  OnRequestCancelled* = proc(requestId: RequestId) {.gcsafe, upraises: [].}
   OnRequestFailed* = proc(requestId: RequestId) {.gcsafe, upraises: [].}
   OnProofSubmitted* = proc(id: SlotId) {.gcsafe, upraises: [].}
   ProofChallenge* = array[32, byte]
@@ -55,9 +54,6 @@ type
   RequestFulfilled* = object of MarketplaceEvent
     requestId* {.indexed.}: RequestId
 
-  RequestCancelled* = object of MarketplaceEvent
-    requestId* {.indexed.}: RequestId
-
   RequestFailed* = object of MarketplaceEvent
     requestId* {.indexed.}: RequestId
 
@@ -230,16 +226,6 @@ method subscribeSlotReservationsFull*(
 ): Future[Subscription] {.base, async.} =
   raiseAssert("not implemented")
 
-method subscribeRequestCancelled*(
-    market: Market, callback: OnRequestCancelled
-): Future[Subscription] {.base, async.} =
-  raiseAssert("not implemented")
-
-method subscribeRequestCancelled*(
-    market: Market, requestId: RequestId, callback: OnRequestCancelled
-): Future[Subscription] {.base, async.} =
-  raiseAssert("not implemented")
-
 method subscribeRequestFailed*(
     market: Market, callback: OnRequestFailed
 ): Future[Subscription] {.base, async.} =

codex/sales.nim

@@ -377,23 +377,6 @@ proc subscribeRequested(sales: Sales) {.async.} =
   except CatchableError as e:
     error "Unable to subscribe to storage request events", msg = e.msg
 
-proc subscribeCancellation(sales: Sales) {.async.} =
-  let context = sales.context
-  let market = context.market
-  let queue = context.slotQueue
-
-  proc onCancelled(requestId: RequestId) =
-    trace "request cancelled (via contract RequestCancelled event), removing all request slots from queue"
-    queue.delete(requestId)
-
-  try:
-    let sub = await market.subscribeRequestCancelled(onCancelled)
-    sales.subscriptions.add(sub)
-  except CancelledError as error:
-    raise error
-  except CatchableError as e:
-    error "Unable to subscribe to cancellation events", msg = e.msg
-
 proc subscribeFulfilled*(sales: Sales) {.async.} =
   let context = sales.context
   let market = context.market
@@ -518,7 +501,6 @@ proc subscribe(sales: Sales) {.async.} =
   await sales.subscribeFailure()
   await sales.subscribeSlotFilled()
   await sales.subscribeSlotFreed()
-  await sales.subscribeCancellation()
   await sales.subscribeSlotReservationsFull()
 
 proc unsubscribe(sales: Sales) {.async.} =

tests/codex/helpers/mockmarket.nim

@@ -72,7 +72,6 @@ type
     onSlotFilled: seq[SlotFilledSubscription]
     onSlotFreed: seq[SlotFreedSubscription]
     onSlotReservationsFull: seq[SlotReservationsFullSubscription]
-    onRequestCancelled: seq[RequestCancelledSubscription]
     onRequestFailed: seq[RequestFailedSubscription]
     onProofSubmitted: seq[ProofSubmittedSubscription]
 
@@ -99,15 +98,10 @@ type
     market: MockMarket
     callback: OnSlotReservationsFull
 
-  RequestCancelledSubscription* = ref object of Subscription
-    market: MockMarket
-    requestId: ?RequestId
-    callback: OnRequestCancelled
-
   RequestFailedSubscription* = ref object of Subscription
     market: MockMarket
     requestId: ?RequestId
-    callback: OnRequestCancelled
+    callback: OnRequestFailed
 
   ProofSubmittedSubscription = ref object of Subscription
     market: MockMarket
@@ -261,12 +255,6 @@ proc emitSlotReservationsFull*(
   for subscription in subscriptions:
     subscription.callback(requestId, slotIndex)
 
-proc emitRequestCancelled*(market: MockMarket, requestId: RequestId) =
-  var subscriptions = market.subscriptions.onRequestCancelled
-  for subscription in subscriptions:
-    if subscription.requestId == requestId.some or subscription.requestId.isNone:
-      subscription.callback(requestId)
-
 proc emitRequestFulfilled*(market: MockMarket, requestId: RequestId) =
   var subscriptions = market.subscriptions.onFulfillment
   for subscription in subscriptions:
@@ -329,9 +317,6 @@ method withdrawFunds*(
 ) {.async: (raises: [CancelledError, MarketError]).} =
   market.withdrawn.add(requestId)
 
-  if state =? market.requestState .? [requestId] and state == RequestState.Cancelled:
-    market.emitRequestCancelled(requestId)
-
 proc setProofRequired*(mock: MockMarket, id: SlotId, required: bool) =
   if required:
     mock.proofsRequired.incl(id)
@@ -480,24 +465,6 @@ method subscribeSlotReservationsFull*(
   market.subscriptions.onSlotReservationsFull.add(subscription)
   return subscription
 
-method subscribeRequestCancelled*(
-    market: MockMarket, callback: OnRequestCancelled
-): Future[Subscription] {.async.} =
-  let subscription = RequestCancelledSubscription(
-    market: market, requestId: none RequestId, callback: callback
-  )
-  market.subscriptions.onRequestCancelled.add(subscription)
-  return subscription
-
-method subscribeRequestCancelled*(
-    market: MockMarket, requestId: RequestId, callback: OnRequestCancelled
-): Future[Subscription] {.async.} =
-  let subscription = RequestCancelledSubscription(
-    market: market, requestId: some requestId, callback: callback
-  )
-  market.subscriptions.onRequestCancelled.add(subscription)
-  return subscription
-
 method subscribeRequestFailed*(
     market: MockMarket, callback: OnRequestFailed
 ): Future[Subscription] {.async.} =
@@ -579,9 +546,6 @@ method unsubscribe*(subscription: SlotFilledSubscription) {.async.} =
 method unsubscribe*(subscription: SlotFreedSubscription) {.async.} =
   subscription.market.subscriptions.onSlotFreed.keepItIf(it != subscription)
 
-method unsubscribe*(subscription: RequestCancelledSubscription) {.async.} =
-  subscription.market.subscriptions.onRequestCancelled.keepItIf(it != subscription)
-
 method unsubscribe*(subscription: RequestFailedSubscription) {.async.} =
   subscription.market.subscriptions.onRequestFailed.keepItIf(it != subscription)
 

tests/codex/sales/testsales.nim

@@ -283,11 +283,6 @@ asyncchecksuite "Sales":
     let items = SlotQueueItem.init(request, collateral = request.ask.collateralPerSlot)
     check eventually items.allIt(itemsProcessed.contains(it))
 
-  test "removes slots from slot queue once RequestCancelled emitted":
-    let request1 = await addRequestToSaturatedQueue()
-    market.emitRequestCancelled(request1.id)
-    check always itemsProcessed.notProcessed(request1)
-
   test "removes request from slot queue once RequestFailed emitted":
     let request1 = await addRequestToSaturatedQueue()
     market.emitRequestFailed(request1.id)

tests/contracts/testMarket.nim

@@ -302,21 +302,6 @@ ethersuite "On-Chain Market":
 
     await subscription.unsubscribe()
 
-  test "support request cancelled subscriptions":
-    await market.requestStorage(request)
-
-    var receivedIds: seq[RequestId]
-    proc onRequestCancelled(id: RequestId) =
-      receivedIds.add(id)
-
-    let subscription =
-      await market.subscribeRequestCancelled(request.id, onRequestCancelled)
-
-    await advanceToCancelledRequest(request)
-    await market.withdrawFunds(request.id)
-    check eventually receivedIds == @[request.id]
-    await subscription.unsubscribe()
-
   test "support request failed subscriptions":
     await market.requestStorage(request)
 
@@ -345,24 +330,6 @@ ethersuite "On-Chain Market":
     check eventually receivedIds == @[request.id]
     await subscription.unsubscribe()
 
-  test "subscribes only to a certain request cancellation":
-    var otherRequest = request
-    otherRequest.nonce = Nonce.example
-    await market.requestStorage(request)
-    await market.requestStorage(otherRequest)
-
-    var receivedIds: seq[RequestId]
-    proc onRequestCancelled(requestId: RequestId) =
-      receivedIds.add(requestId)
-
-    let subscription =
-      await market.subscribeRequestCancelled(request.id, onRequestCancelled)
-    await advanceToCancelledRequest(otherRequest) # shares expiry with otherRequest
-    await market.withdrawFunds(otherRequest.id)
-    await market.withdrawFunds(request.id)
-    check eventually receivedIds == @[request.id]
-    await subscription.unsubscribe()
-
   test "supports proof submission subscriptions":
     await market.requestStorage(request)
     await market.reserveSlot(request.id, slotIndex)