diff --git a/tests/integration/testproofs.nim b/tests/integration/testproofs.nim
index 1cec1b13..d5b8aef8 100644
--- a/tests/integration/testproofs.nim
+++ b/tests/integration/testproofs.nim
@@ -109,85 +109,24 @@ multinodesuite "Simulate invalid proofs",
 
   var marketplace: Marketplace
   var period: uint64
-  var proofSubmitted: Future[void]
-  var subscription: Subscription
-  var submitted: seq[seq[byte]]
-  var missed: UInt256
   var slotId: SlotId
-  var validator: NodeProcess
-  let validatorDir = getTempDir() / "CodexValidator"
-  var periodDowntime: uint8
-  var downtime: seq[(Period, bool)]
-  var periodicity: Periodicity
 
   setup:
     let deployment = Deployment.init()
     marketplace = Marketplace.new(!deployment.address(Marketplace), provider)
     let config = await marketplace.config()
     period = config.proofs.period.truncate(uint64)
-    periodDowntime = config.proofs.downtime
-    proofSubmitted = newFuture[void]("proofSubmitted")
-    proc onProofSubmitted(event: ProofSubmitted) =
-      submitted.add(event.proof)
-      proofSubmitted.complete()
-      proofSubmitted = newFuture[void]("proofSubmitted")
-    subscription = await marketplace.subscribe(ProofSubmitted, onProofSubmitted)
-    missed = 0.u256
     slotId = SlotId(array[32, byte].default) # ensure we aren't reusing from prev test
-    downtime = @[]
-    periodicity = Periodicity(seconds: period.u256)
 
     # Our Hardhat configuration does use automine, which means that time tracked by `provider.currentTime()` is not
     # advanced until blocks are mined and that happens only when transaction is submitted.
     # As we use in tests provider.currentTime() which uses block timestamp this can lead to synchronization issues.
     await provider.advanceTime(1.u256)
 
-  teardown:
-    await subscription.unsubscribe()
-
-  proc getCurrentPeriod(): Future[Period] {.async.} =
-    return periodicity.periodOf(await provider.currentTime())
-
-  proc waitUntilPurchaseIsStarted(proofProbability: uint64 = 1,
-                                  duration: uint64 = 12 * period,
-                                  expiry: uint64 = 4 * period,
-                                  failEveryNProofs: uint): Future[Period] {.async.} =
-
-    if clients().len < 1 or providers().len < 1:
-      raiseAssert("must start at least one client and one provider")
-
-    let client = clients()[0].restClient
-    let storageProvider = providers()[0].restClient
-
-    # The last period is the period in which the slot is freed, and therefore
-    # proofs cannot be submitted. That means that the duration must go an
-    # additional period longer to allow for invalid proofs to be submitted in
-    # the second to last period and counted as missed in the last period.
-    let dur = duration + (1 * period)
-
-    discard storageProvider.postAvailability(
-      size=0xFFFFF,
-      duration=dur,
-      minPrice=300
-    )
-    let cid = client.upload("some file contents " & $ getTime().toUnix)
-    let expiry = (await provider.currentTime()) + expiry.u256
-    let purchase = client.requestStorage(
-      cid,
-      expiry=expiry,
-      duration=dur,
-      proofProbability=proofProbability,
-      reward=400
-    )
-    check eventually client.getPurchase(purchase){"state"} == %"started"
-    debug "purchase state", state = client.getPurchase(purchase){"state"}
-    let requestId = RequestId.fromHex client.getPurchase(purchase){"requestId"}.getStr
-    slotId = slotId(requestId, 0.u256)
-    return await getCurrentPeriod()
-
-  proc inDowntime: Future[bool] {.async.} =
-    var periodPointer = await marketplace.getPointer(slotId)
-    return periodPointer < periodDowntime
+  proc periods(p: Ordinal | uint): uint64 =
+    when p is uint:
+      p * period
+    else: p.uint * period
 
   proc advanceToNextPeriod {.async.} =
     let periodicity = Periodicity(seconds: period.u256)
@@ -195,139 +134,87 @@ multinodesuite "Simulate invalid proofs",
     let endOfPeriod = periodicity.periodEnd(currentPeriod)
     await provider.advanceTimeTo(endOfPeriod + 1)
 
-  proc advanceToNextPeriodStart {.async.} =
-    let currentPeriod = await getCurrentPeriod()
-    let startOfPeriod = periodicity.periodEnd(currentPeriod + 1)
-    await provider.advanceTimeTo(startOfPeriod)
+  proc waitUntilPurchaseIsStarted(proofProbability: uint64 = 1,
+                                  duration: uint64 = 12.periods,
+                                  expiry: uint64 = 4.periods) {.async.} =
 
