{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE UndecidableSuperClasses #-}
{-# OPTIONS_GHC -Wno-orphans #-}

-- | This module contains the type of protocol parameters and EraPParams instance
module Cardano.Ledger.Babbage.PParams (
  BabbageEraPParams (..),
  CoinPerByte (..),
  ppCoinsPerUTxOByteL,
  ppuCoinsPerUTxOByteL,
  BabbagePParams (..),
  emptyBabbagePParams,
  emptyBabbagePParamsUpdate,
  DowngradeBabbagePParams (..),
  upgradeBabbagePParams,
  getLanguageView,
  LangDepView (..),
  encodeLangViews,
  coinsPerUTxOWordToCoinsPerUTxOByte,
  coinsPerUTxOByteToCoinsPerUTxOWord,
  ppCoinsPerUTxOByte,
) where

import Cardano.Ledger.Alonzo (AlonzoEra)
import Cardano.Ledger.Alonzo.Core
import Cardano.Ledger.Alonzo.PParams
import Cardano.Ledger.Alonzo.Scripts (
  CostModels,
  ExUnits (..),
  Prices (..),
  emptyCostModels,
 )
import Cardano.Ledger.Babbage.Era (BabbageEra)
import Cardano.Ledger.BaseTypes (
  EpochInterval (..),
  NonNegativeInterval,
  Nonce,
  ProtVer (..),
  StrictMaybe (..),
  UnitInterval,
 )
import Cardano.Ledger.Binary (
  DecCBOR (..),
  EncCBOR (..),
 )
import Cardano.Ledger.Coin (Coin (..))
import Cardano.Ledger.Core (EraPParams (..))
import Cardano.Ledger.HKD (HKDFunctor (..))
import Cardano.Ledger.Orphans ()
import Cardano.Ledger.Plutus.ToPlutusData (ToPlutusData (..))
import Cardano.Ledger.Shelley.PParams
import Control.DeepSeq (NFData)
import Data.Aeson as Aeson (
  FromJSON (..),
  ToJSON (..),
 )
import Data.Functor.Identity (Identity (..))
import Data.Proxy (Proxy (Proxy))
import Data.Word (Word16, Word32)
import GHC.Generics (Generic)
import Lens.Micro
import NoThunks.Class (NoThunks (..))
import Numeric.Natural (Natural)

newtype CoinPerByte = CoinPerByte {CoinPerByte -> Coin
unCoinPerByte :: Coin}
  deriving stock (CoinPerByte -> CoinPerByte -> Bool
(CoinPerByte -> CoinPerByte -> Bool)
-> (CoinPerByte -> CoinPerByte -> Bool) -> Eq CoinPerByte
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CoinPerByte -> CoinPerByte -> Bool
== :: CoinPerByte -> CoinPerByte -> Bool
$c/= :: CoinPerByte -> CoinPerByte -> Bool
/= :: CoinPerByte -> CoinPerByte -> Bool
Eq, Eq CoinPerByte
Eq CoinPerByte =>
(CoinPerByte -> CoinPerByte -> Ordering)
-> (CoinPerByte -> CoinPerByte -> Bool)
-> (CoinPerByte -> CoinPerByte -> Bool)
-> (CoinPerByte -> CoinPerByte -> Bool)
-> (CoinPerByte -> CoinPerByte -> Bool)
-> (CoinPerByte -> CoinPerByte -> CoinPerByte)
-> (CoinPerByte -> CoinPerByte -> CoinPerByte)
-> Ord CoinPerByte
CoinPerByte -> CoinPerByte -> Bool
CoinPerByte -> CoinPerByte -> Ordering
CoinPerByte -> CoinPerByte -> CoinPerByte
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CoinPerByte -> CoinPerByte -> Ordering
compare :: CoinPerByte -> CoinPerByte -> Ordering
$c< :: CoinPerByte -> CoinPerByte -> Bool
< :: CoinPerByte -> CoinPerByte -> Bool
$c<= :: CoinPerByte -> CoinPerByte -> Bool
<= :: CoinPerByte -> CoinPerByte -> Bool
$c> :: CoinPerByte -> CoinPerByte -> Bool
> :: CoinPerByte -> CoinPerByte -> Bool
$c>= :: CoinPerByte -> CoinPerByte -> Bool
>= :: CoinPerByte -> CoinPerByte -> Bool
$cmax :: CoinPerByte -> CoinPerByte -> CoinPerByte
max :: CoinPerByte -> CoinPerByte -> CoinPerByte
$cmin :: CoinPerByte -> CoinPerByte -> CoinPerByte
min :: CoinPerByte -> CoinPerByte -> CoinPerByte
Ord)
  deriving newtype (Typeable CoinPerByte
Typeable CoinPerByte =>
(CoinPerByte -> Encoding)
-> ((forall t. EncCBOR t => Proxy t -> Size)
    -> Proxy CoinPerByte -> Size)
-> ((forall t. EncCBOR t => Proxy t -> Size)
    -> Proxy [CoinPerByte] -> Size)
-> EncCBOR CoinPerByte
CoinPerByte -> Encoding
(forall t. EncCBOR t => Proxy t -> Size)
-> Proxy [CoinPerByte] -> Size
(forall t. EncCBOR t => Proxy t -> Size)
-> Proxy CoinPerByte -> Size
forall a.
Typeable a =>
(a -> Encoding)
-> ((forall t. EncCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. EncCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> EncCBOR a
$cencCBOR :: CoinPerByte -> Encoding
encCBOR :: CoinPerByte -> Encoding
$cencodedSizeExpr :: (forall t. EncCBOR t => Proxy t -> Size)
-> Proxy CoinPerByte -> Size
encodedSizeExpr :: (forall t. EncCBOR t => Proxy t -> Size)
-> Proxy CoinPerByte -> Size
$cencodedListSizeExpr :: (forall t. EncCBOR t => Proxy t -> Size)
-> Proxy [CoinPerByte] -> Size
encodedListSizeExpr :: (forall t. EncCBOR t => Proxy t -> Size)
-> Proxy [CoinPerByte] -> Size
EncCBOR, Typeable CoinPerByte
Typeable CoinPerByte =>
(forall s. Decoder s CoinPerByte)
-> (forall s. Proxy CoinPerByte -> Decoder s ())
-> (Proxy CoinPerByte -> Text)
-> DecCBOR CoinPerByte
Proxy CoinPerByte -> Text
forall s. Decoder s CoinPerByte
forall a.
Typeable a =>
(forall s. Decoder s a)
-> (forall s. Proxy a -> Decoder s ())
-> (Proxy a -> Text)
-> DecCBOR a
forall s. Proxy CoinPerByte -> Decoder s ()
$cdecCBOR :: forall s. Decoder s CoinPerByte
decCBOR :: forall s. Decoder s CoinPerByte
$cdropCBOR :: forall s. Proxy CoinPerByte -> Decoder s ()
dropCBOR :: forall s. Proxy CoinPerByte -> Decoder s ()
$clabel :: Proxy CoinPerByte -> Text
label :: Proxy CoinPerByte -> Text
DecCBOR, [CoinPerByte] -> Value
[CoinPerByte] -> Encoding
CoinPerByte -> Bool
CoinPerByte -> Value
CoinPerByte -> Encoding
(CoinPerByte -> Value)
-> (CoinPerByte -> Encoding)
-> ([CoinPerByte] -> Value)
-> ([CoinPerByte] -> Encoding)
-> (CoinPerByte -> Bool)
-> ToJSON CoinPerByte
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: CoinPerByte -> Value
toJSON :: CoinPerByte -> Value
$ctoEncoding :: CoinPerByte -> Encoding
toEncoding :: CoinPerByte -> Encoding
$ctoJSONList :: [CoinPerByte] -> Value
toJSONList :: [CoinPerByte] -> Value
$ctoEncodingList :: [CoinPerByte] -> Encoding
toEncodingList :: [CoinPerByte] -> Encoding
$comitField :: CoinPerByte -> Bool
omitField :: CoinPerByte -> Bool
ToJSON, Maybe CoinPerByte
Value -> Parser [CoinPerByte]
Value -> Parser CoinPerByte
(Value -> Parser CoinPerByte)
-> (Value -> Parser [CoinPerByte])
-> Maybe CoinPerByte
-> FromJSON CoinPerByte
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser CoinPerByte
parseJSON :: Value -> Parser CoinPerByte
$cparseJSONList :: Value -> Parser [CoinPerByte]
parseJSONList :: Value -> Parser [CoinPerByte]
$comittedField :: Maybe CoinPerByte
omittedField :: Maybe CoinPerByte
FromJSON, CoinPerByte -> ()
(CoinPerByte -> ()) -> NFData CoinPerByte
forall a. (a -> ()) -> NFData a
$crnf :: CoinPerByte -> ()
rnf :: CoinPerByte -> ()
NFData, Context -> CoinPerByte -> IO (Maybe ThunkInfo)
Proxy CoinPerByte -> String
(Context -> CoinPerByte -> IO (Maybe ThunkInfo))
-> (Context -> CoinPerByte -> IO (Maybe ThunkInfo))
-> (Proxy CoinPerByte -> String)
-> NoThunks CoinPerByte
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> CoinPerByte -> IO (Maybe ThunkInfo)
noThunks :: Context -> CoinPerByte -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> CoinPerByte -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> CoinPerByte -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy CoinPerByte -> String
showTypeOf :: Proxy CoinPerByte -> String
NoThunks, Int -> CoinPerByte -> ShowS
[CoinPerByte] -> ShowS
CoinPerByte -> String
(Int -> CoinPerByte -> ShowS)
-> (CoinPerByte -> String)
-> ([CoinPerByte] -> ShowS)
-> Show CoinPerByte
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CoinPerByte -> ShowS
showsPrec :: Int -> CoinPerByte -> ShowS
$cshow :: CoinPerByte -> String
show :: CoinPerByte -> String
$cshowList :: [CoinPerByte] -> ShowS
showList :: [CoinPerByte] -> ShowS
Show)

instance ToPlutusData CoinPerByte where
  toPlutusData :: CoinPerByte -> Data
toPlutusData (CoinPerByte Coin
c) = forall x. ToPlutusData x => x -> Data
toPlutusData @Coin Coin
c
  fromPlutusData :: Data -> Maybe CoinPerByte
fromPlutusData Data
x = Coin -> CoinPerByte
CoinPerByte (Coin -> CoinPerByte) -> Maybe Coin -> Maybe CoinPerByte
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall x. ToPlutusData x => Data -> Maybe x
fromPlutusData @Coin Data
x

class AlonzoEraPParams era => BabbageEraPParams era where
  hkdCoinsPerUTxOByteL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f CoinPerByte)

ppCoinsPerUTxOByteL ::
  forall era. BabbageEraPParams era => Lens' (PParams era) CoinPerByte
ppCoinsPerUTxOByteL :: forall era.
BabbageEraPParams era =>
Lens' (PParams era) CoinPerByte
ppCoinsPerUTxOByteL = (PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> PParams era -> f (PParams era)
forall era (f :: * -> *).
Functor f =>
(PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> PParams era -> f (PParams era)
ppLensHKD ((PParamsHKD Identity era -> f (PParamsHKD Identity era))
 -> PParams era -> f (PParams era))
-> ((CoinPerByte -> f CoinPerByte)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (CoinPerByte -> f CoinPerByte)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(BabbageEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f CoinPerByte)
hkdCoinsPerUTxOByteL @era @Identity

ppuCoinsPerUTxOByteL ::
  forall era. BabbageEraPParams era => Lens' (PParamsUpdate era) (StrictMaybe CoinPerByte)
ppuCoinsPerUTxOByteL :: forall era.
BabbageEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe CoinPerByte)
ppuCoinsPerUTxOByteL = (PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> PParamsUpdate era -> f (PParamsUpdate era)
forall era (f :: * -> *).
Functor f =>
(PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> PParamsUpdate era -> f (PParamsUpdate era)
ppuLensHKD ((PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
 -> PParamsUpdate era -> f (PParamsUpdate era))
-> ((StrictMaybe CoinPerByte -> f (StrictMaybe CoinPerByte))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe CoinPerByte -> f (StrictMaybe CoinPerByte))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(BabbageEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f CoinPerByte)
hkdCoinsPerUTxOByteL @era @StrictMaybe

-- | Babbage Protocol parameters. Ways in which parameters have changed from Alonzo: lack
-- of @d@, @extraEntropy@ and replacement of @coinsPerUTxOWord@ with @coinsPerUTxOByte@
data BabbagePParams f era = BabbagePParams
  { forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppMinFeeA :: !(HKD f Coin)
  -- ^ The linear factor for the minimum fee calculation
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppMinFeeB :: !(HKD f Coin)
  -- ^ The constant factor for the minimum fee calculation
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f Word32
bppMaxBBSize :: !(HKD f Word32)
  -- ^ Maximal block body size
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f Word32
bppMaxTxSize :: !(HKD f Word32)
  -- ^ Maximal transaction size
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f Word16
bppMaxBHSize :: !(HKD f Word16)
  -- ^ Maximal block header size
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppKeyDeposit :: !(HKD f Coin)
  -- ^ The amount of a key registration deposit
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppPoolDeposit :: !(HKD f Coin)
  -- ^ The amount of a pool registration deposit
  , forall (f :: * -> *) era.
BabbagePParams f era -> HKD f EpochInterval
bppEMax :: !(HKD f EpochInterval)
  -- ^ Maximum number of epochs in the future a pool retirement is allowed to
  -- be scheduled for.
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f Word16
bppNOpt :: !(HKD f Word16)
  -- ^ Desired number of pools
  , forall (f :: * -> *) era.
BabbagePParams f era -> HKD f NonNegativeInterval
bppA0 :: !(HKD f NonNegativeInterval)
  -- ^ Pool influence
  , forall (f :: * -> *) era.
BabbagePParams f era -> HKD f UnitInterval
bppRho :: !(HKD f UnitInterval)
  -- ^ Monetary expansion
  , forall (f :: * -> *) era.
BabbagePParams f era -> HKD f UnitInterval
bppTau :: !(HKD f UnitInterval)
  -- ^ Treasury expansion
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f ProtVer
bppProtocolVersion :: !(HKD f ProtVer)
  -- ^ Protocol version
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppMinPoolCost :: !(HKD f Coin)
  -- ^ Minimum Stake Pool Cost
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f CoinPerByte
bppCoinsPerUTxOByte :: !(HKD f CoinPerByte)
  -- ^ Cost in lovelace per byte of UTxO storage (instead of bppCoinsPerUTxOByte)
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f CostModels
bppCostModels :: !(HKD f CostModels)
  -- ^ Cost models for non-native script languages
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f Prices
bppPrices :: !(HKD f Prices)
  -- ^ Prices of execution units (for non-native script languages)
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f OrdExUnits
bppMaxTxExUnits :: !(HKD f OrdExUnits)
  -- ^ Max total script execution resources units allowed per tx
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f OrdExUnits
bppMaxBlockExUnits :: !(HKD f OrdExUnits)
  -- ^ Max total script execution resources units allowed per block
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f Natural
bppMaxValSize :: !(HKD f Natural)
  -- ^ Max size of a Value in an output
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f Natural
bppCollateralPercentage :: !(HKD f Natural)
  -- ^ Percentage of the txfee which must be provided as collateral when
  -- including non-native scripts.
  , forall (f :: * -> *) era. BabbagePParams f era -> HKD f Natural
bppMaxCollateralInputs :: !(HKD f Natural)
  -- ^ Maximum number of collateral inputs allowed in a transaction
  }
  deriving ((forall x. BabbagePParams f era -> Rep (BabbagePParams f era) x)
-> (forall x. Rep (BabbagePParams f era) x -> BabbagePParams f era)
-> Generic (BabbagePParams f era)
forall x. Rep (BabbagePParams f era) x -> BabbagePParams f era
forall x. BabbagePParams f era -> Rep (BabbagePParams f era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) era x.
Rep (BabbagePParams f era) x -> BabbagePParams f era
forall (f :: * -> *) era x.
BabbagePParams f era -> Rep (BabbagePParams f era) x
$cfrom :: forall (f :: * -> *) era x.
BabbagePParams f era -> Rep (BabbagePParams f era) x
from :: forall x. BabbagePParams f era -> Rep (BabbagePParams f era) x
$cto :: forall (f :: * -> *) era x.
Rep (BabbagePParams f era) x -> BabbagePParams f era
to :: forall x. Rep (BabbagePParams f era) x -> BabbagePParams f era
Generic)

deriving instance Eq (BabbagePParams Identity era)

deriving instance Ord (BabbagePParams Identity era)

deriving instance Show (BabbagePParams Identity era)

instance NoThunks (BabbagePParams Identity era)

instance NFData (BabbagePParams Identity era)

deriving instance Eq (BabbagePParams StrictMaybe era)

deriving instance Ord (BabbagePParams StrictMaybe era)

deriving instance Show (BabbagePParams StrictMaybe era)

instance NoThunks (BabbagePParams StrictMaybe era)

instance NFData (BabbagePParams StrictMaybe era)

data DowngradeBabbagePParams f = DowngradeBabbagePParams
  { forall (f :: * -> *).
DowngradeBabbagePParams f -> HKD f UnitInterval
dbppD :: !(HKD f UnitInterval)
  , forall (f :: * -> *). DowngradeBabbagePParams f -> HKD f Nonce
dbppExtraEntropy :: !(HKD f Nonce)
  }

instance EraPParams BabbageEra where
  type PParamsHKD f BabbageEra = BabbagePParams f BabbageEra
  type UpgradePParams f BabbageEra = ()
  type DowngradePParams f BabbageEra = DowngradeBabbagePParams f

  emptyPParamsIdentity :: PParamsHKD Identity BabbageEra
emptyPParamsIdentity = PParamsHKD Identity BabbageEra
BabbagePParams Identity BabbageEra
forall era. Era era => BabbagePParams Identity era
emptyBabbagePParams
  emptyPParamsStrictMaybe :: PParamsHKD StrictMaybe BabbageEra
emptyPParamsStrictMaybe = PParamsHKD StrictMaybe BabbageEra
BabbagePParams StrictMaybe BabbageEra
forall era. BabbagePParams StrictMaybe era
emptyBabbagePParamsUpdate

  upgradePParamsHKD :: forall (f :: * -> *).
(HKDApplicative f, EraPParams (PreviousEra BabbageEra)) =>
UpgradePParams f BabbageEra
-> PParamsHKD f (PreviousEra BabbageEra) -> PParamsHKD f BabbageEra
upgradePParamsHKD () = Bool -> PParamsHKD f AlonzoEra -> BabbagePParams f BabbageEra
forall (f :: * -> *).
HKDFunctor f =>
Bool -> PParamsHKD f AlonzoEra -> BabbagePParams f BabbageEra
upgradeBabbagePParams Bool
True
  downgradePParamsHKD :: forall (f :: * -> *).
(HKDFunctor f, EraPParams (PreviousEra BabbageEra)) =>
DowngradePParams f BabbageEra
-> PParamsHKD f BabbageEra -> PParamsHKD f (PreviousEra BabbageEra)
downgradePParamsHKD = DowngradePParams f BabbageEra
-> PParamsHKD f BabbageEra -> PParamsHKD f (PreviousEra BabbageEra)
DowngradeBabbagePParams f
-> BabbagePParams f BabbageEra -> PParamsHKD f AlonzoEra
forall (f :: * -> *).
HKDFunctor f =>
DowngradeBabbagePParams f
-> BabbagePParams f BabbageEra -> PParamsHKD f AlonzoEra
downgradeBabbagePParams

  hkdMinFeeAL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f Coin)
hkdMinFeeAL = (PParamsHKD f BabbageEra -> HKD f Coin)
-> (PParamsHKD f BabbageEra
    -> HKD f Coin -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f Coin
BabbagePParams f BabbageEra -> HKD f Coin
forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppMinFeeA ((PParamsHKD f BabbageEra -> HKD f Coin -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Coin -> f (HKD f Coin))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f Coin -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f Coin
x -> PParamsHKD f BabbageEra
pp {bppMinFeeA = x}
  hkdMinFeeBL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f Coin)
hkdMinFeeBL = (PParamsHKD f BabbageEra -> HKD f Coin)
-> (PParamsHKD f BabbageEra
    -> HKD f Coin -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f Coin
BabbagePParams f BabbageEra -> HKD f Coin
forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppMinFeeB ((PParamsHKD f BabbageEra -> HKD f Coin -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Coin -> f (HKD f Coin))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f Coin -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f Coin
x -> PParamsHKD f BabbageEra
pp {bppMinFeeB = x}
  hkdMaxBBSizeL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f Word32)
hkdMaxBBSizeL = (PParamsHKD f BabbageEra -> HKD f Word32)
-> (PParamsHKD f BabbageEra
    -> HKD f Word32 -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word32 -> f (HKD f Word32))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f Word32
BabbagePParams f BabbageEra -> HKD f Word32
forall (f :: * -> *) era. BabbagePParams f era -> HKD f Word32
bppMaxBBSize ((PParamsHKD f BabbageEra
  -> HKD f Word32 -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Word32 -> f (HKD f Word32))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f Word32 -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word32 -> f (HKD f Word32))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f Word32
x -> PParamsHKD f BabbageEra
pp {bppMaxBBSize = x}
  hkdMaxTxSizeL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f Word32)
hkdMaxTxSizeL = (PParamsHKD f BabbageEra -> HKD f Word32)
-> (PParamsHKD f BabbageEra
    -> HKD f Word32 -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word32 -> f (HKD f Word32))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f Word32
BabbagePParams f BabbageEra -> HKD f Word32
forall (f :: * -> *) era. BabbagePParams f era -> HKD f Word32
bppMaxTxSize ((PParamsHKD f BabbageEra
  -> HKD f Word32 -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Word32 -> f (HKD f Word32))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f Word32 -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word32 -> f (HKD f Word32))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f Word32
x -> PParamsHKD f BabbageEra
pp {bppMaxTxSize = x}
  hkdMaxBHSizeL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f Word16)
hkdMaxBHSizeL = (PParamsHKD f BabbageEra -> HKD f Word16)
-> (PParamsHKD f BabbageEra
    -> HKD f Word16 -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word16 -> f (HKD f Word16))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f Word16
BabbagePParams f BabbageEra -> HKD f Word16
forall (f :: * -> *) era. BabbagePParams f era -> HKD f Word16
bppMaxBHSize ((PParamsHKD f BabbageEra
  -> HKD f Word16 -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Word16 -> f (HKD f Word16))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f Word16 -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word16 -> f (HKD f Word16))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f Word16
x -> PParamsHKD f BabbageEra
pp {bppMaxBHSize = x}
  hkdKeyDepositL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f Coin)
hkdKeyDepositL = (PParamsHKD f BabbageEra -> HKD f Coin)
-> (PParamsHKD f BabbageEra
    -> HKD f Coin -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f Coin
BabbagePParams f BabbageEra -> HKD f Coin
forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppKeyDeposit ((PParamsHKD f BabbageEra -> HKD f Coin -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Coin -> f (HKD f Coin))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f Coin -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f Coin
x -> PParamsHKD f BabbageEra
pp {bppKeyDeposit = x}
  hkdPoolDepositL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f Coin)
hkdPoolDepositL = (PParamsHKD f BabbageEra -> HKD f Coin)
-> (PParamsHKD f BabbageEra
    -> HKD f Coin -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f Coin
BabbagePParams f BabbageEra -> HKD f Coin
forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppPoolDeposit ((PParamsHKD f BabbageEra -> HKD f Coin -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Coin -> f (HKD f Coin))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f Coin -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f Coin
x -> PParamsHKD f BabbageEra
pp {bppPoolDeposit = x}
  hkdEMaxL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f EpochInterval)
hkdEMaxL = (PParamsHKD f BabbageEra -> HKD f EpochInterval)
-> (PParamsHKD f BabbageEra
    -> HKD f EpochInterval -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f EpochInterval -> f (HKD f EpochInterval))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f EpochInterval
BabbagePParams f BabbageEra -> HKD f EpochInterval
forall (f :: * -> *) era.
BabbagePParams f era -> HKD f EpochInterval
bppEMax ((PParamsHKD f BabbageEra
  -> HKD f EpochInterval -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f EpochInterval -> f (HKD f EpochInterval))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f EpochInterval -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f EpochInterval -> f (HKD f EpochInterval))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f EpochInterval
x -> PParamsHKD f BabbageEra
pp {bppEMax = x}
  hkdNOptL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f Word16)
hkdNOptL = (PParamsHKD f BabbageEra -> HKD f Word16)
-> (PParamsHKD f BabbageEra
    -> HKD f Word16 -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word16 -> f (HKD f Word16))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f Word16
BabbagePParams f BabbageEra -> HKD f Word16
forall (f :: * -> *) era. BabbagePParams f era -> HKD f Word16
bppNOpt ((PParamsHKD f BabbageEra
  -> HKD f Word16 -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Word16 -> f (HKD f Word16))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f Word16 -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word16 -> f (HKD f Word16))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f Word16
x -> PParamsHKD f BabbageEra
pp {bppNOpt = x}
  hkdA0L :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f NonNegativeInterval)
hkdA0L = (PParamsHKD f BabbageEra -> HKD f NonNegativeInterval)
-> (PParamsHKD f BabbageEra
    -> HKD f NonNegativeInterval -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f NonNegativeInterval -> f (HKD f NonNegativeInterval))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f NonNegativeInterval
BabbagePParams f BabbageEra -> HKD f NonNegativeInterval
forall (f :: * -> *) era.
BabbagePParams f era -> HKD f NonNegativeInterval
bppA0 ((PParamsHKD f BabbageEra
  -> HKD f NonNegativeInterval -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f NonNegativeInterval -> f (HKD f NonNegativeInterval))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f NonNegativeInterval -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f NonNegativeInterval -> f (HKD f NonNegativeInterval))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f NonNegativeInterval
x -> PParamsHKD f BabbageEra
pp {bppA0 = x}
  hkdRhoL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f UnitInterval)
hkdRhoL = (PParamsHKD f BabbageEra -> HKD f UnitInterval)
-> (PParamsHKD f BabbageEra
    -> HKD f UnitInterval -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f UnitInterval -> f (HKD f UnitInterval))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f UnitInterval
BabbagePParams f BabbageEra -> HKD f UnitInterval
forall (f :: * -> *) era.
BabbagePParams f era -> HKD f UnitInterval
bppRho ((PParamsHKD f BabbageEra
  -> HKD f UnitInterval -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f UnitInterval -> f (HKD f UnitInterval))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f UnitInterval -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f UnitInterval -> f (HKD f UnitInterval))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f UnitInterval
x -> PParamsHKD f BabbageEra
pp {bppRho = x}
  hkdTauL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f UnitInterval)
hkdTauL = (PParamsHKD f BabbageEra -> HKD f UnitInterval)
-> (PParamsHKD f BabbageEra
    -> HKD f UnitInterval -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f UnitInterval -> f (HKD f UnitInterval))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f UnitInterval
BabbagePParams f BabbageEra -> HKD f UnitInterval
forall (f :: * -> *) era.
BabbagePParams f era -> HKD f UnitInterval
bppTau ((PParamsHKD f BabbageEra
  -> HKD f UnitInterval -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f UnitInterval -> f (HKD f UnitInterval))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f UnitInterval -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f UnitInterval -> f (HKD f UnitInterval))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f UnitInterval
x -> PParamsHKD f BabbageEra
pp {bppTau = x}
  hkdProtocolVersionL :: forall (f :: * -> *).
(HKDFunctor f, ProtVerAtMost BabbageEra 8) =>
Lens' (PParamsHKD f BabbageEra) (HKD f ProtVer)
hkdProtocolVersionL = (PParamsHKD f BabbageEra -> HKD f ProtVer)
-> (PParamsHKD f BabbageEra
    -> HKD f ProtVer -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f ProtVer -> f (HKD f ProtVer))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f ProtVer
BabbagePParams f BabbageEra -> HKD f ProtVer
forall (f :: * -> *) era. BabbagePParams f era -> HKD f ProtVer
bppProtocolVersion ((PParamsHKD f BabbageEra
  -> HKD f ProtVer -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f ProtVer -> f (HKD f ProtVer))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f ProtVer -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f ProtVer -> f (HKD f ProtVer))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f ProtVer
x -> PParamsHKD f BabbageEra
pp {bppProtocolVersion = x}
  hkdMinPoolCostL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f Coin)
hkdMinPoolCostL = (PParamsHKD f BabbageEra -> HKD f Coin)
-> (PParamsHKD f BabbageEra
    -> HKD f Coin -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f Coin
BabbagePParams f BabbageEra -> HKD f Coin
forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppMinPoolCost ((PParamsHKD f BabbageEra -> HKD f Coin -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Coin -> f (HKD f Coin))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f Coin -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f Coin
x -> PParamsHKD f BabbageEra
pp {bppMinPoolCost = x}

  ppDG :: SimpleGetter (PParams BabbageEra) UnitInterval
ppDG = (PParams BabbageEra -> UnitInterval)
-> SimpleGetter (PParams BabbageEra) UnitInterval
forall s a. (s -> a) -> SimpleGetter s a
to (UnitInterval -> PParams BabbageEra -> UnitInterval
forall a b. a -> b -> a
const UnitInterval
forall a. Bounded a => a
minBound)
  hkdDL :: forall (f :: * -> *).
(HKDFunctor f, ProtVerAtMost BabbageEra 6) =>
Lens' (PParamsHKD f BabbageEra) (HKD f UnitInterval)
hkdDL = (HKD f UnitInterval -> f (HKD f UnitInterval))
-> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
(HKD f UnitInterval -> f (HKD f UnitInterval))
-> BabbagePParams f BabbageEra -> f (BabbagePParams f BabbageEra)
forall a b. HasCallStack => Lens' a b
Lens' (BabbagePParams f BabbageEra) (HKD f UnitInterval)
notSupportedInThisEraL
  hkdExtraEntropyL :: forall (f :: * -> *).
(HKDFunctor f, ProtVerAtMost BabbageEra 6) =>
Lens' (PParamsHKD f BabbageEra) (HKD f Nonce)
hkdExtraEntropyL = (HKD f Nonce -> f (HKD f Nonce))
-> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
(HKD f Nonce -> f (HKD f Nonce))
-> BabbagePParams f BabbageEra -> f (BabbagePParams f BabbageEra)
forall a b. HasCallStack => Lens' a b
Lens' (BabbagePParams f BabbageEra) (HKD f Nonce)
notSupportedInThisEraL
  hkdMinUTxOValueL :: forall (f :: * -> *).
(HKDFunctor f, ProtVerAtMost BabbageEra 4) =>
Lens' (PParamsHKD f BabbageEra) (HKD f Coin)
hkdMinUTxOValueL = (HKD f Coin -> f (HKD f Coin))
-> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
(HKD f Coin -> f (HKD f Coin))
-> BabbagePParams f BabbageEra -> f (BabbagePParams f BabbageEra)
forall a b. HasCallStack => Lens' a b
Lens' (BabbagePParams f BabbageEra) (HKD f Coin)
notSupportedInThisEraL

  eraPParams :: [PParam BabbageEra]
eraPParams =
    [ PParam BabbageEra
forall era. EraPParams era => PParam era
ppMinFeeA
    , PParam BabbageEra
forall era. EraPParams era => PParam era
ppMinFeeB
    , PParam BabbageEra
forall era. EraPParams era => PParam era
ppMaxBBSize
    , PParam BabbageEra
forall era. EraPParams era => PParam era
ppMaxTxSize
    , PParam BabbageEra
forall era. EraPParams era => PParam era
ppMaxBHSize
    , PParam BabbageEra
forall era. EraPParams era => PParam era
ppKeyDeposit
    , PParam BabbageEra
forall era. EraPParams era => PParam era
ppPoolDeposit
    , PParam BabbageEra
forall era. EraPParams era => PParam era
ppEMax
    , PParam BabbageEra
forall era. EraPParams era => PParam era
ppNOpt
    , PParam BabbageEra
forall era. EraPParams era => PParam era
ppA0
    , PParam BabbageEra
forall era. EraPParams era => PParam era
ppRho
    , PParam BabbageEra
forall era. EraPParams era => PParam era
ppTau
    , PParam BabbageEra
forall era. (EraPParams era, ProtVerAtMost era 8) => PParam era
ppProtocolVersion
    , PParam BabbageEra
forall era. EraPParams era => PParam era
ppMinPoolCost
    , PParam BabbageEra
forall era. BabbageEraPParams era => PParam era
ppCoinsPerUTxOByte
    , PParam BabbageEra
forall era. AlonzoEraPParams era => PParam era
ppCostModels
    , PParam BabbageEra
forall era. AlonzoEraPParams era => PParam era
ppPrices
    , PParam BabbageEra
forall era. AlonzoEraPParams era => PParam era
ppMaxTxExUnits
    , PParam BabbageEra
forall era. AlonzoEraPParams era => PParam era
ppMaxBlockExUnits
    , PParam BabbageEra
forall era. AlonzoEraPParams era => PParam era
ppMaxValSize
    , PParam BabbageEra
forall era. AlonzoEraPParams era => PParam era
ppCollateralPercentage
    , PParam BabbageEra
forall era. AlonzoEraPParams era => PParam era
ppMaxCollateralInputs
    ]

instance AlonzoEraPParams BabbageEra where
  hkdCoinsPerUTxOWordL :: forall (f :: * -> *).
(HKDFunctor f, ExactEra AlonzoEra BabbageEra) =>
Lens' (PParamsHKD f BabbageEra) (HKD f CoinPerWord)
hkdCoinsPerUTxOWordL = (HKD f CoinPerWord -> f (HKD f CoinPerWord))
-> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
(HKD f CoinPerWord -> f (HKD f CoinPerWord))
-> BabbagePParams f BabbageEra -> f (BabbagePParams f BabbageEra)
forall a b. HasCallStack => Lens' a b
Lens' (BabbagePParams f BabbageEra) (HKD f CoinPerWord)
notSupportedInThisEraL
  hkdCostModelsL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f CostModels)
hkdCostModelsL = (PParamsHKD f BabbageEra -> HKD f CostModels)
-> (PParamsHKD f BabbageEra
    -> HKD f CostModels -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f CostModels -> f (HKD f CostModels))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f CostModels
BabbagePParams f BabbageEra -> HKD f CostModels
forall (f :: * -> *) era. BabbagePParams f era -> HKD f CostModels
bppCostModels ((PParamsHKD f BabbageEra
  -> HKD f CostModels -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f CostModels -> f (HKD f CostModels))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f CostModels -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f CostModels -> f (HKD f CostModels))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f CostModels
x -> PParamsHKD f BabbageEra
pp {bppCostModels = x}
  hkdPricesL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f Prices)
hkdPricesL = (PParamsHKD f BabbageEra -> HKD f Prices)
-> (PParamsHKD f BabbageEra
    -> HKD f Prices -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Prices -> f (HKD f Prices))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f Prices
BabbagePParams f BabbageEra -> HKD f Prices
forall (f :: * -> *) era. BabbagePParams f era -> HKD f Prices
bppPrices ((PParamsHKD f BabbageEra
  -> HKD f Prices -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Prices -> f (HKD f Prices))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f Prices -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Prices -> f (HKD f Prices))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f Prices
x -> PParamsHKD f BabbageEra
pp {bppPrices = x}
  hkdMaxTxExUnitsL :: forall f. HKDFunctor f => Lens' (PParamsHKD f BabbageEra) (HKD f ExUnits)
  hkdMaxTxExUnitsL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f ExUnits)
hkdMaxTxExUnitsL =
    (PParamsHKD f BabbageEra -> HKD f ExUnits)
-> (PParamsHKD f BabbageEra
    -> HKD f ExUnits -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f ExUnits -> f (HKD f ExUnits))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Proxy f
-> (OrdExUnits -> ExUnits) -> HKD f OrdExUnits -> HKD f ExUnits
forall (f :: * -> *) (proxy :: (* -> *) -> *) a b.
HKDFunctor f =>
proxy f -> (a -> b) -> HKD f a -> HKD f b
forall (proxy :: (* -> *) -> *) a b.
proxy f -> (a -> b) -> HKD f a -> HKD f b
hkdMap (forall {k} (t :: k). Proxy t
forall (t :: * -> *). Proxy t
Proxy @f) OrdExUnits -> ExUnits
unOrdExUnits (HKD f OrdExUnits -> HKD f ExUnits)
-> (BabbagePParams f BabbageEra -> HKD f OrdExUnits)
-> BabbagePParams f BabbageEra
-> HKD f ExUnits
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BabbagePParams f BabbageEra -> HKD f OrdExUnits
forall (f :: * -> *) era. BabbagePParams f era -> HKD f OrdExUnits
bppMaxTxExUnits) ((PParamsHKD f BabbageEra
  -> HKD f ExUnits -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f ExUnits -> f (HKD f ExUnits))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f ExUnits -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f ExUnits -> f (HKD f ExUnits))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f ExUnits
x ->
      PParamsHKD f BabbageEra
pp {bppMaxTxExUnits = hkdMap (Proxy @f) OrdExUnits x}
  hkdMaxBlockExUnitsL :: forall f. HKDFunctor f => Lens' (PParamsHKD f BabbageEra) (HKD f ExUnits)
  hkdMaxBlockExUnitsL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f ExUnits)
