{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE EmptyCase #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilyDependencies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE UndecidableSuperClasses #-}

module Cardano.Ledger.Core.PParams (
  EraPParams (..),
  PParams (..),
  PParam (..),
  PParamUpdate (..),
  EraDecoder (..),
  emptyPParams,
  PParamsUpdate (..),
  emptyPParamsUpdate,
  genericApplyPPUpdates,
  CoinPerByte (..),

  -- * PParams lens
  ppTxFeePerByteL,
  ppTxFeeFixedL,
  ppTxFeeFixedCompactL,
  ppMaxBBSizeL,
  ppMaxTxSizeL,
  ppMaxBHSizeL,
  ppKeyDepositL,
  ppKeyDepositCompactL,
  ppPoolDepositL,
  ppPoolDepositCompactL,
  ppEMaxL,
  ppNOptL,
  ppA0L,
  ppRhoL,
  ppTauL,
  ppDL,
  ppExtraEntropyL,
  ppMinUTxOValueL,
  ppMinUTxOValueCompactL,
  ppMinPoolCostL,
  ppMinPoolCostCompactL,

  -- * PParamsUpdate lens
  ppuTxFeePerByteL,
  ppuTxFeeFixedL,
  ppuTxFeeFixedCompactL,
  ppuMaxBBSizeL,
  ppuMaxTxSizeL,
  ppuMaxBHSizeL,
  ppuKeyDepositL,
  ppuKeyDepositCompactL,
  ppuPoolDepositL,
  ppuPoolDepositCompactL,
  ppuEMaxL,
  ppuNOptL,
  ppuA0L,
  ppuRhoL,
  ppuTauL,
  ppuDL,
  ppuExtraEntropyL,
  ppuMinUTxOValueL,
  ppuMinUTxOValueCompactL,
  ppuMinPoolCostL,
  ppuMinPoolCostCompactL,

  -- * Utility
  ppLensHKD,
  ppuLensHKD,
  mapPParams,
  mapPParamsUpdate,
  upgradePParams,
  downgradePParams,
  upgradePParamsUpdate,
  downgradePParamsUpdate,

  -- * Deprecated
  hkdMinFeeAL,
  hkdMinFeeBL,
  ppMinFeeAL,
  ppMinFeeBL,
  ppuMinFeeAL,
  ppuMinFeeBL,
) where

import Cardano.Ledger.BaseTypes (
  EpochInterval (..),
  KeyValuePairs (..),
  NonNegativeInterval,
  Nonce (..),
  ProtVer,
  StrictMaybe (..),
  ToKeyValuePairs (..),
  UnitInterval,
  maybeToStrictMaybe,
 )
import Cardano.Ledger.Binary (
  DecCBOR (..),
  Decoder,
  EncCBOR (..),
  FromCBOR (..),
  ToCBOR (..),
  decodeRecordNamed,
  encodeListLen,
  encodeMapLen,
  encodeWord,
 )
import Cardano.Ledger.Binary.Coders (Decode (..), Field (..), decode, field, invalidField)
import Cardano.Ledger.Coin (
  Coin (..),
  CoinPerByte (..),
  coinPerByteFL,
  coinPerByteL,
  hkdCoinPerByteL,
  hkdPartialCompactCoinL,
  partialCompactCoinL,
 )
import Cardano.Ledger.Compactible (Compactible (..), partialCompactFL)
import Cardano.Ledger.Core.Era (
  AtMostEra,
  Era (..),
  PreviousEra,
  fromEraCBOR,
  toEraCBOR,
 )
import Cardano.Ledger.HKD (HKD, HKDApplicative, HKDFunctor (..), NoUpdate (..))
import Cardano.Ledger.Plutus.ToPlutusData (ToPlutusData (..))
import Control.DeepSeq (NFData)
import Control.Monad.Identity (Identity)
import Data.Aeson (FromJSON (..), ToJSON (..), withObject, (.:), (.:!), (.=))
import qualified Data.Aeson.Key as Aeson (fromText)
import Data.Default (Default (..))
import qualified Data.Foldable as F (foldMap', foldl', foldlM)
import Data.IntMap (IntMap)
import qualified Data.IntMap as IntMap
import Data.Kind (Type)
import Data.Proxy (Proxy (..))
import Data.Text (Text)
import qualified Data.Text as T
import Data.Typeable (typeRep)
import Data.Word (Word16, Word32)
import GHC.Generics (Generic (..), K1 (..), M1 (..), U1, V1, type (:*:) (..))
import GHC.Stack (HasCallStack)
import Lens.Micro (Lens', SimpleGetter, lens, set, (^.))
import NoThunks.Class (NoThunks)

-- | Protocol parameters
newtype PParams era = PParams (PParamsHKD Identity era)

instance EraPParams era => Default (PParams era) where
  def :: PParams era
def = PParams era
forall era. EraPParams era => PParams era
emptyPParams

deriving newtype instance
  Eq (PParamsHKD Identity era) => Eq (PParams era)

deriving newtype instance
  Ord (PParamsHKD Identity era) => Ord (PParams era)

deriving newtype instance
  NFData (PParamsHKD Identity era) => NFData (PParams era)

deriving newtype instance
  NoThunks (PParamsHKD Identity era) => NoThunks (PParams era)

deriving stock instance
  Show (PParamsHKD Identity era) => Show (PParams era)

deriving via
  KeyValuePairs (PParams era)
  instance
    EraPParams era => ToJSON (PParams era)

instance EraPParams era => FromJSON (PParams era) where
  parseJSON :: Value -> Parser (PParams era)
parseJSON =
    String
-> (Object -> Parser (PParams era))
-> Value
-> Parser (PParams era)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject (TypeRep -> String
forall a. Show a => a -> String
show (TypeRep -> String)
-> (Proxy (PParams era) -> TypeRep)
-> Proxy (PParams era)
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (PParams era) -> TypeRep
forall {k} (proxy :: k -> *) (a :: k).
Typeable a =>
proxy a -> TypeRep
typeRep (Proxy (PParams era) -> String) -> Proxy (PParams era) -> String
forall a b. (a -> b) -> a -> b
$ forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(PParams era)) ((Object -> Parser (PParams era)) -> Value -> Parser (PParams era))
-> (Object -> Parser (PParams era))
-> Value
-> Parser (PParams era)
forall a b. (a -> b) -> a -> b
$ \Object
obj ->
      let accum :: PParams era -> PParam era -> Parser (PParams era)
accum PParams era
acc PParam {Text
ppName :: Text
ppName :: forall era. PParam era -> Text
ppName, Lens' (PParams era) t
ppLens :: Lens' (PParams era) t
ppLens :: ()
ppLens} =
            ASetter (PParams era) (PParams era) t t
-> t -> PParams era -> PParams era
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter (PParams era) (PParams era) t t
Lens' (PParams era) t
ppLens (t -> PParams era -> PParams era)
-> Parser t -> Parser (PParams era -> PParams era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
obj Object -> Key -> Parser t
forall a. FromJSON a => Object -> Key -> Parser a
.: Text -> Key
Aeson.fromText Text
ppName Parser (PParams era -> PParams era)
-> Parser (PParams era) -> Parser (PParams era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> PParams era -> Parser (PParams era)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PParams era
acc
       in (PParams era -> PParam era -> Parser (PParams era))
-> PParams era -> [PParam era] -> Parser (PParams era)
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
F.foldlM PParams era -> PParam era -> Parser (PParams era)
accum (forall era. EraPParams era => PParams era
emptyPParams @era) (forall era. EraPParams era => [PParam era]
eraPParams @era)

instance EraPParams era => EncCBOR (PParams era) where
  encCBOR :: PParams era -> Encoding
encCBOR PParams era
pp =
    Word -> Encoding
encodeListLen (Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([PParam era] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (forall era. EraPParams era => [PParam era]
eraPParams @era)))
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> (PParam era -> Encoding) -> [PParam era] -> Encoding
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
F.foldMap' PParam era -> Encoding
toEnc (forall era. EraPParams era => [PParam era]
eraPParams @era)
    where
      toEnc :: PParam era -> Encoding
toEnc PParam {Lens' (PParams era) t
ppLens :: ()
ppLens :: Lens' (PParams era) t
ppLens} = t -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR (t -> Encoding) -> t -> Encoding
forall a b. (a -> b) -> a -> b
$ PParams era
pp PParams era -> Getting t (PParams era) t -> t
forall s a. s -> Getting a s a -> a
^. Getting t (PParams era) t
Lens' (PParams era) t
ppLens

instance EraPParams era => DecCBOR (PParams era) where
  decCBOR :: forall s. Decoder s (PParams era)
decCBOR =
    Text
-> (PParams era -> Int)
-> Decoder s (PParams era)
-> Decoder s (PParams era)
forall a s. Text -> (a -> Int) -> Decoder s a -> Decoder s a
decodeRecordNamed
      (String -> Text
T.pack (String -> Text)
-> (Proxy (PParams era) -> String) -> Proxy (PParams era) -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeRep -> String
forall a. Show a => a -> String
show (TypeRep -> String)
-> (Proxy (PParams era) -> TypeRep)
-> Proxy (PParams era)
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (PParams era) -> TypeRep
forall {k} (proxy :: k -> *) (a :: k).
Typeable a =>
proxy a -> TypeRep
typeRep (Proxy (PParams era) -> Text) -> Proxy (PParams era) -> Text
forall a b. (a -> b) -> a -> b
$ forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(PParams era))
      (Int -> PParams era -> Int
forall a b. a -> b -> a
const (Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([PParam era] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (forall era. EraPParams era => [PParam era]
eraPParams @era))))
      (Decoder s (PParams era) -> Decoder s (PParams era))
-> Decoder s (PParams era) -> Decoder s (PParams era)
forall a b. (a -> b) -> a -> b
$ (PParams era -> PParam era -> Decoder s (PParams era))
-> PParams era -> [PParam era] -> Decoder s (PParams era)
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
F.foldlM PParams era -> PParam era -> Decoder s (PParams era)
forall {era} {s}.
PParams era -> PParam era -> Decoder s (PParams era)
accum (forall era. EraPParams era => PParams era
emptyPParams @era) (forall era. EraPParams era => [PParam era]
eraPParams @era)
    where
      accum :: PParams era -> PParam era -> Decoder s (PParams era)
accum PParams era
acc PParam {Lens' (PParams era) t
ppLens :: ()
ppLens :: Lens' (PParams era) t
ppLens} =
        ASetter (PParams era) (PParams era) t t
-> t -> PParams era -> PParams era
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter (PParams era) (PParams era) t t
Lens' (PParams era) t
ppLens (t -> PParams era -> PParams era)
-> Decoder s t -> Decoder s (PParams era -> PParams era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s t
forall s. Decoder s t
forall a s. DecCBOR a => Decoder s a
decCBOR Decoder s (PParams era -> PParams era)
-> Decoder s (PParams era) -> Decoder s (PParams era)
forall a b. Decoder s (a -> b) -> Decoder s a -> Decoder s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> PParams era -> Decoder s (PParams era)
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PParams era
acc

instance EraPParams era => ToCBOR (PParams era) where
  toCBOR :: PParams era -> Encoding
toCBOR = forall era t. (Era era, EncCBOR t) => t -> Encoding
toEraCBOR @era

instance EraPParams era => FromCBOR (PParams era) where
  fromCBOR :: forall s. Decoder s (PParams era)
fromCBOR = forall era t s. (Era era, DecCBOR t) => Decoder s t
fromEraCBOR @era

deriving instance Generic (PParams era)

-- | The type of updates to Protocol parameters
newtype PParamsUpdate era = PParamsUpdate (PParamsHKD StrictMaybe era)

instance EraPParams era => Default (PParamsUpdate era) where
  def :: PParamsUpdate era
def = PParamsUpdate era
forall era. EraPParams era => PParamsUpdate era
emptyPParamsUpdate

deriving newtype instance
  Eq (PParamsHKD StrictMaybe era) => Eq (PParamsUpdate era)

deriving newtype instance
  Ord (PParamsHKD StrictMaybe era) => Ord (PParamsUpdate era)

deriving newtype instance
  NFData (PParamsHKD StrictMaybe era) => NFData (PParamsUpdate era)

deriving newtype instance
  NoThunks (PParamsHKD StrictMaybe era) => NoThunks (PParamsUpdate era)

deriving stock instance
  Show (PParamsHKD StrictMaybe era) => Show (PParamsUpdate era)

instance EraPParams era => EncCBOR (PParamsUpdate era) where
  encCBOR :: PParamsUpdate era -> Encoding
encCBOR PParamsUpdate era
pp = Word -> Encoding
encodeMapLen Word
count Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> Encoding
enc
    where
      !(!Word
count, !Encoding
enc) = [PParam era] -> (Word, Encoding)
countAndConcat (forall era. EraPParams era => [PParam era]
eraPParams @era)
      encodeField :: PParam era -> StrictMaybe Encoding
encodeField PParam {Maybe (PParamUpdate era t)
ppUpdate :: Maybe (PParamUpdate era t)
ppUpdate :: ()
ppUpdate} = do
        PParamUpdate {ppuTag, ppuLens} <- Maybe (PParamUpdate era t) -> StrictMaybe (PParamUpdate era t)
forall a. Maybe a -> StrictMaybe a
maybeToStrictMaybe Maybe (PParamUpdate era t)
ppUpdate
        (encodeWord ppuTag <>) . encCBOR <$> pp ^. ppuLens
      countAndConcat :: [PParam era] -> (Word, Encoding)
countAndConcat = ((Word, Encoding) -> PParam era -> (Word, Encoding))
-> (Word, Encoding) -> [PParam era] -> (Word, Encoding)
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl' (Word, Encoding) -> PParam era -> (Word, Encoding)
accum (Word
0, Encoding
forall a. Monoid a => a
mempty)
        where
          accum :: (Word, Encoding) -> PParam era -> (Word, Encoding)
accum (!Word
n, !Encoding
acc) PParam era
x = case PParam era -> StrictMaybe Encoding
encodeField PParam era
x of
            SJust Encoding
y -> (Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
+ Word
1, Encoding
acc Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> Encoding
y)
            StrictMaybe Encoding
SNothing -> (Word
n, Encoding
acc)

instance EraPParams era => DecCBOR (PParamsUpdate era) where
  decCBOR :: forall s. Decoder s (PParamsUpdate era)
decCBOR =
    Decode (Closed Dense) (PParamsUpdate era)
-> Decoder s (PParamsUpdate era)
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode (Decode (Closed Dense) (PParamsUpdate era)
 -> Decoder s (PParamsUpdate era))
-> Decode (Closed Dense) (PParamsUpdate era)
-> Decoder s (PParamsUpdate era)
forall a b. (a -> b) -> a -> b
$
      String
-> PParamsUpdate era
-> (Word -> Field (PParamsUpdate era))
-> [(Word, String)]
-> Decode (Closed Dense) (PParamsUpdate era)
forall t.
Typeable t =>
String
-> t
-> (Word -> Field t)
-> [(Word, String)]
-> Decode (Closed Dense) t
SparseKeyed
        (TypeRep -> String
forall a. Show a => a -> String
show (TypeRep -> String)
-> (Proxy (PParamsUpdate era) -> TypeRep)
-> Proxy (PParamsUpdate era)
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (PParamsUpdate era) -> TypeRep
forall {k} (proxy :: k -> *) (a :: k).
Typeable a =>
proxy a -> TypeRep
typeRep (Proxy (PParamsUpdate era) -> String)
-> Proxy (PParamsUpdate era) -> String
forall a b. (a -> b) -> a -> b
$ forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(PParamsUpdate era))
        PParamsUpdate era
forall era. EraPParams era => PParamsUpdate era
emptyPParamsUpdate
        Word -> Field (PParamsUpdate era)
updateField
        []
    where
      updateField :: Word -> Field (PParamsUpdate era)
updateField Word
k =
        Field (PParamsUpdate era)
-> Int
-> IntMap (Field (PParamsUpdate era))
-> Field (PParamsUpdate era)
forall a. a -> Int -> IntMap a -> a
IntMap.findWithDefault
          (Word -> Field (PParamsUpdate era)
forall t. Word -> Field t
invalidField Word
k)
          (Word -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
k)
          IntMap (Field (PParamsUpdate era))
updateFieldMap
      updateFieldMap :: IntMap (Field (PParamsUpdate era))
      updateFieldMap :: IntMap (Field (PParamsUpdate era))
updateFieldMap =
        [(Int, Field (PParamsUpdate era))]
-> IntMap (Field (PParamsUpdate era))
forall a. [(Int, a)] -> IntMap a
IntMap.fromList
          [ (Word -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
ppuTag, Maybe (EraDecoder t)
-> Lens' (PParamsUpdate era) (StrictMaybe t)
-> Field (PParamsUpdate era)
forall t.
DecCBOR t =>
Maybe (EraDecoder t)
-> Lens' (PParamsUpdate era) (StrictMaybe t)
-> Field (PParamsUpdate era)
mkField Maybe (EraDecoder t)
ppEraDecoder (StrictMaybe t -> f (StrictMaybe t))
-> PParamsUpdate era -> f (PParamsUpdate era)
Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens)
          | PParam {Maybe (EraDecoder t)
ppEraDecoder :: Maybe (EraDecoder t)
ppEraDecoder :: ()
ppEraDecoder, ppUpdate :: ()
ppUpdate = Just PParamUpdate {Word
ppuTag :: forall era t. PParamUpdate era t -> Word
ppuTag :: Word
ppuTag, Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens :: forall era t.
PParamUpdate era t -> Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens :: Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens}} <- forall era. EraPParams era => [PParam era]
eraPParams @era
          ]
      mkField ::
        forall t.
        DecCBOR t =>
        Maybe (EraDecoder t) ->
        Lens' (PParamsUpdate era) (StrictMaybe t) ->
        Field (PParamsUpdate era)
      mkField :: forall t.
DecCBOR t =>
Maybe (EraDecoder t)
-> Lens' (PParamsUpdate era) (StrictMaybe t)
-> Field (PParamsUpdate era)
mkField Maybe (EraDecoder t)
Nothing Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens = (t -> PParamsUpdate era -> PParamsUpdate era)
-> Decode (Closed (ZonkAny 0)) t -> Field (PParamsUpdate era)
forall x t (d :: Density).
Typeable x =>
(x -> t -> t) -> Decode (Closed d) x -> Field t
field (ASetter
  (PParamsUpdate era)
  (PParamsUpdate era)
  (StrictMaybe t)
  (StrictMaybe t)
-> StrictMaybe t -> PParamsUpdate era -> PParamsUpdate era
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter
  (PParamsUpdate era)
  (PParamsUpdate era)
  (StrictMaybe t)
  (StrictMaybe t)
Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens (StrictMaybe t -> PParamsUpdate era -> PParamsUpdate era)
-> (t -> StrictMaybe t)
-> t
-> PParamsUpdate era
-> PParamsUpdate era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t -> StrictMaybe t
forall a. a -> StrictMaybe a
SJust) Decode (Closed (ZonkAny 0)) t
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
      mkField (Just (EraDecoder forall s. Decoder s t
d)) Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens = (t -> PParamsUpdate era -> PParamsUpdate era)
-> (forall s. Decoder s t) -> Field (PParamsUpdate era)
forall x t. (x -> t -> t) -> (forall s. Decoder s x) -> Field t
Field (ASetter
  (PParamsUpdate era)
  (PParamsUpdate era)
  (StrictMaybe t)
  (StrictMaybe t)
-> StrictMaybe t -> PParamsUpdate era -> PParamsUpdate era
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter
  (PParamsUpdate era)
  (PParamsUpdate era)
  (StrictMaybe t)
  (StrictMaybe t)
Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens (StrictMaybe t -> PParamsUpdate era -> PParamsUpdate era)
-> (t -> StrictMaybe t)
-> t
-> PParamsUpdate era
-> PParamsUpdate era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t -> StrictMaybe t
forall a. a -> StrictMaybe a
SJust) Decoder s t
forall s. Decoder s t
d

instance EraPParams era => ToCBOR (PParamsUpdate era) where
  toCBOR :: PParamsUpdate era -> Encoding
toCBOR = forall era t. (Era era, EncCBOR t) => t -> Encoding
toEraCBOR @era

instance EraPParams era => FromCBOR (PParamsUpdate era) where
  fromCBOR :: forall s. Decoder s (PParamsUpdate era)
fromCBOR = forall era t s. (Era era, DecCBOR t) => Decoder s t
fromEraCBOR @era

deriving via
  KeyValuePairs (PParamsUpdate era)
  instance
    EraPParams era => ToJSON (PParamsUpdate era)

instance EraPParams era => FromJSON (PParamsUpdate era) where
  parseJSON :: Value -> Parser (PParamsUpdate era)
parseJSON =
    String
-> (Object -> Parser (PParamsUpdate era))
-> Value
-> Parser (PParamsUpdate era)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject (TypeRep -> String
forall a. Show a => a -> String
show (TypeRep -> String)
-> (Proxy (PParamsUpdate era) -> TypeRep)
-> Proxy (PParamsUpdate era)
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy (PParamsUpdate era) -> TypeRep
forall {k} (proxy :: k -> *) (a :: k).
Typeable a =>
proxy a -> TypeRep
typeRep (Proxy (PParamsUpdate era) -> String)
-> Proxy (PParamsUpdate era) -> String
forall a b. (a -> b) -> a -> b
$ forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @(PParamsUpdate era)) ((Object -> Parser (PParamsUpdate era))
 -> Value -> Parser (PParamsUpdate era))
-> (Object -> Parser (PParamsUpdate era))
-> Value
-> Parser (PParamsUpdate era)
forall a b. (a -> b) -> a -> b
$ \Object
obj ->
      let go :: PParamsUpdate era -> PParam era -> Parser (PParamsUpdate era)
go PParamsUpdate era
acc PParam {Text
ppName :: forall era. PParam era -> Text
ppName :: Text
ppName, Maybe (PParamUpdate era t)
ppUpdate :: ()
ppUpdate :: Maybe (PParamUpdate era t)
ppUpdate} =
            (PParamsUpdate era -> PParamsUpdate era)
-> (t -> PParamsUpdate era -> PParamsUpdate era)
-> Maybe t
-> PParamsUpdate era
-> PParamsUpdate era
forall b a. b -> (a -> b) -> Maybe a -> b
maybe PParamsUpdate era -> PParamsUpdate era
forall a. a -> a
id t -> PParamsUpdate era -> PParamsUpdate era
setPpu (Maybe t -> PParamsUpdate era -> PParamsUpdate era)
-> Parser (Maybe t)
-> Parser (PParamsUpdate era -> PParamsUpdate era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
obj Object -> Key -> Parser (Maybe t)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:! Text -> Key
Aeson.fromText Text
ppName Parser (PParamsUpdate era -> PParamsUpdate era)
-> Parser (PParamsUpdate era) -> Parser (PParamsUpdate era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> PParamsUpdate era -> Parser (PParamsUpdate era)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PParamsUpdate era
acc
            where
              setPpu :: t -> PParamsUpdate era -> PParamsUpdate era
setPpu = (t -> PParamsUpdate era -> PParamsUpdate era)
-> (PParamUpdate era t
    -> t -> PParamsUpdate era -> PParamsUpdate era)
-> Maybe (PParamUpdate era t)
-> t
-> PParamsUpdate era
-> PParamsUpdate era
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ((PParamsUpdate era -> PParamsUpdate era)
-> t -> PParamsUpdate era -> PParamsUpdate era
forall a b. a -> b -> a
const PParamsUpdate era -> PParamsUpdate era
forall a. a -> a
id) (\PParamUpdate {Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens :: forall era t.
PParamUpdate era t -> Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens :: Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens} -> ASetter
  (PParamsUpdate era)
  (PParamsUpdate era)
  (StrictMaybe t)
  (StrictMaybe t)
-> StrictMaybe t -> PParamsUpdate era -> PParamsUpdate era
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter
  (PParamsUpdate era)
  (PParamsUpdate era)
  (StrictMaybe t)
  (StrictMaybe t)
Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens (StrictMaybe t -> PParamsUpdate era -> PParamsUpdate era)
-> (t -> StrictMaybe t)
-> t
-> PParamsUpdate era
-> PParamsUpdate era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t -> StrictMaybe t
forall a. a -> StrictMaybe a
SJust) Maybe (PParamUpdate era t)
ppUpdate
       in (PParamsUpdate era -> PParam era -> Parser (PParamsUpdate era))
-> PParamsUpdate era -> [PParam era] -> Parser (PParamsUpdate era)
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
F.foldlM
            PParamsUpdate era -> PParam era -> Parser (PParamsUpdate era)
go
            (forall era. EraPParams era => PParamsUpdate era
emptyPParamsUpdate @era)
            (forall era. EraPParams era => [PParam era]
eraPParams @era)

deriving instance Generic (PParamsUpdate era)

-- Generic derivation of `applyPPUpdates`

class Updatable a u where
  applyUpdate :: a -> u -> a

instance Updatable (U1 a) (U1 u) where
  applyUpdate :: U1 a -> U1 u -> U1 a
applyUpdate U1 a
x U1 u
_ = U1 a
x

instance Updatable (V1 a) (V1 u) where
  applyUpdate :: V1 a -> V1 u -> V1 a
applyUpdate V1 a
x V1 u
_ = case V1 a
x of {}

instance
  (Updatable (a1 a) (u1 u), Updatable (a2 a) (u2 u)) =>
  Updatable ((a1 :*: a2) a) ((u1 :*: u2) u)
  where
  applyUpdate :: (:*:) a1 a2 a -> (:*:) u1 u2 u -> (:*:) a1 a2 a
applyUpdate (a1 a
x1 :*: a2 a
x2) (u1 u
u1 :*: u2 u
u2) = a1 a -> u1 u -> a1 a
forall a u. Updatable a u => a -> u -> a
applyUpdate a1 a
x1 u1 u
u1 a1 a -> a2 a -> (:*:) a1 a2 a
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: a2 a -> u2 u -> a2 a
forall a u. Updatable a u => a -> u -> a
applyUpdate a2 a
x2 u2 u
u2

instance Updatable (a x) (a' x') => Updatable (M1 i c a x) (M1 i' c' a' x') where
  applyUpdate :: M1 i c a x -> M1 i' c' a' x' -> M1 i c a x
applyUpdate (M1 a x
x) (M1 a' x'
y) = a x -> M1 i c a x
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (a x -> M1 i c a x) -> a x -> M1 i c a x
forall a b. (a -> b) -> a -> b
$ a x -> a' x' -> a x
forall a u. Updatable a u => a -> u -> a
applyUpdate a x
x a' x'
y

instance Updatable (K1 t x a) (K1 t (StrictMaybe x) u) where
  applyUpdate :: K1 t x a -> K1 t (StrictMaybe x) u -> K1 t x a
applyUpdate (K1 x
x') (K1 StrictMaybe x
sm) = x -> K1 t x a
forall k i c (p :: k). c -> K1 i c p
K1 (x -> K1 t x a) -> x -> K1 t x a
forall a b. (a -> b) -> a -> b
$ case StrictMaybe x
sm of
    SJust x
x -> x
x
    StrictMaybe x
SNothing -> x
x'

instance Updatable (K1 t x a) (K1 t (NoUpdate x) u) where
  applyUpdate :: K1 t x a -> K1 t (NoUpdate x) u -> K1 t x a
applyUpdate (K1 x
x) (K1 NoUpdate x
NoUpdate) = x -> K1 t x a
forall k i c (p :: k). c -> K1 i c p
K1 x
x

genericApplyPPUpdates ::
  forall era a u.
  ( Generic (PParamsHKD Identity era)
  , Generic (PParamsHKD StrictMaybe era)
  , Updatable (Rep (PParamsHKD Identity era) a) (Rep (PParamsHKD StrictMaybe era) u)
  ) =>
  PParams era ->
  PParamsUpdate era ->
  PParams era
genericApplyPPUpdates :: forall era a u.
(Generic (PParamsHKD Identity era),
 Generic (PParamsHKD StrictMaybe era),
 Updatable
   (Rep (PParamsHKD Identity era) a)
   (Rep (PParamsHKD StrictMaybe era) u)) =>
PParams era -> PParamsUpdate era -> PParams era
genericApplyPPUpdates (PParams PParamsHKD Identity era
a) (PParamsUpdate PParamsHKD StrictMaybe era
u) =
  PParamsHKD Identity era -> PParams era
forall era. PParamsHKD Identity era -> PParams era
PParams (PParamsHKD Identity era -> PParams era)
-> (Rep (PParamsHKD Identity era) a -> PParamsHKD Identity era)
-> Rep (PParamsHKD Identity era) a
-> PParams era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep (PParamsHKD Identity era) a -> PParamsHKD Identity era
forall a x. Generic a => Rep a x -> a
forall x.
Rep (PParamsHKD Identity era) x -> PParamsHKD Identity era
to (Rep (PParamsHKD Identity era) a -> PParams era)
-> Rep (PParamsHKD Identity era) a -> PParams era
forall a b. (a -> b) -> a -> b
$ Rep (PParamsHKD Identity era) a
-> Rep (PParamsHKD StrictMaybe era) u
-> Rep (PParamsHKD Identity era) a
forall a u. Updatable a u => a -> u -> a
applyUpdate (forall a x. Generic a => a -> Rep a x
from @_ @a PParamsHKD Identity era
a) (forall a x. Generic a => a -> Rep a x
from @_ @u PParamsHKD StrictMaybe era
u)

class
  ( Era era
  , Eq (PParamsHKD Identity era)
  , Ord (PParamsHKD Identity era)
  , Show (PParamsHKD Identity era)
  , NFData (PParamsHKD Identity era)
  , NoThunks (PParamsHKD Identity era)
  , Eq (PParamsHKD StrictMaybe era)
  , Ord (PParamsHKD StrictMaybe era)
  , Show (PParamsHKD StrictMaybe era)
  , NFData (PParamsHKD StrictMaybe era)
  , NoThunks (PParamsHKD StrictMaybe era)
  ) =>
  EraPParams era
  where
  -- | Protocol parameters where the fields are represented with a HKD
  type PParamsHKD (f :: Type -> Type) era = (r :: Type) | r -> era

  -- | Applies a protocol parameters update
  applyPPUpdates ::
    PParams era ->
    PParamsUpdate era ->
    PParams era
  default applyPPUpdates ::
    forall a u.
    ( Generic (PParamsHKD Identity era)
    , Generic (PParamsHKD StrictMaybe era)
    , Updatable (Rep (PParamsHKD Identity era) a) (Rep (PParamsHKD StrictMaybe era) u)
    ) =>
    PParams era ->
    PParamsUpdate era ->
    PParams era
  applyPPUpdates = forall era a u.
(Generic (PParamsHKD Identity era),
 Generic (PParamsHKD StrictMaybe era),
 Updatable
   (Rep (PParamsHKD Identity era) a)
   (Rep (PParamsHKD StrictMaybe era) u)) =>
PParams era -> PParamsUpdate era -> PParams era
genericApplyPPUpdates @_ @a @u

  emptyPParamsIdentity :: PParamsHKD Identity era
  emptyPParamsStrictMaybe :: PParamsHKD StrictMaybe era

  -- |
  type UpgradePParams (f :: Type -> Type) era :: Type

  type DowngradePParams (f :: Type -> Type) era :: Type

  emptyUpgradePParamsUpdate :: UpgradePParams StrictMaybe era
  default emptyUpgradePParamsUpdate ::
    UpgradePParams StrictMaybe era ~ () => UpgradePParams StrictMaybe era
  emptyUpgradePParamsUpdate = ()

  -- | Upgrade PParams from previous era to the current one
  upgradePParamsHKD ::
    (HKDApplicative f, EraPParams (PreviousEra era)) =>
    UpgradePParams f era ->
    PParamsHKD f (PreviousEra era) ->
    PParamsHKD f era

  -- | Downgrade PParams from the current era to the previous one
  downgradePParamsHKD ::
    (HKDFunctor f, EraPParams (PreviousEra era)) =>
    DowngradePParams f era ->
    PParamsHKD f era ->
    PParamsHKD f (PreviousEra era)

  -- HKD Versions of lenses

  -- | The linear factor for the minimum fee calculation
  hkdTxFeePerByteL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f CoinPerByte)

  -- | The constant factor for the minimum fee calculation
  hkdTxFeeFixedCompactL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))

  -- | Maximal block body size
  hkdMaxBBSizeL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f Word32)

  -- | Maximal transaction size
  hkdMaxTxSizeL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f Word32)

  -- | Maximal block header size
  hkdMaxBHSizeL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f Word16)

  -- | The amount of a key registration deposit
  hkdKeyDepositCompactL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))

  -- | The amount of a pool registration deposit
  hkdPoolDepositCompactL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))

  -- | epoch bound on pool retirement
  hkdEMaxL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f EpochInterval)

  -- | Desired number of pools
  hkdNOptL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f Word16)

  -- | Pool influence
  hkdA0L :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f NonNegativeInterval)

  -- | Monetary expansion
  hkdRhoL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f UnitInterval)

  -- | Treasury expansion
  hkdTauL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f UnitInterval)

  -- | Decentralization parameter
  hkdDL :: (HKDFunctor f, AtMostEra "Alonzo" era) => Lens' (PParamsHKD f era) (HKD f UnitInterval)

  -- | Decentralization parameter getter
  ppDG :: SimpleGetter (PParams era) UnitInterval
  default ppDG :: AtMostEra "Alonzo" era => SimpleGetter (PParams era) UnitInterval
  ppDG = (PParamsHKD Identity era -> Const r (PParamsHKD Identity era))
