[BUG] - Mismatch in ChainDB.q-s-m wrt MaxSlotNo

[jasagredo]

https://github.com/IntersectMBO/ouroboros-consensus/actions/runs/21832592717/job/62994870493?pr=1826#logs

The chain is:

Genesis -- A (0, -8986190201926803368, Valid)
        \- B (2, -1486433721842374672, Invalid) 

When the block B arrives, it is popped from the queue

TraceAddBlockEvent (PoppedBlockFromQueue (RealPoint (SlotNo 2) (TestHeaderHash (-1486433721842374672))))

and then it is ignored, because the block A has been boosted with Peras certificates, and the chainsel logic sees that it is at the same block number than the immutable tip so we should not switch:

          TraceAddBlockEvent (IgnoreBlockOlderThanImmTip (RealPoint (SlotNo 2) (TestHeaderHash (-1486433721842374672))))

However when the ChainDB is then asked what is the MaxSlotNo, it reports 2. However this answer comes from:

  curChainMaxSlotNo <-
    maxSlotNoFromWithOrigin . AF.headSlot . icWithoutTime
      <$> readTVar cdbChain
  volatileDbMaxSlotNo <- VolatileDB.getMaxSlotNo cdbVolatileDB
  queuedMaxSlotNo <- getMaxSlotNoChainSelQueue cdbChainSelQueue
  return $ curChainMaxSlotNo `max` volatileDbMaxSlotNo `max` queuedMaxSlotNo

And the block is not in the cdbChain (as we saw no AddedToCurrentChain for this block), nor in the cdbVolatileDB (as we saw no AddedBlockToVolatileDB traces for this block) so it has to be in the chain sel queue? but it was unqueued precisely by the existance of the PoppedBlockFromQueue so something fishy is going on here.

Moreover, I cannot reproduce this test failure on my machine with the same seed and GHC

❯ cabal test storage-test --test-option="-p /ChainDB q-s-m.sequential/" --test-option="--quickcheck-replay=(SMGen 15194541575572225434 13540340026014931941,80)" --test-option="--hide-successes"
Build profile: -w ghc-9.12.2 -O1
In order, the following will be built (use -v for more details):
 - ouroboros-consensus-0.28.0.0 (test:storage-test) (ephemeral targets)
Preprocessing test suite 'storage-test' for ouroboros-consensus-0.28.0.0...
Building test suite 'storage-test' for ouroboros-consensus-0.28.0.0...
Running 1 test suites...
Test suite storage-test: RUNNING...

All 1 tests passed (22.08s)
Test suite storage-test: PASS
Test suite logged to:
/home/javier/code/cardano/ouroboros-consensus/dist-newstyle/build/x86_64-linux/ghc-9.12.2/ouroboros-consensus-0.28.0.0/t/storage-test/test/ouroboros-consensus-0.28.0.0-storage-test.log
1 of 1 test suites (1 of 1 test cases) passed.

EDIT: actually, the reading from the queue happens from the set of known points:

data ChainSelQueue m blk = ChainSelQueue
  { varChainSelQueue :: TBQueue m (ChainSelMessage m blk)
  , varChainSelPoints :: StrictTVar m (MultiSet (RealPoint blk))
  }

but we only add when we add a block to the queue:

addBlockToAdd tracer (ChainSelQueue{varChainSelQueue, varChainSelPoints}) punish blk = do
  ...
  modifyTVar varChainSelPoints $ MultiSet.insert pt

and we delete when we processed a block:

processedChainSelMessage ChainSelQueue{varChainSelPoints} = \case
  ChainSelAddBlock BlockToAdd{blockToAdd = blk} ->
    modifyTVar varChainSelPoints $ MultiSet.delete (blockRealPoint blk)

which gets called immediately after the chainSelSync:

      ( \message -> do
          lift $ case message of
            ChainSelReprocessLoEBlocks _ ->
              trace PoppedReprocessLoEBlocksFromQueue
            ChainSelAddBlock BlockToAdd{blockToAdd} ->
              trace $ PoppedBlockFromQueue $ blockRealPoint blockToAdd
            ChainSelAddPerasCert cert _varProcessed ->
              traceWith cdbTracer $
                TraceAddPerasCertEvent $
                  PoppedPerasCertFromQueue (getPerasCertRound cert) (getPerasCertBoostedBlock cert)
          chainSelSync cdb message
          lift $ atomically $ processedChainSelMessage cdbChainSelQueue message
      )

[jasagredo]

The log just in case the CI run disappears

Model {
  dbModel = Model {
    volatileDbBlocks = Map.fromList [],
    immutableDbChain = Genesis,
    perasCerts = Map.fromList [],
    cps = ChainProducerState {
      chainState = Genesis,
      chainFollowers = Map.fromList [],
      nextFollowerId = 0},
    currentLedger = ExtLedgerState {
      ledgerState = TestLedger {
        lastAppliedPoint = Point Origin,
        lastAppliedHash = GenesisHash},
      headerState = HeaderState {
        headerStateTip = Origin,
        headerStateChainDep = `()`}},
    initLedger = ExtLedgerState {
      ledgerState = TestLedger {
        lastAppliedPoint = Point Origin,
        lastAppliedHash = GenesisHash},
      headerState = HeaderState {
        headerStateTip = Origin,
        headerStateChainDep = `()`}},
    iterators = Map.fromList [],
    valid = Set.fromList [],
    invalid = Map.fromList [],
    loeFragment = LoEDisabled,
    isOpen = True},
  knownIters = RefEnv [],
  knownFollowers = RefEnv [],
  modelConfig = Opaque,
  genState = GenState (Map.fromList [])}

   == AddPerasCert
  ValidatedPerasCert
    { vpcCert =
        PerasCert
          { pcCertRound = PerasRoundNo 0
          , pcCertBoostedBlock =
              Point
                (At
                   Block
                     { blockPointSlot = SlotNo 2
                     , blockPointHash = TestHeaderHash (-1486433721842374672)
                     })
          }
    , vpcCertBoost = PerasWeight 1
    }
  Persistent
    { unPersistent =
        [ TestBlock
            { testHeader =
                TestHeader
                  { thHash = TestHeaderHash (-1486433721842374672)
                  , thPrevHash = GenesisHash
                  , thBodyHash = TestBodyHash 7896947812457579993
                  , thSlotNo = SlotNo 2
                  , thBlockNo = BlockNo 0
                  , thChainLength = ChainLength 1
                  , thIsEBB = RegularBlock
                  }
            , testBody = TestBody { tbForkNo = 1 , tbIsValid = False }
            }
        ]
    } ==> Resp { getResp = Right (Unit ()) } [ 0 ]

