{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Ledger.Conway.Rules.Bbody (
  ConwayBBODY,
  ConwayBbodyPredFailure (..),
  alonzoToConwayBbodyPredFailure,
  shelleyToConwayBbodyPredFailure,
  totalRefScriptSizeInBlock,
  conwayBbodyTransition,
) where

import Cardano.Ledger.Allegra.Rules (AllegraUtxoPredFailure)
import Cardano.Ledger.Alonzo.PParams (AlonzoEraPParams)
import Cardano.Ledger.Alonzo.Rules (
  AlonzoBbodyEvent (..),
  AlonzoBbodyPredFailure (ShelleyInAlonzoBbodyPredFailure),
  AlonzoUtxoPredFailure,
  AlonzoUtxosPredFailure,
  AlonzoUtxowPredFailure,
  alonzoBbodyTransition,
 )
import qualified Cardano.Ledger.Alonzo.Rules as Alonzo (AlonzoBbodyPredFailure (..))
import Cardano.Ledger.Alonzo.Scripts (ExUnits (..))
import Cardano.Ledger.Alonzo.Tx (AlonzoEraTx, IsValid (..), isValidTxL)
import Cardano.Ledger.Alonzo.TxWits (AlonzoEraTxWits (..))
import Cardano.Ledger.BHeaderView (BHeaderView (..))
import Cardano.Ledger.Babbage.Collateral (collOuts)
import Cardano.Ledger.Babbage.Core (BabbageEraTxBody)
import Cardano.Ledger.Babbage.Rules (BabbageUtxoPredFailure, BabbageUtxowPredFailure)
import Cardano.Ledger.BaseTypes (
  Mismatch (..),
  ProtVer,
  Relation (..),
  ShelleyBase,
  natVersion,
  pvMajor,
 )
import Cardano.Ledger.Binary (DecCBOR (..), EncCBOR (..))
import Cardano.Ledger.Binary.Coders (Decode (..), Encode (..), decode, encode, (!>), (<!))
import Cardano.Ledger.Block (Block (..))
import Cardano.Ledger.Conway.Era (ConwayBBODY, ConwayEra)
import Cardano.Ledger.Conway.PParams (ConwayEraPParams (..))
import Cardano.Ledger.Conway.Rules.Cert (ConwayCertPredFailure)
import Cardano.Ledger.Conway.Rules.Certs (ConwayCertsPredFailure)
import Cardano.Ledger.Conway.Rules.Deleg (ConwayDelegPredFailure)
import Cardano.Ledger.Conway.Rules.Gov (ConwayGovPredFailure)
import Cardano.Ledger.Conway.Rules.GovCert (ConwayGovCertPredFailure)
import Cardano.Ledger.Conway.Rules.Ledger (ConwayLedgerPredFailure)
import Cardano.Ledger.Conway.Rules.Ledgers ()
import Cardano.Ledger.Conway.Rules.Utxo (ConwayUtxoPredFailure)
import Cardano.Ledger.Conway.Rules.Utxos (ConwayUtxosPredFailure)
import Cardano.Ledger.Conway.Rules.Utxow (ConwayUtxowPredFailure)
import Cardano.Ledger.Conway.UTxO (txNonDistinctRefScriptsSize)
import Cardano.Ledger.Core
import Cardano.Ledger.Shelley.LedgerState (LedgerState (..), lsUTxOState, utxosUtxo)
import Cardano.Ledger.Shelley.Rules (
  BbodyEnv (..),
  ShelleyBbodyEvent (..),
  ShelleyBbodyPredFailure,
  ShelleyBbodyState (..),
  ShelleyLedgersEnv (..),
  ShelleyLedgersPredFailure,
  ShelleyPoolPredFailure,
  ShelleyUtxoPredFailure,
  ShelleyUtxowPredFailure,
 )
import qualified Cardano.Ledger.Shelley.Rules as Shelley (ShelleyBbodyPredFailure (..))
import Cardano.Ledger.Shelley.UTxO (UTxO (..), txouts, unUTxO)
import Control.State.Transition (
  Embed (..),
  STS (..),
  TRC (..),
  TransitionRule,
  judgmentContext,
  (?!),
 )
import Data.Foldable (Foldable (foldMap'))
import qualified Data.Foldable as F (foldl')
import qualified Data.Map.Strict as Map
import Data.Monoid (Sum (getSum))
import qualified Data.Monoid as Monoid (Sum (..))
import Data.Sequence (Seq)
import Data.Sequence.Strict (StrictSeq (..))
import Data.Word (Word32)
import GHC.Generics (Generic)
import Lens.Micro
import NoThunks.Class (NoThunks (..))

data ConwayBbodyPredFailure era
  = WrongBlockBodySizeBBODY (Mismatch RelEQ Int)
  | InvalidBodyHashBBODY (Mismatch RelEQ (Hash HASH EraIndependentBlockBody))
  | -- | LEDGERS rule subtransition Failures
    LedgersFailure (PredicateFailure (EraRule "LEDGERS" era))
  | TooManyExUnits (Mismatch RelLTEQ ExUnits)
  | BodyRefScriptsSizeTooBig (Mismatch RelLTEQ Int)
  deriving ((forall x.
 ConwayBbodyPredFailure era -> Rep (ConwayBbodyPredFailure era) x)
-> (forall x.
    Rep (ConwayBbodyPredFailure era) x -> ConwayBbodyPredFailure era)
-> Generic (ConwayBbodyPredFailure era)
forall x.
Rep (ConwayBbodyPredFailure era) x -> ConwayBbodyPredFailure era
forall x.
ConwayBbodyPredFailure era -> Rep (ConwayBbodyPredFailure era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall era x.
Rep (ConwayBbodyPredFailure era) x -> ConwayBbodyPredFailure era
forall era x.
ConwayBbodyPredFailure era -> Rep (ConwayBbodyPredFailure era) x
$cfrom :: forall era x.
ConwayBbodyPredFailure era -> Rep (ConwayBbodyPredFailure era) x
from :: forall x.
ConwayBbodyPredFailure era -> Rep (ConwayBbodyPredFailure era) x
$cto :: forall era x.
Rep (ConwayBbodyPredFailure era) x -> ConwayBbodyPredFailure era
to :: forall x.
Rep (ConwayBbodyPredFailure era) x -> ConwayBbodyPredFailure era
Generic)

deriving instance
  (Era era, Show (PredicateFailure (EraRule "LEDGERS" era))) =>
  Show (ConwayBbodyPredFailure era)

deriving instance
  (Era era, Eq (PredicateFailure (EraRule "LEDGERS" era))) =>
  Eq (ConwayBbodyPredFailure era)

deriving anyclass instance
  (Era era, NoThunks (PredicateFailure (EraRule "LEDGERS" era))) =>
  NoThunks (ConwayBbodyPredFailure era)

instance
  ( Era era
  , EncCBOR (PredicateFailure (EraRule "LEDGERS" era))
  ) =>
  EncCBOR (ConwayBbodyPredFailure era)
  where
  encCBOR :: ConwayBbodyPredFailure era -> Encoding
encCBOR =
    Encode Open (ConwayBbodyPredFailure era) -> Encoding
forall (w :: Wrapped) t. Encode w t -> Encoding
encode (Encode Open (ConwayBbodyPredFailure era) -> Encoding)
-> (ConwayBbodyPredFailure era
    -> Encode Open (ConwayBbodyPredFailure era))
-> ConwayBbodyPredFailure era
-> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. \case
      WrongBlockBodySizeBBODY Mismatch RelEQ Int
mm -> (Mismatch RelEQ Int -> ConwayBbodyPredFailure era)
-> Word
-> Encode Open (Mismatch RelEQ Int -> ConwayBbodyPredFailure era)
forall t. t -> Word -> Encode Open t
Sum Mismatch RelEQ Int -> ConwayBbodyPredFailure era
forall era. Mismatch RelEQ Int -> ConwayBbodyPredFailure era
WrongBlockBodySizeBBODY Word
0 Encode Open (Mismatch RelEQ Int -> ConwayBbodyPredFailure era)
-> Encode (Closed Dense) (Mismatch RelEQ Int)
-> Encode Open (ConwayBbodyPredFailure era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Mismatch RelEQ Int -> Encode (Closed Dense) (Mismatch RelEQ Int)
forall t. EncCBORGroup t => t -> Encode (Closed Dense) t
ToGroup Mismatch RelEQ Int
mm
      InvalidBodyHashBBODY Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
mm -> (Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
 -> ConwayBbodyPredFailure era)
-> Word
-> Encode
     Open
     (Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
      -> ConwayBbodyPredFailure era)
forall t. t -> Word -> Encode Open t
Sum (forall era.
Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
-> ConwayBbodyPredFailure era
InvalidBodyHashBBODY @era) Word
1 Encode
  Open
  (Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
   -> ConwayBbodyPredFailure era)
-> Encode
     (Closed Dense) (Mismatch RelEQ (Hash HASH EraIndependentBlockBody))
-> Encode Open (ConwayBbodyPredFailure era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
-> Encode
     (Closed Dense) (Mismatch RelEQ (Hash HASH EraIndependentBlockBody))
forall t. EncCBORGroup t => t -> Encode (Closed Dense) t
ToGroup Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
mm
      LedgersFailure PredicateFailure (EraRule "LEDGERS" era)
x -> (PredicateFailure (EraRule "LEDGERS" era)
 -> ConwayBbodyPredFailure era)
-> Word
-> Encode
     Open
     (PredicateFailure (EraRule "LEDGERS" era)
      -> ConwayBbodyPredFailure era)
forall t. t -> Word -> Encode Open t
Sum (forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ConwayBbodyPredFailure era
LedgersFailure @era) Word
2 Encode
  Open
  (PredicateFailure (EraRule "LEDGERS" era)
   -> ConwayBbodyPredFailure era)
-> Encode (Closed Dense) (PredicateFailure (EraRule "LEDGERS" era))
-> Encode Open (ConwayBbodyPredFailure era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> PredicateFailure (EraRule "LEDGERS" era)
-> Encode (Closed Dense) (PredicateFailure (EraRule "LEDGERS" era))
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To PredicateFailure (EraRule "LEDGERS" era)
x
      TooManyExUnits Mismatch RelLTEQ ExUnits
mm -> (Mismatch RelLTEQ ExUnits -> ConwayBbodyPredFailure era)
-> Word
-> Encode
     Open (Mismatch RelLTEQ ExUnits -> ConwayBbodyPredFailure era)
forall t. t -> Word -> Encode Open t
Sum Mismatch RelLTEQ ExUnits -> ConwayBbodyPredFailure era
forall era. Mismatch RelLTEQ ExUnits -> ConwayBbodyPredFailure era
TooManyExUnits Word
3 Encode
  Open (Mismatch RelLTEQ ExUnits -> ConwayBbodyPredFailure era)
-> Encode (Closed Dense) (Mismatch RelLTEQ ExUnits)
-> Encode Open (ConwayBbodyPredFailure era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Mismatch RelLTEQ ExUnits
-> Encode (Closed Dense) (Mismatch RelLTEQ ExUnits)
forall t. EncCBORGroup t => t -> Encode (Closed Dense) t
ToGroup Mismatch RelLTEQ ExUnits
mm
      BodyRefScriptsSizeTooBig Mismatch RelLTEQ Int
mm -> (Mismatch RelLTEQ Int -> ConwayBbodyPredFailure era)
-> Word
-> Encode Open (Mismatch RelLTEQ Int -> ConwayBbodyPredFailure era)
forall t. t -> Word -> Encode Open t
Sum Mismatch RelLTEQ Int -> ConwayBbodyPredFailure era
forall era. Mismatch RelLTEQ Int -> ConwayBbodyPredFailure era
BodyRefScriptsSizeTooBig Word
4 Encode Open (Mismatch RelLTEQ Int -> ConwayBbodyPredFailure era)
-> Encode (Closed Dense) (Mismatch RelLTEQ Int)
-> Encode Open (ConwayBbodyPredFailure era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Mismatch RelLTEQ Int
-> Encode (Closed Dense) (Mismatch RelLTEQ Int)
forall t. EncCBORGroup t => t -> Encode (Closed Dense) t
ToGroup Mismatch RelLTEQ Int
mm

instance
  ( Era era
  , DecCBOR (PredicateFailure (EraRule "LEDGERS" era))
  ) =>
  DecCBOR (ConwayBbodyPredFailure era)
  where
  decCBOR :: forall s. Decoder s (ConwayBbodyPredFailure era)
decCBOR = Decode (Closed Dense) (ConwayBbodyPredFailure era)
-> Decoder s (ConwayBbodyPredFailure era)
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode (Decode (Closed Dense) (ConwayBbodyPredFailure era)
 -> Decoder s (ConwayBbodyPredFailure era))
-> ((Word -> Decode Open (ConwayBbodyPredFailure era))
    -> Decode (Closed Dense) (ConwayBbodyPredFailure era))
-> (Word -> Decode Open (ConwayBbodyPredFailure era))
-> Decoder s (ConwayBbodyPredFailure era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text
-> (Word -> Decode Open (ConwayBbodyPredFailure era))
-> Decode (Closed Dense) (ConwayBbodyPredFailure era)
forall t.
Text -> (Word -> Decode Open t) -> Decode (Closed Dense) t
Summands Text
"ConwayBbodyPred" ((Word -> Decode Open (ConwayBbodyPredFailure era))
 -> Decoder s (ConwayBbodyPredFailure era))
-> (Word -> Decode Open (ConwayBbodyPredFailure era))
-> Decoder s (ConwayBbodyPredFailure era)
forall a b. (a -> b) -> a -> b
$ \case
    Word
0 -> (Mismatch RelEQ Int -> ConwayBbodyPredFailure era)
-> Decode Open (Mismatch RelEQ Int -> ConwayBbodyPredFailure era)
forall t. t -> Decode Open t
SumD Mismatch RelEQ Int -> ConwayBbodyPredFailure era
forall era. Mismatch RelEQ Int -> ConwayBbodyPredFailure era
WrongBlockBodySizeBBODY Decode Open (Mismatch RelEQ Int -> ConwayBbodyPredFailure era)
-> Decode (Closed (ZonkAny 0)) (Mismatch RelEQ Int)
-> Decode Open (ConwayBbodyPredFailure era)
forall a (w1 :: Wrapped) t (w :: Density).
Typeable a =>
Decode w1 (a -> t) -> Decode (Closed w) a -> Decode w1 t
<! Decode (Closed (ZonkAny 0)) (Mismatch RelEQ Int)
forall t (w :: Wrapped).
(EncCBORGroup t, DecCBORGroup t) =>
Decode w t
FromGroup
    Word
1 -> (Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
 -> ConwayBbodyPredFailure era)
-> Decode
     Open
     (Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
      -> ConwayBbodyPredFailure era)
forall t. t -> Decode Open t
SumD Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
-> ConwayBbodyPredFailure era
forall era.
Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
-> ConwayBbodyPredFailure era
InvalidBodyHashBBODY Decode
  Open
  (Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
   -> ConwayBbodyPredFailure era)
-> Decode
     (Closed (ZonkAny 1))
     (Mismatch RelEQ (Hash HASH EraIndependentBlockBody))
-> Decode Open (ConwayBbodyPredFailure era)
forall a (w1 :: Wrapped) t (w :: Density).
Typeable a =>
Decode w1 (a -> t) -> Decode (Closed w) a -> Decode w1 t
<! Decode
  (Closed (ZonkAny 1))
  (Mismatch RelEQ (Hash HASH EraIndependentBlockBody))
forall t (w :: Wrapped).
(EncCBORGroup t, DecCBORGroup t) =>
Decode w t
FromGroup
    Word
2 -> (PredicateFailure (EraRule "LEDGERS" era)
 -> ConwayBbodyPredFailure era)
-> Decode
     Open
     (PredicateFailure (EraRule "LEDGERS" era)
      -> ConwayBbodyPredFailure era)
forall t. t -> Decode Open t
SumD PredicateFailure (EraRule "LEDGERS" era)
-> ConwayBbodyPredFailure era
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ConwayBbodyPredFailure era
LedgersFailure Decode
  Open
  (PredicateFailure (EraRule "LEDGERS" era)
   -> ConwayBbodyPredFailure era)
-> Decode
     (Closed (ZonkAny 2)) (PredicateFailure (EraRule "LEDGERS" era))
-> Decode Open (ConwayBbodyPredFailure era)
forall a (w1 :: Wrapped) t (w :: Density).
Typeable a =>
Decode w1 (a -> t) -> Decode (Closed w) a -> Decode w1 t
<! Decode
  (Closed (ZonkAny 2)) (PredicateFailure (EraRule "LEDGERS" era))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
    Word
3 -> (Mismatch RelLTEQ ExUnits -> ConwayBbodyPredFailure era)
-> Decode
     Open (Mismatch RelLTEQ ExUnits -> ConwayBbodyPredFailure era)
forall t. t -> Decode Open t
SumD Mismatch RelLTEQ ExUnits -> ConwayBbodyPredFailure era
forall era. Mismatch RelLTEQ ExUnits -> ConwayBbodyPredFailure era
TooManyExUnits Decode
  Open (Mismatch RelLTEQ ExUnits -> ConwayBbodyPredFailure era)
-> Decode (Closed (ZonkAny 3)) (Mismatch RelLTEQ ExUnits)
-> Decode Open (ConwayBbodyPredFailure era)
forall a (w1 :: Wrapped) t (w :: Density).
Typeable a =>
Decode w1 (a -> t) -> Decode (Closed w) a -> Decode w1 t
<! Decode (Closed (ZonkAny 3)) (Mismatch RelLTEQ ExUnits)
forall t (w :: Wrapped).
(EncCBORGroup t, DecCBORGroup t) =>
Decode w t
FromGroup
    Word
4 -> (Mismatch RelLTEQ Int -> ConwayBbodyPredFailure era)
-> Decode Open (Mismatch RelLTEQ Int -> ConwayBbodyPredFailure era)
forall t. t -> Decode Open t
SumD Mismatch RelLTEQ Int -> ConwayBbodyPredFailure era
forall era. Mismatch RelLTEQ Int -> ConwayBbodyPredFailure era
BodyRefScriptsSizeTooBig Decode Open (Mismatch RelLTEQ Int -> ConwayBbodyPredFailure era)
-> Decode (Closed (ZonkAny 4)) (Mismatch RelLTEQ Int)
-> Decode Open (ConwayBbodyPredFailure era)
forall a (w1 :: Wrapped) t (w :: Density).
Typeable a =>
Decode w1 (a -> t) -> Decode (Closed w) a -> Decode w1 t
<! Decode (Closed (ZonkAny 4)) (Mismatch RelLTEQ Int)
forall t (w :: Wrapped).
(EncCBORGroup t, DecCBORGroup t) =>
Decode w t
FromGroup
    Word
n -> Word -> Decode Open (ConwayBbodyPredFailure era)
forall (w :: Wrapped) t. Word -> Decode w t
Invalid Word
n

type instance EraRuleFailure "BBODY" ConwayEra = ConwayBbodyPredFailure ConwayEra

type instance EraRuleEvent "BBODY" ConwayEra = AlonzoBbodyEvent ConwayEra

instance InjectRuleFailure "BBODY" ConwayBbodyPredFailure ConwayEra

instance InjectRuleFailure "BBODY" AlonzoBbodyPredFailure ConwayEra where
  injectFailure :: AlonzoBbodyPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = AlonzoBbodyPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
AlonzoBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
AlonzoBbodyPredFailure era -> ConwayBbodyPredFailure era
alonzoToConwayBbodyPredFailure

instance InjectRuleFailure "BBODY" ShelleyBbodyPredFailure ConwayEra where
  injectFailure :: ShelleyBbodyPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure

instance InjectRuleFailure "BBODY" ShelleyLedgersPredFailure ConwayEra where
  injectFailure :: ShelleyLedgersPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (ShelleyLedgersPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> ShelleyLedgersPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure

instance InjectRuleFailure "BBODY" ConwayLedgerPredFailure ConwayEra where
  injectFailure :: ConwayLedgerPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (ConwayLedgerPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> ConwayLedgerPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (ConwayLedgerPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> ConwayLedgerPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConwayLedgerPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
ConwayLedgerPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" ConwayUtxowPredFailure ConwayEra where
  injectFailure :: ConwayUtxowPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (ConwayUtxowPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> ConwayUtxowPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (ConwayUtxowPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> ConwayUtxowPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConwayUtxowPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
ConwayUtxowPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" BabbageUtxowPredFailure ConwayEra where
  injectFailure :: BabbageUtxowPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (BabbageUtxowPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> BabbageUtxowPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (BabbageUtxowPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> BabbageUtxowPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BabbageUtxowPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
BabbageUtxowPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" AlonzoUtxowPredFailure ConwayEra where
  injectFailure :: AlonzoUtxowPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (AlonzoUtxowPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> AlonzoUtxowPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (AlonzoUtxowPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> AlonzoUtxowPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AlonzoUtxowPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
AlonzoUtxowPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" ShelleyUtxowPredFailure ConwayEra where
  injectFailure :: ShelleyUtxowPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (ShelleyUtxowPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> ShelleyUtxowPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (ShelleyUtxowPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> ShelleyUtxowPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShelleyUtxowPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
ShelleyUtxowPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" ConwayUtxoPredFailure ConwayEra where
  injectFailure :: ConwayUtxoPredFailure ConwayEra -> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (ConwayUtxoPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> ConwayUtxoPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (ConwayUtxoPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> ConwayUtxoPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConwayUtxoPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
ConwayUtxoPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" BabbageUtxoPredFailure ConwayEra where
  injectFailure :: BabbageUtxoPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (BabbageUtxoPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> BabbageUtxoPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (BabbageUtxoPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> BabbageUtxoPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BabbageUtxoPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
BabbageUtxoPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" AlonzoUtxoPredFailure ConwayEra where
  injectFailure :: AlonzoUtxoPredFailure ConwayEra -> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (AlonzoUtxoPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> AlonzoUtxoPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (AlonzoUtxoPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> AlonzoUtxoPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AlonzoUtxoPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
AlonzoUtxoPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" AlonzoUtxosPredFailure ConwayEra where
  injectFailure :: AlonzoUtxosPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (AlonzoUtxosPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> AlonzoUtxosPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (AlonzoUtxosPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> AlonzoUtxosPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AlonzoUtxosPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
AlonzoUtxosPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" ConwayUtxosPredFailure ConwayEra where
  injectFailure :: ConwayUtxosPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (ConwayUtxosPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> ConwayUtxosPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (ConwayUtxosPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> ConwayUtxosPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConwayUtxosPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
ConwayUtxosPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" ShelleyUtxoPredFailure ConwayEra where
  injectFailure :: ShelleyUtxoPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (ShelleyUtxoPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> ShelleyUtxoPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (ShelleyUtxoPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> ShelleyUtxoPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShelleyUtxoPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
ShelleyUtxoPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" AllegraUtxoPredFailure ConwayEra where
  injectFailure :: AllegraUtxoPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (AllegraUtxoPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> AllegraUtxoPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (AllegraUtxoPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> AllegraUtxoPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AllegraUtxoPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
AllegraUtxoPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" ConwayCertsPredFailure ConwayEra where
  injectFailure :: ConwayCertsPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (ConwayCertsPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> ConwayCertsPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (ConwayCertsPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> ConwayCertsPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConwayCertsPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
ConwayCertsPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" ConwayCertPredFailure ConwayEra where
  injectFailure :: ConwayCertPredFailure ConwayEra -> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (ConwayCertPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> ConwayCertPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (ConwayCertPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> ConwayCertPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConwayCertPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
ConwayCertPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" ConwayDelegPredFailure ConwayEra where
  injectFailure :: ConwayDelegPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (ConwayDelegPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> ConwayDelegPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (ConwayDelegPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> ConwayDelegPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConwayDelegPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
ConwayDelegPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" ShelleyPoolPredFailure ConwayEra where
  injectFailure :: ShelleyPoolPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (ShelleyPoolPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> ShelleyPoolPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (ShelleyPoolPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> ShelleyPoolPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShelleyPoolPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
ShelleyPoolPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" ConwayGovCertPredFailure ConwayEra where
  injectFailure :: ConwayGovCertPredFailure ConwayEra
-> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (ConwayGovCertPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> ConwayGovCertPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (ConwayGovCertPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> ConwayGovCertPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConwayGovCertPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
ConwayGovCertPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

instance InjectRuleFailure "BBODY" ConwayGovPredFailure ConwayEra where
  injectFailure :: ConwayGovPredFailure ConwayEra -> EraRuleFailure "BBODY" ConwayEra
injectFailure = ShelleyBbodyPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure (ShelleyBbodyPredFailure ConwayEra
 -> ConwayBbodyPredFailure ConwayEra)
-> (ConwayGovPredFailure ConwayEra
    -> ShelleyBbodyPredFailure ConwayEra)
-> ConwayGovPredFailure ConwayEra
-> ConwayBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PredicateFailure (EraRule "LEDGERS" ConwayEra)
-> ShelleyBbodyPredFailure ConwayEra
ShelleyLedgersPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ShelleyBbodyPredFailure era
Shelley.LedgersFailure (ShelleyLedgersPredFailure ConwayEra
 -> ShelleyBbodyPredFailure ConwayEra)
-> (ConwayGovPredFailure ConwayEra
    -> ShelleyLedgersPredFailure ConwayEra)
-> ConwayGovPredFailure ConwayEra
-> ShelleyBbodyPredFailure ConwayEra
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConwayGovPredFailure ConwayEra
-> EraRuleFailure "LEDGERS" ConwayEra
ConwayGovPredFailure ConwayEra
-> ShelleyLedgersPredFailure ConwayEra
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure

shelleyToConwayBbodyPredFailure ::
  forall era.
  ShelleyBbodyPredFailure era ->
  ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure :: forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure
  (Shelley.WrongBlockBodySizeBBODY Mismatch RelEQ Int
m) =
    Mismatch RelEQ Int -> ConwayBbodyPredFailure era
forall era. Mismatch RelEQ Int -> ConwayBbodyPredFailure era
WrongBlockBodySizeBBODY Mismatch RelEQ Int
m
shelleyToConwayBbodyPredFailure
  (Shelley.InvalidBodyHashBBODY Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
m) =
    Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
-> ConwayBbodyPredFailure era
forall era.
Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
-> ConwayBbodyPredFailure era
InvalidBodyHashBBODY Mismatch RelEQ (Hash HASH EraIndependentBlockBody)
m
shelleyToConwayBbodyPredFailure (Shelley.LedgersFailure PredicateFailure (EraRule "LEDGERS" era)
x) = PredicateFailure (EraRule "LEDGERS" era)
-> ConwayBbodyPredFailure era
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ConwayBbodyPredFailure era
LedgersFailure PredicateFailure (EraRule "LEDGERS" era)
x

alonzoToConwayBbodyPredFailure ::
  forall era.
  AlonzoBbodyPredFailure era ->
  ConwayBbodyPredFailure era
alonzoToConwayBbodyPredFailure :: forall era.
AlonzoBbodyPredFailure era -> ConwayBbodyPredFailure era
alonzoToConwayBbodyPredFailure (ShelleyInAlonzoBbodyPredFailure ShelleyBbodyPredFailure era
x) = ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
forall era.
ShelleyBbodyPredFailure era -> ConwayBbodyPredFailure era
shelleyToConwayBbodyPredFailure ShelleyBbodyPredFailure era
x
alonzoToConwayBbodyPredFailure (Alonzo.TooManyExUnits Mismatch RelLTEQ ExUnits
m) = Mismatch RelLTEQ ExUnits -> ConwayBbodyPredFailure era
forall era. Mismatch RelLTEQ ExUnits -> ConwayBbodyPredFailure era
TooManyExUnits Mismatch RelLTEQ ExUnits
m

instance
  ( Embed (EraRule "LEDGERS" era) (EraRule "BBODY" era)
  , Environment (EraRule "LEDGERS" era) ~ ShelleyLedgersEnv era
  , State (EraRule "LEDGERS" era) ~ LedgerState era
  , Signal (EraRule "LEDGERS" era) ~ Seq (Tx TopTx era)
  , AlonzoEraTxWits era
  , EraBlockBody era
  , AlonzoEraPParams era
  , InjectRuleFailure "BBODY" AlonzoBbodyPredFailure era
  , InjectRuleFailure "BBODY" ConwayBbodyPredFailure era
  , EraRule "BBODY" era ~ ConwayBBODY era
  , AlonzoEraTx era
  , BabbageEraTxBody era
  , ConwayEraPParams era
  ) =>
  STS (ConwayBBODY era)
  where
  type State (ConwayBBODY era) = ShelleyBbodyState era

  type Signal (ConwayBBODY era) = Block BHeaderView era

  type Environment (ConwayBBODY era) = BbodyEnv era

  type BaseM (ConwayBBODY era) = ShelleyBase

  type PredicateFailure (ConwayBBODY era) = ConwayBbodyPredFailure era

  type Event (ConwayBBODY era) = AlonzoBbodyEvent era

  initialRules :: [InitialRule (ConwayBBODY era)]
initialRules = []
  transitionRules :: [TransitionRule (ConwayBBODY era)]
transitionRules = [forall era.
(Signal (EraRule "BBODY" era) ~ Block BHeaderView era,
 State (EraRule "BBODY" era) ~ ShelleyBbodyState era,
 Environment (EraRule "BBODY" era) ~ BbodyEnv era,
 State (EraRule "LEDGERS" era) ~ LedgerState era,
 InjectRuleFailure "BBODY" AlonzoBbodyPredFailure era,
 InjectRuleFailure "BBODY" ConwayBbodyPredFailure era,
 AlonzoEraTx era, EraBlockBody era, BabbageEraTxBody era,
 ConwayEraPParams era) =>
TransitionRule (EraRule "BBODY" era)
conwayBbodyTransition @era F (Clause (ConwayBBODY era) 'Transition) (ShelleyBbodyState era)
-> F (Clause (ConwayBBODY era) 'Transition) (ShelleyBbodyState era)
-> F (Clause (ConwayBBODY era) 'Transition) (ShelleyBbodyState era)
forall a b.
F (Clause (ConwayBBODY era) 'Transition) a
-> F (Clause (ConwayBBODY era) 'Transition) b
-> F (Clause (ConwayBBODY era) 'Transition) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall era.
(STS (EraRule "BBODY" era),
 Signal (EraRule "BBODY" era) ~ Block BHeaderView era,
 InjectRuleFailure "BBODY" AlonzoBbodyPredFailure era,
 BaseM (EraRule "BBODY" era) ~ ShelleyBase,
 State (EraRule "BBODY" era) ~ ShelleyBbodyState era,
 Environment (EraRule "BBODY" era) ~ BbodyEnv era,
 Embed (EraRule "LEDGERS" era) (EraRule "BBODY" era),
 Environment (EraRule "LEDGERS" era) ~ ShelleyLedgersEnv era,
 State (EraRule "LEDGERS" era) ~ LedgerState era,
 Signal (EraRule "LEDGERS" era) ~ Seq (Tx TopTx era),
 EraBlockBody era, AlonzoEraTxWits era, AlonzoEraPParams era) =>
TransitionRule (EraRule "BBODY" era)
alonzoBbodyTransition @era]

conwayBbodyTransition ::
  forall era.
  ( Signal (EraRule "BBODY" era) ~ Block BHeaderView era
  , State (EraRule "BBODY" era) ~ ShelleyBbodyState era
  , Environment (EraRule "BBODY" era) ~ BbodyEnv era
  , State (EraRule "LEDGERS" era) ~ LedgerState era
  , InjectRuleFailure "BBODY" AlonzoBbodyPredFailure era
  , InjectRuleFailure "BBODY" ConwayBbodyPredFailure era
  , AlonzoEraTx era
  , EraBlockBody era
  , BabbageEraTxBody era
  , ConwayEraPParams era
  ) =>
  TransitionRule (EraRule "BBODY" era)
conwayBbodyTransition :: forall era.
(Signal (EraRule "BBODY" era) ~ Block BHeaderView era,
 State (EraRule "BBODY" era) ~ ShelleyBbodyState era,
 Environment (EraRule "BBODY" era) ~ BbodyEnv era,
 State (EraRule "LEDGERS" era) ~ LedgerState era,
 InjectRuleFailure "BBODY" AlonzoBbodyPredFailure era,
 InjectRuleFailure "BBODY" ConwayBbodyPredFailure era,
 AlonzoEraTx era, EraBlockBody era, BabbageEraTxBody era,
 ConwayEraPParams era) =>
TransitionRule (EraRule "BBODY" era)
conwayBbodyTransition = do
  Rule
  (EraRule "BBODY" era)
  'Transition
  (RuleContext 'Transition (EraRule "BBODY" era))
F (Clause (EraRule "BBODY" era) 'Transition)
  (TRC (EraRule "BBODY" era))
forall sts (rtype :: RuleType).
Rule sts rtype (RuleContext rtype sts)
judgmentContext
    F (Clause (EraRule "BBODY" era) 'Transition)
  (TRC (EraRule "BBODY" era))
-> (TRC (EraRule "BBODY" era)
    -> F (Clause (EraRule "BBODY" era) 'Transition)
         (ShelleyBbodyState era))
-> F (Clause (EraRule "BBODY" era) 'Transition)
     (ShelleyBbodyState era)
forall a b.
F (Clause (EraRule "BBODY" era) 'Transition) a
-> (a -> F (Clause (EraRule "BBODY" era) 'Transition) b)
-> F (Clause (EraRule "BBODY" era) 'Transition) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \( TRC
             ( BbodyEnv PParams era
pp ChainAccountState
_
               , state :: State (EraRule "BBODY" era)
state@(BbodyState State (EraRule "LEDGERS" era)
ls BlocksMade
_)
               , Block BHeaderView
_ BlockBody era
txsSeq
               )
           ) -> do
        let utxo :: UTxO era
utxo = UTxOState era -> UTxO era
forall era. UTxOState era -> UTxO era
utxosUtxo (LedgerState era -> UTxOState era
forall era. LedgerState era -> UTxOState era
lsUTxOState State (EraRule "LEDGERS" era)
LedgerState era
ls)
            txs :: StrictSeq (Tx TopTx era)
txs = BlockBody era
txsSeq BlockBody era
-> Getting
     (StrictSeq (Tx TopTx era))
     (BlockBody era)
     (StrictSeq (Tx TopTx era))
-> StrictSeq (Tx TopTx era)
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictSeq (Tx TopTx era))
  (BlockBody era)
  (StrictSeq (Tx TopTx era))
forall era.
EraBlockBody era =>
Lens' (BlockBody era) (StrictSeq (Tx TopTx era))
Lens' (BlockBody era) (StrictSeq (Tx TopTx era))
txSeqBlockBodyL
            totalRefScriptSize :: Int
totalRefScriptSize = ProtVer -> StrictSeq (Tx TopTx era) -> UTxO era -> Int
forall era.
(AlonzoEraTx era, BabbageEraTxBody era) =>
ProtVer -> StrictSeq (Tx TopTx era) -> UTxO era -> Int
totalRefScriptSizeInBlock (PParams era
pp PParams era -> Getting ProtVer (PParams era) ProtVer -> ProtVer
forall s a. s -> Getting a s a -> a
^. Getting ProtVer (PParams era) ProtVer
forall era. EraPParams era => Lens' (PParams era) ProtVer
Lens' (PParams era) ProtVer
ppProtocolVersionL) StrictSeq (Tx TopTx era)
txs UTxO era
utxo
            maxRefScriptSizePerBlock :: Int
maxRefScriptSizePerBlock = forall a b. (Integral a, Num b) => a -> b
fromIntegral @Word32 @Int (Word32 -> Int) -> Word32 -> Int
forall a b. (a -> b) -> a -> b
$ PParams era
pp PParams era -> Getting Word32 (PParams era) Word32 -> Word32
forall s a. s -> Getting a s a -> a
^. Getting Word32 (PParams era) Word32
forall era.
ConwayEraPParams era =>
SimpleGetter (PParams era) Word32
SimpleGetter (PParams era) Word32
ppMaxRefScriptSizePerBlockG
        Int
totalRefScriptSize
          Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
maxRefScriptSizePerBlock
            Bool
-> PredicateFailure (EraRule "BBODY" era)
-> Rule (EraRule "BBODY" era) 'Transition ()
forall sts (ctx :: RuleType).
Bool -> PredicateFailure sts -> Rule sts ctx ()
?! ConwayBbodyPredFailure era -> EraRuleFailure "BBODY" era
forall (rule :: Symbol) (t :: * -> *) era.
InjectRuleFailure rule t era =>
t era -> EraRuleFailure rule era
injectFailure
              ( Mismatch RelLTEQ Int -> ConwayBbodyPredFailure era
forall era. Mismatch RelLTEQ Int -> ConwayBbodyPredFailure era
BodyRefScriptsSizeTooBig (Mismatch RelLTEQ Int -> ConwayBbodyPredFailure era)
-> Mismatch RelLTEQ Int -> ConwayBbodyPredFailure era
forall a b. (a -> b) -> a -> b
$
                  Mismatch
                    { mismatchSupplied :: Int
mismatchSupplied = Int
totalRefScriptSize
                    , mismatchExpected :: Int
mismatchExpected = Int
maxRefScriptSizePerBlock
                    }
              )
        ShelleyBbodyState era
-> F (Clause (EraRule "BBODY" era) 'Transition)
     (ShelleyBbodyState era)
forall a. a -> F (Clause (EraRule "BBODY" era) 'Transition) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure State (EraRule "BBODY" era)
ShelleyBbodyState era
state

instance
  ( Era era
  , BaseM ledgers ~ ShelleyBase
  , ledgers ~ EraRule "LEDGERS" era
  , STS ledgers
  ) =>
  Embed ledgers (ConwayBBODY era)
  where
  wrapFailed :: PredicateFailure ledgers -> PredicateFailure (ConwayBBODY era)
wrapFailed = PredicateFailure ledgers -> PredicateFailure (ConwayBBODY era)
PredicateFailure (EraRule "LEDGERS" era)
-> ConwayBbodyPredFailure era
forall era.
PredicateFailure (EraRule "LEDGERS" era)
-> ConwayBbodyPredFailure era
LedgersFailure
  wrapEvent :: Event ledgers -> Event (ConwayBBODY era)
wrapEvent = ShelleyBbodyEvent era -> AlonzoBbodyEvent era
forall era. ShelleyBbodyEvent era -> AlonzoBbodyEvent era
ShelleyInAlonzoEvent (ShelleyBbodyEvent era -> AlonzoBbodyEvent era)
-> (Event ledgers -> ShelleyBbodyEvent era)
-> Event ledgers
-> AlonzoBbodyEvent era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Event ledgers -> ShelleyBbodyEvent era
Event (EraRule "LEDGERS" era) -> ShelleyBbodyEvent era
forall era. Event (EraRule "LEDGERS" era) -> ShelleyBbodyEvent era
LedgersEvent

totalRefScriptSizeInBlock ::
  (AlonzoEraTx era, BabbageEraTxBody era) => ProtVer -> StrictSeq (Tx TopTx era) -> UTxO era -> Int
totalRefScriptSizeInBlock :: forall era.
(AlonzoEraTx era, BabbageEraTxBody era) =>
ProtVer -> StrictSeq (Tx TopTx era) -> UTxO era -> Int
totalRefScriptSizeInBlock ProtVer
protVer StrictSeq (Tx TopTx era)
txs (UTxO Map TxIn (TxOut era)
utxo)
  | ProtVer -> Version
pvMajor ProtVer
protVer Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
<= forall (v :: Natural).
(KnownNat v, 0 <= v, v <= MaxVersion) =>
Version
natVersion @10 =
      Sum Int -> Int
forall a. Sum a -> a
getSum (Sum Int -> Int) -> Sum Int -> Int
forall a b. (a -> b) -> a -> b
$ (Tx TopTx era -> Sum Int) -> StrictSeq (Tx TopTx era) -> Sum Int
forall m a. Monoid m => (a -> m) -> StrictSeq a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap' (Int -> Sum Int
forall a. a -> Sum a
Monoid.Sum (Int -> Sum Int)
-> (Tx TopTx era -> Int) -> Tx TopTx era -> Sum Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Tx TopTx era -> Int
forall era (l :: TxLevel).
(EraTx era, BabbageEraTxBody era) =>
UTxO era -> Tx l era -> Int
txNonDistinctRefScriptsSize (Map TxIn (TxOut era) -> UTxO era
forall era. Map TxIn (TxOut era) -> UTxO era
UTxO Map TxIn (TxOut era)
utxo)) StrictSeq (Tx TopTx era)
txs
  | Bool
otherwise =
      (Map TxIn (TxOut era), Int) -> Int
forall a b. (a, b) -> b
snd ((Map TxIn (TxOut era), Int) -> Int)
-> (Map TxIn (TxOut era), Int) -> Int
forall a b. (a -> b) -> a -> b
$ ((Map TxIn (TxOut era), Int)
 -> Tx TopTx era -> (Map TxIn (TxOut era), Int))
-> (Map TxIn (TxOut era), Int)
-> StrictSeq (Tx TopTx era)
-> (Map TxIn (TxOut era), Int)
forall b a. (b -> a -> b) -> b -> StrictSeq a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl' (Map TxIn (TxOut era), Int)
-> Tx TopTx era -> (Map TxIn (TxOut 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 ...),
 AlonzoEraTx era, BabbageEraTxBody era) =>
(Map TxIn (TxOut era), Int)
-> Tx TopTx era -> (Map TxIn (TxOut era), Int)
accum (Map TxIn (TxOut era)
utxo, Int
0) StrictSeq (Tx TopTx era)
txs
  where
    accum :: (Map TxIn (TxOut era), Int)
-> Tx TopTx era -> (Map TxIn (TxOut era), Int)
accum (!Map TxIn (TxOut era)
accUtxo, !Int
accSum) Tx TopTx era
tx =
      let updatedUtxo :: Map TxIn (TxOut era)
updatedUtxo = Map TxIn (TxOut era)
accUtxo Map TxIn (TxOut era)
-> Map TxIn (TxOut era) -> Map TxIn (TxOut era)
forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union` UTxO era -> Map TxIn (TxOut era)
forall era. UTxO era -> Map TxIn (TxOut era)
unUTxO UTxO era
toAdd
          toAdd :: UTxO era
toAdd
            | IsValid Bool
True <- Tx TopTx era
tx Tx TopTx era -> Getting IsValid (Tx TopTx era) IsValid -> IsValid
forall s a. s -> Getting a s a -> a
^. Getting IsValid (Tx TopTx era) IsValid
forall era. AlonzoEraTx era => Lens' (Tx TopTx era) IsValid
Lens' (Tx TopTx era) IsValid
isValidTxL = TxBody TopTx era -> UTxO era
forall era (l :: TxLevel).
EraTxBody era =>
TxBody l era -> UTxO era
txouts (TxBody TopTx era -> UTxO era) -> TxBody TopTx era -> UTxO era
forall a b. (a -> b) -> a -> b
$ Tx TopTx era
tx Tx TopTx era
-> Getting (TxBody TopTx era) (Tx TopTx era) (TxBody TopTx era)
-> TxBody TopTx era
forall s a. s -> Getting a s a -> a
^. Getting (TxBody TopTx era) (Tx TopTx era) (TxBody TopTx era)
forall era (l :: TxLevel).
EraTx era =>
Lens' (Tx l era) (TxBody l era)
forall (l :: TxLevel). Lens' (Tx l era) (TxBody l era)
bodyTxL
            | Bool
otherwise = TxBody TopTx era -> UTxO era
forall era. BabbageEraTxBody era => TxBody TopTx era -> UTxO era
collOuts (TxBody TopTx era -> UTxO era) -> TxBody TopTx era -> UTxO era
forall a b. (a -> b) -> a -> b
$ Tx TopTx era
tx Tx TopTx era
-> Getting (TxBody TopTx era) (Tx TopTx era) (TxBody TopTx era)
-> TxBody TopTx era
forall s a. s -> Getting a s a -> a
^. Getting (TxBody TopTx era) (Tx TopTx era) (TxBody TopTx era)
forall era (l :: TxLevel).
EraTx era =>
Lens' (Tx l era) (TxBody l era)
forall (l :: TxLevel). Lens' (Tx l era) (TxBody l era)
bodyTxL
       in (Map TxIn (TxOut era)
updatedUtxo, Int
accSum Int -> Int -> Int
forall a. Num a => a -> a -> a
+ UTxO era -> Tx TopTx era -> Int
forall era (l :: TxLevel).
(EraTx era, BabbageEraTxBody era) =>
UTxO era -> Tx l era -> Int
txNonDistinctRefScriptsSize (Map TxIn (TxOut era) -> UTxO era
forall era. Map TxIn (TxOut era) -> UTxO era
UTxO Map TxIn (TxOut era)
accUtxo) Tx TopTx era
tx)