-> PParams era -> Const r (PParams era)
forall era (f :: * -> *).
Functor f =>
(PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> PParams era -> f (PParams era)
ppLensHKD ((PParamsHKD Identity era -> Const r (PParamsHKD Identity era))
 -> PParams era -> Const r (PParams era))
-> ((UnitInterval -> Const r UnitInterval)
    -> PParamsHKD Identity era -> Const r (PParamsHKD Identity era))
-> (UnitInterval -> Const r UnitInterval)
-> PParams era
-> Const r (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f, AtMostEra "Alonzo" era) =>
Lens' (PParamsHKD f era) (HKD f UnitInterval)
hkdDL @era @Identity

  -- | Extra entropy
  hkdExtraEntropyL :: (HKDFunctor f, AtMostEra "Alonzo" era) => Lens' (PParamsHKD f era) (HKD f Nonce)

  -- | Protocol version
  hkdProtocolVersionL ::
    (HKDFunctor f, AtMostEra "Babbage" era) => Lens' (PParamsHKD f era) (HKD f ProtVer)

  ppProtocolVersionL :: Lens' (PParams era) ProtVer
  default ppProtocolVersionL :: AtMostEra "Babbage" era => Lens' (PParams era) ProtVer
  ppProtocolVersionL = (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))
-> ((ProtVer -> f ProtVer)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (ProtVer -> f ProtVer)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f, AtMostEra "Babbage" era) =>
Lens' (PParamsHKD f era) (HKD f ProtVer)
hkdProtocolVersionL @era @Identity

  -- | PParamsUpdate Protocol version
  ppuProtocolVersionL :: AtMostEra "Babbage" era => Lens' (PParamsUpdate era) (StrictMaybe ProtVer)
  ppuProtocolVersionL = (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 ProtVer -> f (StrictMaybe ProtVer))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe ProtVer -> f (StrictMaybe ProtVer))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f, AtMostEra "Babbage" era) =>