Model {
  dbModel = Model {
    immutableDbChain = Genesis,
    perasCerts = Map.fromList
      [
        +_×_
          (PerasRoundNo 0)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 0,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 2,
                    blockPointHash = TestHeaderHash `-1486433721842374672`})},
            vpcCertBoost = PerasWeight 1}],
    loeFragment = LoEDisabled,
    isOpen = True,
    volatileDbBlocks = ...},
  modelConfig = Opaque,
  genState = GenState
    (Map.fromList
      [
        +_×_
          (TestHeaderHash `-1486433721842374672`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-1486433721842374672`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash 7896947812457579993,
              thSlotNo = SlotNo 2,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 1, tbIsValid = False}}]),
  knownIters = ...}

   == AddPerasCert
  ValidatedPerasCert
    { vpcCert =
        PerasCert
          { pcCertRound = PerasRoundNo 1
          , pcCertBoostedBlock =
              Point
                (At
                   Block
                     { blockPointSlot = SlotNo 0
                     , blockPointHash = TestHeaderHash (-8986190201926803368)
                     })
          }
    , vpcCertBoost = PerasWeight 1
    }
  Persistent
    { unPersistent =
        [ TestBlock
            { testHeader =
                TestHeader
                  { thHash = TestHeaderHash (-8986190201926803368)
                  , thPrevHash = GenesisHash
                  , thBodyHash = TestBodyHash (-7587558942263677962)
                  , thSlotNo = SlotNo 0
                  , thBlockNo = BlockNo 0
                  , thChainLength = ChainLength 1
                  , thIsEBB = RegularBlock
                  }
            , testBody = TestBody { tbForkNo = 2 , tbIsValid = True }
            }
        ]
    } ==> Resp { getResp = Right (Unit ()) } [ 0 ]

Model {
  dbModel = Model {
    immutableDbChain = Genesis,
    perasCerts = Map.fromList
      [
        _×_
          (PerasRoundNo 0)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 0,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 2,
                    blockPointHash = TestHeaderHash `-1486433721842374672`})},
            vpcCertBoost = PerasWeight 1},
        +_×_
          (PerasRoundNo 1)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 1,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1}],
    loeFragment = LoEDisabled,
    isOpen = True,
    volatileDbBlocks = ...},
  modelConfig = Opaque,
  genState = GenState
    (Map.fromList
      [
        +_×_
          (TestHeaderHash `-8986190201926803368`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-8986190201926803368`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash `-7587558942263677962`,
              thSlotNo = SlotNo 0,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 2, tbIsValid = True}},
        _×_
          (TestHeaderHash `-1486433721842374672`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-1486433721842374672`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash 7896947812457579993,
              thSlotNo = SlotNo 2,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 1, tbIsValid = False}}]),
  knownIters = ...}

   == AddPerasCert
  ValidatedPerasCert
    { vpcCert =
        PerasCert
          { pcCertRound = PerasRoundNo 2
          , pcCertBoostedBlock =
              Point
                (At
                   Block
                     { blockPointSlot = SlotNo 0
                     , blockPointHash = TestHeaderHash (-8986190201926803368)
                     })
          }
    , vpcCertBoost = PerasWeight 1
    }
  Persistent
    { unPersistent =
        [ TestBlock
            { testHeader =
                TestHeader
                  { thHash = TestHeaderHash (-8986190201926803368)
                  , thPrevHash = GenesisHash
                  , thBodyHash = TestBodyHash (-7587558942263677962)
                  , thSlotNo = SlotNo 0
                  , thBlockNo = BlockNo 0
                  , thChainLength = ChainLength 1
                  , thIsEBB = RegularBlock
                  }
            , testBody = TestBody { tbForkNo = 2 , tbIsValid = True }
            }
        ]
    } ==> Resp { getResp = Right (Unit ()) } [ 0 ]

Model {
  dbModel = Model {
    immutableDbChain = Genesis,
    perasCerts = Map.fromList
      [
        _×_
          (PerasRoundNo 0)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 0,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 2,
                    blockPointHash = TestHeaderHash `-1486433721842374672`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 1)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 1,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1},
        +_×_
          (PerasRoundNo 2)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 2,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1}],
    loeFragment = LoEDisabled,
    isOpen = True,
    volatileDbBlocks = ...},
  modelConfig = Opaque,
  knownIters = ...}

   == GetMaxSlotNo ==> Resp { getResp = Right (MaxSlot NoMaxSlotNo) } [ 0 ]

Model {
  dbModel = Model {
    volatileDbBlocks = Map.fromList [],
    immutableDbChain = Genesis,
    perasCerts = Map.fromList
      [
        _×_
          (PerasRoundNo 0)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 0,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 2,
                    blockPointHash = TestHeaderHash `-1486433721842374672`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 1)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 1,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 2)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 2,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1}],
    cps = ChainProducerState {
      chainState = Genesis,
      chainFollowers = Map.fromList [],
      nextFollowerId = 0},
    currentLedger = ExtLedgerState {
      ledgerState = TestLedger {
        lastAppliedPoint = Point Origin,
        lastAppliedHash = GenesisHash},
      headerState = HeaderState {
        headerStateTip = Origin,
        headerStateChainDep = `()`}},
    initLedger = ExtLedgerState {
      ledgerState = TestLedger {
        lastAppliedPoint = Point Origin,
        lastAppliedHash = GenesisHash},
      headerState = HeaderState {
        headerStateTip = Origin,
        headerStateChainDep = `()`}},
    iterators = Map.fromList [],
    valid = Set.fromList [],
    invalid = Map.fromList [],
    loeFragment = LoEDisabled,
    isOpen = True},
  knownIters = RefEnv [],
  knownFollowers = RefEnv [],
  modelConfig = Opaque,
  genState = GenState
    (Map.fromList
      [
        _×_
          (TestHeaderHash `-8986190201926803368`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-8986190201926803368`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash `-7587558942263677962`,
              thSlotNo = SlotNo 0,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 2, tbIsValid = True}},
        _×_
          (TestHeaderHash `-1486433721842374672`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-1486433721842374672`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash 7896947812457579993,
              thSlotNo = SlotNo 2,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 1, tbIsValid = False}}])}

   == AddPerasCert
  ValidatedPerasCert
    { vpcCert =
        PerasCert
          { pcCertRound = PerasRoundNo 3
          , pcCertBoostedBlock =
              Point
                (At
                   Block
                     { blockPointSlot = SlotNo 0
                     , blockPointHash = TestHeaderHash (-8986190201926803368)
                     })
          }
    , vpcCertBoost = PerasWeight 3
    }
  Persistent
    { unPersistent =
        [ TestBlock
            { testHeader =
                TestHeader
                  { thHash = TestHeaderHash (-8986190201926803368)
                  , thPrevHash = GenesisHash
                  , thBodyHash = TestBodyHash (-7587558942263677962)
                  , thSlotNo = SlotNo 0
                  , thBlockNo = BlockNo 0
                  , thChainLength = ChainLength 1
                  , thIsEBB = RegularBlock
                  }
            , testBody = TestBody { tbForkNo = 2 , tbIsValid = True }
            }
        ]
    } ==> Resp { getResp = Right (Unit ()) } [ 0 ]

Model {
  dbModel = Model {
    immutableDbChain = Genesis,
    perasCerts = Map.fromList
      [
        _×_
          (PerasRoundNo 0)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 0,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 2,
                    blockPointHash = TestHeaderHash `-1486433721842374672`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 1)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 1,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 2)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 2,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1},
        +_×_
          (PerasRoundNo 3)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 3,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 3}],
    loeFragment = LoEDisabled,
    isOpen = True,
    volatileDbBlocks = ...},
  modelConfig = Opaque,
  knownIters = ...}

   == AddBlock
  TestBlock
    { testHeader =
        TestHeader
          { thHash = TestHeaderHash (-8986190201926803368)
          , thPrevHash = GenesisHash
          , thBodyHash = TestBodyHash (-7587558942263677962)
          , thSlotNo = SlotNo 0
          , thBlockNo = BlockNo 0
          , thChainLength = ChainLength 1
          , thIsEBB = RegularBlock
          }
    , testBody = TestBody { tbForkNo = 2 , tbIsValid = True }
    }
  Persistent { unPersistent = [] } ==> Resp
  { getResp =
      Right
        (Point
           (Point
              (At
                 Block
                   { blockPointSlot = SlotNo 0
                   , blockPointHash = TestHeaderHash (-8986190201926803368)
                   })))
  } [ 0 ]

Model {
  dbModel = Model {
    volatileDbBlocks = Map.fromList
      [
        +_×_
          (TestHeaderHash `-8986190201926803368`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-8986190201926803368`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash `-7587558942263677962`,
              thSlotNo = SlotNo 0,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 2, tbIsValid = True}}],
    immutableDbChain = Genesis,
    cps = ChainProducerState {
      chainState = -Genesis
      +:>
        Genesis
        TestBlock {
          testHeader = TestHeader {
            thHash = TestHeaderHash `-8986190201926803368`,
            thPrevHash = GenesisHash,
            thBodyHash = TestBodyHash `-7587558942263677962`,
            thSlotNo = SlotNo 0,
            thBlockNo = BlockNo 0,
            thChainLength = ChainLength 1,
            thIsEBB = RegularBlock},
          testBody = TestBody {tbForkNo = 2, tbIsValid = True}},
      nextFollowerId = 0,
      chainFollowers = ...},
    currentLedger = ExtLedgerState {
      ledgerState = TestLedger {
        lastAppliedPoint = Point
          -Origin
          +(At
            Block {
              blockPointSlot = SlotNo 0,
              blockPointHash = TestHeaderHash `-8986190201926803368`}),
        lastAppliedHash = -GenesisHash
        +BlockHash (TestHeaderHash `-8986190201926803368`)},
      headerState = HeaderState {
        headerStateTip = -Origin
        +At
          AnnTip {
            annTipSlotNo = SlotNo 0,
            annTipBlockNo = BlockNo 0,
            annTipInfo = TipInfoIsEBB
              (TestHeaderHash `-8986190201926803368`)
              IsNotEBB},
        headerStateChainDep = `()`}},
    valid = Set.fromList [+TestHeaderHash `-8986190201926803368`],
    loeFragment = LoEDisabled,
    isOpen = True,
    perasCerts = ...},
  modelConfig = Opaque,
  knownIters = ...}

   == GetTipBlock ==> Resp
  { getResp =
      Right
        (MbBlock
           (Just
              TestBlock
                { testHeader =
                    TestHeader
                      { thHash = TestHeaderHash (-8986190201926803368)
                      , thPrevHash = GenesisHash
                      , thBodyHash = TestBodyHash (-7587558942263677962)
                      , thSlotNo = SlotNo 0
                      , thBlockNo = BlockNo 0
                      , thChainLength = ChainLength 1
                      , thIsEBB = RegularBlock
                      }
                , testBody = TestBody { tbForkNo = 2 , tbIsValid = True }
                }))
  } [ 0 ]