+    if clients().len < 1 or providers().len < 1:
+      raiseAssert("must start at least one client and one provider")
 
-  proc advanceToCurrentPeriodEnd {.async.} =
-    let currentPeriod = await getCurrentPeriod()
-    let endOfPeriod = periodicity.periodEnd(currentPeriod)
-    await provider.advanceTimeTo(endOfPeriod)
+    let client = clients()[0].restClient
+    let storageProvider = providers()[0].restClient
 
-  proc recordDowntime() {.async.} =
-    let currentPeriod = await getCurrentPeriod()
-    let isInDowntime = await inDowntime()
-    downtime.add (currentPeriod, isInDowntime)
-    debug "downtime recorded", currentPeriod, isInDowntime
+    discard storageProvider.postAvailability(
+      size=0xFFFFF,
+      duration=duration,
+      minPrice=300,
+      maxCollateral=200
+    )
+    let cid = client.upload("some file contents " & $ getTime().toUnix)
+    let expiry = (await provider.currentTime()) + expiry.u256
+    # avoid timing issues by filling the slot at the start of the next period
+    await advanceToNextPeriod()
+    let purchase = client.requestStorage(
+      cid,
+      expiry=expiry,
+      duration=duration,
+      proofProbability=proofProbability,
+      collateral=100,
+      reward=400
+    )
+    check eventually client.getPurchase(purchase){"state"} == %"started"
+    let requestId = RequestId.fromHex client.getPurchase(purchase){"requestId"}.getStr
+    slotId = slotId(requestId, 0.u256)
 
-  proc waitUntilSlotNoLongerFilled() {.async.} =
-    var i = 0
-    # await recordDowntime()
-    # await advanceToNextPeriodStart()
-    while (await marketplace.slotState(slotId)) == SlotState.Filled:
-      let currentPeriod = await getCurrentPeriod()
-      # await advanceToCurrentPeriodEnd()
-      await advanceToNextPeriod()
-      debug "--------------- PERIOD START ---------------", currentPeriod
-      await recordDowntime()
-      # debug "--------------- PERIOD END ---------------", currentPeriod
-      await sleepAsync(1.seconds) # let validation happen
-      debug "Checked previous period for missed proofs", missedProofs = $(await marketplace.missingProofs(slotId))
-      i += 1
-    # downtime.del downtime.len - 1 # remove last downtime as it is an additional proving round adding to duration for checking proofs, and we are offset by one as we are checking previous periods
-    missed = await marketplace.missingProofs(slotId)
-    debug "Total missed proofs", missed
+  # TODO: these are very loose tests in that they are not testing EXACTLY how
+  # proofs were marked as missed by the validator. These tests should be
+  # tightened so that they are showing, as an integration test, that specific
+  # proofs are being marked as missed by the validator.
 
-  proc expectedInvalid(startPeriod: Period,
-                       failEveryNProofs: uint,
-                       periods: Positive): seq[(Period, bool)] =
-    # Create a seq of bools where each bool represents a proving round.
-    # If true, an invalid proof should have been sent.
-    var p = startPeriod + 1.u256
-    var invalid: seq[(Period, bool)] = @[]
-    if failEveryNProofs == 0:
-      for i in 0..<periods:
-        p += 1.u256
-        invalid.add (p, false)
-      return invalid
-
-    for j in 0..<(periods div failEveryNProofs.int):
-      for i in 0..<failEveryNProofs - 1'u:
-        p += 1.u256
-        invalid.add (p, false)
-      p += 1.u256
-      invalid.add (p, true)
-    # add remaining falses
-    for k in 0..<(periods mod failEveryNProofs.int):
-      p += 1.u256
-      invalid.add (p, false)
-    # var proofs = false.repeat(failEveryNProofs - 1)
-    # proofs.add true
-    # proofs = proofs.cycle(periods div failEveryNProofs.int)
-    #                .concat(false.repeat(periods mod failEveryNProofs.int)) # leftover falses
-    # return proofs
-    return invalid
-
-  proc expectedMissed(startPeriod: Period, failEveryNProofs: uint, periods: Positive): int =
-    # Intersects a seq of expected invalid proofs (true = invalid proof) with
-    # a seq of bools indicating a period was in pointer downtime (true = period
-    # was in pointer downtime).
-    # We can only expect an invalid proof to have been submitted if the slot
-    # was accepting proofs in that period, meaning it cannot be in downtime.
-    # eg failEveryNProofs = 3, periods = 2, the invalid proofs seq will be:
-    # @[false, false, true, false, false, true]
-    # If we hit downtime in the second half of running our test, the
-    # downtime seq might be @[false, false, false, true, true, true]
-    # When these two are intersected such that invalid is true and downtime is false,
-    # the result would be @[false, false, false, false, false, true], or 1 total
-    # invalid proof that should be marked as missed.
-    let invalid = expectedInvalid(startPeriod, failEveryNProofs, periods)
-    var expectedMissed = 0
-    for i in 0..<invalid.len:
-      let (invalidPeriod, isInvalidProof) = invalid[i]
-      for j in 0..<downtime.len:
-        let (downtimePeriod, isDowntime) = downtime[j]
-        if invalidPeriod == downtimePeriod:
-          if isInvalidProof and not isDowntime:
-            inc expectedMissed
-          break
-      # if invalid[i] == true and downtime[i] == false:
-      #   expectedMissed += 1
-
-    debug "expectedMissed invalid / downtime", invalid, downtime, expectedMissed
-    return expectedMissed
-
-  test "simulates invalid proof for every proofs":
-    let failEveryNProofs = 1'u
-    let totalProofs = 12
+  test "slot is freed after too many invalid proofs submitted":
+    let failEveryNProofs = 2'u
+    let totalProofs = 100'u
     startProviderNode(failEveryNProofs)
 