Lens' (PParamsHKD f era) (HKD f ProtVer)
hkdProtocolVersionL @era @StrictMaybe

  -- | Minimum UTxO value
  hkdMinUTxOValueCompactL ::
    (HKDFunctor f, AtMostEra "Mary" era) => Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))

  -- | Minimum Stake Pool Cost
  hkdMinPoolCostCompactL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))

  eraPParams :: [PParam era]

hkdMinFeeAL ::
  forall era f. (EraPParams era, HKDFunctor f) => Lens' (PParamsHKD f era) (HKD f Coin)
hkdMinFeeAL :: forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Coin)
hkdMinFeeAL = forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f CoinPerByte)
hkdTxFeePerByteL @era @f ((HKD f CoinPerByte -> f (HKD f CoinPerByte))
 -> PParamsHKD f era -> f (PParamsHKD f era))
-> ((HKD f Coin -> f (HKD f Coin))
    -> HKD f CoinPerByte -> f (HKD f CoinPerByte))
-> (HKD f Coin -> f (HKD f Coin))
-> PParamsHKD f era
-> f (PParamsHKD f era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *).
HKDFunctor f =>
Lens' (HKD f CoinPerByte) (HKD f (CompactForm Coin))
hkdCoinPerByteL @f ((HKD f (CompactForm Coin) -> f (HKD f (CompactForm Coin)))
 -> HKD f CoinPerByte -> f (HKD f CoinPerByte))