Model {
  dbModel = Model {
    volatileDbBlocks = Map.fromList
      [
        _×_
          (TestHeaderHash `-8986190201926803368`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-8986190201926803368`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash `-7587558942263677962`,
              thSlotNo = SlotNo 0,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 2, tbIsValid = True}}],
    immutableDbChain = Genesis,
    perasCerts = Map.fromList
      [
        _×_
          (PerasRoundNo 0)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 0,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 2,
                    blockPointHash = TestHeaderHash `-1486433721842374672`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 1)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 1,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 2)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 2,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 3)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 3,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 3}],
    cps = ChainProducerState {
      chainState = :>
        Genesis
        TestBlock {
          testHeader = TestHeader {
            thHash = TestHeaderHash `-8986190201926803368`,
            thPrevHash = GenesisHash,
            thBodyHash = TestBodyHash `-7587558942263677962`,
            thSlotNo = SlotNo 0,
            thBlockNo = BlockNo 0,
            thChainLength = ChainLength 1,
            thIsEBB = RegularBlock},
          testBody = TestBody {tbForkNo = 2, tbIsValid = True}},
      chainFollowers = Map.fromList [],
      nextFollowerId = 0},
    currentLedger = ExtLedgerState {
      ledgerState = TestLedger {
        lastAppliedPoint = Point
          (At
            Block {
              blockPointSlot = SlotNo 0,
              blockPointHash = TestHeaderHash `-8986190201926803368`}),
        lastAppliedHash = BlockHash (TestHeaderHash `-8986190201926803368`)},
      headerState = HeaderState {
        headerStateTip = At
          AnnTip {
            annTipSlotNo = SlotNo 0,
            annTipBlockNo = BlockNo 0,
            annTipInfo = TipInfoIsEBB
              (TestHeaderHash `-8986190201926803368`)
              IsNotEBB},
        headerStateChainDep = `()`}},
    initLedger = ExtLedgerState {
      ledgerState = TestLedger {
        lastAppliedPoint = Point Origin,
        lastAppliedHash = GenesisHash},
      headerState = HeaderState {
        headerStateTip = Origin,
        headerStateChainDep = `()`}},
    iterators = Map.fromList [],
    valid = Set.fromList [TestHeaderHash `-8986190201926803368`],
    invalid = Map.fromList [],
    loeFragment = LoEDisabled,
    isOpen = True},
  knownIters = RefEnv [],
  knownFollowers = RefEnv [],
  modelConfig = Opaque,
  genState = GenState
    (Map.fromList
      [
        _×_
          (TestHeaderHash `-8986190201926803368`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-8986190201926803368`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash `-7587558942263677962`,
              thSlotNo = SlotNo 0,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 2, tbIsValid = True}},
        _×_
          (TestHeaderHash `-1486433721842374672`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-1486433721842374672`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash 7896947812457579993,
              thSlotNo = SlotNo 2,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 1, tbIsValid = False}}])}

   == AddPerasCert
  ValidatedPerasCert
    { vpcCert =
        PerasCert
          { pcCertRound = PerasRoundNo 4
          , pcCertBoostedBlock =
              Point
                (At
                   Block
                     { blockPointSlot = SlotNo 0
                     , blockPointHash = TestHeaderHash (-8986190201926803368)
                     })
          }
    , vpcCertBoost = PerasWeight 1
    }
  Persistent
    { unPersistent =
        [ TestBlock
            { testHeader =
                TestHeader
                  { thHash = TestHeaderHash (-8986190201926803368)
                  , thPrevHash = GenesisHash
                  , thBodyHash = TestBodyHash (-7587558942263677962)
                  , thSlotNo = SlotNo 0
                  , thBlockNo = BlockNo 0
                  , thChainLength = ChainLength 1
                  , thIsEBB = RegularBlock
                  }
            , testBody = TestBody { tbForkNo = 2 , tbIsValid = True }
            }
        ]
    } ==> Resp { getResp = Right (Unit ()) } [ 0 ]

Model {
  dbModel = Model {
    immutableDbChain = Genesis,
    perasCerts = Map.fromList
      [
        _×_
          (PerasRoundNo 0)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 0,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 2,
                    blockPointHash = TestHeaderHash `-1486433721842374672`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 1)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 1,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 2)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 2,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 3)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 3,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 3},
        +_×_
          (PerasRoundNo 4)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 4,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1}],
    loeFragment = LoEDisabled,
    isOpen = True,
    volatileDbBlocks = ...},
  modelConfig = Opaque,
  knownIters = ...}

   == AddBlock
  TestBlock
    { testHeader =
        TestHeader
          { thHash = TestHeaderHash (-1486433721842374672)
          , thPrevHash = GenesisHash
          , thBodyHash = TestBodyHash 7896947812457579993
          , thSlotNo = SlotNo 2
          , thBlockNo = BlockNo 0
          , thChainLength = ChainLength 1
          , thIsEBB = RegularBlock
          }
    , testBody = TestBody { tbForkNo = 1 , tbIsValid = False }
    }
  Persistent { unPersistent = [] } ==> Resp
  { getResp =
      Right
        (Point
           (Point
              (At
                 Block
                   { blockPointSlot = SlotNo 0
                   , blockPointHash = TestHeaderHash (-8986190201926803368)
                   })))
  } [ 0 ]

Model {
  dbModel = Model {
    volatileDbBlocks = Map.fromList
      [
        _×_
          (TestHeaderHash `-8986190201926803368`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-8986190201926803368`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash `-7587558942263677962`,
              thSlotNo = SlotNo 0,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 2, tbIsValid = True}}],
    immutableDbChain = Genesis,
    perasCerts = Map.fromList
      [
        _×_
          (PerasRoundNo 0)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 0,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 2,
                    blockPointHash = TestHeaderHash `-1486433721842374672`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 1)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 1,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 2)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 2,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 3)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 3,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 3},
        _×_
          (PerasRoundNo 4)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 4,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1}],
    cps = ChainProducerState {
      chainState = :>
        Genesis
        TestBlock {
          testHeader = TestHeader {
            thHash = TestHeaderHash `-8986190201926803368`,
            thPrevHash = GenesisHash,
            thBodyHash = TestBodyHash `-7587558942263677962`,
            thSlotNo = SlotNo 0,
            thBlockNo = BlockNo 0,
            thChainLength = ChainLength 1,
            thIsEBB = RegularBlock},
          testBody = TestBody {tbForkNo = 2, tbIsValid = True}},
      chainFollowers = Map.fromList [],
      nextFollowerId = 0},
    currentLedger = ExtLedgerState {
      ledgerState = TestLedger {
        lastAppliedPoint = Point
          (At
            Block {
              blockPointSlot = SlotNo 0,
              blockPointHash = TestHeaderHash `-8986190201926803368`}),
        lastAppliedHash = BlockHash (TestHeaderHash `-8986190201926803368`)},
      headerState = HeaderState {
        headerStateTip = At
          AnnTip {
            annTipSlotNo = SlotNo 0,
            annTipBlockNo = BlockNo 0,
            annTipInfo = TipInfoIsEBB
              (TestHeaderHash `-8986190201926803368`)
              IsNotEBB},
        headerStateChainDep = `()`}},
    initLedger = ExtLedgerState {
      ledgerState = TestLedger {
        lastAppliedPoint = Point Origin,
        lastAppliedHash = GenesisHash},
      headerState = HeaderState {
        headerStateTip = Origin,
        headerStateChainDep = `()`}},
    iterators = Map.fromList [],
    valid = Set.fromList [TestHeaderHash `-8986190201926803368`],
    invalid = Map.fromList [],
    loeFragment = LoEDisabled,
    isOpen = True},
  knownIters = RefEnv [],
  knownFollowers = RefEnv [],
  modelConfig = Opaque,
  genState = GenState
    (Map.fromList
      [
        _×_
          (TestHeaderHash `-8986190201926803368`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-8986190201926803368`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash `-7587558942263677962`,
              thSlotNo = SlotNo 0,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 2, tbIsValid = True}},
        _×_
          (TestHeaderHash `-1486433721842374672`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-1486433721842374672`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash 7896947812457579993,
              thSlotNo = SlotNo 2,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 1, tbIsValid = False}}])}

   == GetMaxSlotNo ==> Resp { getResp = Right (MaxSlot (MaxSlotNo (SlotNo 2))) } [ 0 ]

