{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}

module Test.Cardano.Ledger.Dijkstra.Imp.EbSpec (spec) where

import Cardano.Ledger.BaseTypes
import Cardano.Ledger.Block (
  EbReferencesAnnouncement (..),
  LeiosEraBlockHeader (..),
  ebReferencesAnnouncementHashL,
  ebReferencesAnnouncementSizeL,
  slotNoBlockHeaderL,
 )
import Cardano.Ledger.Coin (Coin (..))
import Cardano.Ledger.Dijkstra (
  DijkstraApplyBlock (..),
  InvalidEndorserBlockReferences (..),
  applyEndorserBlockNoValidation,
 )
import Cardano.Ledger.Dijkstra.Block.Endorser (EraEndorserBlock (..))
import Cardano.Ledger.Dijkstra.Core
import Cardano.Ledger.Dijkstra.PParams (ppMaxEndorserBlockReferencesSizeL)
import Cardano.Ledger.Dijkstra.Rules (
  EbAlreadyApplied (..),
  EbAnnouncementHashMismatch (..),
  EbAnnouncementSizeMismatch (..),
  EbAnnouncementSlotMismatch (..),
  EbReferencesSizeTooBig (..),
  EbWasNotAnnounced (..),
 )
import Cardano.Ledger.Shelley.LedgerState (
  esLStateL,
  lsLastEbAnnouncementL,
  nesEsL,
  nesLastTickSlotNoL,
 )
import Cardano.Ledger.State (EbAnnouncement (..))
import Cardano.Ledger.Tools (ensureMinCoinTxOut)
import Control.Exception (evaluate)
import Control.Monad.IO.Class (liftIO)
import Control.Monad.State.Strict (MonadState (..), gets)
import Control.State.Transition.Extended (SingEP (..), ValidationPolicy (..))
import Data.Word (Word32)
import Lens.Micro ((&), (.~), (^.))
import Test.Cardano.Ledger.BlockHeader (TestBlockHeader)
import Test.Cardano.Ledger.Dijkstra.ImpTest
import Test.Cardano.Ledger.Imp.Common

spec ::
  forall era.
  ( DijkstraEraImp era
  , HashAnnotated (Tx TopTx era) EraIndependentTx
  ) =>
  SpecWith (ImpInit (LedgerSpec era))
spec :: forall era.
(DijkstraEraImp era,
 HashAnnotated (Tx TopTx era) EraIndependentTx) =>
SpecWith (ImpInit (LedgerSpec era))
spec = String
-> SpecWith (ImpInit (LedgerSpec era))
-> SpecWith (ImpInit (LedgerSpec era))
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"EB" (SpecWith (ImpInit (LedgerSpec era))
 -> SpecWith (ImpInit (LedgerSpec era)))
-> SpecWith (ImpInit (LedgerSpec era))
-> SpecWith (ImpInit (LedgerSpec era))
forall a b. (a -> b) -> a -> b
$ do
  String
-> SpecWith (ImpInit (LedgerSpec era))
-> SpecWith (ImpInit (LedgerSpec era))
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Applying EB" (SpecWith (ImpInit (LedgerSpec era))
 -> SpecWith (ImpInit (LedgerSpec era)))
-> SpecWith (ImpInit (LedgerSpec era))
-> SpecWith (ImpInit (LedgerSpec era))
forall a b. (a -> b) -> a -> b
$ do
    let
      genSimpleTx :: ImpTestM era (AnyLevelTx era)
      genSimpleTx :: ImpTestM era (AnyLevelTx era)
genSimpleTx = do
        pp <- Lens' (PParams era) (PParams era) -> ImpTestM era (PParams era)