-> ((HKD f Coin -> f (HKD f Coin))
    -> HKD f (CompactForm Coin) -> f (HKD f (CompactForm Coin)))
-> (HKD f Coin -> f (HKD f Coin))
-> HKD f CoinPerByte
-> f (HKD f CoinPerByte)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *).
(HasCallStack, HKDFunctor f) =>
Lens' (HKD f (CompactForm Coin)) (HKD f Coin)
hkdPartialCompactCoinL @f
{-# DEPRECATED hkdMinFeeAL "In favor of `hkdTxFeePerByteL`" #-}

hkdMinFeeBL ::
  forall era f. (EraPParams era, HKDFunctor f) => Lens' (PParamsHKD f era) (HKD f Coin)
hkdMinFeeBL :: forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Coin)
hkdMinFeeBL = forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdTxFeeFixedCompactL @era @f ((HKD f (CompactForm Coin) -> f (HKD f (CompactForm Coin)))
 -> PParamsHKD f era -> f (PParamsHKD f era))
-> ((HKD f Coin -> f (HKD f Coin))
    -> HKD f (CompactForm Coin) -> f (HKD f (CompactForm Coin)))
-> (HKD f Coin -> f (HKD f Coin))
-> PParamsHKD f era
-> f (PParamsHKD f era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *).
(HasCallStack, HKDFunctor f) =>
Lens' (HKD f (CompactForm Coin)) (HKD f Coin)
hkdPartialCompactCoinL @f
{-# DEPRECATED hkdMinFeeBL "In favor of `hkdTxFeeFixedCompactL`" #-}

emptyPParams :: EraPParams era => PParams era
emptyPParams :: forall era. EraPParams era => PParams era
emptyPParams = PParamsHKD Identity era -> PParams era
forall era. PParamsHKD Identity era -> PParams era
PParams PParamsHKD Identity era
forall era. EraPParams era => PParamsHKD Identity era
emptyPParamsIdentity

emptyPParamsUpdate :: EraPParams era => PParamsUpdate era
emptyPParamsUpdate :: forall era. EraPParams era => PParamsUpdate era
emptyPParamsUpdate = PParamsHKD StrictMaybe era -> PParamsUpdate era
forall era. PParamsHKD StrictMaybe era -> PParamsUpdate era
PParamsUpdate PParamsHKD StrictMaybe era
forall era. EraPParams era => PParamsHKD StrictMaybe era
emptyPParamsStrictMaybe

ppLensHKD :: Lens' (PParams era) (PParamsHKD Identity era)
ppLensHKD :: forall era (f :: * -> *).
Functor f =>
(PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> PParams era -> f (PParams era)
ppLensHKD = (PParams era -> PParamsHKD Identity era)
-> (PParams era -> PParamsHKD Identity era -> PParams era)
-> Lens
     (PParams era)
     (PParams era)
     (PParamsHKD Identity era)
     (PParamsHKD Identity era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (\(PParams PParamsHKD Identity era
x) -> PParamsHKD Identity era
x) (\PParams era
_ PParamsHKD Identity era
pp -> PParamsHKD Identity era -> PParams era
forall era. PParamsHKD Identity era -> PParams era
PParams PParamsHKD Identity era
pp)

ppuLensHKD :: Lens' (PParamsUpdate era) (PParamsHKD StrictMaybe era)
ppuLensHKD :: forall era (f :: * -> *).
Functor f =>
(PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> PParamsUpdate era -> f (PParamsUpdate era)
ppuLensHKD = (PParamsUpdate era -> PParamsHKD StrictMaybe era)
-> (PParamsUpdate era
    -> PParamsHKD StrictMaybe era -> PParamsUpdate era)
-> Lens
     (PParamsUpdate era)
     (PParamsUpdate era)
     (PParamsHKD StrictMaybe era)
     (PParamsHKD StrictMaybe era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (\(PParamsUpdate PParamsHKD StrictMaybe era
x) -> PParamsHKD StrictMaybe era
x) (\PParamsUpdate era
_ PParamsHKD StrictMaybe era
pp -> PParamsHKD StrictMaybe era -> PParamsUpdate era
forall era. PParamsHKD StrictMaybe era -> PParamsUpdate era
PParamsUpdate PParamsHKD StrictMaybe era
pp)

-- PParams versions of lenses

-- | The linear factor for the minimum fee calculation
ppTxFeePerByteL :: forall era. EraPParams era => Lens' (PParams era) CoinPerByte
ppTxFeePerByteL :: forall era. EraPParams era => Lens' (PParams era) CoinPerByte
ppTxFeePerByteL = (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 :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f CoinPerByte)
hkdTxFeePerByteL @era @Identity

ppMinFeeAL :: forall era. EraPParams era => Lens' (PParams era) Coin
ppMinFeeAL :: forall era. EraPParams era => Lens' (PParams era) Coin
ppMinFeeAL = (CoinPerByte -> f CoinPerByte) -> PParams era -> f (PParams era)
forall era. EraPParams era => Lens' (PParams era) CoinPerByte
Lens' (PParams era) CoinPerByte
ppTxFeePerByteL ((CoinPerByte -> f CoinPerByte) -> PParams era -> f (PParams era))
-> ((Coin -> f Coin) -> CoinPerByte -> f CoinPerByte)
-> (Coin -> f Coin)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CompactForm Coin -> f (CompactForm Coin))
-> CoinPerByte -> f CoinPerByte
Lens' CoinPerByte (CompactForm Coin)
coinPerByteL ((CompactForm Coin -> f (CompactForm Coin))
 -> CoinPerByte -> f CoinPerByte)
-> ((Coin -> f Coin) -> CompactForm Coin -> f (CompactForm Coin))
-> (Coin -> f Coin)
-> CoinPerByte
-> f CoinPerByte
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => Lens' (CompactForm Coin) Coin
(Coin -> f Coin) -> CompactForm Coin -> f (CompactForm Coin)
Lens' (CompactForm Coin) Coin
partialCompactCoinL
{-# DEPRECATED ppMinFeeAL "In favor of `ppTxFeePerByteL`" #-}

-- | The constant factor for the minimum fee calculation
ppTxFeeFixedL :: forall era. (EraPParams era, HasCallStack) => Lens' (PParams era) Coin
ppTxFeeFixedL :: forall era.
(EraPParams era, HasCallStack) =>
Lens' (PParams era) Coin
ppTxFeeFixedL = (CompactForm Coin -> f (CompactForm Coin))
-> PParams era -> f (PParams era)
forall era.
EraPParams era =>
Lens' (PParams era) (CompactForm Coin)
Lens' (PParams era) (CompactForm Coin)
ppTxFeeFixedCompactL ((CompactForm Coin -> f (CompactForm Coin))
 -> PParams era -> f (PParams era))
-> ((Coin -> f Coin) -> CompactForm Coin -> f (CompactForm Coin))
-> (Coin -> f Coin)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => Lens' (CompactForm Coin) Coin
(Coin -> f Coin) -> CompactForm Coin -> f (CompactForm Coin)
Lens' (CompactForm Coin) Coin
partialCompactCoinL

ppMinFeeBL :: forall era. EraPParams era => Lens' (PParams era) Coin
ppMinFeeBL :: forall era. EraPParams era => Lens' (PParams era) Coin
ppMinFeeBL = (Coin -> f Coin) -> PParams era -> f (PParams era)
forall era.
(EraPParams era, HasCallStack) =>
Lens' (PParams era) Coin
Lens' (PParams era) Coin
ppTxFeeFixedL
{-# DEPRECATED ppMinFeeBL "In favor of `ppTxFeeFixedL`" #-}

-- | The constant factor for the minimum fee calculation in compacted form
ppTxFeeFixedCompactL :: forall era. EraPParams era => Lens' (PParams era) (CompactForm Coin)
ppTxFeeFixedCompactL :: forall era.
EraPParams era =>
Lens' (PParams era) (CompactForm Coin)
ppTxFeeFixedCompactL = (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))
-> ((CompactForm Coin -> f (CompactForm Coin))
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (CompactForm Coin -> f (CompactForm Coin))
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdTxFeeFixedCompactL @era @Identity

-- | Maximal block body size
ppMaxBBSizeL :: forall era. EraPParams era => Lens' (PParams era) Word32
ppMaxBBSizeL :: forall era. EraPParams era => Lens' (PParams era) Word32
ppMaxBBSizeL = (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))
-> ((Word32 -> f Word32)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (Word32 -> f Word32)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Word32)
hkdMaxBBSizeL @era @Identity

-- | Maximal transaction size
ppMaxTxSizeL :: forall era. EraPParams era => Lens' (PParams era) Word32
ppMaxTxSizeL :: forall era. EraPParams era => Lens' (PParams era) Word32
ppMaxTxSizeL = (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))
-> ((Word32 -> f Word32)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (Word32 -> f Word32)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Word32)
hkdMaxTxSizeL @era @Identity

-- | Maximal block header size
ppMaxBHSizeL :: forall era. EraPParams era => Lens' (PParams era) Word16
ppMaxBHSizeL :: forall era. EraPParams era => Lens' (PParams era) Word16
ppMaxBHSizeL = (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))
-> ((Word16 -> f Word16)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (Word16 -> f Word16)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Word16)
hkdMaxBHSizeL @era @Identity

-- | The amount of a key registration deposit
ppKeyDepositL :: forall era. (EraPParams era, HasCallStack) => Lens' (PParams era) Coin
ppKeyDepositL :: forall era.
(EraPParams era, HasCallStack) =>
Lens' (PParams era) Coin
ppKeyDepositL = (CompactForm Coin -> f (CompactForm Coin))
-> PParams era -> f (PParams era)
forall era.
EraPParams era =>
Lens' (PParams era) (CompactForm Coin)
Lens' (PParams era) (CompactForm Coin)
ppKeyDepositCompactL ((CompactForm Coin -> f (CompactForm Coin))
 -> PParams era -> f (PParams era))
-> ((Coin -> f Coin) -> CompactForm Coin -> f (CompactForm Coin))
-> (Coin -> f Coin)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => Lens' (CompactForm Coin) Coin
(Coin -> f Coin) -> CompactForm Coin -> f (CompactForm Coin)
Lens' (CompactForm Coin) Coin
partialCompactCoinL

-- | The amount of a key registration deposit in compacted form
ppKeyDepositCompactL :: forall era. EraPParams era => Lens' (PParams era) (CompactForm Coin)
ppKeyDepositCompactL :: forall era.
EraPParams era =>
Lens' (PParams era) (CompactForm Coin)
ppKeyDepositCompactL = (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))
-> ((CompactForm Coin -> f (CompactForm Coin))
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (CompactForm Coin -> f (CompactForm Coin))
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdKeyDepositCompactL @era @Identity

-- | The amount of a pool registration deposit
ppPoolDepositL :: forall era. (EraPParams era, HasCallStack) => Lens' (PParams era) Coin
ppPoolDepositL :: forall era.
(EraPParams era, HasCallStack) =>
Lens' (PParams era) Coin
ppPoolDepositL = (CompactForm Coin -> f (CompactForm Coin))
-> PParams era -> f (PParams era)
forall era.
EraPParams era =>
Lens' (PParams era) (CompactForm Coin)
Lens' (PParams era) (CompactForm Coin)
ppPoolDepositCompactL ((CompactForm Coin -> f (CompactForm Coin))
 -> PParams era -> f (PParams era))
-> ((Coin -> f Coin) -> CompactForm Coin -> f (CompactForm Coin))
-> (Coin -> f Coin)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => Lens' (CompactForm Coin) Coin
(Coin -> f Coin) -> CompactForm Coin -> f (CompactForm Coin)
Lens' (CompactForm Coin) Coin
partialCompactCoinL

-- | The amount of a pool registration deposit in compacted form
ppPoolDepositCompactL :: forall era. EraPParams era => Lens' (PParams era) (CompactForm Coin)
ppPoolDepositCompactL :: forall era.
EraPParams era =>
Lens' (PParams era) (CompactForm Coin)
ppPoolDepositCompactL = (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))
-> ((CompactForm Coin -> f (CompactForm Coin))
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (CompactForm Coin -> f (CompactForm Coin))
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdPoolDepositCompactL @era @Identity

-- | epoch bound on pool retirement
ppEMaxL :: forall era. EraPParams era => Lens' (PParams era) EpochInterval
ppEMaxL :: forall era. EraPParams era => Lens' (PParams era) EpochInterval
ppEMaxL = (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))
-> ((EpochInterval -> f EpochInterval)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (EpochInterval -> f EpochInterval)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f EpochInterval)
hkdEMaxL @era @Identity

-- | Desired number of pools
ppNOptL :: forall era. EraPParams era => Lens' (PParams era) Word16
ppNOptL :: forall era. EraPParams era => Lens' (PParams era) Word16
ppNOptL = (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))
-> ((Word16 -> f Word16)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (Word16 -> f Word16)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Word16)
hkdNOptL @era @Identity

-- | Pool influence
ppA0L :: forall era. EraPParams era => Lens' (PParams era) NonNegativeInterval
ppA0L :: forall era.
EraPParams era =>
Lens' (PParams era) NonNegativeInterval
ppA0L = (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))
-> ((NonNegativeInterval -> f NonNegativeInterval)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (NonNegativeInterval -> f NonNegativeInterval)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f NonNegativeInterval)
hkdA0L @era @Identity