hkdMaxBlockExUnitsL =
    (PParamsHKD f BabbageEra -> HKD f ExUnits)
-> (PParamsHKD f BabbageEra
    -> HKD f ExUnits -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f ExUnits -> f (HKD f ExUnits))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Proxy f
-> (OrdExUnits -> ExUnits) -> HKD f OrdExUnits -> HKD f ExUnits
forall (f :: * -> *) (proxy :: (* -> *) -> *) a b.
HKDFunctor f =>
proxy f -> (a -> b) -> HKD f a -> HKD f b
forall (proxy :: (* -> *) -> *) a b.
proxy f -> (a -> b) -> HKD f a -> HKD f b
hkdMap (forall {k} (t :: k). Proxy t
forall (t :: * -> *). Proxy t
Proxy @f) OrdExUnits -> ExUnits
unOrdExUnits (HKD f OrdExUnits -> HKD f ExUnits)
-> (BabbagePParams f BabbageEra -> HKD f OrdExUnits)
-> BabbagePParams f BabbageEra
-> HKD f ExUnits
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BabbagePParams f BabbageEra -> HKD f OrdExUnits
forall (f :: * -> *) era. BabbagePParams f era -> HKD f OrdExUnits
bppMaxBlockExUnits) ((PParamsHKD f BabbageEra
  -> HKD f ExUnits -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f ExUnits -> f (HKD f ExUnits))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f ExUnits -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f ExUnits -> f (HKD f ExUnits))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f ExUnits