forall era a. EraGov era => Lens' (PParams era) a -> ImpTestM era a
getsPParams (PParams era -> f (PParams era)) -> PParams era -> f (PParams era)
forall a. a -> a
Lens' (PParams era) (PParams era)
id
        addr <- freshKeyAddr_
        amnt <- inject . Coin <$> choose (100, 1000000000)
        pure $
          AnyLevelTx $
            mkBasicTx @era mkBasicTxBody
              & bodyTxL . outputsTxBodyL .~ [ensureMinCoinTxOut pp $ mkBasicTxOut addr amnt]

      genRBandEB :: ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
genRBandEB = ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
-> ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
forall era a. ImpTestM era a -> ImpTestM era a
simulateThenRestore (ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
 -> ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era))
-> ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
-> ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
forall a b. (a -> b) -> a -> b
$ do
        nBlockTxs <- (Int, Int) -> ImpM (LedgerSpec era) Int
forall a. Random a => (a, a) -> ImpM (LedgerSpec era) a
forall (g :: * -> *) a. (MonadGen g, Random a) => (a, a) -> g a
choose (Int
0, Int
10)
        blockTxs <- impRecordSubmittedTxs $ replicateM_ nBlockTxs $ do
          AnyLevelTx tx <- genSimpleTx
          submitAnyTx tx
        nEbTxs <- choose (1, 100)
        ebTxs <- impRecordSubmittedTxs $ replicateM_ nEbTxs $ do
          AnyLevelTx tx <- genSimpleTx
          submitAnyTx tx
        eb <- makeEndorserBlock ebTxs
        pure (blockTxs, eb)

      submitAnnouncingRB :: StrictSeq (Tx TopTx era)
-> EbReferencesAnnouncement
-> ImpM (LedgerSpec era) (Block TestBlockHeader era)
submitAnnouncingRB StrictSeq (Tx TopTx era)
blockTxs EbReferencesAnnouncement
announcement = do
        ImpTestM era ()
forall era. (HasCallStack, ShelleyEraImp era) => ImpTestM era ()
tickToCurSlot
        st <- ImpM (LedgerSpec era) (ImpTestState era)
forall s (m :: * -> *). MonadState s m => m s
get
        issuer <- freshKeyHash
        impAnn "Submit RB" $
          expectRightDeepExpr
            =<< tryTxsInBlock
              (ebReferencesAnnouncementBlockHeaderL .~ SJust announcement)
              blockTxs
              st
              issuer

      ebRefsSize :: EndorserBlock era -> Int
ebRefsSize EndorserBlock era
eb = EbReferences era -> Int
forall t. SafeToHash t => t -> Int
originalBytesSize (EbReferences era -> Int) -> EbReferences era -> Int
forall a b. (a -> b) -> a -> b
$ EndorserBlock era
eb EndorserBlock era
-> Getting
     (EbReferences era) (EndorserBlock era) (EbReferences era)
-> EbReferences era
forall s a. s -> Getting a s a -> a
^. Getting (EbReferences era) (EndorserBlock era) (EbReferences era)
forall era.
EraEndorserBlock era =>
Lens' (EndorserBlock era) (EbReferences era)
Lens' (EndorserBlock era) (EbReferences era)
referencesEndorserBlockL

      expectNoValidationToThrow :: EndorserBlock era
-> NonEmpty (EraRuleFailure "EB" era) -> ImpM (LedgerSpec era) ()
expectNoValidationToThrow EndorserBlock era
eb NonEmpty (EraRuleFailure "EB" era)
expected = do
        nes <- SimpleGetter (NewEpochState era) (NewEpochState era)
-> ImpTestM era (NewEpochState era)
forall era a. SimpleGetter (NewEpochState era) a -> ImpTestM era a
getsNES (NewEpochState era -> Const r (NewEpochState era))
-> NewEpochState era -> Const r (NewEpochState era)
forall a. a -> a
SimpleGetter (NewEpochState era) (NewEpochState era)
id
        globals <- gets (^. impGlobalsL)
        liftIO $
          evaluate (applyEndorserBlockNoValidation @TestBlockHeader @era globals nes eb)
            `shouldThrow` \(InvalidEndorserBlockReferences era
err :: InvalidEndorserBlockReferences era) ->
              case InvalidEndorserBlockReferences era