-- | Monetary expansion
ppRhoL :: forall era. EraPParams era => Lens' (PParams era) UnitInterval
ppRhoL :: forall era. EraPParams era => Lens' (PParams era) UnitInterval
ppRhoL = (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))
-> ((UnitInterval -> f UnitInterval)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (UnitInterval -> f UnitInterval)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f UnitInterval)
hkdRhoL @era @Identity

-- | Treasury expansion
ppTauL :: forall era. EraPParams era => Lens' (PParams era) UnitInterval
ppTauL :: forall era. EraPParams era => Lens' (PParams era) UnitInterval
ppTauL = (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))
-> ((UnitInterval -> f UnitInterval)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (UnitInterval -> f UnitInterval)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f UnitInterval)
hkdTauL @era @Identity

-- | Decentralization parameter
ppDL :: forall era. (EraPParams era, AtMostEra "Alonzo" era) => Lens' (PParams era) UnitInterval
ppDL :: forall era.
(EraPParams era, AtMostEra "Alonzo" era) =>
Lens' (PParams era) UnitInterval
ppDL = (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))
-> ((UnitInterval -> f UnitInterval)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (UnitInterval -> f UnitInterval)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f, AtMostEra "Alonzo" era) =>
Lens' (PParamsHKD f era) (HKD f UnitInterval)
hkdDL @era @Identity