Model {
  dbModel = Model {
    volatileDbBlocks = Map.fromList
      [
        _×_
          (TestHeaderHash `-8986190201926803368`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-8986190201926803368`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash `-7587558942263677962`,
              thSlotNo = SlotNo 0,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 2, tbIsValid = True}}],
    immutableDbChain = Genesis,
    perasCerts = Map.fromList
      [
        _×_
          (PerasRoundNo 0)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 0,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 2,
                    blockPointHash = TestHeaderHash `-1486433721842374672`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 1)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 1,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 2)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 2,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1},
        _×_
          (PerasRoundNo 3)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 3,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 3},
        _×_
          (PerasRoundNo 4)
          ValidatedPerasCert {
            vpcCert = PerasCert {
              pcCertRound = PerasRoundNo 4,
              pcCertBoostedBlock = Point
                (At
                  Block {
                    blockPointSlot = SlotNo 0,
                    blockPointHash = TestHeaderHash `-8986190201926803368`})},
            vpcCertBoost = PerasWeight 1}],
    cps = ChainProducerState {
      chainState = :>
        Genesis
        TestBlock {
          testHeader = TestHeader {
            thHash = TestHeaderHash `-8986190201926803368`,
            thPrevHash = GenesisHash,
            thBodyHash = TestBodyHash `-7587558942263677962`,
            thSlotNo = SlotNo 0,
            thBlockNo = BlockNo 0,
            thChainLength = ChainLength 1,
            thIsEBB = RegularBlock},
          testBody = TestBody {tbForkNo = 2, tbIsValid = True}},
      chainFollowers = Map.fromList [],
      nextFollowerId = 0},
    currentLedger = ExtLedgerState {
      ledgerState = TestLedger {
        lastAppliedPoint = Point
          (At
            Block {
              blockPointSlot = SlotNo 0,
              blockPointHash = TestHeaderHash `-8986190201926803368`}),
        lastAppliedHash = BlockHash (TestHeaderHash `-8986190201926803368`)},
      headerState = HeaderState {
        headerStateTip = At
          AnnTip {
            annTipSlotNo = SlotNo 0,
            annTipBlockNo = BlockNo 0,
            annTipInfo = TipInfoIsEBB
              (TestHeaderHash `-8986190201926803368`)
              IsNotEBB},
        headerStateChainDep = `()`}},
    initLedger = ExtLedgerState {
      ledgerState = TestLedger {
        lastAppliedPoint = Point Origin,
        lastAppliedHash = GenesisHash},
      headerState = HeaderState {
        headerStateTip = Origin,
        headerStateChainDep = `()`}},
    iterators = Map.fromList [],
    valid = Set.fromList [TestHeaderHash `-8986190201926803368`],
    invalid = Map.fromList [],
    loeFragment = LoEDisabled,
    isOpen = True},
  knownIters = RefEnv [],
  knownFollowers = RefEnv [],
  modelConfig = Opaque,
  genState = GenState
    (Map.fromList
      [
        _×_
          (TestHeaderHash `-8986190201926803368`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-8986190201926803368`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash `-7587558942263677962`,
              thSlotNo = SlotNo 0,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 2, tbIsValid = True}},
        _×_
          (TestHeaderHash `-1486433721842374672`)
          TestBlock {
            testHeader = TestHeader {
              thHash = TestHeaderHash `-1486433721842374672`,
              thPrevHash = GenesisHash,
              thBodyHash = TestBodyHash 7896947812457579993,
              thSlotNo = SlotNo 2,
              thBlockNo = BlockNo 0,
              thChainLength = ChainLength 1,
              thIsEBB = RegularBlock},
            testBody = TestBody {tbForkNo = 1, tbIsValid = False}}])}