err of
                InvalidEndorserBlockReferences NonEmpty (EbPredFailure era)
failures CallStack
_ -> (EbPredFailure era -> EraRuleFailure "EB" era)
-> NonEmpty (EbPredFailure era)
-> NonEmpty (EraRuleFailure "EB" era)
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure @"EB") NonEmpty (EbPredFailure era)
failures NonEmpty (EraRuleFailure "EB" era)
-> NonEmpty (EraRuleFailure "EB" era) -> Bool
forall a. Eq a => a -> a -> Bool
== NonEmpty (EraRuleFailure "EB" era)
expected

      expectSameStateWithoutValidation :: EndorserBlock era -> ImpM (LedgerSpec era) ()
expectSameStateWithoutValidation EndorserBlock era
eb = do
        nes <- SimpleGetter (NewEpochState era) (NewEpochState era)
-> ImpTestM era (NewEpochState era)
forall era a. SimpleGetter (NewEpochState era) a -> ImpTestM era a
getsNES (NewEpochState era -> Const r (NewEpochState era))
-> NewEpochState era -> Const r (NewEpochState era)
forall a. a -> a
SimpleGetter (NewEpochState era) (NewEpochState era)
id
        globals <- gets (^. impGlobalsL)
        let (validatedNes, failures, _) =
              applyEndorserBlock @TestBlockHeader @era EPDiscard ValidateAll globals nes eb
        failures `shouldBeExpr` []
        applyEndorserBlockNoValidation @TestBlockHeader @era globals nes eb
          `shouldBeExpr` validatedNes

      injectEbFailure :: InjectRuleFailure "EB" t era => t era -> EraRuleFailure "EB" era
      injectEbFailure :: forall (t :: * -> *).
InjectRuleFailure "EB" t era =>
t era -> EraRuleFailure "EB" era
injectEbFailure = t era -> EraRuleFailure "EB" era
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

      ebRefsHash :: EndorserBlock era -> SafeHash EraIndependentEbReferences
ebRefsHash EndorserBlock era
eb = EbReferences era -> SafeHash EraIndependentEbReferences
forall x i. HashAnnotated x i => x -> SafeHash i
hashAnnotated (EbReferences era -> SafeHash EraIndependentEbReferences)
-> EbReferences era -> SafeHash EraIndependentEbReferences
forall a b. (a -> b) -> a -> b
$ EndorserBlock era
eb EndorserBlock era
-> Getting
     (EbReferences era) (EndorserBlock era) (EbReferences era)
-> EbReferences era
forall s a. s -> Getting a s a -> a
^. Getting (EbReferences era) (EndorserBlock era) (EbReferences era)
forall era.
EraEndorserBlock era =>
Lens' (EndorserBlock era) (EbReferences era)
Lens' (EndorserBlock era) (EbReferences era)
referencesEndorserBlockL

      announcementHashMismatch :: EndorserBlock era
-> SafeHash EraIndependentEbReferences -> EraRuleFailure "EB" era
announcementHashMismatch EndorserBlock era
eb SafeHash EraIndependentEbReferences
announcedHash =
        EbAnnouncementHashMismatch era -> EraRuleFailure "EB" era
forall (t :: * -> *).
InjectRuleFailure "EB" t era =>
t era -> EraRuleFailure "EB" era
injectEbFailure (EbAnnouncementHashMismatch era -> EraRuleFailure "EB" era)
-> EbAnnouncementHashMismatch era -> EraRuleFailure "EB" era
forall a b. (a -> b) -> a -> b
$
          Mismatch RelEQ (SafeHash EraIndependentEbReferences)