-- | Extra entropy
ppExtraEntropyL :: forall era. (EraPParams era, AtMostEra "Alonzo" era) => Lens' (PParams era) Nonce
ppExtraEntropyL :: forall era.
(EraPParams era, AtMostEra "Alonzo" era) =>
Lens' (PParams era) Nonce
ppExtraEntropyL = (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))
-> ((Nonce -> f Nonce)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (Nonce -> f Nonce)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f, AtMostEra "Alonzo" era) =>
Lens' (PParamsHKD f era) (HKD f Nonce)
hkdExtraEntropyL @era @Identity

-- | Minimum UTxO value
ppMinUTxOValueL ::
  forall era. (EraPParams era, AtMostEra "Mary" era, HasCallStack) => Lens' (PParams era) Coin
ppMinUTxOValueL :: forall era.
(EraPParams era, AtMostEra "Mary" era, HasCallStack) =>
Lens' (PParams era) Coin
ppMinUTxOValueL = (CompactForm Coin -> f (CompactForm Coin))
-> PParams era -> f (PParams era)
forall era.
(EraPParams era, AtMostEra "Mary" era) =>
Lens' (PParams era) (CompactForm Coin)
Lens' (PParams era) (CompactForm Coin)
ppMinUTxOValueCompactL ((CompactForm Coin -> f (CompactForm Coin))
 -> PParams era -> f (PParams era))
-> ((Coin -> f Coin) -> CompactForm Coin -> f (CompactForm Coin))
-> (Coin -> f Coin)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => Lens' (CompactForm Coin) Coin
(Coin -> f Coin) -> CompactForm Coin -> f (CompactForm Coin)
Lens' (CompactForm Coin) Coin
partialCompactCoinL

-- | Minimum UTxO value in compacted form
ppMinUTxOValueCompactL ::
  forall era. (EraPParams era, AtMostEra "Mary" era) => Lens' (PParams era) (CompactForm Coin)
ppMinUTxOValueCompactL :: forall era.
(EraPParams era, AtMostEra "Mary" era) =>
Lens' (PParams era) (CompactForm Coin)
ppMinUTxOValueCompactL = (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))
-> ((CompactForm Coin -> f (CompactForm Coin))
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (CompactForm Coin -> f (CompactForm Coin))
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f, AtMostEra "Mary" era) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdMinUTxOValueCompactL @era @Identity

-- | Minimum Stake Pool Cost
ppMinPoolCostL :: forall era. (EraPParams era, HasCallStack) => Lens' (PParams era) Coin
ppMinPoolCostL :: forall era.
(EraPParams era, HasCallStack) =>
Lens' (PParams era) Coin
ppMinPoolCostL = (CompactForm Coin -> f (CompactForm Coin))
-> PParams era -> f (PParams era)
forall era.
EraPParams era =>
Lens' (PParams era) (CompactForm Coin)
Lens' (PParams era) (CompactForm Coin)
ppMinPoolCostCompactL ((CompactForm Coin -> f (CompactForm Coin))
 -> PParams era -> f (PParams era))
-> ((Coin -> f Coin) -> CompactForm Coin -> f (CompactForm Coin))
-> (Coin -> f Coin)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => Lens' (CompactForm Coin) Coin
(Coin -> f Coin) -> CompactForm Coin -> f (CompactForm Coin)
Lens' (CompactForm Coin) Coin
partialCompactCoinL

-- | Minimum Stake Pool Cost in compacted form
ppMinPoolCostCompactL :: forall era. EraPParams era => Lens' (PParams era) (CompactForm Coin)
ppMinPoolCostCompactL :: forall era.
EraPParams era =>
Lens' (PParams era) (CompactForm Coin)
ppMinPoolCostCompactL = (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))
-> ((CompactForm Coin -> f (CompactForm Coin))
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (CompactForm Coin -> f (CompactForm Coin))
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdMinPoolCostCompactL @era @Identity

-- PParamsUpdate versions of lenses

-- | The linear factor for the minimum fee calculation
ppuTxFeePerByteL ::
  forall era. EraPParams era => Lens' (PParamsUpdate era) (StrictMaybe CoinPerByte)
ppuTxFeePerByteL :: forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe CoinPerByte)
ppuTxFeePerByteL = (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 :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f CoinPerByte)
hkdTxFeePerByteL @era @StrictMaybe

ppuMinFeeAL ::
  forall era. (EraPParams era, HasCallStack) => Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuMinFeeAL :: forall era.
(EraPParams era, HasCallStack) =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuMinFeeAL = (StrictMaybe CoinPerByte -> f (StrictMaybe CoinPerByte))
-> PParamsUpdate era -> f (PParamsUpdate era)
forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe CoinPerByte)
Lens' (PParamsUpdate era) (StrictMaybe CoinPerByte)
ppuTxFeePerByteL ((StrictMaybe CoinPerByte -> f (StrictMaybe CoinPerByte))
 -> PParamsUpdate era -> f (PParamsUpdate era))
-> ((StrictMaybe Coin -> f (StrictMaybe Coin))
    -> StrictMaybe CoinPerByte -> f (StrictMaybe CoinPerByte))
-> (StrictMaybe Coin -> f (StrictMaybe Coin))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StrictMaybe (CompactForm Coin)
 -> f (StrictMaybe (CompactForm Coin)))
-> StrictMaybe CoinPerByte -> f (StrictMaybe CoinPerByte)
Lens' (StrictMaybe CoinPerByte) (StrictMaybe (CompactForm Coin))
forall (f :: * -> *).
Functor f =>
Lens' (f CoinPerByte) (f (CompactForm Coin))
coinPerByteFL ((StrictMaybe (CompactForm Coin)
  -> f (StrictMaybe (CompactForm Coin)))
 -> StrictMaybe CoinPerByte -> f (StrictMaybe CoinPerByte))
-> ((StrictMaybe Coin -> f (StrictMaybe Coin))
    -> StrictMaybe (CompactForm Coin)
    -> f (StrictMaybe (CompactForm Coin)))
-> (StrictMaybe Coin -> f (StrictMaybe Coin))
-> StrictMaybe CoinPerByte
-> f (StrictMaybe CoinPerByte)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StrictMaybe Coin -> f (StrictMaybe Coin))
-> StrictMaybe (CompactForm Coin)
-> f (StrictMaybe (CompactForm Coin))
Lens' (StrictMaybe (CompactForm Coin)) (StrictMaybe Coin)
forall (f :: * -> *) c.
(Functor f, Compactible c, HasCallStack) =>
Lens' (f (CompactForm c)) (f c)
partialCompactFL
{-# DEPRECATED ppuMinFeeAL "In favor of `ppuTxFeePerByteL`" #-}

-- | The constant factor for the minimum fee calculation
ppuTxFeeFixedL ::
  forall era. (EraPParams era, HasCallStack) => Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuTxFeeFixedL :: forall era.
(EraPParams era, HasCallStack) =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuTxFeeFixedL = (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 Coin -> f (StrictMaybe Coin))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe Coin -> f (StrictMaybe Coin))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdTxFeeFixedCompactL @era @StrictMaybe ((StrictMaybe (CompactForm Coin)
  -> f (StrictMaybe (CompactForm Coin)))
 -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> ((StrictMaybe Coin -> f (StrictMaybe Coin))
    -> StrictMaybe (CompactForm Coin)
    -> f (StrictMaybe (CompactForm Coin)))
-> (StrictMaybe Coin -> f (StrictMaybe Coin))
-> PParamsHKD StrictMaybe era
-> f (PParamsHKD StrictMaybe era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StrictMaybe Coin -> f (StrictMaybe Coin))
-> StrictMaybe (CompactForm Coin)
-> f (StrictMaybe (CompactForm Coin))
Lens' (StrictMaybe (CompactForm Coin)) (StrictMaybe Coin)
forall (f :: * -> *) c.
(Functor f, Compactible c, HasCallStack) =>
Lens' (f (CompactForm c)) (f c)
partialCompactFL

ppuMinFeeBL ::
  forall era. (EraPParams era, HasCallStack) => Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuMinFeeBL :: forall era.
(EraPParams era, HasCallStack) =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuMinFeeBL = (StrictMaybe Coin -> f (StrictMaybe Coin))
-> PParamsUpdate era -> f (PParamsUpdate era)
forall era.
(EraPParams era, HasCallStack) =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuTxFeeFixedL
{-# DEPRECATED ppuMinFeeBL "In favor of `ppuTxFeeFixedL`" #-}

-- | The constant factor for the minimum fee calculation in compacted form
ppuTxFeeFixedCompactL ::
  forall era. EraPParams era => Lens' (PParamsUpdate era) (StrictMaybe (CompactForm Coin))
ppuTxFeeFixedCompactL :: forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe (CompactForm Coin))
ppuTxFeeFixedCompactL = (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 (CompactForm Coin)
     -> f (StrictMaybe (CompactForm Coin)))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe (CompactForm Coin)
    -> f (StrictMaybe (CompactForm Coin)))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdTxFeeFixedCompactL @era @StrictMaybe

-- | Maximal block body size
ppuMaxBBSizeL :: forall era. EraPParams era => Lens' (PParamsUpdate era) (StrictMaybe Word32)
ppuMaxBBSizeL :: forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Word32)
ppuMaxBBSizeL = (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 Word32 -> f (StrictMaybe Word32))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe Word32 -> f (StrictMaybe Word32))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Word32)
hkdMaxBBSizeL @era @StrictMaybe

-- | Maximal transaction size
ppuMaxTxSizeL :: forall era. EraPParams era => Lens' (PParamsUpdate era) (StrictMaybe Word32)
ppuMaxTxSizeL :: forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Word32)
ppuMaxTxSizeL = (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 Word32 -> f (StrictMaybe Word32))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe Word32 -> f (StrictMaybe Word32))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Word32)
hkdMaxTxSizeL @era @StrictMaybe

-- | Maximal block header size
ppuMaxBHSizeL :: forall era. EraPParams era => Lens' (PParamsUpdate era) (StrictMaybe Word16)
ppuMaxBHSizeL :: forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Word16)
ppuMaxBHSizeL = (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 Word16 -> f (StrictMaybe Word16))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe Word16 -> f (StrictMaybe Word16))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Word16)
hkdMaxBHSizeL @era @StrictMaybe