-    let startPeriod = await waitUntilPurchaseIsStarted(duration=totalProofs.uint * period,
-                                     failEveryNProofs = failEveryNProofs)
-    await waitUntilSlotNoLongerFilled()
+    await waitUntilPurchaseIsStarted(duration=totalProofs.periods)
 
-    check missed.truncate(int) == expectedMissed(startPeriod, failEveryNProofs, totalProofs)
+    var slotWasFreed = false
+    proc onSlotFreed(event: SlotFreed) =
+      if event.slotId == slotId:
+        slotWasFreed = true
+    let subscription = await marketplace.subscribe(SlotFreed, onSlotFreed)
 
-  # test "simulates invalid proof every N proofs":
-  #   let failEveryNProofs = 3'u
-  #   let totalProofs = 12
-  #   startProviderNode(failEveryNProofs)
+    for _ in 0..<totalProofs:
+      if slotWasFreed:
+        break
+      else:
+        await advanceToNextPeriod()
+        await sleepAsync(1.seconds)
 
-  #   await waitUntilPurchaseIsStarted(duration=totalProofs.uint * period,
-  #                                    failEveryNProofs = failEveryNProofs)
-  #   await waitUntilSlotNoLongerFilled()
+    check slotWasFreed
 
-  #   check missed.truncate(int) == expectedMissed(failEveryNProofs, totalProofs)
+    await subscription.unsubscribe()
 
-  # test "does not simulate invalid proofs when --simulate-failed-proofs is 0":
-  #   let failEveryNProofs = 0'u
-  #   let totalProofs = 12
-  #   startProviderNode(failEveryNProofs)
+  test "slot is not freed when not enough invalid proofs submitted":
+    let failEveryNProofs = 3'u
+    let totalProofs = 12'u
+    startProviderNode(failEveryNProofs)
 
-  #   await waitUntilPurchaseIsStarted(duration=totalProofs.uint * period,
-  #                                    failEveryNProofs = failEveryNProofs)
-  #   await waitUntilSlotNoLongerFilled()
+    await waitUntilPurchaseIsStarted(duration=totalProofs.periods)
 
-  #   check missed.truncate(int) == expectedMissed(failEveryNProofs, totalProofs)
+    var slotWasFreed = false
+    proc onSlotFreed(event: SlotFreed) =
+      if event.slotId == slotId:
+        slotWasFreed = true
+    let subscription = await marketplace.subscribe(SlotFreed, onSlotFreed)
 
-  # test "does not simulate invalid proof when --simulate-failed-proofs is 0":
-  #   # 1. instantiate node manually (startNode) with --simulate-failed-proofs=0
-  #   # 2. check that the number of expected missed proofs is 0
-  #   check 1 == 1
+    for _ in 0..<totalProofs:
+      if slotWasFreed:
+        break
+      else:
+        await advanceToNextPeriod()
+        await sleepAsync(1.seconds)
 
-  # test "does not simulate invalid proof when chainId is 1":
-  #   # 1. instantiate node manually (startNode) with --simulate-failed-proofs=3
-  #   # 2. check that the number of expected missed proofs is 0
-  #   check 1 == 1
\ No newline at end of file
+    check not slotWasFreed
+
+    await subscription.unsubscribe()