x ->
      PParamsHKD f BabbageEra
pp {bppMaxBlockExUnits = hkdMap (Proxy @f) OrdExUnits x}
  hkdMaxValSizeL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f Natural)
hkdMaxValSizeL = (PParamsHKD f BabbageEra -> HKD f Natural)
-> (PParamsHKD f BabbageEra
    -> HKD f Natural -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Natural -> f (HKD f Natural))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f Natural
BabbagePParams f BabbageEra -> HKD f Natural
forall (f :: * -> *) era. BabbagePParams f era -> HKD f Natural
bppMaxValSize ((PParamsHKD f BabbageEra
  -> HKD f Natural -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Natural -> f (HKD f Natural))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f Natural -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Natural -> f (HKD f Natural))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f Natural
x -> PParamsHKD f BabbageEra
pp {bppMaxValSize = x}
  hkdCollateralPercentageL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f Natural)
hkdCollateralPercentageL =
    (PParamsHKD f BabbageEra -> HKD f Natural)
-> (PParamsHKD f BabbageEra
    -> HKD f Natural -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Natural -> f (HKD f Natural))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f Natural
BabbagePParams f BabbageEra -> HKD f Natural
forall (f :: * -> *) era. BabbagePParams f era -> HKD f Natural
bppCollateralPercentage ((PParamsHKD f BabbageEra
  -> HKD f Natural -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Natural -> f (HKD f Natural))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f Natural -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Natural -> f (HKD f Natural))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f Natural
