{-# 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]