Merge branch 'master' into feat/rework-zk-proving

Author: dryajov

codex/contracts/market.nim

@@ -366,7 +366,12 @@ method submitProof*(
     market: OnChainMarket, id: SlotId, proof: Groth16Proof
 ) {.async: (raises: [CancelledError, MarketError]).} =
   convertEthersError("Failed to submit proof"):
-    discard await market.contract.submitProof(id, proof).confirm(1)
+    try:
+      discard await market.contract.submitProof(id, proof).confirm(1)
+    except Proofs_InvalidProof as parent:
+      raise newException(
+        ProofInvalidError, "Failed to submit proof because the proof is invalid", parent
+      )
 
 method markProofAsMissing*(
     market: OnChainMarket, id: SlotId, period: Period
@@ -379,14 +384,12 @@ method markProofAsMissing*(
 
     discard await market.contract.markProofAsMissing(id, period, overrides).confirm(1)
 
-method canProofBeMarkedAsMissing*(
+method canMarkProofAsMissing*(
     market: OnChainMarket, id: SlotId, period: Period
-): Future[bool] {.async.} =
-  let provider = market.contract.provider
-  let contractWithoutSigner = market.contract.connect(provider)
-  let overrides = CallOverrides(blockTag: some BlockTag.pending)
+): Future[bool] {.async: (raises: [CancelledError]).} =
   try:
-    discard await contractWithoutSigner.markProofAsMissing(id, period, overrides)
+    let overrides = CallOverrides(blockTag: some BlockTag.pending)
+    discard await market.contract.canMarkProofAsMissing(id, period, overrides)
     return true
   except EthersError as e:
     trace "Proof cannot be marked as missing", msg = e.msg

codex/contracts/marketplace.nim

@@ -178,6 +178,17 @@ proc markProofAsMissing*(
   ]
 .}
 
+proc canMarkProofAsMissing*(
+  marketplace: Marketplace, id: SlotId, period: uint64
+): Confirmable {.
+  contract,
+  errors: [
+    Marketplace_SlotNotAcceptingProofs, Proofs_PeriodNotEnded,
+    Proofs_ValidationTimedOut, Proofs_ProofNotMissing, Proofs_ProofNotRequired,
+    Proofs_ProofAlreadyMarkedMissing,
+  ]
+.}
+
 proc reserveSlot*(
   marketplace: Marketplace, requestId: RequestId, slotIndex: uint64
 ): Confirmable {.contract.}

codex/market.nim

@@ -20,6 +20,7 @@ type
   MarketError* = object of CodexError
   SlotStateMismatchError* = object of MarketError
   SlotReservationNotAllowedError* = object of MarketError
+  ProofInvalidError* = object of MarketError
   Subscription* = ref object of RootObj
   OnRequest* =
     proc(id: RequestId, ask: StorageAsk, expiry: uint64) {.gcsafe, upraises: [].}
@@ -204,9 +205,9 @@ method markProofAsMissing*(
 ) {.base, async: (raises: [CancelledError, MarketError]).} =
   raiseAssert("not implemented")
 
-method canProofBeMarkedAsMissing*(
+method canMarkProofAsMissing*(
     market: Market, id: SlotId, period: Period
-): Future[bool] {.base, async.} =
+): Future[bool] {.base, async: (raises: [CancelledError]).} =
   raiseAssert("not implemented")
 
 method reserveSlot*(

codex/sales/reservations.nim

@@ -351,7 +351,8 @@ proc updateAvailability(
 
   if oldAvailability.freeSize < obj.freeSize or oldAvailability.duration < obj.duration or
       oldAvailability.minPricePerBytePerSecond < obj.minPricePerBytePerSecond or
-      oldAvailability.totalCollateral < obj.totalCollateral: # availability updated
+      oldAvailability.totalRemainingCollateral < obj.totalRemainingCollateral:
+    # availability updated
     # inform subscribers that Availability has been modified (with increased
     # size)
     if OnAvailabilitySaved =? self.OnAvailabilitySaved:

codex/sales/states/provingsimulated.nim

@@ -40,7 +40,7 @@ when codex_enable_proof_failures:
         try:
           warn "Submitting INVALID proof", period = currentPeriod, slotId = slot.id
           await market.submitProof(slot.id, Groth16Proof.default)
-        except Proofs_InvalidProof as e:
+        except ProofInvalidError as e:
           discard # expected
         except CancelledError as error:
           raise error

codex/validation.nim

@@ -85,7 +85,7 @@ proc markProofAsMissing(
     currentPeriod = validation.getCurrentPeriod()
 
   try:
-    if await validation.market.canProofBeMarkedAsMissing(slotId, period):
+    if await validation.market.canMarkProofAsMissing(slotId, period):
       trace "Marking proof as missing", slotId, periodProofMissed = period
       await validation.market.markProofAsMissing(slotId, period)
     else:

tests/codex/helpers/mockmarket.nim

@@ -381,15 +381,15 @@ method markProofAsMissing*(
 ) {.async: (raises: [CancelledError, MarketError]).} =
   market.markedAsMissingProofs.add(id)
 
-proc setCanProofBeMarkedAsMissing*(mock: MockMarket, id: SlotId, required: bool) =
+proc setCanMarkProofAsMissing*(mock: MockMarket, id: SlotId, required: bool) =
   if required:
     mock.canBeMarkedAsMissing.incl(id)
   else:
     mock.canBeMarkedAsMissing.excl(id)
 
-method canProofBeMarkedAsMissing*(
+method canMarkProofAsMissing*(
     market: MockMarket, id: SlotId, period: Period
-): Future[bool] {.async.} =
+): Future[bool] {.async: (raises: [CancelledError]).} =
   return market.canBeMarkedAsMissing.contains(id)
 
 method reserveSlot*(

tests/codex/sales/testreservations.nim

@@ -427,22 +427,24 @@ asyncchecksuite "Reservations module":
 
     check not called
 
-  test "OnAvailabilitySaved called when availability totalCollateral is increased":
+  test "OnAvailabilitySaved called when availability totalRemainingCollateral is increased":
     var availability = createAvailability()
     var added: Availability
     reservations.OnAvailabilitySaved = proc(a: Availability) {.async: (raises: []).} =
       added = a
-    availability.totalCollateral = availability.totalCollateral + 1.u256
+    availability.totalRemainingCollateral =
+      availability.totalRemainingCollateral + 1.u256
     discard await reservations.update(availability)
 
     check added == availability
 
-  test "OnAvailabilitySaved is not called when availability totalCollateral is decreased":
+  test "OnAvailabilitySaved is not called when availability totalRemainingCollateral is decreased":
     var availability = createAvailability()
     var called = false
     reservations.OnAvailabilitySaved = proc(a: Availability) {.async: (raises: []).} =
       called = true
-    availability.totalCollateral = availability.totalCollateral - 1.u256
+    availability.totalRemainingCollateral =
+      availability.totalRemainingCollateral - 1.u256
     discard await reservations.update(availability)
 
     check not called

tests/codex/testvalidation.nim

@@ -142,15 +142,15 @@ asyncchecksuite "validation":
   test "when a proof is missed, it is marked as missing":
     await validation.start()
     await market.fillSlot(slot.request.id, slot.slotIndex, proof, collateral)
-    market.setCanProofBeMarkedAsMissing(slot.id, true)
+    market.setCanMarkProofAsMissing(slot.id, true)
     advanceToNextPeriod()
     await sleepAsync(100.millis) # allow validation loop to run
     check market.markedAsMissingProofs.contains(slot.id)
 
   test "when a proof can not be marked as missing, it will not be marked":
     await validation.start()
     await market.fillSlot(slot.request.id, slot.slotIndex, proof, collateral)
-    market.setCanProofBeMarkedAsMissing(slot.id, false)
+    market.setCanMarkProofAsMissing(slot.id, false)
     advanceToNextPeriod()
     await sleepAsync(100.millis) # allow validation loop to run
     check market.markedAsMissingProofs.len == 0

tests/contracts/testMarket.nim

@@ -189,7 +189,46 @@ ethersuite "On-Chain Market":
     let missingPeriod =
       periodicity.periodOf((await ethProvider.currentTime()).truncate(uint64))
     await advanceToNextPeriod()
-    check (await market.canProofBeMarkedAsMissing(slotId, missingPeriod)) == true
+    check (await market.canMarkProofAsMissing(slotId, missingPeriod)) == true
+
+  test "can check whether a proof cannot be marked as missing when the slot is free":
+    let slotId = slotId(request, slotIndex)
+    await market.requestStorage(request)
+    await market.reserveSlot(request.id, slotIndex)
+    await market.fillSlot(request.id, slotIndex, proof, request.ask.collateralPerSlot)
+    await waitUntilProofRequired(slotId)
+
+    await market.freeSlot(slotId(request.id, slotIndex))
+
+    let missingPeriod =
+      periodicity.periodOf((await ethProvider.currentTime()).truncate(uint64))
+    await advanceToNextPeriod()
+    check (await market.canMarkProofAsMissing(slotId, missingPeriod)) == false
+
+  test "can check whether a proof cannot be marked as missing before a proof is required":
+    let slotId = slotId(request, slotIndex)
+    await market.requestStorage(request)
+    await market.reserveSlot(request.id, slotIndex)
+    await market.fillSlot(request.id, slotIndex, proof, request.ask.collateralPerSlot)
+
+    let missingPeriod =
+      periodicity.periodOf((await ethProvider.currentTime()).truncate(uint64))
+    await advanceToNextPeriod()
+    check (await market.canMarkProofAsMissing(slotId, missingPeriod)) == false
+
+  test "can check whether a proof cannot be marked as missing if the proof was submitted":
+    let slotId = slotId(request, slotIndex)
+    await market.requestStorage(request)
+    await market.reserveSlot(request.id, slotIndex)
+    await market.fillSlot(request.id, slotIndex, proof, request.ask.collateralPerSlot)
+    await waitUntilProofRequired(slotId)
+
+    await market.submitProof(slotId(request.id, slotIndex), proof)
+
+    let missingPeriod =
+      periodicity.periodOf((await ethProvider.currentTime()).truncate(uint64))
+    await advanceToNextPeriod()
+    check (await market.canMarkProofAsMissing(slotId, missingPeriod)) == false
 
   test "supports slot filled subscriptions":
     await market.requestStorage(request)
@@ -575,7 +614,7 @@ ethersuite "On-Chain Market":
     switchAccount(host)
     await market.reserveSlot(request.id, 0.uint64)
     await market.fillSlot(request.id, 0.uint64, proof, request.ask.collateralPerSlot)
-    let filledAt = (await ethProvider.currentTime())
+    let filledAt = await ethProvider.blockTime(BlockTag.latest)
 
     for slotIndex in 1 ..< request.ask.slots:
       await market.reserveSlot(request.id, slotIndex.uint64)