x -> PParamsHKD f BabbageEra
pp {bppCollateralPercentage = x}
  hkdMaxCollateralInputsL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f Natural)
hkdMaxCollateralInputsL =
    (PParamsHKD f BabbageEra -> HKD f Natural)
-> (PParamsHKD f BabbageEra
    -> HKD f Natural -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Natural -> f (HKD f Natural))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f BabbageEra -> HKD f Natural
BabbagePParams f BabbageEra -> HKD f Natural
forall (f :: * -> *) era. BabbagePParams f era -> HKD f Natural
bppMaxCollateralInputs ((PParamsHKD f BabbageEra
  -> HKD f Natural -> PParamsHKD f BabbageEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Natural -> f (HKD f Natural))
    -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra))
-> (PParamsHKD f BabbageEra
    -> HKD f Natural -> PParamsHKD f BabbageEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Natural -> f (HKD f Natural))
   -> PParamsHKD f BabbageEra -> f (PParamsHKD f BabbageEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f BabbageEra
pp HKD f Natural
x -> PParamsHKD f BabbageEra
pp {bppMaxCollateralInputs = x}

instance BabbageEraPParams BabbageEra where
  hkdCoinsPerUTxOByteL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f BabbageEra) (HKD f CoinPerByte)
hkdCoinsPerUTxOByteL = (BabbagePParams f BabbageEra -> HKD f CoinPerByte)
-> (BabbagePParams f BabbageEra
    -> HKD f CoinPerByte -> BabbagePParams f BabbageEra)