-> EbAnnouncementHashMismatch era
forall era.
Mismatch RelEQ (SafeHash EraIndependentEbReferences)
-> EbAnnouncementHashMismatch era
EbAnnouncementHashMismatch
            Mismatch {mismatchSupplied :: SafeHash EraIndependentEbReferences
mismatchSupplied = EndorserBlock era -> SafeHash EraIndependentEbReferences
forall {era}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 EraEndorserBlock era) =>
EndorserBlock era -> SafeHash EraIndependentEbReferences
ebRefsHash EndorserBlock era
eb, mismatchExpected :: SafeHash EraIndependentEbReferences
mismatchExpected = SafeHash EraIndependentEbReferences
announcedHash}

      announcementSizeMismatch :: EndorserBlock era -> Word32 -> EraRuleFailure "EB" era
announcementSizeMismatch EndorserBlock era
eb Word32
announcedSize =
        EbAnnouncementSizeMismatch era -> EraRuleFailure "EB" era
forall (t :: * -> *).
InjectRuleFailure "EB" t era =>
t era -> EraRuleFailure "EB" era
injectEbFailure (EbAnnouncementSizeMismatch era -> EraRuleFailure "EB" era)
-> EbAnnouncementSizeMismatch era -> EraRuleFailure "EB" era
forall a b. (a -> b) -> a -> b
$
          Mismatch RelEQ Int -> EbAnnouncementSizeMismatch era
forall era. Mismatch RelEQ Int -> EbAnnouncementSizeMismatch era
EbAnnouncementSizeMismatch
            Mismatch
              { mismatchSupplied :: Int
mismatchSupplied = EndorserBlock era -> Int
forall {era}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 EraEndorserBlock era) =>
EndorserBlock era -> Int
ebRefsSize EndorserBlock era
eb
              , mismatchExpected :: Int
mismatchExpected = forall a b. (Integral a, Num b) => a -> b
fromIntegral @Word32 @Int Word32
announcedSize
              }

      referencesSizeTooBig :: EndorserBlock era -> Int -> EraRuleFailure "EB" era
referencesSizeTooBig EndorserBlock era
eb Int
maxEbRefsSize =
        EbReferencesSizeTooBig era -> EraRuleFailure "EB" era
forall (t :: * -> *).
InjectRuleFailure "EB" t era =>
t era -> EraRuleFailure "EB" era
injectEbFailure (EbReferencesSizeTooBig era -> EraRuleFailure "EB" era)
-> EbReferencesSizeTooBig era -> EraRuleFailure "EB" era
forall a b. (a -> b) -> a -> b
$
          Mismatch RelLTEQ Int -> EbReferencesSizeTooBig era
forall era. Mismatch RelLTEQ Int -> EbReferencesSizeTooBig era
EbReferencesSizeTooBig
            Mismatch {mismatchSupplied :: Int
mismatchSupplied = EndorserBlock era -> Int
forall {era}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 EraEndorserBlock era) =>
EndorserBlock era -> Int
ebRefsSize EndorserBlock era
eb, mismatchExpected :: Int
mismatchExpected = Int
maxEbRefsSize}

    String
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Succeeds when EB is announced" (ImpM (LedgerSpec era) ()
 -> SpecWith (Arg (ImpM (LedgerSpec era) ())))
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a b. (a -> b) -> a -> b
$ do
      (blockTxs, eb) <- ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
genRBandEB
      _ <- submitAnnouncingRB blockTxs $ mkEbReferencesAnnouncement eb
      impAnn "Submit EB" $ submitEndorserBlock eb
      fmap ebIsApplied
        <$> getsNES (nesEsL . esLStateL . lsLastEbAnnouncementL)
          `shouldReturn` SJust True
    String
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Produces the same state with and without validation" (ImpM (LedgerSpec era) ()
 -> SpecWith (Arg (ImpM (LedgerSpec era) ())))
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a b. (a -> b) -> a -> b
$ do
      (blockTxs, eb) <- ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
genRBandEB
      _ <- submitAnnouncingRB blockTxs $ mkEbReferencesAnnouncement eb
      expectSameStateWithoutValidation eb
    String
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Fails when the EB is not announced" (ImpM (LedgerSpec era) ()
 -> SpecWith (Arg (ImpM (LedgerSpec era) ())))
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a b. (a -> b) -> a -> b
$ do
      (_, eb) <- ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