ouroboros-storage
  Storage
    ChainDB
      ChainDB q-s-m
        sequential:                                FAIL (39.80s)
          *** Failed! Falsified (after 8281 tests):
          LoEDisabled
          SmallChunkInfo (UniformChunkSize (ChunkSize {chunkCanContainEBB = False, numRegularBlocks = 9}))
          SecurityParam (NonZero {unNonZero = 2})
          Commands
            { unCommands =
                [ Command
                    (AddPerasCert
                       ValidatedPerasCert
                         { vpcCert =
                             PerasCert
                               { pcCertRound = PerasRoundNo 0
                               , pcCertBoostedBlock =
                                   Point
                                     (At
                                        Block
                                          { blockPointSlot = SlotNo 2
                                          , blockPointHash = TestHeaderHash (-1486433721842374672)
                                          })
                               }
                         , vpcCertBoost = PerasWeight 1
                         }
                       Persistent
                         { unPersistent =
                             [ TestBlock
                                 { testHeader =
                                     TestHeader
                                       { thHash = TestHeaderHash (-1486433721842374672)
                                       , thPrevHash = GenesisHash
                                       , thBodyHash = TestBodyHash 7896947812457579993
                                       , thSlotNo = SlotNo 2
                                       , thBlockNo = BlockNo 0
                                       , thChainLength = ChainLength 1
                                       , thIsEBB = RegularBlock
                                       }
                                 , testBody = TestBody { tbForkNo = 1 , tbIsValid = False }
                                 }
                             ]
                         })
                    Resp { getResp = Right (Unit ()) }
                    []
                , Command
                    (AddPerasCert
                       ValidatedPerasCert
                         { vpcCert =
                             PerasCert
                               { pcCertRound = PerasRoundNo 1
                               , pcCertBoostedBlock =
                                   Point
                                     (At
                                        Block
                                          { blockPointSlot = SlotNo 0
                                          , blockPointHash = TestHeaderHash (-8986190201926803368)
                                          })
                               }
                         , vpcCertBoost = PerasWeight 1
                         }
                       Persistent
                         { unPersistent =
                             [ TestBlock
                                 { testHeader =
                                     TestHeader
                                       { thHash = TestHeaderHash (-8986190201926803368)
                                       , thPrevHash = GenesisHash
                                       , thBodyHash = TestBodyHash (-7587558942263677962)
                                       , thSlotNo = SlotNo 0
                                       , thBlockNo = BlockNo 0
                                       , thChainLength = ChainLength 1
                                       , thIsEBB = RegularBlock
                                       }
                                 , testBody = TestBody { tbForkNo = 2 , tbIsValid = True }
                                 }
                             ]
                         })
                    Resp { getResp = Right (Unit ()) }
                    []
                , Command
                    (AddPerasCert
                       ValidatedPerasCert
                         { vpcCert =
                             PerasCert
                               { pcCertRound = PerasRoundNo 2
                               , pcCertBoostedBlock =
                                   Point
                                     (At
                                        Block
                                          { blockPointSlot = SlotNo 0
                                          , blockPointHash = TestHeaderHash (-8986190201926803368)
                                          })
                               }
                         , vpcCertBoost = PerasWeight 1
                         }
                       Persistent
                         { unPersistent =
                             [ TestBlock
                                 { testHeader =
                                     TestHeader
                                       { thHash = TestHeaderHash (-8986190201926803368)
                                       , thPrevHash = GenesisHash
                                       , thBodyHash = TestBodyHash (-7587558942263677962)
                                       , thSlotNo = SlotNo 0
                                       , thBlockNo = BlockNo 0
                                       , thChainLength = ChainLength 1
                                       , thIsEBB = RegularBlock
                                       }
                                 , testBody = TestBody { tbForkNo = 2 , tbIsValid = True }
                                 }
                             ]
                         })
                    Resp { getResp = Right (Unit ()) }
                    []
                , Command
                    GetMaxSlotNo Resp { getResp = Right (MaxSlot NoMaxSlotNo) } []
                , Command
                    (AddPerasCert
                       ValidatedPerasCert
                         { vpcCert =
                             PerasCert
                               { pcCertRound = PerasRoundNo 3
                               , pcCertBoostedBlock =
                                   Point
                                     (At
                                        Block
                                          { blockPointSlot = SlotNo 0
                                          , blockPointHash = TestHeaderHash (-8986190201926803368)
                                          })
                               }
                         , vpcCertBoost = PerasWeight 3
                         }
                       Persistent
                         { unPersistent =
                             [ TestBlock
                                 { testHeader =
                                     TestHeader
                                       { thHash = TestHeaderHash (-8986190201926803368)
                                       , thPrevHash = GenesisHash
                                       , thBodyHash = TestBodyHash (-7587558942263677962)
                                       , thSlotNo = SlotNo 0
                                       , thBlockNo = BlockNo 0
                                       , thChainLength = ChainLength 1
                                       , thIsEBB = RegularBlock
                                       }
                                 , testBody = TestBody { tbForkNo = 2 , tbIsValid = True }
                                 }
                             ]
                         })
                    Resp { getResp = Right (Unit ()) }
                    []
                , Command
                    (AddBlock
                       TestBlock
                         { testHeader =
                             TestHeader
                               { thHash = TestHeaderHash (-8986190201926803368)
                               , thPrevHash = GenesisHash
                               , thBodyHash = TestBodyHash (-7587558942263677962)
                               , thSlotNo = SlotNo 0
                               , thBlockNo = BlockNo 0
                               , thChainLength = ChainLength 1
                               , thIsEBB = RegularBlock
                               }
                         , testBody = TestBody { tbForkNo = 2 , tbIsValid = True }
                         }
                       Persistent { unPersistent = [] })
                    Resp
                      { getResp =
                          Right
                            (Point
                               (Point
                                  (At
                                     Block
                                       { blockPointSlot = SlotNo 0
                                       , blockPointHash = TestHeaderHash (-8986190201926803368)
                                       })))
                      }
                    []
                , Command
                    GetTipBlock
                    Resp
                      { getResp =
                          Right
                            (MbBlock
                               (Just
                                  TestBlock
                                    { testHeader =
                                        TestHeader
                                          { thHash = TestHeaderHash (-8986190201926803368)
                                          , thPrevHash = GenesisHash
                                          , thBodyHash = TestBodyHash (-7587558942263677962)
                                          , thSlotNo = SlotNo 0
                                          , thBlockNo = BlockNo 0
                                          , thChainLength = ChainLength 1
                                          , thIsEBB = RegularBlock
                                          }
                                    , testBody = TestBody { tbForkNo = 2 , tbIsValid = True }
                                    }))
                      }
                    []
                , Command
                    (AddPerasCert
                       ValidatedPerasCert
                         { vpcCert =
                             PerasCert
                               { pcCertRound = PerasRoundNo 4
                               , pcCertBoostedBlock =
                                   Point
                                     (At
                                        Block
                                          { blockPointSlot = SlotNo 0
                                          , blockPointHash = TestHeaderHash (-8986190201926803368)
                                          })
                               }
                         , vpcCertBoost = PerasWeight 1
                         }
                       Persistent
                         { unPersistent =
                             [ TestBlock
                                 { testHeader =
                                     TestHeader
                                       { thHash = TestHeaderHash (-8986190201926803368)
                                       , thPrevHash = GenesisHash
                                       , thBodyHash = TestBodyHash (-7587558942263677962)
                                       , thSlotNo = SlotNo 0
                                       , thBlockNo = BlockNo 0
                                       , thChainLength = ChainLength 1
                                       , thIsEBB = RegularBlock
                                       }
                                 , testBody = TestBody { tbForkNo = 2 , tbIsValid = True }
                                 }
                             ]
                         })
                    Resp { getResp = Right (Unit ()) }
                    []
                , Command
                    (AddBlock
                       TestBlock
                         { testHeader =
                             TestHeader
                               { thHash = TestHeaderHash (-1486433721842374672)
                               , thPrevHash = GenesisHash
                               , thBodyHash = TestBodyHash 7896947812457579993
                               , thSlotNo = SlotNo 2
                               , thBlockNo = BlockNo 0
                               , thChainLength = ChainLength 1
                               , thIsEBB = RegularBlock
                               }
                         , testBody = TestBody { tbForkNo = 1 , tbIsValid = False }
                         }
                       Persistent { unPersistent = [] })
                    Resp
                      { getResp =
                          Right
                            (Point
                               (Point
                                  (At
                                     Block
                                       { blockPointSlot = SlotNo 0
                                       , blockPointHash = TestHeaderHash (-8986190201926803368)
                                       })))
                      }
                    []
                , Command
                    GetMaxSlotNo
                    Resp { getResp = Right (MaxSlot (MaxSlotNo (SlotNo 0))) }
                    []
                , Command
                    (AddBlock
                       TestBlock
                         { testHeader =
                             TestHeader
                               { thHash = TestHeaderHash (-1486433721842374672)
                               , thPrevHash = GenesisHash
                               , thBodyHash = TestBodyHash 7896947812457579993
                               , thSlotNo = SlotNo 2
                               , thBlockNo = BlockNo 0
                               , thChainLength = ChainLength 1
                               , thIsEBB = RegularBlock
                               }
                         , testBody = TestBody { tbForkNo = 1 , tbIsValid = False }
                         }
                       Persistent { unPersistent = [] })
                    Resp
                      { getResp =
                          Right
                            (Point
                               (Point
                                  (At
                                     Block
                                       { blockPointSlot = SlotNo 0
                                       , blockPointHash = TestHeaderHash (-8986190201926803368)
                                       })))
                      }
                    []
                , Command
                    (NewFollower SelectedChain)
                    Resp { getResp = Right (Flr (Reference (Symbolic (Var 0)))) }
                    [ Var 0 ]
                , Command
                    (AddPerasCert
                       ValidatedPerasCert
                         { vpcCert =
                             PerasCert
                               { pcCertRound = PerasRoundNo 5
                               , pcCertBoostedBlock =
                                   Point
                                     (At
                                        Block
                                          { blockPointSlot = SlotNo 0
                                          , blockPointHash = TestHeaderHash (-8986190201926803368)
                                          })
                               }
                         , vpcCertBoost = PerasWeight 1
                         }
                       Persistent
                         { unPersistent =
                             [ TestBlock
                                 { testHeader =
                                     TestHeader
                                       { thHash = TestHeaderHash (-8986190201926803368)
                                       , thPrevHash = GenesisHash
                                       , thBodyHash = TestBodyHash (-7587558942263677962)
                                       , thSlotNo = SlotNo 0
                                       , thBlockNo = BlockNo 0
                                       , thChainLength = ChainLength 1
                                       , thIsEBB = RegularBlock
                                       }
                                 , testBody = TestBody { tbForkNo = 2 , tbIsValid = True }
                                 }
                             ]
                         })
                    Resp { getResp = Right (Unit ()) }
                    []
                , Command PersistBlks Resp { getResp = Right (Unit ()) } []
                , Command
                    (AddPerasCert
                       ValidatedPerasCert
                         { vpcCert =
                             PerasCert
                               { pcCertRound = PerasRoundNo 6
                               , pcCertBoostedBlock =
                                   Point
                                     (At
                                        Block
                                          { blockPointSlot = SlotNo 2
                                          , blockPointHash = TestHeaderHash (-1486433721842374672)
                                          })
                               }
                         , vpcCertBoost = PerasWeight 1
                         }
                       Persistent
                         { unPersistent =
                             [ TestBlock
                                 { testHeader =
                                     TestHeader
                                       { thHash = TestHeaderHash (-1486433721842374672)
                                       , thPrevHash = GenesisHash
                                       , thBodyHash = TestBodyHash 7896947812457579993
                                       , thSlotNo = SlotNo 2
                                       , thBlockNo = BlockNo 0
                                       , thChainLength = ChainLength 1
                                       , thIsEBB = RegularBlock
                                       }
                                 , testBody = TestBody { tbForkNo = 1 , tbIsValid = False }
                                 }
                             ]
                         })
                    Resp { getResp = Right (Unit ()) }
                    []
                , Command
                    (AddPerasCert
                       ValidatedPerasCert
                         { vpcCert =
                             PerasCert
                               { pcCertRound = PerasRoundNo 7
                               , pcCertBoostedBlock =
                                   Point
                                     (At
                                        Block
                                          { blockPointSlot = SlotNo 2
                                          , blockPointHash = TestHeaderHash (-1486433721842374672)
                                          })
                               }
                         , vpcCertBoost = PerasWeight 1
                         }
                       Persistent
                         { unPersistent =
                             [ TestBlock
                                 { testHeader =
                                     TestHeader
                                       { thHash = TestHeaderHash (-1486433721842374672)
                                       , thPrevHash = GenesisHash
                                       , thBodyHash = TestBodyHash 7896947812457579993
                                       , thSlotNo = SlotNo 2
                                       , thBlockNo = BlockNo 0
                                       , thChainLength = ChainLength 1
                                       , thIsEBB = RegularBlock
                                       }
                                 , testBody = TestBody { tbForkNo = 1 , tbIsValid = False }
                                 }
                             ]
                         })
                    Resp { getResp = Right (Unit ()) }
                    []
                , Command
                    (GetIsValid
                       (RealPoint (SlotNo 0) (TestHeaderHash (-8986190201926803368))))
                    Resp
                      { getResp =
                          Right
                            (IsValid IsValidResult { real = False , isValid = Just True })
                      }
                    []
                , Command
                    (GetIsValid
                       (RealPoint (SlotNo 0) (TestHeaderHash (-8986190201926803368))))
                    Resp
                      { getResp =
                          Right
                            (IsValid IsValidResult { real = False , isValid = Just True })
                      }
                    []
                , Command
                    GetCurrentChain
                    Resp
                      { getResp =
                          Right
                            (Chain
                               AnchoredSeq
                                 { anchor =
                                     Anchor
                                       (SlotNo 0) (TestHeaderHash (-8986190201926803368)) (BlockNo 0)
                                 , unanchorSeq = SFT { fromStrict = fromList [] }
                                 })
                      }
                    []
                ]
            }
          SecurityParam (NonZero {unNonZero = 2})
          Model chain: Genesis :> TestBlock {testHeader = TestHeader {thHash = TestHeaderHash (-8986190201926803368), thPrevHash = GenesisHash, thBodyHash = TestBodyHash (-7587558942263677962), thSlotNo = SlotNo 0, thBlockNo = BlockNo 0, thChainLength = ChainLength 1, thIsEBB = RegularBlock}, testBody = TestBody {tbForkNo = 2, tbIsValid = True}}
          TraceEvents: TraceOpenEvent StartedOpeningDB
          TraceOpenEvent StartedOpeningImmutableDB
          TraceImmutableDBEvent NoValidLastLocation
          TraceOpenEvent (OpenedImmutableDB (Point Origin) 0)
          TraceOpenEvent StartedOpeningVolatileDB
          TraceOpenEvent (OpenedVolatileDB NoMaxSlotNo)
          TraceOpenEvent StartedOpeningLgrDB
          TraceLedgerDBEvent (LedgerReplayEvent (TraceReplayStartEvent ReplayFromGenesis))
          TraceLedgerDBEvent (LedgerDBFlavorImplEvent (FlavorImplSpecificTraceV2 (TraceLedgerTablesHandleCreate RisingEdge)))
          TraceLedgerDBEvent (LedgerDBFlavorImplEvent (FlavorImplSpecificTraceV2 (TraceLedgerTablesHandleCreate (FallingEdgeWith 0.000001814s))))
          TraceOpenEvent OpenedLgrDB
          TracePerasCertDbEvent OpenedPerasCertDB
          TraceInitChainSelEvent StartedInitChainSelection
          TraceLedgerDBEvent (LedgerDBFlavorImplEvent (FlavorImplSpecificTraceV2 (TraceLedgerTablesHandleCreate RisingEdge)))
          TraceLedgerDBEvent (LedgerDBFlavorImplEvent (FlavorImplSpecificTraceV2 (TraceLedgerTablesHandleCreate (FallingEdgeWith 0.000001022s))))
          TraceLedgerDBEvent (LedgerDBForkerEvent (TraceForkerEventWithKey (ForkerKey 0) ForkerOpen))
          TraceInitChainSelEvent InitialChainSelected
          TraceLedgerDBEvent (LedgerDBForkerEvent (TraceForkerEventWithKey (ForkerKey 0) (ForkerClose ForkerWasCommitted)))
          TraceLedgerDBEvent (LedgerDBFlavorImplEvent (FlavorImplSpecificTraceV2 (TraceLedgerTablesHandleClose RisingEdge)))
          TraceLedgerDBEvent (LedgerDBFlavorImplEvent (FlavorImplSpecificTraceV2 (TraceLedgerTablesHandleClose (FallingEdgeWith 0.000000541s))))
          TraceOpenEvent (OpenedDB (Point Origin) (Point Origin))
          TraceAddBlockEvent PoppingFromQueue
          TraceAddPerasCertEvent (AddedPerasCertToQueue (PerasRoundNo 0) (Point (At (Block {blockPointSlot = SlotNo 2, blockPointHash = TestHeaderHash (-1486433721842374672)}))) RisingEdge)
          TraceAddPerasCertEvent (AddedPerasCertToQueue (PerasRoundNo 0) (Point (At (Block {blockPointSlot = SlotNo 2, blockPointHash = TestHeaderHash (-1486433721842374672)}))) (FallingEdgeWith 1))
          TraceAddPerasCertEvent (PoppedPerasCertFromQueue (PerasRoundNo 0) (Point (At (Block {blockPointSlot = SlotNo 2, blockPointHash = TestHeaderHash (-1486433721842374672)}))))
          TracePerasCertDbEvent (AddingPerasCert (PerasRoundNo 0) (Point (At (Block {blockPointSlot = SlotNo 2, blockPointHash = TestHeaderHash (-1486433721842374672)}))))
          TracePerasCertDbEvent (AddedPerasCert (PerasRoundNo 0) (Point (At (Block {blockPointSlot = SlotNo 2, blockPointHash = TestHeaderHash (-1486433721842374672)}))))
          TraceAddPerasCertEvent (PerasCertBoostsBlockNotYetReceived (PerasRoundNo 0) (Point (At (Block {blockPointSlot = SlotNo 2, blockPointHash = TestHeaderHash (-1486433721842374672)}))))
          TraceAddBlockEvent PoppingFromQueue
          TraceAddPerasCertEvent (AddedPerasCertToQueue (PerasRoundNo 1) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))) RisingEdge)
          TraceAddPerasCertEvent (AddedPerasCertToQueue (PerasRoundNo 1) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))) (FallingEdgeWith 1))
          TraceAddPerasCertEvent (PoppedPerasCertFromQueue (PerasRoundNo 1) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TracePerasCertDbEvent (AddingPerasCert (PerasRoundNo 1) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TracePerasCertDbEvent (AddedPerasCert (PerasRoundNo 1) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TraceAddPerasCertEvent (PerasCertBoostsBlockNotYetReceived (PerasRoundNo 1) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TraceAddBlockEvent PoppingFromQueue
          TraceAddPerasCertEvent (AddedPerasCertToQueue (PerasRoundNo 2) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))) RisingEdge)
          TraceAddPerasCertEvent (AddedPerasCertToQueue (PerasRoundNo 2) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))) (FallingEdgeWith 1))
          TraceAddPerasCertEvent (PoppedPerasCertFromQueue (PerasRoundNo 2) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TracePerasCertDbEvent (AddingPerasCert (PerasRoundNo 2) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TracePerasCertDbEvent (AddedPerasCert (PerasRoundNo 2) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TraceAddPerasCertEvent (PerasCertBoostsBlockNotYetReceived (PerasRoundNo 2) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TraceAddBlockEvent PoppingFromQueue
          TraceAddPerasCertEvent (AddedPerasCertToQueue (PerasRoundNo 3) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))) RisingEdge)
          TraceAddPerasCertEvent (AddedPerasCertToQueue (PerasRoundNo 3) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))) (FallingEdgeWith 1))
          TraceAddPerasCertEvent (PoppedPerasCertFromQueue (PerasRoundNo 3) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TracePerasCertDbEvent (AddingPerasCert (PerasRoundNo 3) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TracePerasCertDbEvent (AddedPerasCert (PerasRoundNo 3) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TraceAddPerasCertEvent (PerasCertBoostsBlockNotYetReceived (PerasRoundNo 3) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TraceAddBlockEvent PoppingFromQueue
          TraceAddBlockEvent (AddedBlockToQueue (RealPoint (SlotNo 0) (TestHeaderHash (-8986190201926803368))) RisingEdge)
          TraceAddBlockEvent (AddedBlockToQueue (RealPoint (SlotNo 0) (TestHeaderHash (-8986190201926803368))) (FallingEdgeWith 1))
          TraceChainSelStarvationEvent (ChainSelStarvation (FallingEdgeWith (RealPoint (SlotNo 0) (TestHeaderHash (-8986190201926803368)))))
          TraceAddBlockEvent (PoppedBlockFromQueue (RealPoint (SlotNo 0) (TestHeaderHash (-8986190201926803368))))
          TraceAddBlockEvent (AddedBlockToVolatileDB (RealPoint (SlotNo 0) (TestHeaderHash (-8986190201926803368))) (BlockNo 0) IsNotEBB RisingEdge)
          TraceAddBlockEvent (AddedBlockToVolatileDB (RealPoint (SlotNo 0) (TestHeaderHash (-8986190201926803368))) (BlockNo 0) IsNotEBB (FallingEdgeWith ()))
          TraceAddBlockEvent (ChainSelectionLoEDebug (AnchoredSeq {anchor = AnchorGenesis, unanchorSeq = SFT {fromStrict = fromList []}}) LoEDisabled)
          TraceAddBlockEvent (TryAddToCurrentChain (RealPoint (SlotNo 0) (TestHeaderHash (-8986190201926803368))))
          TraceAddBlockEvent (PipeliningEvent (SetTentativeHeader (TestHeader {thHash = TestHeaderHash (-8986190201926803368), thPrevHash = GenesisHash, thBodyHash = TestBodyHash (-7587558942263677962), thSlotNo = SlotNo 0, thBlockNo = BlockNo 0, thChainLength = ChainLength 1, thIsEBB = RegularBlock}) RisingEdge))
          TraceAddBlockEvent (PipeliningEvent (SetTentativeHeader (TestHeader {thHash = TestHeaderHash (-8986190201926803368), thPrevHash = GenesisHash, thBodyHash = TestBodyHash (-7587558942263677962), thSlotNo = SlotNo 0, thBlockNo = BlockNo 0, thChainLength = ChainLength 1, thIsEBB = RegularBlock}) (FallingEdgeWith ())))
          TraceLedgerDBEvent (LedgerDBFlavorImplEvent (FlavorImplSpecificTraceV2 (TraceLedgerTablesHandleCreate RisingEdge)))
          TraceLedgerDBEvent (LedgerDBFlavorImplEvent (FlavorImplSpecificTraceV2 (TraceLedgerTablesHandleCreate (FallingEdgeWith 0.000001533s))))
          TraceLedgerDBEvent (LedgerDBForkerEvent (TraceForkerEventWithKey (ForkerKey 1) ForkerOpen))
          TraceAddBlockEvent (AddBlockValidation (UpdateLedgerDbTraceEvent (StartedPushingBlockToTheLedgerDb (PushStart {unPushStart = RealPoint (SlotNo 0) (TestHeaderHash (-8986190201926803368))}) (PushGoal {unPushGoal = RealPoint (SlotNo 0) (TestHeaderHash (-8986190201926803368))}) (Pushing {unPushing = RealPoint (SlotNo 0) (TestHeaderHash (-8986190201926803368))}))))
          TraceLedgerDBEvent (LedgerDBForkerEvent (TraceForkerEventWithKey (ForkerKey 1) (ForkerReadTables RisingEdge)))
          TraceLedgerDBEvent (LedgerDBForkerEvent (TraceForkerEventWithKey (ForkerKey 1) (ForkerReadTables (FallingEdgeWith 0.000001573s))))
          TraceLedgerDBEvent (LedgerDBForkerEvent (TraceForkerEventWithKey (ForkerKey 1) (ForkerPush RisingEdge)))
          TraceLedgerDBEvent (LedgerDBFlavorImplEvent (FlavorImplSpecificTraceV2 (TraceLedgerTablesHandleCreate RisingEdge)))
          TraceLedgerDBEvent (LedgerDBFlavorImplEvent (FlavorImplSpecificTraceV2 (TraceLedgerTablesHandleCreate (FallingEdgeWith 0.000001172s))))
          TraceLedgerDBEvent (LedgerDBForkerEvent (TraceForkerEventWithKey (ForkerKey 1) (ForkerPush (FallingEdgeWith 0.000012373s))))
          TraceAddBlockEvent (AddBlockValidation (ValidCandidate (AnchoredSeq {anchor = AnchorGenesis, unanchorSeq = SFT {fromStrict = fromList [MeasuredWith {unMeasuredWith = TestHeader {thHash = TestHeaderHash (-8986190201926803368), thPrevHash = GenesisHash, thBodyHash = TestBodyHash (-7587558942263677962), thSlotNo = SlotNo 0, thBlockNo = BlockNo 0, thChainLength = ChainLength 1, thIsEBB = RegularBlock}}]}})))
          TraceAddBlockEvent (ChangingSelection (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TraceAddBlockEvent (AddedToCurrentChain [] (SelectionChangedInfo {newTipPoint = RealPoint (SlotNo 0) (TestHeaderHash (-8986190201926803368)), newTipEpoch = EpochNo 0, newTipSlotInEpoch = 0, newTipTrigger = Just (RealPoint (SlotNo 0) (TestHeaderHash (-8986190201926803368))), newSuffixSelectView = WeightedSelectView {wsvBlockNo = BlockNo 0, wsvWeightBoost = PerasWeight 5, wsvTiebreaker = BftWithEBBsTiebreakerView {bebbIsEBB = IsNotEBB, bebbChainLength = ChainLength 1, bebbHash = TestHeaderHash (-8986190201926803368)}}, oldSuffixSelectView = Nothing}) (AnchoredSeq {anchor = AnchorGenesis, unanchorSeq = SFT {fromStrict = fromList []}}) (AnchoredSeq {anchor = AnchorGenesis, unanchorSeq = SFT {fromStrict = fromList [MeasuredWith {unMeasuredWith = TestHeader {thHash = TestHeaderHash (-8986190201926803368), thPrevHash = GenesisHash, thBodyHash = TestBodyHash (-7587558942263677962), thSlotNo = SlotNo 0, thBlockNo = BlockNo 0, thChainLength = ChainLength 1, thIsEBB = RegularBlock}}]}}) (Left CandidateIsNonEmpty))
          TraceAddBlockEvent (PipeliningEvent (OutdatedTentativeHeader (TestHeader {thHash = TestHeaderHash (-8986190201926803368), thPrevHash = GenesisHash, thBodyHash = TestBodyHash (-7587558942263677962), thSlotNo = SlotNo 0, thBlockNo = BlockNo 0, thChainLength = ChainLength 1, thIsEBB = RegularBlock})))
          TraceLedgerDBEvent (LedgerDBForkerEvent (TraceForkerEventWithKey (ForkerKey 1) (ForkerClose ForkerWasCommitted)))
          TraceLedgerDBEvent (LedgerDBFlavorImplEvent (FlavorImplSpecificTraceV2 (TraceLedgerTablesHandleClose RisingEdge)))
          TraceLedgerDBEvent (LedgerDBFlavorImplEvent (FlavorImplSpecificTraceV2 (TraceLedgerTablesHandleClose (FallingEdgeWith 0.000000631s))))
          TraceAddBlockEvent PoppingFromQueue
          TraceChainSelStarvationEvent (ChainSelStarvation RisingEdge)
          TraceAddPerasCertEvent (AddedPerasCertToQueue (PerasRoundNo 4) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))) RisingEdge)
          TraceAddPerasCertEvent (AddedPerasCertToQueue (PerasRoundNo 4) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))) (FallingEdgeWith 1))
          TraceAddPerasCertEvent (PoppedPerasCertFromQueue (PerasRoundNo 4) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TracePerasCertDbEvent (AddingPerasCert (PerasRoundNo 4) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TracePerasCertDbEvent (AddedPerasCert (PerasRoundNo 4) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TraceAddPerasCertEvent (PerasCertBoostsCurrentChain (PerasRoundNo 4) (Point (At (Block {blockPointSlot = SlotNo 0, blockPointHash = TestHeaderHash (-8986190201926803368)}))))
          TraceAddBlockEvent PoppingFromQueue
          TraceAddBlockEvent (AddedBlockToQueue (RealPoint (SlotNo 2) (TestHeaderHash (-1486433721842374672))) RisingEdge)
          TraceAddBlockEvent (AddedBlockToQueue (RealPoint (SlotNo 2) (TestHeaderHash (-1486433721842374672))) (FallingEdgeWith 1))
          TraceChainSelStarvationEvent (ChainSelStarvation (FallingEdgeWith (RealPoint (SlotNo 2) (TestHeaderHash (-1486433721842374672)))))
          TraceAddBlockEvent (PoppedBlockFromQueue (RealPoint (SlotNo 2) (TestHeaderHash (-1486433721842374672))))
          TraceAddBlockEvent (IgnoreBlockOlderThanImmTip (RealPoint (SlotNo 2) (TestHeaderHash (-1486433721842374672))))
          
          PostconditionFailed "Fst (AnnotateC \"real response didn't match model response\" (PredicateC (Resp {getResp = Right (MaxSlot (MaxSlotNo (SlotNo 2)))} :/= Resp {getResp = Right (MaxSlot (MaxSlotNo (SlotNo 0)))})))" /= Ok
          Use --quickcheck-replay="(SMGen 15194541575572225434 13540340026014931941,80)" to reproduce.
          Use -p '/ChainDB q-s-m.sequential/' to rerun this test only.