-> Lens
     (BabbagePParams f BabbageEra)
     (BabbagePParams f BabbageEra)
     (HKD f CoinPerByte)
     (HKD f CoinPerByte)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens BabbagePParams f BabbageEra -> HKD f CoinPerByte
forall (f :: * -> *) era. BabbagePParams f era -> HKD f CoinPerByte
bppCoinsPerUTxOByte (\BabbagePParams f BabbageEra
pp HKD f CoinPerByte
x -> BabbagePParams f BabbageEra
pp {bppCoinsPerUTxOByte = x})

instance EraGov BabbageEra where
  type GovState BabbageEra = ShelleyGovState BabbageEra
  emptyGovState :: GovState BabbageEra
emptyGovState = GovState BabbageEra
ShelleyGovState BabbageEra
forall era. EraPParams era => ShelleyGovState era
emptyShelleyGovState

  curPParamsGovStateL :: Lens' (GovState BabbageEra) (PParams BabbageEra)
curPParamsGovStateL = (PParams BabbageEra -> f (PParams BabbageEra))
-> GovState BabbageEra -> f (GovState BabbageEra)
(PParams BabbageEra -> f (PParams BabbageEra))
-> ShelleyGovState BabbageEra -> f (ShelleyGovState BabbageEra)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> ShelleyGovState era -> f (ShelleyGovState era)
curPParamsShelleyGovStateL

  prevPParamsGovStateL :: Lens' (GovState BabbageEra) (PParams BabbageEra)
prevPParamsGovStateL = (PParams BabbageEra -> f (PParams BabbageEra))
-> GovState BabbageEra -> f (GovState BabbageEra)
(PParams BabbageEra -> f (PParams BabbageEra))
-> ShelleyGovState BabbageEra -> f (ShelleyGovState BabbageEra)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> ShelleyGovState era -> f (ShelleyGovState era)
prevPParamsShelleyGovStateL

  futurePParamsGovStateL :: Lens' (GovState BabbageEra) (FuturePParams BabbageEra)