genRBandEB
      impAnn "Submit EB" $
        submitFailingEndorserBlock eb [injectFailure $ EbWasNotAnnounced $ ebRefsHash eb]
    String
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Fails when the EB announcement has a different hash" (ImpM (LedgerSpec era) ()
 -> SpecWith (Arg (ImpM (LedgerSpec era) ())))
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a b. (a -> b) -> a -> b
$ do
      (blockTxs, eb) <- ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
genRBandEB
      wrongHash <- arbitrary
      _ <-
        submitAnnouncingRB blockTxs $
          mkEbReferencesAnnouncement eb & ebReferencesAnnouncementHashL .~ wrongHash
      impAnn "Submit EB" $ submitFailingEndorserBlock eb [announcementHashMismatch eb wrongHash]
    String
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Fails when the EB announcement has a different size" (ImpM (LedgerSpec era) ()
 -> SpecWith (Arg (ImpM (LedgerSpec era) ())))
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a b. (a -> b) -> a -> b
$ do
      (blockTxs, eb) <- ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
genRBandEB
      let announcement = EndorserBlock era -> EbReferencesAnnouncement
forall era.
EraEndorserBlock era =>
EndorserBlock era -> EbReferencesAnnouncement
mkEbReferencesAnnouncement EndorserBlock era
eb
          wrongSize = EbReferencesAnnouncement -> Word32
ebReferencesAnnouncementSize EbReferencesAnnouncement
announcement Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
+ Word32
1
      _ <- submitAnnouncingRB blockTxs $ announcement & ebReferencesAnnouncementSizeL .~ wrongSize
      impAnn "Submit EB" $ submitFailingEndorserBlock eb [announcementSizeMismatch eb wrongSize]
    String
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Fails when the EB is applied at a slot after the announcing block" (ImpM (LedgerSpec era) ()
 -> SpecWith (Arg (ImpM (LedgerSpec era) ())))
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a b. (a -> b) -> a -> b
$ do
      (blockTxs, eb) <- ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
genRBandEB
      block <- submitAnnouncingRB blockTxs $ mkEbReferencesAnnouncement eb
      passTick
      tickToCurSlot
      laterSlot <- getsNES nesLastTickSlotNoL
      impAnn "Submit EB" $
        submitFailingEndorserBlock
          eb
          [ injectFailure $
              EbAnnouncementSlotMismatch
                Mismatch
                  { mismatchSupplied = laterSlot
                  , mismatchExpected = block ^. slotNoBlockHeaderL
                  }
          ]
    String
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Succeeds when the EB references are exactly at the size limit" (ImpM (LedgerSpec era) ()
 -> SpecWith (Arg (ImpM (LedgerSpec era) ())))
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a b. (a -> b) -> a -> b
$ do
      (blockTxs, eb) <- ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
genRBandEB
      _ <- submitAnnouncingRB blockTxs $ mkEbReferencesAnnouncement eb
      modifyPParams $ ppMaxEndorserBlockReferencesSizeL .~ fromIntegral @Int @Word32 (ebRefsSize eb)
      expectSameStateWithoutValidation eb
    String
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Fails when the EB references exceed the size limit" (ImpM (LedgerSpec era) ()
 -> SpecWith (Arg (ImpM (LedgerSpec era) ())))
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a b. (a -> b) -> a -> b
$ do
      (blockTxs, eb) <- ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
genRBandEB
      let maxEbRefsSize = EndorserBlock era -> Int