-- | The amount of a key registration deposit
ppuKeyDepositL ::
  forall era. (EraPParams era, HasCallStack) => Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuKeyDepositL :: forall era.
(EraPParams era, HasCallStack) =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuKeyDepositL = (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 Coin -> f (StrictMaybe Coin))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe Coin -> f (StrictMaybe Coin))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdKeyDepositCompactL @era @StrictMaybe ((StrictMaybe (CompactForm Coin)
  -> f (StrictMaybe (CompactForm Coin)))
 -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> ((StrictMaybe Coin -> f (StrictMaybe Coin))
    -> StrictMaybe (CompactForm Coin)
    -> f (StrictMaybe (CompactForm Coin)))
-> (StrictMaybe Coin -> f (StrictMaybe Coin))
-> PParamsHKD StrictMaybe era
-> f (PParamsHKD StrictMaybe era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StrictMaybe Coin -> f (StrictMaybe Coin))
-> StrictMaybe (CompactForm Coin)
-> f (StrictMaybe (CompactForm Coin))
Lens' (StrictMaybe (CompactForm Coin)) (StrictMaybe Coin)
forall (f :: * -> *) c.
(Functor f, Compactible c, HasCallStack) =>
Lens' (f (CompactForm c)) (f c)
partialCompactFL

-- | The amount of a key registration deposit
ppuKeyDepositCompactL ::
  forall era. EraPParams era => Lens' (PParamsUpdate era) (StrictMaybe (CompactForm Coin))
ppuKeyDepositCompactL :: forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe (CompactForm Coin))
ppuKeyDepositCompactL = (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 (CompactForm Coin)
     -> f (StrictMaybe (CompactForm Coin)))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe (CompactForm Coin)
    -> f (StrictMaybe (CompactForm Coin)))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdKeyDepositCompactL @era @StrictMaybe

-- | The amount of a pool registration deposit. The value must be small enough
-- to fit into a Word64.
ppuPoolDepositL ::
  forall era. (EraPParams era, HasCallStack) => Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuPoolDepositL :: forall era.
(EraPParams era, HasCallStack) =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuPoolDepositL = (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 Coin -> f (StrictMaybe Coin))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe Coin -> f (StrictMaybe Coin))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdPoolDepositCompactL @era @StrictMaybe ((StrictMaybe (CompactForm Coin)
  -> f (StrictMaybe (CompactForm Coin)))
 -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> ((StrictMaybe Coin -> f (StrictMaybe Coin))
    -> StrictMaybe (CompactForm Coin)
    -> f (StrictMaybe (CompactForm Coin)))
-> (StrictMaybe Coin -> f (StrictMaybe Coin))
-> PParamsHKD StrictMaybe era
-> f (PParamsHKD StrictMaybe era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StrictMaybe Coin -> f (StrictMaybe Coin))
-> StrictMaybe (CompactForm Coin)
-> f (StrictMaybe (CompactForm Coin))
Lens' (StrictMaybe (CompactForm Coin)) (StrictMaybe Coin)
forall (f :: * -> *) c.
(Functor f, Compactible c, HasCallStack) =>
Lens' (f (CompactForm c)) (f c)
partialCompactFL

-- | The amount of a pool registration deposit in compacted form
ppuPoolDepositCompactL ::
  forall era. EraPParams era => Lens' (PParamsUpdate era) (StrictMaybe (CompactForm Coin))
ppuPoolDepositCompactL :: forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe (CompactForm Coin))
ppuPoolDepositCompactL = (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 (CompactForm Coin)
     -> f (StrictMaybe (CompactForm Coin)))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe (CompactForm Coin)
    -> f (StrictMaybe (CompactForm Coin)))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdPoolDepositCompactL @era @StrictMaybe

-- | epoch bound on pool retirement
ppuEMaxL :: forall era. EraPParams era => Lens' (PParamsUpdate era) (StrictMaybe EpochInterval)
ppuEMaxL :: forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe EpochInterval)
ppuEMaxL = (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 EpochInterval -> f (StrictMaybe EpochInterval))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe EpochInterval -> f (StrictMaybe EpochInterval))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f EpochInterval)
hkdEMaxL @era @StrictMaybe

-- | Desired number of pools
ppuNOptL :: forall era. EraPParams era => Lens' (PParamsUpdate era) (StrictMaybe Word16)
ppuNOptL :: forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Word16)
ppuNOptL = (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 Word16 -> f (StrictMaybe Word16))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe Word16 -> f (StrictMaybe Word16))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Word16)
hkdNOptL @era @StrictMaybe

-- | Pool influence
ppuA0L :: forall era. EraPParams era => Lens' (PParamsUpdate era) (StrictMaybe NonNegativeInterval)
ppuA0L :: forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe NonNegativeInterval)
ppuA0L = (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 NonNegativeInterval
     -> f (StrictMaybe NonNegativeInterval))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe NonNegativeInterval
    -> f (StrictMaybe NonNegativeInterval))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f NonNegativeInterval)
hkdA0L @era @StrictMaybe

-- | Monetary expansion
ppuRhoL :: forall era. EraPParams era => Lens' (PParamsUpdate era) (StrictMaybe UnitInterval)
ppuRhoL :: forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe UnitInterval)
ppuRhoL = (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 UnitInterval -> f (StrictMaybe UnitInterval))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe UnitInterval -> f (StrictMaybe UnitInterval))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f UnitInterval)
hkdRhoL @era @StrictMaybe

-- | Treasury expansion
ppuTauL :: forall era. EraPParams era => Lens' (PParamsUpdate era) (StrictMaybe UnitInterval)
ppuTauL :: forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe UnitInterval)
ppuTauL = (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 UnitInterval -> f (StrictMaybe UnitInterval))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe UnitInterval -> f (StrictMaybe UnitInterval))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f UnitInterval)
hkdTauL @era @StrictMaybe

-- | Decentralization parameter
ppuDL ::
  forall era.
  (EraPParams era, AtMostEra "Alonzo" era) =>
  Lens' (PParamsUpdate era) (StrictMaybe UnitInterval)
ppuDL :: forall era.
(EraPParams era, AtMostEra "Alonzo" era) =>
Lens' (PParamsUpdate era) (StrictMaybe UnitInterval)
ppuDL = (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 UnitInterval -> f (StrictMaybe UnitInterval))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe UnitInterval -> f (StrictMaybe UnitInterval))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f, AtMostEra "Alonzo" era) =>
Lens' (PParamsHKD f era) (HKD f UnitInterval)
hkdDL @era @StrictMaybe

-- | Extra entropy
ppuExtraEntropyL ::
  forall era.
  (EraPParams era, AtMostEra "Alonzo" era) =>
  Lens' (PParamsUpdate era) (StrictMaybe Nonce)
ppuExtraEntropyL :: forall era.
(EraPParams era, AtMostEra "Alonzo" era) =>
Lens' (PParamsUpdate era) (StrictMaybe Nonce)
ppuExtraEntropyL = (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 Nonce -> f (StrictMaybe Nonce))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe Nonce -> f (StrictMaybe Nonce))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f, AtMostEra "Alonzo" era) =>
Lens' (PParamsHKD f era) (HKD f Nonce)
hkdExtraEntropyL @era @StrictMaybe

-- | Minimum UTxO value
ppuMinUTxOValueL ::
  forall era.
  (EraPParams era, AtMostEra "Mary" era, HasCallStack) =>
  Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuMinUTxOValueL :: forall era.
(EraPParams era, AtMostEra "Mary" era, HasCallStack) =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuMinUTxOValueL = (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 Coin -> f (StrictMaybe Coin))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe Coin -> f (StrictMaybe Coin))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f, AtMostEra "Mary" era) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdMinUTxOValueCompactL @era @StrictMaybe ((StrictMaybe (CompactForm Coin)
  -> f (StrictMaybe (CompactForm Coin)))
 -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> ((StrictMaybe Coin -> f (StrictMaybe Coin))
    -> StrictMaybe (CompactForm Coin)
    -> f (StrictMaybe (CompactForm Coin)))
-> (StrictMaybe Coin -> f (StrictMaybe Coin))
-> PParamsHKD StrictMaybe era
-> f (PParamsHKD StrictMaybe era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StrictMaybe Coin -> f (StrictMaybe Coin))
-> StrictMaybe (CompactForm Coin)
-> f (StrictMaybe (CompactForm Coin))
Lens' (StrictMaybe (CompactForm Coin)) (StrictMaybe Coin)
forall (f :: * -> *) c.
(Functor f, Compactible c, HasCallStack) =>
Lens' (f (CompactForm c)) (f c)
partialCompactFL

-- | Minimum UTxO value in compacted form
ppuMinUTxOValueCompactL ::
  forall era.
  (EraPParams era, AtMostEra "Mary" era) =>
  Lens' (PParamsUpdate era) (StrictMaybe (CompactForm Coin))
ppuMinUTxOValueCompactL :: forall era.
(EraPParams era, AtMostEra "Mary" era) =>
Lens' (PParamsUpdate era) (StrictMaybe (CompactForm Coin))
ppuMinUTxOValueCompactL = (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 (CompactForm Coin)
     -> f (StrictMaybe (CompactForm Coin)))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe (CompactForm Coin)
    -> f (StrictMaybe (CompactForm Coin)))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f, AtMostEra "Mary" era) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdMinUTxOValueCompactL @era @StrictMaybe

-- | Minimum Stake Pool Cost
ppuMinPoolCostL ::
  forall era. (EraPParams era, HasCallStack) => Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuMinPoolCostL :: forall era.
(EraPParams era, HasCallStack) =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuMinPoolCostL = (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 Coin -> f (StrictMaybe Coin))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe Coin -> f (StrictMaybe Coin))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdMinPoolCostCompactL @era @StrictMaybe ((StrictMaybe (CompactForm Coin)
  -> f (StrictMaybe (CompactForm Coin)))
 -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> ((StrictMaybe Coin -> f (StrictMaybe Coin))
    -> StrictMaybe (CompactForm Coin)
    -> f (StrictMaybe (CompactForm Coin)))
-> (StrictMaybe Coin -> f (StrictMaybe Coin))
-> PParamsHKD StrictMaybe era
-> f (PParamsHKD StrictMaybe era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StrictMaybe Coin -> f (StrictMaybe Coin))
-> StrictMaybe (CompactForm Coin)
-> f (StrictMaybe (CompactForm Coin))
Lens' (StrictMaybe (CompactForm Coin)) (StrictMaybe Coin)
forall (f :: * -> *) c.
(Functor f, Compactible c, HasCallStack) =>
Lens' (f (CompactForm c)) (f c)
partialCompactFL

-- | Minimum Stake Pool Cost in compacted form
ppuMinPoolCostCompactL ::
  forall era. EraPParams era => Lens' (PParamsUpdate era) (StrictMaybe (CompactForm Coin))
ppuMinPoolCostCompactL :: forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe (CompactForm Coin))
ppuMinPoolCostCompactL = (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 (CompactForm Coin)
     -> f (StrictMaybe (CompactForm Coin)))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe (CompactForm Coin)
    -> f (StrictMaybe (CompactForm Coin)))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(EraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f (CompactForm Coin))