futurePParamsGovStateL = (FuturePParams BabbageEra -> f (FuturePParams BabbageEra))
-> GovState BabbageEra -> f (GovState BabbageEra)
(FuturePParams BabbageEra -> f (FuturePParams BabbageEra))
-> ShelleyGovState BabbageEra -> f (ShelleyGovState BabbageEra)
forall era (f :: * -> *).
Functor f =>
(FuturePParams era -> f (FuturePParams era))
-> ShelleyGovState era -> f (ShelleyGovState era)
futurePParamsShelleyGovStateL

  obligationGovState :: GovState BabbageEra -> Obligations
obligationGovState = Obligations -> ShelleyGovState BabbageEra -> Obligations
forall a b. a -> b -> a
const Obligations
forall a. Monoid a => a
mempty

-- | Returns a basic "empty" `PParams` structure with all zero values.
emptyBabbagePParams :: forall era. Era era => BabbagePParams Identity era
emptyBabbagePParams :: forall era. Era era => BabbagePParams Identity era
emptyBabbagePParams =
  BabbagePParams
    { bppMinFeeA :: HKD Identity Coin
bppMinFeeA = Integer -> Coin
Coin Integer
0
    , bppMinFeeB :: HKD Identity Coin
bppMinFeeB = Integer -> Coin
Coin Integer
0
    , bppMaxBBSize :: HKD Identity Word32
bppMaxBBSize = Word32
HKD Identity Word32
0
    , bppMaxTxSize :: HKD Identity Word32
bppMaxTxSize = Word32
HKD Identity Word32
2048
    , bppMaxBHSize :: HKD Identity Word16
bppMaxBHSize = Word16
HKD Identity Word16
0
    , bppKeyDeposit :: HKD Identity Coin
bppKeyDeposit = Integer -> Coin
Coin Integer
0
    , bppPoolDeposit :: HKD Identity Coin
bppPoolDeposit = Integer -> Coin
Coin Integer
0
    , bppEMax :: HKD Identity EpochInterval
bppEMax = Word32 -> EpochInterval
EpochInterval Word32
0
    , bppNOpt :: HKD Identity Word16
bppNOpt = Word16
HKD Identity Word16
100
    , bppA0 :: HKD Identity NonNegativeInterval
bppA0 = HKD Identity NonNegativeInterval
NonNegativeInterval
forall a. Bounded a => a
minBound
    , bppRho :: HKD Identity UnitInterval
bppRho = HKD Identity UnitInterval
UnitInterval
forall a. Bounded a => a
minBound
    , bppTau :: HKD Identity UnitInterval
bppTau = HKD Identity UnitInterval
UnitInterval
forall a. Bounded a => a
minBound
    , bppProtocolVersion :: HKD Identity ProtVer
bppProtocolVersion = Version -> Natural -> ProtVer
ProtVer (forall era. Era era => Version
eraProtVerLow @era) Natural
0
    , bppMinPoolCost :: HKD Identity Coin
bppMinPoolCost = HKD Identity Coin
Coin
forall a. Monoid a => a
mempty
    , bppCoinsPerUTxOByte :: HKD Identity CoinPerByte
bppCoinsPerUTxOByte = Coin -> CoinPerByte
CoinPerByte (Coin -> CoinPerByte) -> Coin -> CoinPerByte
forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
0
    , bppCostModels :: HKD Identity CostModels
bppCostModels = CostModels
HKD Identity CostModels
emptyCostModels
    , bppPrices :: HKD Identity Prices
bppPrices = NonNegativeInterval -> NonNegativeInterval -> Prices
Prices NonNegativeInterval
forall a. Bounded a => a
minBound NonNegativeInterval
forall a. Bounded a => a
minBound
    , bppMaxTxExUnits :: HKD Identity OrdExUnits
bppMaxTxExUnits = ExUnits -> OrdExUnits
OrdExUnits (ExUnits -> OrdExUnits) -> ExUnits -> OrdExUnits
forall a b. (a -> b) -> a -> b
$ Natural -> Natural -> ExUnits
ExUnits Natural
0 Natural
0
    , bppMaxBlockExUnits :: HKD Identity OrdExUnits
bppMaxBlockExUnits = ExUnits -> OrdExUnits
OrdExUnits (ExUnits -> OrdExUnits) -> ExUnits -> OrdExUnits
forall a b. (a -> b) -> a -> b
$ Natural -> Natural -> ExUnits
ExUnits Natural
0 Natural
0
    , bppMaxValSize :: HKD Identity Natural
bppMaxValSize = Natural
HKD Identity Natural
0
    , bppCollateralPercentage :: HKD Identity Natural
bppCollateralPercentage = Natural
HKD Identity Natural
150
    , bppMaxCollateralInputs :: HKD Identity Natural
bppMaxCollateralInputs = Natural
HKD Identity Natural
5
    }

emptyBabbagePParamsUpdate :: BabbagePParams StrictMaybe era
emptyBabbagePParamsUpdate :: forall era. BabbagePParams StrictMaybe era
emptyBabbagePParamsUpdate =
  BabbagePParams
    { bppMinFeeA :: HKD StrictMaybe Coin
bppMinFeeA = StrictMaybe Coin
HKD StrictMaybe Coin
forall a. StrictMaybe a
SNothing
    , bppMinFeeB :: HKD StrictMaybe Coin
bppMinFeeB = StrictMaybe Coin
HKD StrictMaybe Coin
forall a. StrictMaybe a
SNothing
    , bppMaxBBSize :: HKD StrictMaybe Word32
bppMaxBBSize = StrictMaybe Word32
HKD StrictMaybe Word32
forall a. StrictMaybe a
SNothing
    , bppMaxTxSize :: HKD StrictMaybe Word32
bppMaxTxSize = StrictMaybe Word32
HKD StrictMaybe Word32
forall a. StrictMaybe a
SNothing
    , bppMaxBHSize :: HKD StrictMaybe Word16
bppMaxBHSize = StrictMaybe Word16
HKD StrictMaybe Word16
forall a. StrictMaybe a
SNothing
    , bppKeyDeposit :: HKD StrictMaybe Coin
bppKeyDeposit = StrictMaybe Coin
HKD StrictMaybe Coin
forall a. StrictMaybe a
SNothing
    , bppPoolDeposit :: HKD StrictMaybe Coin
bppPoolDeposit = StrictMaybe Coin
HKD StrictMaybe Coin
forall a. StrictMaybe a
SNothing
    , bppEMax :: HKD StrictMaybe EpochInterval
bppEMax = StrictMaybe EpochInterval
HKD StrictMaybe EpochInterval
forall a. StrictMaybe a
SNothing
    , bppNOpt :: HKD StrictMaybe Word16
bppNOpt = StrictMaybe Word16
HKD StrictMaybe Word16
forall a. StrictMaybe a
SNothing
    , bppA0 :: HKD StrictMaybe NonNegativeInterval
bppA0 = StrictMaybe NonNegativeInterval
HKD StrictMaybe NonNegativeInterval
forall a. StrictMaybe a
SNothing
    , bppRho :: HKD StrictMaybe UnitInterval
bppRho = StrictMaybe UnitInterval
HKD StrictMaybe UnitInterval
forall a. StrictMaybe a
SNothing
    , bppTau :: HKD StrictMaybe UnitInterval
bppTau = StrictMaybe UnitInterval
HKD StrictMaybe UnitInterval
forall a. StrictMaybe a
SNothing
    , bppProtocolVersion :: HKD StrictMaybe ProtVer
bppProtocolVersion = StrictMaybe ProtVer
HKD StrictMaybe ProtVer
forall a. StrictMaybe a
SNothing
    , bppMinPoolCost :: HKD StrictMaybe Coin
bppMinPoolCost = StrictMaybe Coin
HKD StrictMaybe Coin
forall a. StrictMaybe a
SNothing
    , bppCoinsPerUTxOByte :: HKD StrictMaybe CoinPerByte
bppCoinsPerUTxOByte = StrictMaybe CoinPerByte
HKD StrictMaybe CoinPerByte
forall a. StrictMaybe a
SNothing
    , bppCostModels :: HKD StrictMaybe CostModels
bppCostModels = StrictMaybe CostModels
HKD StrictMaybe CostModels
forall a. StrictMaybe a
SNothing
    , bppPrices :: HKD StrictMaybe Prices
bppPrices = StrictMaybe Prices
HKD StrictMaybe Prices
forall a. StrictMaybe a
SNothing
    , bppMaxTxExUnits :: HKD StrictMaybe OrdExUnits
bppMaxTxExUnits = StrictMaybe OrdExUnits
HKD StrictMaybe OrdExUnits
forall a. StrictMaybe a
SNothing
    , bppMaxBlockExUnits :: HKD StrictMaybe OrdExUnits
bppMaxBlockExUnits = StrictMaybe OrdExUnits
HKD StrictMaybe OrdExUnits
forall a. StrictMaybe a
SNothing
    , bppMaxValSize :: HKD StrictMaybe Natural
bppMaxValSize = StrictMaybe Natural
HKD StrictMaybe Natural
forall a. StrictMaybe a
SNothing
    , bppCollateralPercentage :: HKD StrictMaybe Natural
bppCollateralPercentage = StrictMaybe Natural
HKD StrictMaybe Natural
forall a. StrictMaybe a
SNothing
    , bppMaxCollateralInputs :: HKD StrictMaybe Natural
bppMaxCollateralInputs = StrictMaybe Natural
HKD StrictMaybe Natural
forall a. StrictMaybe a
SNothing
    }