forall {era}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 EraEndorserBlock era) =>
EndorserBlock era -> Int
ebRefsSize EndorserBlock era
eb Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
      _ <- submitAnnouncingRB blockTxs $ mkEbReferencesAnnouncement eb
      modifyPParams $ ppMaxEndorserBlockReferencesSizeL .~ fromIntegral @Int @Word32 maxEbRefsSize
      impAnn "Submit EB" $ submitFailingEndorserBlock eb [referencesSizeTooBig eb maxEbRefsSize]
    String
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Errors without validation when the EB was not announced" (ImpM (LedgerSpec era) ()
 -> SpecWith (Arg (ImpM (LedgerSpec era) ())))
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a b. (a -> b) -> a -> b
$ do
      (_, eb) <- ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
genRBandEB
      expectNoValidationToThrow eb [injectFailure $ EbWasNotAnnounced $ ebRefsHash eb]
    String
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Errors without validation with every failure of the EB references, ignoring the slot" (ImpM (LedgerSpec era) ()
 -> SpecWith (Arg (ImpM (LedgerSpec era) ())))
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a b. (a -> b) -> a -> b
$ do
      (blockTxs, eb) <- ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
genRBandEB
      wrongHash <- arbitrary
      let announcedSize = EbReferencesAnnouncement -> Word32
ebReferencesAnnouncementSize (EndorserBlock era -> EbReferencesAnnouncement
forall era.
EraEndorserBlock era =>
EndorserBlock era -> EbReferencesAnnouncement
mkEbReferencesAnnouncement EndorserBlock era
eb) Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
+ Word32
1
          maxEbRefsSize = EndorserBlock era -> Int
forall {era}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 EraEndorserBlock era) =>
EndorserBlock era -> Int
ebRefsSize EndorserBlock era
eb Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
      _ <-
        submitAnnouncingRB blockTxs $
          mkEbReferencesAnnouncement eb
            & ebReferencesAnnouncementHashL .~ wrongHash
            & ebReferencesAnnouncementSizeL .~ announcedSize
      modifyPParams $ ppMaxEndorserBlockReferencesSizeL .~ fromIntegral @Int @Word32 maxEbRefsSize
      passTick
      tickToCurSlot
      expectNoValidationToThrow
        eb
        [ referencesSizeTooBig eb maxEbRefsSize
        , announcementHashMismatch eb wrongHash
        , announcementSizeMismatch eb announcedSize
        ]
    String
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Fails when the EB is applied again" (ImpM (LedgerSpec era) ()
 -> SpecWith (Arg (ImpM (LedgerSpec era) ())))
-> ImpM (LedgerSpec era) ()
-> SpecWith (Arg (ImpM (LedgerSpec era) ()))
forall a b. (a -> b) -> a -> b
$ do
      (blockTxs, eb) <- ImpTestM era (StrictSeq (Tx TopTx era), EndorserBlock era)
genRBandEB
      _ <- submitAnnouncingRB blockTxs $ mkEbReferencesAnnouncement eb
      impAnn "Submit EB" $ submitEndorserBlock eb
      let alreadyApplied = EbAlreadyApplied era -> EraRuleFailure "EB" era
forall (t :: * -> *).
InjectRuleFailure "EB" t era =>
t era -> EraRuleFailure "EB" era
injectEbFailure (EbAlreadyApplied era -> EraRuleFailure "EB" era)
-> EbAlreadyApplied era -> EraRuleFailure "EB" era
forall a b. (a -> b) -> a -> b
$ SafeHash EraIndependentEbReferences -> EbAlreadyApplied era
forall era.
SafeHash EraIndependentEbReferences -> EbAlreadyApplied era
EbAlreadyApplied (SafeHash EraIndependentEbReferences -> EbAlreadyApplied era)
-> SafeHash EraIndependentEbReferences -> EbAlreadyApplied era
forall a b. (a -> b) -> a -> b
$ EndorserBlock era -> SafeHash EraIndependentEbReferences
forall {era}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 EraEndorserBlock era) =>
EndorserBlock era -> SafeHash EraIndependentEbReferences
ebRefsHash EndorserBlock era
eb
      impAnn "Submit EB again" $ submitFailingEndorserBlock eb [alreadyApplied]
      expectNoValidationToThrow eb [alreadyApplied]