hkdMinPoolCostCompactL @era @StrictMaybe

instance EraPParams era => ToKeyValuePairs (PParams era) where
  toKeyValuePairs :: forall e kv. KeyValue e kv => PParams era -> [kv]
toKeyValuePairs PParams era
pp =
    [ Text -> Key
Aeson.fromText Text
ppName Key -> Value -> kv
forall v. ToJSON v => Key -> v -> kv
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= t -> Value
forall a. ToJSON a => a -> Value
toJSON (PParams era
pp PParams era -> Getting t (PParams era) t -> t
forall s a. s -> Getting a s a -> a
^. Getting t (PParams era) t
Lens' (PParams era) t
ppLens)
    | PParam {Text
ppName :: forall era. PParam era -> Text
ppName :: Text
ppName, Lens' (PParams era) t
ppLens :: ()
ppLens :: Lens' (PParams era) t
ppLens} <- forall era. EraPParams era => [PParam era]
eraPParams @era
    ]

instance EraPParams era => ToKeyValuePairs (PParamsUpdate era) where
  toKeyValuePairs :: forall e kv. KeyValue e kv => PParamsUpdate era -> [kv]
toKeyValuePairs PParamsUpdate era
ppu =
    [ Text -> Key
Aeson.fromText Text
ppName Key -> Value -> kv
forall v. ToJSON v => Key -> v -> kv
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= t -> Value
forall a. ToJSON a => a -> Value
toJSON t
v
    | PParam {Text
ppName :: forall era. PParam era -> Text
ppName :: Text
ppName, ppUpdate :: ()
ppUpdate = Just (PParamUpdate {Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens :: forall era t.
PParamUpdate era t -> Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens :: Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens})} <- forall era. EraPParams era => [PParam era]
eraPParams @era
    , SJust t
v <- [PParamsUpdate era
ppu PParamsUpdate era
-> Getting (StrictMaybe t) (PParamsUpdate era) (StrictMaybe t)
-> StrictMaybe t
forall s a. s -> Getting a s a -> a
^. Getting (StrictMaybe t) (PParamsUpdate era) (StrictMaybe t)
Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens]
    ]

mapPParams :: (PParamsHKD Identity era1 -> PParamsHKD Identity era2) -> PParams era1 -> PParams era2
mapPParams :: forall era1 era2.
(PParamsHKD Identity era1 -> PParamsHKD Identity era2)
-> PParams era1 -> PParams era2
mapPParams PParamsHKD Identity era1 -> PParamsHKD Identity era2
f (PParams PParamsHKD Identity era1
pp) = PParamsHKD Identity era2 -> PParams era2
forall era. PParamsHKD Identity era -> PParams era
PParams (PParamsHKD Identity era2 -> PParams era2)
-> PParamsHKD Identity era2 -> PParams era2
forall a b. (a -> b) -> a -> b
$ PParamsHKD Identity era1 -> PParamsHKD Identity era2
f PParamsHKD Identity era1
pp

mapPParamsUpdate ::
  (PParamsHKD StrictMaybe era1 -> PParamsHKD StrictMaybe era2) ->
  PParamsUpdate era1 ->
  PParamsUpdate era2
mapPParamsUpdate :: forall era1 era2.
(PParamsHKD StrictMaybe era1 -> PParamsHKD StrictMaybe era2)
-> PParamsUpdate era1 -> PParamsUpdate era2
mapPParamsUpdate PParamsHKD StrictMaybe era1 -> PParamsHKD StrictMaybe era2
f (PParamsUpdate PParamsHKD StrictMaybe era1
pp) = PParamsHKD StrictMaybe era2 -> PParamsUpdate era2
forall era. PParamsHKD StrictMaybe era -> PParamsUpdate era
PParamsUpdate (PParamsHKD StrictMaybe era2 -> PParamsUpdate era2)
-> PParamsHKD StrictMaybe era2 -> PParamsUpdate era2
forall a b. (a -> b) -> a -> b
$ PParamsHKD StrictMaybe era1 -> PParamsHKD StrictMaybe era2
f PParamsHKD StrictMaybe era1
pp

upgradePParams ::
  (EraPParams era, EraPParams (PreviousEra era)) =>
  UpgradePParams Identity era ->
  PParams (PreviousEra era) ->
  PParams era
upgradePParams :: forall era.
(EraPParams era, EraPParams (PreviousEra era)) =>
UpgradePParams Identity era
-> PParams (PreviousEra era) -> PParams era
upgradePParams UpgradePParams Identity era
args (PParams PParamsHKD Identity (PreviousEra era)
pphkd) =
  PParamsHKD Identity era -> PParams era
forall era. PParamsHKD Identity era -> PParams era
PParams (forall era (f :: * -> *).
(EraPParams era, HKDApplicative f, EraPParams (PreviousEra era)) =>
UpgradePParams f era
-> PParamsHKD f (PreviousEra era) -> PParamsHKD f era
upgradePParamsHKD @_ @Identity UpgradePParams Identity era
args PParamsHKD Identity (PreviousEra era)
pphkd)

downgradePParams ::
  (EraPParams era, EraPParams (PreviousEra era)) =>
  DowngradePParams Identity era ->
  PParams era ->
  PParams (PreviousEra era)
downgradePParams :: forall era.
(EraPParams era, EraPParams (PreviousEra era)) =>
DowngradePParams Identity era
-> PParams era -> PParams (PreviousEra era)
downgradePParams DowngradePParams Identity era
args (PParams PParamsHKD Identity era
pphkd) =
  PParamsHKD Identity (PreviousEra era) -> PParams (PreviousEra era)
forall era. PParamsHKD Identity era -> PParams era
PParams (forall era (f :: * -> *).
(EraPParams era, HKDFunctor f, EraPParams (PreviousEra era)) =>
DowngradePParams f era
-> PParamsHKD f era -> PParamsHKD f (PreviousEra era)
downgradePParamsHKD @_ @Identity DowngradePParams Identity era
args PParamsHKD Identity era
pphkd)

upgradePParamsUpdate ::
  (EraPParams era, EraPParams (PreviousEra era)) =>
  UpgradePParams StrictMaybe era ->
  PParamsUpdate (PreviousEra era) ->
  PParamsUpdate era
upgradePParamsUpdate :: forall era.
(EraPParams era, EraPParams (PreviousEra era)) =>
UpgradePParams StrictMaybe era
-> PParamsUpdate (PreviousEra era) -> PParamsUpdate era
upgradePParamsUpdate UpgradePParams StrictMaybe era
args (PParamsUpdate PParamsHKD StrictMaybe (PreviousEra era)
pphkd) =
  PParamsHKD StrictMaybe era -> PParamsUpdate era
forall era. PParamsHKD StrictMaybe era -> PParamsUpdate era
PParamsUpdate (forall era (f :: * -> *).
(EraPParams era, HKDApplicative f, EraPParams (PreviousEra era)) =>
UpgradePParams f era
-> PParamsHKD f (PreviousEra era) -> PParamsHKD f era
upgradePParamsHKD @_ @StrictMaybe UpgradePParams StrictMaybe era
args PParamsHKD StrictMaybe (PreviousEra era)
pphkd)

downgradePParamsUpdate ::
  (EraPParams era, EraPParams (PreviousEra era)) =>
  DowngradePParams StrictMaybe era ->
  PParamsUpdate era ->
  PParamsUpdate (PreviousEra era)
downgradePParamsUpdate :: forall era.
(EraPParams era, EraPParams (PreviousEra era)) =>
DowngradePParams StrictMaybe era
-> PParamsUpdate era -> PParamsUpdate (PreviousEra era)
downgradePParamsUpdate DowngradePParams StrictMaybe era
args (PParamsUpdate PParamsHKD StrictMaybe era
pphkd) =
  PParamsHKD StrictMaybe (PreviousEra era)
-> PParamsUpdate (PreviousEra era)
forall era. PParamsHKD StrictMaybe era -> PParamsUpdate era
PParamsUpdate (forall era (f :: * -> *).
(EraPParams era, HKDFunctor f, EraPParams (PreviousEra era)) =>
DowngradePParams f era
-> PParamsHKD f era -> PParamsHKD f (PreviousEra era)
downgradePParamsHKD @_ @StrictMaybe DowngradePParams StrictMaybe era
args PParamsHKD StrictMaybe era
pphkd)

-- | A CBOR decoder with universally quantified state type, suitable for
-- storage inside a GADT. Used when a protocol parameter needs an era-aware
-- decoder instead of the default 'decCBOR'.
newtype EraDecoder t = EraDecoder (forall s. Decoder s t)

-- | Represents a single protocol parameter and the data required to serialize it.
data PParam era where
  PParam ::
    (DecCBOR t, EncCBOR t, FromJSON t, ToJSON t, ToPlutusData t) =>
    { forall era. PParam era -> Text
ppName :: Text
    -- ^ Used as JSON key
    , ()
ppLens :: Lens' (PParams era) t
    , ()
ppEraDecoder :: Maybe (EraDecoder t)
    -- ^ When present, this decoder will be used instead of 'decCBOR', which is
    -- helpful when a decoder needs access to the @era@ parameter, like 'ProtVer'.
    , ()
ppUpdate :: Maybe (PParamUpdate era t)
    -- ^ Not all protocol parameters have an update functionality in all eras
    } ->
    PParam era

data PParamUpdate era t = PParamUpdate
  { forall era t. PParamUpdate era t -> Word
ppuTag :: Word
  -- ^ Used in CBOR and Plutus Data encoding of
  , forall era t.
PParamUpdate era t -> Lens' (PParamsUpdate era) (StrictMaybe t)
ppuLens :: Lens' (PParamsUpdate era) (StrictMaybe t)
  }