upgradeBabbagePParams ::
  forall f.
  HKDFunctor f =>
  Bool ->
  PParamsHKD f AlonzoEra ->
  BabbagePParams f BabbageEra
upgradeBabbagePParams :: forall (f :: * -> *).
HKDFunctor f =>
Bool -> PParamsHKD f AlonzoEra -> BabbagePParams f BabbageEra
upgradeBabbagePParams Bool
updateCoinsPerUTxOWord AlonzoPParams {HKD f Natural
HKD f Word16
HKD f Word32
HKD f OrdExUnits
HKD f CoinPerWord
HKD f CostModels
HKD f Prices
HKD f EpochInterval
HKD f Nonce
HKD f UnitInterval
HKD f NonNegativeInterval
HKD f ProtVer
HKD f Coin
appMinFeeA :: HKD f Coin
appMinFeeB :: HKD f Coin
appMaxBBSize :: HKD f Word32
appMaxTxSize :: HKD f Word32
appMaxBHSize :: HKD f Word16
appKeyDeposit :: HKD f Coin
appPoolDeposit :: HKD f Coin
appEMax :: HKD f EpochInterval
appNOpt :: HKD f Word16
appA0 :: HKD f NonNegativeInterval
appRho :: HKD f UnitInterval
appTau :: HKD f UnitInterval
appD :: HKD f UnitInterval
appExtraEntropy :: HKD f Nonce
appProtocolVersion :: HKD f ProtVer
appMinPoolCost :: HKD f Coin
appCoinsPerUTxOWord :: HKD f CoinPerWord
appCostModels :: HKD f CostModels
appPrices :: HKD f Prices
appMaxTxExUnits :: HKD f OrdExUnits
appMaxBlockExUnits :: HKD f OrdExUnits
appMaxValSize :: HKD f Natural
appCollateralPercentage :: HKD f Natural
appMaxCollateralInputs :: HKD f Natural
appMinFeeA :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appMinFeeB :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appMaxBBSize :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word32
appMaxTxSize :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word32
appMaxBHSize :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word16
appKeyDeposit :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appPoolDeposit :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appEMax :: forall (f :: * -> *) era.
AlonzoPParams f era -> HKD f EpochInterval
appNOpt :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word16
appA0 :: forall (f :: * -> *) era.
AlonzoPParams f era -> HKD f NonNegativeInterval
appRho :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f UnitInterval
appTau :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f UnitInterval
appD :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f UnitInterval
appExtraEntropy :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Nonce
appProtocolVersion :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f ProtVer
appMinPoolCost :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appCoinsPerUTxOWord :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f CoinPerWord
appCostModels :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f CostModels
appPrices :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Prices
appMaxTxExUnits :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f OrdExUnits
appMaxBlockExUnits :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f OrdExUnits
appMaxValSize :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Natural
appCollateralPercentage :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Natural
appMaxCollateralInputs :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Natural
..} =
  BabbagePParams
    { bppMinFeeA :: HKD f Coin
bppMinFeeA = HKD f Coin
appMinFeeA
    , bppMinFeeB :: HKD f Coin
bppMinFeeB = HKD f Coin
appMinFeeB
    , bppMaxBBSize :: HKD f Word32
bppMaxBBSize = HKD f Word32
appMaxBBSize
    , bppMaxTxSize :: HKD f Word32
bppMaxTxSize = HKD f Word32
appMaxTxSize
    , bppMaxBHSize :: HKD f Word16
bppMaxBHSize = HKD f Word16
appMaxBHSize
    , bppKeyDeposit :: HKD f Coin
bppKeyDeposit = HKD f Coin
appKeyDeposit
    , bppPoolDeposit :: HKD f Coin
bppPoolDeposit = HKD f Coin
appPoolDeposit
    , bppEMax :: HKD f EpochInterval
bppEMax = HKD f EpochInterval
appEMax
    , bppNOpt :: HKD f Word16
bppNOpt = HKD f Word16
appNOpt
    , bppA0 :: HKD f NonNegativeInterval
bppA0 = HKD f NonNegativeInterval
appA0
    , bppRho :: HKD f UnitInterval
bppRho = HKD f UnitInterval
appRho
    , bppTau :: HKD f UnitInterval
bppTau = HKD f UnitInterval
appTau
    , bppProtocolVersion :: HKD f ProtVer
bppProtocolVersion = HKD f ProtVer
appProtocolVersion
    , bppMinPoolCost :: HKD f Coin
bppMinPoolCost = HKD f Coin
appMinPoolCost
    , bppCoinsPerUTxOByte :: HKD f CoinPerByte
bppCoinsPerUTxOByte =
        Proxy f
-> (CoinPerWord -> CoinPerByte)
-> HKD f CoinPerWord
-> HKD f CoinPerByte
forall (f :: * -> *) (proxy :: (* -> *) -> *) a b.
HKDFunctor f =>
proxy f -> (a -> b) -> HKD f a -> HKD f b
forall (proxy :: (* -> *) -> *) a b.
proxy f -> (a -> b) -> HKD f a -> HKD f b
hkdMap
          (forall {k} (t :: k). Proxy t
forall (t :: * -> *). Proxy t
Proxy @f)
          ( if Bool
updateCoinsPerUTxOWord
              then CoinPerWord -> CoinPerByte
coinsPerUTxOWordToCoinsPerUTxOByte
              else CoinPerWord -> CoinPerByte
coinsPerUTxOWordToCoinsPerUTxOByteInTx
          )
          HKD f CoinPerWord
appCoinsPerUTxOWord
    , bppCostModels :: HKD f CostModels
bppCostModels = HKD f CostModels
appCostModels
    , bppPrices :: HKD f Prices
bppPrices = HKD f Prices
appPrices
    , bppMaxTxExUnits :: HKD f OrdExUnits
bppMaxTxExUnits = HKD f OrdExUnits
appMaxTxExUnits
    , bppMaxBlockExUnits :: HKD f OrdExUnits
bppMaxBlockExUnits = HKD f OrdExUnits
appMaxBlockExUnits
    , bppMaxValSize :: HKD f Natural
bppMaxValSize = HKD f Natural
appMaxValSize
    , bppCollateralPercentage :: HKD f Natural
bppCollateralPercentage = HKD f Natural
appCollateralPercentage
    , bppMaxCollateralInputs :: HKD f Natural
bppMaxCollateralInputs = HKD f Natural
appMaxCollateralInputs
    }

downgradeBabbagePParams ::
  forall f.
  HKDFunctor f =>
  DowngradeBabbagePParams f ->
  BabbagePParams f BabbageEra ->
  PParamsHKD f AlonzoEra
downgradeBabbagePParams :: forall (f :: * -> *).
HKDFunctor f =>
DowngradeBabbagePParams f
-> BabbagePParams f BabbageEra -> PParamsHKD f AlonzoEra
downgradeBabbagePParams DowngradeBabbagePParams {HKD f Nonce
HKD f UnitInterval
dbppD :: forall (f :: * -> *).
DowngradeBabbagePParams f -> HKD f UnitInterval
dbppExtraEntropy :: forall (f :: * -> *). DowngradeBabbagePParams f -> HKD f Nonce
dbppD :: HKD f UnitInterval
dbppExtraEntropy :: HKD f Nonce
..} BabbagePParams {HKD f Natural
HKD f Word16
HKD f Word32
HKD f OrdExUnits
HKD f CostModels
HKD f Prices
HKD f EpochInterval
HKD f UnitInterval
HKD f NonNegativeInterval
HKD f ProtVer
HKD f Coin
HKD f CoinPerByte
bppMinFeeA :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppMinFeeB :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppMaxBBSize :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f Word32
bppMaxTxSize :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f Word32
bppMaxBHSize :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f Word16
bppKeyDeposit :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppPoolDeposit :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppEMax :: forall (f :: * -> *) era.
BabbagePParams f era -> HKD f EpochInterval
bppNOpt :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f Word16
bppA0 :: forall (f :: * -> *) era.
BabbagePParams f era -> HKD f NonNegativeInterval
bppRho :: forall (f :: * -> *) era.
BabbagePParams f era -> HKD f UnitInterval
bppTau :: forall (f :: * -> *) era.
BabbagePParams f era -> HKD f UnitInterval
bppProtocolVersion :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f ProtVer
bppMinPoolCost :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f Coin
bppCoinsPerUTxOByte :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f CoinPerByte
bppCostModels :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f CostModels
bppPrices :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f Prices
bppMaxTxExUnits :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f OrdExUnits
bppMaxBlockExUnits :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f OrdExUnits
bppMaxValSize :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f Natural
bppCollateralPercentage :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f Natural
bppMaxCollateralInputs :: forall (f :: * -> *) era. BabbagePParams f era -> HKD f Natural
bppMinFeeA :: HKD f Coin
bppMinFeeB :: HKD f Coin
bppMaxBBSize :: HKD f Word32
bppMaxTxSize :: HKD f Word32
bppMaxBHSize :: HKD f Word16
bppKeyDeposit :: HKD f Coin
bppPoolDeposit :: HKD f Coin
bppEMax :: HKD f EpochInterval
bppNOpt :: HKD f Word16
bppA0 :: HKD f NonNegativeInterval
bppRho :: HKD f UnitInterval
bppTau :: HKD f UnitInterval
bppProtocolVersion :: HKD f ProtVer
bppMinPoolCost :: HKD f Coin
bppCoinsPerUTxOByte :: HKD f CoinPerByte
bppCostModels :: HKD f CostModels
bppPrices :: HKD f Prices
bppMaxTxExUnits :: HKD f OrdExUnits
bppMaxBlockExUnits :: HKD f OrdExUnits
bppMaxValSize :: HKD f Natural
bppCollateralPercentage :: HKD f Natural
bppMaxCollateralInputs :: HKD f Natural
..} =
  AlonzoPParams
    { appMinFeeA :: HKD f Coin
appMinFeeA = HKD f Coin
bppMinFeeA
    , appMinFeeB :: HKD f Coin
appMinFeeB = HKD f Coin
bppMinFeeB
    , appMaxBBSize :: HKD f Word32
appMaxBBSize = HKD f Word32
bppMaxBBSize
    , appMaxTxSize :: HKD f Word32
appMaxTxSize = HKD f Word32
bppMaxTxSize
    , appMaxBHSize :: HKD f Word16
appMaxBHSize = HKD f Word16
bppMaxBHSize
    , appKeyDeposit :: HKD f Coin
appKeyDeposit = HKD f Coin
bppKeyDeposit
    , appPoolDeposit :: HKD f Coin
appPoolDeposit = HKD f Coin
bppPoolDeposit
    , appEMax :: HKD f EpochInterval
appEMax = HKD f EpochInterval
bppEMax
    , appNOpt :: HKD f Word16
appNOpt = HKD f Word16
bppNOpt
    , appA0 :: HKD f NonNegativeInterval
appA0 = HKD f NonNegativeInterval
bppA0
    , appRho :: HKD f UnitInterval
appRho = HKD f UnitInterval
bppRho
    , appTau :: HKD f UnitInterval
appTau = HKD f UnitInterval
bppTau
    , appD :: HKD f UnitInterval
appD = HKD f UnitInterval
dbppD
    , appExtraEntropy :: HKD f Nonce
appExtraEntropy = HKD f Nonce
dbppExtraEntropy
    , appProtocolVersion :: HKD f ProtVer
appProtocolVersion = HKD f ProtVer
bppProtocolVersion
    , appMinPoolCost :: HKD f Coin
appMinPoolCost = HKD f Coin
bppMinPoolCost
    , appCoinsPerUTxOWord :: HKD f CoinPerWord
appCoinsPerUTxOWord = Proxy f
-> (CoinPerByte -> CoinPerWord)
-> HKD f CoinPerByte
-> HKD f CoinPerWord
forall (f :: * -> *) (proxy :: (* -> *) -> *) a b.
HKDFunctor f =>
proxy f -> (a -> b) -> HKD f a -> HKD f b
forall (proxy :: (* -> *) -> *) a b.
proxy f -> (a -> b) -> HKD f a -> HKD f b
hkdMap (forall {k} (t :: k). Proxy t
forall (t :: * -> *). Proxy t
Proxy @f) CoinPerByte -> CoinPerWord
coinsPerUTxOByteToCoinsPerUTxOWord HKD f CoinPerByte
bppCoinsPerUTxOByte
    , appCostModels :: HKD f CostModels
appCostModels = HKD f CostModels
bppCostModels
    , appPrices :: HKD f Prices
appPrices = HKD f Prices
bppPrices
    , appMaxTxExUnits :: HKD f OrdExUnits
appMaxTxExUnits = HKD f OrdExUnits
bppMaxTxExUnits
    , appMaxBlockExUnits :: HKD f OrdExUnits
appMaxBlockExUnits = HKD f OrdExUnits
bppMaxBlockExUnits
    , appMaxValSize :: HKD f Natural
appMaxValSize = HKD f Natural
bppMaxValSize
    , appCollateralPercentage :: HKD f Natural
appCollateralPercentage = HKD f Natural
bppCollateralPercentage
    , appMaxCollateralInputs :: HKD f Natural
appMaxCollateralInputs = HKD f Natural
bppMaxCollateralInputs
    }

-- | A word is 8 bytes, so convert from coinsPerUTxOWord to coinsPerUTxOByte, rounding down.
coinsPerUTxOWordToCoinsPerUTxOByte :: CoinPerWord -> CoinPerByte
coinsPerUTxOWordToCoinsPerUTxOByte :: CoinPerWord -> CoinPerByte
coinsPerUTxOWordToCoinsPerUTxOByte (CoinPerWord (Coin Integer
c)) = Coin -> CoinPerByte
CoinPerByte (Coin -> CoinPerByte) -> Coin -> CoinPerByte
forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin (Integer -> Coin) -> Integer -> Coin
forall a b. (a -> b) -> a -> b
$ Integer
c Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
`div` Integer
8

-- | A word is 8 bytes, so convert from coinsPerUTxOByte to coinsPerUTxOWord.
coinsPerUTxOByteToCoinsPerUTxOWord :: CoinPerByte -> CoinPerWord
coinsPerUTxOByteToCoinsPerUTxOWord :: CoinPerByte -> CoinPerWord
coinsPerUTxOByteToCoinsPerUTxOWord (CoinPerByte (Coin Integer
c)) = Coin -> CoinPerWord
CoinPerWord (Coin -> CoinPerWord) -> Coin -> CoinPerWord
forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin (Integer -> Coin) -> Integer -> Coin
forall a b. (a -> b) -> a -> b
$ Integer
c Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
8

-- | Naively convert coins per UTxO word to coins per byte. This function only
-- exists to support the very unusual case of translating a transaction
-- containing an update to the 'coinsPerUTxOWord' field, in which case we must
-- not do the translation above, since this would render the transaction
-- invalid.
coinsPerUTxOWordToCoinsPerUTxOByteInTx :: CoinPerWord -> CoinPerByte
coinsPerUTxOWordToCoinsPerUTxOByteInTx :: CoinPerWord -> CoinPerByte
coinsPerUTxOWordToCoinsPerUTxOByteInTx (CoinPerWord (Coin Integer
c)) = Coin -> CoinPerByte
CoinPerByte (Coin -> CoinPerByte) -> Coin -> CoinPerByte
forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
c

ppCoinsPerUTxOByte :: BabbageEraPParams era => PParam era
ppCoinsPerUTxOByte :: forall era. BabbageEraPParams era => PParam era
ppCoinsPerUTxOByte =
  PParam
    { ppName :: Text
ppName = Text
"utxoCostPerByte"
    , ppLens :: Lens' (PParams era) CoinPerByte
ppLens = (CoinPerByte -> f CoinPerByte) -> PParams era -> f (PParams era)
forall era.
BabbageEraPParams era =>
Lens' (PParams era) CoinPerByte
Lens' (PParams era) CoinPerByte
ppCoinsPerUTxOByteL
    , ppUpdate :: Maybe (PParamUpdate era CoinPerByte)
ppUpdate = PParamUpdate era CoinPerByte
-> Maybe (PParamUpdate era CoinPerByte)
forall a. a -> Maybe a
Just (PParamUpdate era CoinPerByte
 -> Maybe (PParamUpdate era CoinPerByte))
-> PParamUpdate era CoinPerByte
-> Maybe (PParamUpdate era CoinPerByte)
forall a b. (a -> b) -> a -> b
$ Word
-> Lens' (PParamsUpdate era) (StrictMaybe CoinPerByte)
-> PParamUpdate era CoinPerByte
forall era t.
Word
-> Lens' (PParamsUpdate era) (StrictMaybe t) -> PParamUpdate era t
PParamUpdate Word
17 (StrictMaybe CoinPerByte -> f (StrictMaybe CoinPerByte))
-> PParamsUpdate era -> f (PParamsUpdate era)
forall era.
BabbageEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe CoinPerByte)
Lens' (PParamsUpdate era) (StrictMaybe CoinPerByte)
ppuCoinsPerUTxOByteL
    }