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

-- | This module contains just the type of protocol parameters.
module Cardano.Ledger.Alonzo.PParams (
  -- * Era Agnostic
  AlonzoEraPParams (..),
  ppCoinsPerUTxOWordL,
  ppCostModelsL,
  ppPricesL,
  ppMaxTxExUnitsL,
  ppMaxBlockExUnitsL,
  ppMaxValSizeL,
  ppCollateralPercentageL,
  ppMaxCollateralInputsL,
  ppuCoinsPerUTxOWordL,
  ppuCostModelsL,
  ppuPricesL,
  ppuMaxTxExUnitsL,
  ppuMaxBlockExUnitsL,
  ppuMaxValSizeL,
  ppuCollateralPercentageL,
  ppuMaxCollateralInputsL,

  -- * Alonzo specific
  AlonzoPParams (..),
  UpgradeAlonzoPParams (..),
  DowngradeAlonzoPParams (..),
  emptyAlonzoPParams,
  emptyAlonzoPParamsUpdate,
  upgradeAlonzoPParams,
  downgradeAlonzoPParams,
  getLanguageView,
  LangDepView (..),
  encodeLangViews,
  OrdExUnits (..),
  CoinPerWord (..),

  -- * PParam
  ppCollateralPercentage,
  ppCostModels,
  ppMaxBlockExUnits,
  ppMaxCollateralInputs,
  ppMaxTxExUnits,
  ppMaxValSize,
  ppPrices,
) where

import Cardano.Ledger.Alonzo.Era (AlonzoEra)
import Cardano.Ledger.BaseTypes (
  EpochInterval (..),
  NonNegativeInterval,
  Nonce (NeutralNonce),
  StrictMaybe (..),
  UnitInterval,
 )
import qualified Cardano.Ledger.BaseTypes as BT (ProtVer (..))
import Cardano.Ledger.Binary (
  DecCBOR (..),
  EncCBOR (..),
  Encoding,
  encodeFoldableAsDefLenList,
  encodeFoldableAsIndefLenList,
  encodeMapLen,
  encodeNull,
  encodePreEncoded,
  serialize',
 )
import Cardano.Ledger.Coin (Coin (..))
import Cardano.Ledger.Core (EraPParams (..))
import Cardano.Ledger.HKD (HKDFunctor (..))
import Cardano.Ledger.Mary.Core
import Cardano.Ledger.Plutus.CostModels (
  CostModel,
  CostModels,
  costModelsValid,
  emptyCostModels,
  getCostModelLanguage,
  getCostModelParams,
 )
import Cardano.Ledger.Plutus.ExUnits (
  ExUnits (..),
  Prices (..),
  zipSemiExUnits,
 )
import Cardano.Ledger.Plutus.Language (Language (..))
import Cardano.Ledger.Plutus.ToPlutusData (ToPlutusData (..))
import Cardano.Ledger.Shelley.PParams
import Control.DeepSeq (NFData)
import Data.Aeson as Aeson (
  FromJSON,
  ToJSON (..),
 )
import Data.ByteString (ByteString)
import qualified Data.ByteString as BS
import Data.Coerce (coerce)
import Data.Default (Default (def))
import Data.Function (on)
import Data.Functor.Identity (Identity (..))
import Data.List (sortBy)
import qualified Data.Map.Strict as Map
import Data.Proxy (Proxy (Proxy))
import Data.Set (Set)
import qualified Data.Set as Set
import Data.Word (Word16, Word32)
import GHC.Generics (Generic)
import Lens.Micro (Lens', lens, (^.))
import NoThunks.Class (NoThunks (..))
import Numeric.Natural (Natural)

class EraPParams era => AlonzoEraPParams era where
  hkdCoinsPerUTxOWordL ::
    (HKDFunctor f, ExactEra AlonzoEra era) =>
    Lens' (PParamsHKD f era) (HKD f CoinPerWord)

  hkdCostModelsL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f CostModels)

  hkdPricesL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f Prices)

  hkdMaxTxExUnitsL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f ExUnits)

  hkdMaxBlockExUnitsL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f ExUnits)

  hkdMaxValSizeL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f Natural)

  hkdCollateralPercentageL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f Natural)

  hkdMaxCollateralInputsL :: HKDFunctor f => Lens' (PParamsHKD f era) (HKD f Natural)

ppCoinsPerUTxOWordL ::
  forall era.
  (AlonzoEraPParams era, ExactEra AlonzoEra era) =>
  Lens' (PParams era) CoinPerWord
ppCoinsPerUTxOWordL :: forall era.
(AlonzoEraPParams era, ExactEra AlonzoEra era) =>
Lens' (PParams era) CoinPerWord
ppCoinsPerUTxOWordL = (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))
-> ((CoinPerWord -> f CoinPerWord)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (CoinPerWord -> f CoinPerWord)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f, ExactEra AlonzoEra era) =>
Lens' (PParamsHKD f era) (HKD f CoinPerWord)
hkdCoinsPerUTxOWordL @era @Identity

ppCostModelsL :: forall era. AlonzoEraPParams era => Lens' (PParams era) CostModels
ppCostModelsL :: forall era. AlonzoEraPParams era => Lens' (PParams era) CostModels
ppCostModelsL = (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))
-> ((CostModels -> f CostModels)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (CostModels -> f CostModels)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f CostModels)
hkdCostModelsL @era @Identity

ppPricesL :: forall era. AlonzoEraPParams era => Lens' (PParams era) Prices
ppPricesL :: forall era. AlonzoEraPParams era => Lens' (PParams era) Prices
ppPricesL = (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))
-> ((Prices -> f Prices)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (Prices -> f Prices)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Prices)
hkdPricesL @era @Identity

ppMaxTxExUnitsL :: forall era. AlonzoEraPParams era => Lens' (PParams era) ExUnits
ppMaxTxExUnitsL :: forall era. AlonzoEraPParams era => Lens' (PParams era) ExUnits
ppMaxTxExUnitsL = (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))
-> ((ExUnits -> f ExUnits)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (ExUnits -> f ExUnits)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f ExUnits)
hkdMaxTxExUnitsL @era @Identity

ppMaxBlockExUnitsL :: forall era. AlonzoEraPParams era => Lens' (PParams era) ExUnits
ppMaxBlockExUnitsL :: forall era. AlonzoEraPParams era => Lens' (PParams era) ExUnits
ppMaxBlockExUnitsL = (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))
-> ((ExUnits -> f ExUnits)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (ExUnits -> f ExUnits)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f ExUnits)
hkdMaxBlockExUnitsL @era @Identity

ppMaxValSizeL :: forall era. AlonzoEraPParams era => Lens' (PParams era) Natural
ppMaxValSizeL :: forall era. AlonzoEraPParams era => Lens' (PParams era) Natural
ppMaxValSizeL = (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))
-> ((Natural -> f Natural)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (Natural -> f Natural)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Natural)
hkdMaxValSizeL @era @Identity

ppCollateralPercentageL :: forall era. AlonzoEraPParams era => Lens' (PParams era) Natural
ppCollateralPercentageL :: forall era. AlonzoEraPParams era => Lens' (PParams era) Natural
ppCollateralPercentageL = (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))
-> ((Natural -> f Natural)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (Natural -> f Natural)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Natural)
hkdCollateralPercentageL @era @Identity

ppMaxCollateralInputsL :: forall era. AlonzoEraPParams era => Lens' (PParams era) Natural
ppMaxCollateralInputsL :: forall era. AlonzoEraPParams era => Lens' (PParams era) Natural
ppMaxCollateralInputsL = (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))
-> ((Natural -> f Natural)
    -> PParamsHKD Identity era -> f (PParamsHKD Identity era))
-> (Natural -> f Natural)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Natural)
hkdMaxCollateralInputsL @era @Identity

ppuCoinsPerUTxOWordL ::
  forall era.
  (AlonzoEraPParams era, ExactEra AlonzoEra era) =>
  Lens' (PParamsUpdate era) (StrictMaybe CoinPerWord)
ppuCoinsPerUTxOWordL :: forall era.
(AlonzoEraPParams era, ExactEra AlonzoEra era) =>
Lens' (PParamsUpdate era) (StrictMaybe CoinPerWord)
ppuCoinsPerUTxOWordL = (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 CoinPerWord -> f (StrictMaybe CoinPerWord))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe CoinPerWord -> f (StrictMaybe CoinPerWord))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f, ExactEra AlonzoEra era) =>
Lens' (PParamsHKD f era) (HKD f CoinPerWord)
hkdCoinsPerUTxOWordL @era @StrictMaybe

ppuCostModelsL ::
  forall era.
  AlonzoEraPParams era =>
  Lens' (PParamsUpdate era) (StrictMaybe CostModels)
ppuCostModelsL :: forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe CostModels)
ppuCostModelsL = (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 CostModels -> f (StrictMaybe CostModels))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe CostModels -> f (StrictMaybe CostModels))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f CostModels)
hkdCostModelsL @era @StrictMaybe

ppuPricesL ::
  forall era.
  AlonzoEraPParams era =>
  Lens' (PParamsUpdate era) (StrictMaybe Prices)
ppuPricesL :: forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Prices)
ppuPricesL = (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 Prices -> f (StrictMaybe Prices))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe Prices -> f (StrictMaybe Prices))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Prices)
hkdPricesL @era @StrictMaybe

ppuMaxTxExUnitsL ::
  forall era.
  AlonzoEraPParams era =>
  Lens' (PParamsUpdate era) (StrictMaybe ExUnits)
ppuMaxTxExUnitsL :: forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe ExUnits)
ppuMaxTxExUnitsL = (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 ExUnits -> f (StrictMaybe ExUnits))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe ExUnits -> f (StrictMaybe ExUnits))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f ExUnits)
hkdMaxTxExUnitsL @era @StrictMaybe

ppuMaxBlockExUnitsL ::
  forall era.
  AlonzoEraPParams era =>
  Lens' (PParamsUpdate era) (StrictMaybe ExUnits)
ppuMaxBlockExUnitsL :: forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe ExUnits)
ppuMaxBlockExUnitsL = (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 ExUnits -> f (StrictMaybe ExUnits))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe ExUnits -> f (StrictMaybe ExUnits))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f ExUnits)
hkdMaxBlockExUnitsL @era @StrictMaybe

ppuMaxValSizeL ::
  forall era.
  AlonzoEraPParams era =>
  Lens' (PParamsUpdate era) (StrictMaybe Natural)
ppuMaxValSizeL :: forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Natural)
ppuMaxValSizeL = (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 Natural -> f (StrictMaybe Natural))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe Natural -> f (StrictMaybe Natural))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Natural)
hkdMaxValSizeL @era @StrictMaybe

ppuCollateralPercentageL ::
  forall era.
  AlonzoEraPParams era =>
  Lens' (PParamsUpdate era) (StrictMaybe Natural)
ppuCollateralPercentageL :: forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Natural)
ppuCollateralPercentageL = (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 Natural -> f (StrictMaybe Natural))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe Natural -> f (StrictMaybe Natural))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Natural)
hkdCollateralPercentageL @era @StrictMaybe

ppuMaxCollateralInputsL ::
  forall era.
  AlonzoEraPParams era =>
  Lens' (PParamsUpdate era) (StrictMaybe Natural)
ppuMaxCollateralInputsL :: forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Natural)
ppuMaxCollateralInputsL = (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 Natural -> f (StrictMaybe Natural))
    -> PParamsHKD StrictMaybe era -> f (PParamsHKD StrictMaybe era))
-> (StrictMaybe Natural -> f (StrictMaybe Natural))
-> PParamsUpdate era
-> f (PParamsUpdate era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era (f :: * -> *).
(AlonzoEraPParams era, HKDFunctor f) =>
Lens' (PParamsHKD f era) (HKD f Natural)
hkdMaxCollateralInputsL @era @StrictMaybe

-- | Protocol parameters.
-- Shelley parameters + additional ones
data AlonzoPParams f era = AlonzoPParams
  { forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appMinFeeA :: !(HKD f Coin)
  -- ^ The linear factor for the minimum fee calculation
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appMinFeeB :: !(HKD f Coin)
  -- ^ The constant factor for the minimum fee calculation
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word32
appMaxBBSize :: !(HKD f Word32)
  -- ^ Maximal block body size
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word32
appMaxTxSize :: !(HKD f Word32)
  -- ^ Maximal transaction size
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word16
appMaxBHSize :: !(HKD f Word16)
  -- ^ Maximal block header size
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appKeyDeposit :: !(HKD f Coin)
  -- ^ The amount of a key registration deposit
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appPoolDeposit :: !(HKD f Coin)
  -- ^ The amount of a pool registration deposit
  , forall (f :: * -> *) era.
AlonzoPParams f era -> HKD f EpochInterval
appEMax :: !(HKD f EpochInterval)
  -- ^ Maximum number of epochs in the future a pool retirement is allowed to
  -- be scheduled for.
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word16
appNOpt :: !(HKD f Word16)
  -- ^ Desired number of pools
  , forall (f :: * -> *) era.
AlonzoPParams f era -> HKD f NonNegativeInterval
appA0 :: !(HKD f NonNegativeInterval)
  -- ^ Pool influence
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f UnitInterval
appRho :: !(HKD f UnitInterval)
  -- ^ Monetary expansion
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f UnitInterval
appTau :: !(HKD f UnitInterval)
  -- ^ Treasury expansion
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f UnitInterval
appD :: !(HKD f UnitInterval)
  -- ^ Decentralization parameter. Note that the scale is inverted here - a
  -- value of 0 indicates full decentralisation, where 1 indicates full
  -- federalisation.
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Nonce
appExtraEntropy :: !(HKD f Nonce)
  -- ^ Extra entropy
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f ProtVer
appProtocolVersion :: !(HKD f BT.ProtVer)
  -- ^ Protocol version
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appMinPoolCost :: !(HKD f Coin)
  -- ^ Minimum Stake Pool Cost
  , -- new/updated for alonzo

    forall (f :: * -> *) era. AlonzoPParams f era -> HKD f CoinPerWord
appCoinsPerUTxOWord :: !(HKD f CoinPerWord)
  -- ^ Cost in lovelace per word (8 bytes) of UTxO storage (instead of appMinUTxOValue)
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f CostModels
appCostModels :: !(HKD f CostModels)
  -- ^ Cost models for non-native script languages
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Prices
appPrices :: !(HKD f Prices)
  -- ^ Prices of execution units (for non-native script languages)
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f OrdExUnits
appMaxTxExUnits :: !(HKD f OrdExUnits)
  -- ^ Max total script execution resources units allowed per tx
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f OrdExUnits
appMaxBlockExUnits :: !(HKD f OrdExUnits)
  -- ^ Max total script execution resources units allowed per block
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Natural
appMaxValSize :: !(HKD f Natural)
  -- ^ Max size of a Value in an output
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Natural
appCollateralPercentage :: !(HKD f Natural)
  -- ^ Percentage of the txfee which must be provided as collateral when
  -- including non-native scripts.
  , forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Natural
appMaxCollateralInputs :: !(HKD f Natural)
  -- ^ Maximum number of collateral inputs allowed in a transaction
  }
  deriving ((forall x. AlonzoPParams f era -> Rep (AlonzoPParams f era) x)
-> (forall x. Rep (AlonzoPParams f era) x -> AlonzoPParams f era)
-> Generic (AlonzoPParams f era)
forall x. Rep (AlonzoPParams f era) x -> AlonzoPParams f era
forall x. AlonzoPParams f era -> Rep (AlonzoPParams f era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) era x.
Rep (AlonzoPParams f era) x -> AlonzoPParams f era
forall (f :: * -> *) era x.
AlonzoPParams f era -> Rep (AlonzoPParams f era) x
$cfrom :: forall (f :: * -> *) era x.
AlonzoPParams f era -> Rep (AlonzoPParams f era) x
from :: forall x. AlonzoPParams f era -> Rep (AlonzoPParams f era) x
$cto :: forall (f :: * -> *) era x.
Rep (AlonzoPParams f era) x -> AlonzoPParams f era
to :: forall x. Rep (AlonzoPParams f era) x -> AlonzoPParams f era
Generic)

deriving instance Eq (AlonzoPParams Identity era)

deriving instance Ord (AlonzoPParams Identity era)

deriving instance Show (AlonzoPParams Identity era)

instance NoThunks (AlonzoPParams Identity era)

instance NFData (AlonzoPParams Identity era)

deriving instance Eq (AlonzoPParams StrictMaybe era)

deriving instance Ord (AlonzoPParams StrictMaybe era)

deriving instance Show (AlonzoPParams StrictMaybe era)

instance NoThunks (AlonzoPParams StrictMaybe era)

instance NFData (AlonzoPParams StrictMaybe era)

instance EraPParams AlonzoEra where
  type PParamsHKD f AlonzoEra = AlonzoPParams f AlonzoEra
  type UpgradePParams f AlonzoEra = UpgradeAlonzoPParams f
  type DowngradePParams f AlonzoEra = DowngradeAlonzoPParams f

  emptyPParamsIdentity :: PParamsHKD Identity AlonzoEra
emptyPParamsIdentity = PParamsHKD Identity AlonzoEra
AlonzoPParams Identity AlonzoEra
forall era. Era era => AlonzoPParams Identity era
emptyAlonzoPParams
  emptyPParamsStrictMaybe :: PParamsHKD StrictMaybe AlonzoEra
emptyPParamsStrictMaybe = PParamsHKD StrictMaybe AlonzoEra
AlonzoPParams StrictMaybe AlonzoEra
forall era. AlonzoPParams StrictMaybe era
emptyAlonzoPParamsUpdate

  upgradePParamsHKD :: forall (f :: * -> *).
(HKDApplicative f, EraPParams (PreviousEra AlonzoEra)) =>
UpgradePParams f AlonzoEra
-> PParamsHKD f (PreviousEra AlonzoEra) -> PParamsHKD f AlonzoEra
upgradePParamsHKD = UpgradePParams f AlonzoEra
-> PParamsHKD f (PreviousEra AlonzoEra) -> PParamsHKD f AlonzoEra
UpgradeAlonzoPParams f
-> ShelleyPParams f MaryEra -> AlonzoPParams f AlonzoEra
forall (f :: * -> *) era1 era2.
HKDFunctor f =>
UpgradeAlonzoPParams f
-> ShelleyPParams f era1 -> AlonzoPParams f era2
upgradeAlonzoPParams
  downgradePParamsHKD :: forall (f :: * -> *).
(HKDFunctor f, EraPParams (PreviousEra AlonzoEra)) =>
DowngradePParams f AlonzoEra
-> PParamsHKD f AlonzoEra -> PParamsHKD f (PreviousEra AlonzoEra)
downgradePParamsHKD = DowngradePParams f AlonzoEra
-> PParamsHKD f AlonzoEra -> PParamsHKD f (PreviousEra AlonzoEra)
DowngradeAlonzoPParams f
-> AlonzoPParams f AlonzoEra -> ShelleyPParams f MaryEra
forall (f :: * -> *) era2 era1.
DowngradeAlonzoPParams f
-> AlonzoPParams f era2 -> ShelleyPParams f era1
downgradeAlonzoPParams

  hkdMinFeeAL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Coin)
hkdMinFeeAL = (PParamsHKD f AlonzoEra -> HKD f Coin)
-> (PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f Coin
AlonzoPParams f AlonzoEra -> HKD f Coin
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appMinFeeA ((PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Coin -> f (HKD f Coin))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f Coin
x -> PParamsHKD f AlonzoEra
pp {appMinFeeA = x}
  hkdMinFeeBL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Coin)
hkdMinFeeBL = (PParamsHKD f AlonzoEra -> HKD f Coin)
-> (PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f Coin
AlonzoPParams f AlonzoEra -> HKD f Coin
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appMinFeeB ((PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Coin -> f (HKD f Coin))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f Coin
x -> PParamsHKD f AlonzoEra
pp {appMinFeeB = x}
  hkdMaxBBSizeL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Word32)
hkdMaxBBSizeL = (PParamsHKD f AlonzoEra -> HKD f Word32)
-> (PParamsHKD f AlonzoEra
    -> HKD f Word32 -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word32 -> f (HKD f Word32))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f Word32
AlonzoPParams f AlonzoEra -> HKD f Word32
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word32
appMaxBBSize ((PParamsHKD f AlonzoEra -> HKD f Word32 -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Word32 -> f (HKD f Word32))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f Word32 -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word32 -> f (HKD f Word32))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f Word32
x -> PParamsHKD f AlonzoEra
pp {appMaxBBSize = x}
  hkdMaxTxSizeL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Word32)
hkdMaxTxSizeL = (PParamsHKD f AlonzoEra -> HKD f Word32)
-> (PParamsHKD f AlonzoEra
    -> HKD f Word32 -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word32 -> f (HKD f Word32))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f Word32
AlonzoPParams f AlonzoEra -> HKD f Word32
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word32
appMaxTxSize ((PParamsHKD f AlonzoEra -> HKD f Word32 -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Word32 -> f (HKD f Word32))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f Word32 -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word32 -> f (HKD f Word32))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f Word32
x -> PParamsHKD f AlonzoEra
pp {appMaxTxSize = x}
  hkdMaxBHSizeL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Word16)
hkdMaxBHSizeL = (PParamsHKD f AlonzoEra -> HKD f Word16)
-> (PParamsHKD f AlonzoEra
    -> HKD f Word16 -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word16 -> f (HKD f Word16))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f Word16
AlonzoPParams f AlonzoEra -> HKD f Word16
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word16
appMaxBHSize ((PParamsHKD f AlonzoEra -> HKD f Word16 -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Word16 -> f (HKD f Word16))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f Word16 -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word16 -> f (HKD f Word16))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f Word16
x -> PParamsHKD f AlonzoEra
pp {appMaxBHSize = x}
  hkdKeyDepositL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Coin)
hkdKeyDepositL = (PParamsHKD f AlonzoEra -> HKD f Coin)
-> (PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f Coin
AlonzoPParams f AlonzoEra -> HKD f Coin
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appKeyDeposit ((PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Coin -> f (HKD f Coin))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f Coin
x -> PParamsHKD f AlonzoEra
pp {appKeyDeposit = x}
  hkdPoolDepositL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Coin)
hkdPoolDepositL = (PParamsHKD f AlonzoEra -> HKD f Coin)
-> (PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f Coin
AlonzoPParams f AlonzoEra -> HKD f Coin
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appPoolDeposit ((PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Coin -> f (HKD f Coin))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f Coin
x -> PParamsHKD f AlonzoEra
pp {appPoolDeposit = x}
  hkdEMaxL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f EpochInterval)
hkdEMaxL = (PParamsHKD f AlonzoEra -> HKD f EpochInterval)
-> (PParamsHKD f AlonzoEra
    -> HKD f EpochInterval -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f EpochInterval -> f (HKD f EpochInterval))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f EpochInterval
AlonzoPParams f AlonzoEra -> HKD f EpochInterval
forall (f :: * -> *) era.
AlonzoPParams f era -> HKD f EpochInterval
appEMax ((PParamsHKD f AlonzoEra
  -> HKD f EpochInterval -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f EpochInterval -> f (HKD f EpochInterval))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f EpochInterval -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f EpochInterval -> f (HKD f EpochInterval))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f EpochInterval
x -> PParamsHKD f AlonzoEra
pp {appEMax = x}
  hkdNOptL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Word16)
hkdNOptL = (PParamsHKD f AlonzoEra -> HKD f Word16)
-> (PParamsHKD f AlonzoEra
    -> HKD f Word16 -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word16 -> f (HKD f Word16))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f Word16
AlonzoPParams f AlonzoEra -> HKD f Word16
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word16
appNOpt ((PParamsHKD f AlonzoEra -> HKD f Word16 -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Word16 -> f (HKD f Word16))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f Word16 -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Word16 -> f (HKD f Word16))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f Word16
x -> PParamsHKD f AlonzoEra
pp {appNOpt = x}
  hkdA0L :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f NonNegativeInterval)
hkdA0L = (PParamsHKD f AlonzoEra -> HKD f NonNegativeInterval)
-> (PParamsHKD f AlonzoEra
    -> HKD f NonNegativeInterval -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f NonNegativeInterval -> f (HKD f NonNegativeInterval))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f NonNegativeInterval
AlonzoPParams f AlonzoEra -> HKD f NonNegativeInterval
forall (f :: * -> *) era.
AlonzoPParams f era -> HKD f NonNegativeInterval
appA0 ((PParamsHKD f AlonzoEra
  -> HKD f NonNegativeInterval -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f NonNegativeInterval -> f (HKD f NonNegativeInterval))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f NonNegativeInterval -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f NonNegativeInterval -> f (HKD f NonNegativeInterval))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f NonNegativeInterval
x -> PParamsHKD f AlonzoEra
pp {appA0 = x}
  hkdRhoL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f UnitInterval)
hkdRhoL = (PParamsHKD f AlonzoEra -> HKD f UnitInterval)
-> (PParamsHKD f AlonzoEra
    -> HKD f UnitInterval -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f UnitInterval -> f (HKD f UnitInterval))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f UnitInterval
AlonzoPParams f AlonzoEra -> HKD f UnitInterval
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f UnitInterval
appRho ((PParamsHKD f AlonzoEra
  -> HKD f UnitInterval -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f UnitInterval -> f (HKD f UnitInterval))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f UnitInterval -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f UnitInterval -> f (HKD f UnitInterval))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f UnitInterval
x -> PParamsHKD f AlonzoEra
pp {appRho = x}
  hkdTauL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f UnitInterval)
hkdTauL = (PParamsHKD f AlonzoEra -> HKD f UnitInterval)
-> (PParamsHKD f AlonzoEra
    -> HKD f UnitInterval -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f UnitInterval -> f (HKD f UnitInterval))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f UnitInterval
AlonzoPParams f AlonzoEra -> HKD f UnitInterval
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f UnitInterval
appTau ((PParamsHKD f AlonzoEra
  -> HKD f UnitInterval -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f UnitInterval -> f (HKD f UnitInterval))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f UnitInterval -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f UnitInterval -> f (HKD f UnitInterval))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f UnitInterval
x -> PParamsHKD f AlonzoEra
pp {appTau = x}
  hkdDL :: forall (f :: * -> *).
(HKDFunctor f, ProtVerAtMost AlonzoEra 6) =>
Lens' (PParamsHKD f AlonzoEra) (HKD f UnitInterval)
hkdDL = (PParamsHKD f AlonzoEra -> HKD f UnitInterval)
-> (PParamsHKD f AlonzoEra
    -> HKD f UnitInterval -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f UnitInterval -> f (HKD f UnitInterval))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f UnitInterval
AlonzoPParams f AlonzoEra -> HKD f UnitInterval
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f UnitInterval
appD ((PParamsHKD f AlonzoEra
  -> HKD f UnitInterval -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f UnitInterval -> f (HKD f UnitInterval))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f UnitInterval -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f UnitInterval -> f (HKD f UnitInterval))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f UnitInterval
x -> PParamsHKD f AlonzoEra
pp {appD = x}
  hkdExtraEntropyL :: forall (f :: * -> *).
(HKDFunctor f, ProtVerAtMost AlonzoEra 6) =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Nonce)
hkdExtraEntropyL = (PParamsHKD f AlonzoEra -> HKD f Nonce)
-> (PParamsHKD f AlonzoEra
    -> HKD f Nonce -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Nonce -> f (HKD f Nonce))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f Nonce
AlonzoPParams f AlonzoEra -> HKD f Nonce
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Nonce
appExtraEntropy ((PParamsHKD f AlonzoEra -> HKD f Nonce -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Nonce -> f (HKD f Nonce))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f Nonce -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Nonce -> f (HKD f Nonce))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f Nonce
x -> PParamsHKD f AlonzoEra
pp {appExtraEntropy = x}
  hkdProtocolVersionL :: forall (f :: * -> *).
(HKDFunctor f, ProtVerAtMost AlonzoEra 8) =>
Lens' (PParamsHKD f AlonzoEra) (HKD f ProtVer)
hkdProtocolVersionL = (PParamsHKD f AlonzoEra -> HKD f ProtVer)
-> (PParamsHKD f AlonzoEra
    -> HKD f ProtVer -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f ProtVer -> f (HKD f ProtVer))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f ProtVer
AlonzoPParams f AlonzoEra -> HKD f ProtVer
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f ProtVer
appProtocolVersion ((PParamsHKD f AlonzoEra
  -> HKD f ProtVer -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f ProtVer -> f (HKD f ProtVer))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f ProtVer -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f ProtVer -> f (HKD f ProtVer))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f ProtVer
x -> PParamsHKD f AlonzoEra
pp {appProtocolVersion = x}
  hkdMinUTxOValueL :: forall (f :: * -> *).
(HKDFunctor f, ProtVerAtMost AlonzoEra 4) =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Coin)
hkdMinUTxOValueL = (HKD f Coin -> f (HKD f Coin))
-> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
(HKD f Coin -> f (HKD f Coin))
-> AlonzoPParams f AlonzoEra -> f (AlonzoPParams f AlonzoEra)
forall a b. HasCallStack => Lens' a b
Lens' (AlonzoPParams f AlonzoEra) (HKD f Coin)
notSupportedInThisEraL
  hkdMinPoolCostL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Coin)
hkdMinPoolCostL = (PParamsHKD f AlonzoEra -> HKD f Coin)
-> (PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f Coin
AlonzoPParams f AlonzoEra -> HKD f Coin
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appMinPoolCost ((PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Coin -> f (HKD f Coin))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra -> HKD f Coin -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Coin -> f (HKD f Coin))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f Coin
x -> PParamsHKD f AlonzoEra
pp {appMinPoolCost = x}

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

instance AlonzoEraPParams AlonzoEra where
  hkdCoinsPerUTxOWordL :: forall (f :: * -> *).
(HKDFunctor f, ExactEra AlonzoEra AlonzoEra) =>
Lens' (PParamsHKD f AlonzoEra) (HKD f CoinPerWord)
hkdCoinsPerUTxOWordL = (PParamsHKD f AlonzoEra -> HKD f CoinPerWord)
-> (PParamsHKD f AlonzoEra
    -> HKD f CoinPerWord -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f CoinPerWord -> f (HKD f CoinPerWord))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f CoinPerWord
AlonzoPParams f AlonzoEra -> HKD f CoinPerWord
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f CoinPerWord
appCoinsPerUTxOWord ((PParamsHKD f AlonzoEra
  -> HKD f CoinPerWord -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f CoinPerWord -> f (HKD f CoinPerWord))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f CoinPerWord -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f CoinPerWord -> f (HKD f CoinPerWord))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f CoinPerWord
x -> PParamsHKD f AlonzoEra
pp {appCoinsPerUTxOWord = x}
  hkdCostModelsL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f CostModels)
hkdCostModelsL = (PParamsHKD f AlonzoEra -> HKD f CostModels)
-> (PParamsHKD f AlonzoEra
    -> HKD f CostModels -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f CostModels -> f (HKD f CostModels))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f CostModels
AlonzoPParams f AlonzoEra -> HKD f CostModels
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f CostModels
appCostModels ((PParamsHKD f AlonzoEra
  -> HKD f CostModels -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f CostModels -> f (HKD f CostModels))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f CostModels -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f CostModels -> f (HKD f CostModels))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f CostModels
x -> PParamsHKD f AlonzoEra
pp {appCostModels = x}
  hkdPricesL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Prices)
hkdPricesL = (PParamsHKD f AlonzoEra -> HKD f Prices)
-> (PParamsHKD f AlonzoEra
    -> HKD f Prices -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Prices -> f (HKD f Prices))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f Prices
AlonzoPParams f AlonzoEra -> HKD f Prices
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Prices
appPrices ((PParamsHKD f AlonzoEra -> HKD f Prices -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Prices -> f (HKD f Prices))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f Prices -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Prices -> f (HKD f Prices))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f Prices
x -> PParamsHKD f AlonzoEra
pp {appPrices = x}
  hkdMaxTxExUnitsL :: forall f. HKDFunctor f => Lens' (PParamsHKD f AlonzoEra) (HKD f ExUnits)
  hkdMaxTxExUnitsL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f ExUnits)
hkdMaxTxExUnitsL =
    (PParamsHKD f AlonzoEra -> HKD f ExUnits)
-> (PParamsHKD f AlonzoEra
    -> HKD f ExUnits -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f ExUnits -> f (HKD f ExUnits))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Proxy f
-> (OrdExUnits -> ExUnits) -> HKD f OrdExUnits -> HKD f ExUnits
forall (f :: * -> *) (proxy :: (* -> *) -> *) a b.
HKDFunctor f =>
proxy f -> (a -> b) -> HKD f a -> HKD f b
forall (proxy :: (* -> *) -> *) a b.
proxy f -> (a -> b) -> HKD f a -> HKD f b
hkdMap (forall {k} (t :: k). Proxy t
forall (t :: * -> *). Proxy t
Proxy @f) OrdExUnits -> ExUnits
unOrdExUnits (HKD f OrdExUnits -> HKD f ExUnits)
-> (AlonzoPParams f AlonzoEra -> HKD f OrdExUnits)
-> AlonzoPParams f AlonzoEra
-> HKD f ExUnits
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AlonzoPParams f AlonzoEra -> HKD f OrdExUnits
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f OrdExUnits
appMaxTxExUnits) ((PParamsHKD f AlonzoEra
  -> HKD f ExUnits -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f ExUnits -> f (HKD f ExUnits))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f ExUnits -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f ExUnits -> f (HKD f ExUnits))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f ExUnits
x ->
      PParamsHKD f AlonzoEra
pp {appMaxTxExUnits = hkdMap (Proxy @f) OrdExUnits x}
  hkdMaxBlockExUnitsL :: forall f. HKDFunctor f => Lens' (PParamsHKD f AlonzoEra) (HKD f ExUnits)
  hkdMaxBlockExUnitsL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f ExUnits)
hkdMaxBlockExUnitsL =
    (PParamsHKD f AlonzoEra -> HKD f ExUnits)
-> (PParamsHKD f AlonzoEra
    -> HKD f ExUnits -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f ExUnits -> f (HKD f ExUnits))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Proxy f
-> (OrdExUnits -> ExUnits) -> HKD f OrdExUnits -> HKD f ExUnits
forall (f :: * -> *) (proxy :: (* -> *) -> *) a b.
HKDFunctor f =>
proxy f -> (a -> b) -> HKD f a -> HKD f b
forall (proxy :: (* -> *) -> *) a b.
proxy f -> (a -> b) -> HKD f a -> HKD f b
hkdMap (forall {k} (t :: k). Proxy t
forall (t :: * -> *). Proxy t
Proxy @f) OrdExUnits -> ExUnits
unOrdExUnits (HKD f OrdExUnits -> HKD f ExUnits)
-> (AlonzoPParams f AlonzoEra -> HKD f OrdExUnits)
-> AlonzoPParams f AlonzoEra
-> HKD f ExUnits
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AlonzoPParams f AlonzoEra -> HKD f OrdExUnits
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f OrdExUnits
appMaxBlockExUnits) ((PParamsHKD f AlonzoEra
  -> HKD f ExUnits -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f ExUnits -> f (HKD f ExUnits))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f ExUnits -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f ExUnits -> f (HKD f ExUnits))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f ExUnits
x ->
      PParamsHKD f AlonzoEra
pp {appMaxBlockExUnits = hkdMap (Proxy @f) OrdExUnits x}
  hkdMaxValSizeL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Natural)
hkdMaxValSizeL = (PParamsHKD f AlonzoEra -> HKD f Natural)
-> (PParamsHKD f AlonzoEra
    -> HKD f Natural -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Natural -> f (HKD f Natural))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f Natural
AlonzoPParams f AlonzoEra -> HKD f Natural
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Natural
appMaxValSize ((PParamsHKD f AlonzoEra
  -> HKD f Natural -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Natural -> f (HKD f Natural))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f Natural -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Natural -> f (HKD f Natural))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f Natural
x -> PParamsHKD f AlonzoEra
pp {appMaxValSize = x}
  hkdCollateralPercentageL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Natural)
hkdCollateralPercentageL =
    (PParamsHKD f AlonzoEra -> HKD f Natural)
-> (PParamsHKD f AlonzoEra
    -> HKD f Natural -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Natural -> f (HKD f Natural))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f Natural
AlonzoPParams f AlonzoEra -> HKD f Natural
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Natural
appCollateralPercentage ((PParamsHKD f AlonzoEra
  -> HKD f Natural -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Natural -> f (HKD f Natural))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f Natural -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Natural -> f (HKD f Natural))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f Natural
x -> PParamsHKD f AlonzoEra
pp {appCollateralPercentage = x}
  hkdMaxCollateralInputsL :: forall (f :: * -> *).
HKDFunctor f =>
Lens' (PParamsHKD f AlonzoEra) (HKD f Natural)
hkdMaxCollateralInputsL =
    (PParamsHKD f AlonzoEra -> HKD f Natural)
-> (PParamsHKD f AlonzoEra
    -> HKD f Natural -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Natural -> f (HKD f Natural))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens PParamsHKD f AlonzoEra -> HKD f Natural
AlonzoPParams f AlonzoEra -> HKD f Natural
forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Natural
appMaxCollateralInputs ((PParamsHKD f AlonzoEra
  -> HKD f Natural -> PParamsHKD f AlonzoEra)
 -> forall {f :: * -> *}.
    Functor f =>
    (HKD f Natural -> f (HKD f Natural))
    -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra))
-> (PParamsHKD f AlonzoEra
    -> HKD f Natural -> PParamsHKD f AlonzoEra)
-> forall {f :: * -> *}.
   Functor f =>
   (HKD f Natural -> f (HKD f Natural))
   -> PParamsHKD f AlonzoEra -> f (PParamsHKD f AlonzoEra)
forall a b. (a -> b) -> a -> b
$ \PParamsHKD f AlonzoEra
pp HKD f Natural
x -> PParamsHKD f AlonzoEra
pp {appMaxCollateralInputs = x}

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

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

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

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

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

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

instance ToPlutusData CoinPerWord where
  toPlutusData :: CoinPerWord -> Data
toPlutusData = String -> CoinPerWord -> Data
forall a. HasCallStack => String -> a
error String
"unsupported"
  fromPlutusData :: Data -> Maybe CoinPerWord
fromPlutusData = String -> Data -> Maybe CoinPerWord
forall a. HasCallStack => String -> a
error String
"unsupported"

-- | This is a helper type that allows us to define an `Ord` instance for executions units
-- without affecting the `ExUnits` type. This is needed in order to derive an `Ord` instance`
-- for PParams. This is just a helper type and should not be used directly. Both lenses
-- that operate on TxExUnits and BlockExUnits use the `ExUnits` type, not this one.
newtype OrdExUnits = OrdExUnits {OrdExUnits -> ExUnits
unOrdExUnits :: ExUnits}
  deriving (OrdExUnits -> OrdExUnits -> Bool
(OrdExUnits -> OrdExUnits -> Bool)
-> (OrdExUnits -> OrdExUnits -> Bool) -> Eq OrdExUnits
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OrdExUnits -> OrdExUnits -> Bool
== :: OrdExUnits -> OrdExUnits -> Bool
$c/= :: OrdExUnits -> OrdExUnits -> Bool
/= :: OrdExUnits -> OrdExUnits -> Bool
Eq)
  deriving newtype (Int -> OrdExUnits -> ShowS
[OrdExUnits] -> ShowS
OrdExUnits -> String
(Int -> OrdExUnits -> ShowS)
-> (OrdExUnits -> String)
-> ([OrdExUnits] -> ShowS)
-> Show OrdExUnits
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OrdExUnits -> ShowS
showsPrec :: Int -> OrdExUnits -> ShowS
$cshow :: OrdExUnits -> String
show :: OrdExUnits -> String
$cshowList :: [OrdExUnits] -> ShowS
showList :: [OrdExUnits] -> ShowS
Show, Context -> OrdExUnits -> IO (Maybe ThunkInfo)
Proxy OrdExUnits -> String
(Context -> OrdExUnits -> IO (Maybe ThunkInfo))
-> (Context -> OrdExUnits -> IO (Maybe ThunkInfo))
-> (Proxy OrdExUnits -> String)
-> NoThunks OrdExUnits
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> OrdExUnits -> IO (Maybe ThunkInfo)
noThunks :: Context -> OrdExUnits -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> OrdExUnits -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> OrdExUnits -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy OrdExUnits -> String
showTypeOf :: Proxy OrdExUnits -> String
NoThunks, OrdExUnits -> ()
(OrdExUnits -> ()) -> NFData OrdExUnits
forall a. (a -> ()) -> NFData a
$crnf :: OrdExUnits -> ()
rnf :: OrdExUnits -> ()
NFData, Typeable OrdExUnits
Typeable OrdExUnits =>
(forall s. Decoder s OrdExUnits)
-> (forall s. Proxy OrdExUnits -> Decoder s ())
-> (Proxy OrdExUnits -> Text)
-> DecCBOR OrdExUnits
Proxy OrdExUnits -> Text
forall s. Decoder s OrdExUnits
forall a.
Typeable a =>
(forall s. Decoder s a)
-> (forall s. Proxy a -> Decoder s ())
-> (Proxy a -> Text)
-> DecCBOR a
forall s. Proxy OrdExUnits -> Decoder s ()
$cdecCBOR :: forall s. Decoder s OrdExUnits
decCBOR :: forall s. Decoder s OrdExUnits
$cdropCBOR :: forall s. Proxy OrdExUnits -> Decoder s ()
dropCBOR :: forall s. Proxy OrdExUnits -> Decoder s ()
$clabel :: Proxy OrdExUnits -> Text
label :: Proxy OrdExUnits -> Text
DecCBOR, Typeable OrdExUnits
Typeable OrdExUnits =>
(OrdExUnits -> Encoding)
-> ((forall t. EncCBOR t => Proxy t -> Size)
    -> Proxy OrdExUnits -> Size)
-> ((forall t. EncCBOR t => Proxy t -> Size)
    -> Proxy [OrdExUnits] -> Size)
-> EncCBOR OrdExUnits
OrdExUnits -> Encoding
(forall t. EncCBOR t => Proxy t -> Size)
-> Proxy [OrdExUnits] -> Size
(forall t. EncCBOR t => Proxy t -> Size)
-> Proxy OrdExUnits -> Size
forall a.
Typeable a =>
(a -> Encoding)
-> ((forall t. EncCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. EncCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> EncCBOR a
$cencCBOR :: OrdExUnits -> Encoding
encCBOR :: OrdExUnits -> Encoding
$cencodedSizeExpr :: (forall t. EncCBOR t => Proxy t -> Size)
-> Proxy OrdExUnits -> Size
encodedSizeExpr :: (forall t. EncCBOR t => Proxy t -> Size)
-> Proxy OrdExUnits -> Size
$cencodedListSizeExpr :: (forall t. EncCBOR t => Proxy t -> Size)
-> Proxy [OrdExUnits] -> Size
encodedListSizeExpr :: (forall t. EncCBOR t => Proxy t -> Size)
-> Proxy [OrdExUnits] -> Size
EncCBOR, Maybe OrdExUnits
Value -> Parser [OrdExUnits]
Value -> Parser OrdExUnits
(Value -> Parser OrdExUnits)
-> (Value -> Parser [OrdExUnits])
-> Maybe OrdExUnits
-> FromJSON OrdExUnits
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser OrdExUnits
parseJSON :: Value -> Parser OrdExUnits
$cparseJSONList :: Value -> Parser [OrdExUnits]
parseJSONList :: Value -> Parser [OrdExUnits]
$comittedField :: Maybe OrdExUnits
omittedField :: Maybe OrdExUnits
FromJSON, [OrdExUnits] -> Value
[OrdExUnits] -> Encoding
OrdExUnits -> Bool
OrdExUnits -> Value
OrdExUnits -> Encoding
(OrdExUnits -> Value)
-> (OrdExUnits -> Encoding)
-> ([OrdExUnits] -> Value)
-> ([OrdExUnits] -> Encoding)
-> (OrdExUnits -> Bool)
-> ToJSON OrdExUnits
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: OrdExUnits -> Value
toJSON :: OrdExUnits -> Value
$ctoEncoding :: OrdExUnits -> Encoding
toEncoding :: OrdExUnits -> Encoding
$ctoJSONList :: [OrdExUnits] -> Value
toJSONList :: [OrdExUnits] -> Value
$ctoEncodingList :: [OrdExUnits] -> Encoding
toEncodingList :: [OrdExUnits] -> Encoding
$comitField :: OrdExUnits -> Bool
omitField :: OrdExUnits -> Bool
ToJSON)

instance Ord OrdExUnits where
  compare :: OrdExUnits -> OrdExUnits -> Ordering
compare = (ExUnits -> ExUnits -> Ordering)
-> OrdExUnits -> OrdExUnits -> Ordering
forall a b. Coercible a b => a -> b
coerce ((Natural -> Natural -> Ordering) -> ExUnits -> ExUnits -> Ordering
forall a.
Semigroup a =>
(Natural -> Natural -> a) -> ExUnits -> ExUnits -> a
zipSemiExUnits Natural -> Natural -> Ordering
forall a. Ord a => a -> a -> Ordering
compare)

-- | Parameters that were added in Alonzo
data UpgradeAlonzoPParams f = UpgradeAlonzoPParams
  { forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f CoinPerWord
uappCoinsPerUTxOWord :: !(HKD f CoinPerWord)
  , forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f CostModels
uappCostModels :: !(HKD f CostModels)
  , forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f Prices
uappPrices :: !(HKD f Prices)
  , forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f ExUnits
uappMaxTxExUnits :: !(HKD f ExUnits)
  , forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f ExUnits
uappMaxBlockExUnits :: !(HKD f ExUnits)
  , forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f Natural
uappMaxValSize :: !(HKD f Natural)
  , forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f Natural
uappCollateralPercentage :: !(HKD f Natural)
  , forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f Natural
uappMaxCollateralInputs :: !(HKD f Natural)
  }
  deriving ((forall x.
 UpgradeAlonzoPParams f -> Rep (UpgradeAlonzoPParams f) x)
-> (forall x.
    Rep (UpgradeAlonzoPParams f) x -> UpgradeAlonzoPParams f)
-> Generic (UpgradeAlonzoPParams f)
forall x. Rep (UpgradeAlonzoPParams f) x -> UpgradeAlonzoPParams f
forall x. UpgradeAlonzoPParams f -> Rep (UpgradeAlonzoPParams f) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) x.
Rep (UpgradeAlonzoPParams f) x -> UpgradeAlonzoPParams f
forall (f :: * -> *) x.
UpgradeAlonzoPParams f -> Rep (UpgradeAlonzoPParams f) x
$cfrom :: forall (f :: * -> *) x.
UpgradeAlonzoPParams f -> Rep (UpgradeAlonzoPParams f) x
from :: forall x. UpgradeAlonzoPParams f -> Rep (UpgradeAlonzoPParams f) x
$cto :: forall (f :: * -> *) x.
Rep (UpgradeAlonzoPParams f) x -> UpgradeAlonzoPParams f
to :: forall x. Rep (UpgradeAlonzoPParams f) x -> UpgradeAlonzoPParams f
Generic)

deriving instance Eq (UpgradeAlonzoPParams Identity)

deriving instance Show (UpgradeAlonzoPParams Identity)

instance NoThunks (UpgradeAlonzoPParams Identity)

instance NFData (UpgradeAlonzoPParams Identity)

instance Default (UpgradeAlonzoPParams StrictMaybe) where
  def :: UpgradeAlonzoPParams StrictMaybe
def =
    UpgradeAlonzoPParams
      { uappCoinsPerUTxOWord :: HKD StrictMaybe CoinPerWord
uappCoinsPerUTxOWord = StrictMaybe CoinPerWord
HKD StrictMaybe CoinPerWord
forall a. StrictMaybe a
SNothing
      , uappCostModels :: HKD StrictMaybe CostModels
uappCostModels = StrictMaybe CostModels
HKD StrictMaybe CostModels
forall a. StrictMaybe a
SNothing
      , uappPrices :: HKD StrictMaybe Prices
uappPrices = StrictMaybe Prices
HKD StrictMaybe Prices
forall a. StrictMaybe a
SNothing
      , uappMaxTxExUnits :: HKD StrictMaybe ExUnits
uappMaxTxExUnits = StrictMaybe ExUnits
HKD StrictMaybe ExUnits
forall a. StrictMaybe a
SNothing
      , uappMaxBlockExUnits :: HKD StrictMaybe ExUnits
uappMaxBlockExUnits = StrictMaybe ExUnits
HKD StrictMaybe ExUnits
forall a. StrictMaybe a
SNothing
      , uappMaxValSize :: HKD StrictMaybe Natural
uappMaxValSize = StrictMaybe Natural
HKD StrictMaybe Natural
forall a. StrictMaybe a
SNothing
      , uappCollateralPercentage :: HKD StrictMaybe Natural
uappCollateralPercentage = StrictMaybe Natural
HKD StrictMaybe Natural
forall a. StrictMaybe a
SNothing
      , uappMaxCollateralInputs :: HKD StrictMaybe Natural
uappMaxCollateralInputs = StrictMaybe Natural
HKD StrictMaybe Natural
forall a. StrictMaybe a
SNothing
      }

-- | Parameters that were removed in Alonzo
newtype DowngradeAlonzoPParams f = DowngradeAlonzoPParams
  { forall (f :: * -> *). DowngradeAlonzoPParams f -> HKD f Coin
dappMinUTxOValue :: HKD f Coin
  }
  deriving ((forall x.
 DowngradeAlonzoPParams f -> Rep (DowngradeAlonzoPParams f) x)
-> (forall x.
    Rep (DowngradeAlonzoPParams f) x -> DowngradeAlonzoPParams f)
-> Generic (DowngradeAlonzoPParams f)
forall x.
Rep (DowngradeAlonzoPParams f) x -> DowngradeAlonzoPParams f
forall x.
DowngradeAlonzoPParams f -> Rep (DowngradeAlonzoPParams f) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) x.
Rep (DowngradeAlonzoPParams f) x -> DowngradeAlonzoPParams f
forall (f :: * -> *) x.
DowngradeAlonzoPParams f -> Rep (DowngradeAlonzoPParams f) x
$cfrom :: forall (f :: * -> *) x.
DowngradeAlonzoPParams f -> Rep (DowngradeAlonzoPParams f) x
from :: forall x.
DowngradeAlonzoPParams f -> Rep (DowngradeAlonzoPParams f) x
$cto :: forall (f :: * -> *) x.
Rep (DowngradeAlonzoPParams f) x -> DowngradeAlonzoPParams f
to :: forall x.
Rep (DowngradeAlonzoPParams f) x -> DowngradeAlonzoPParams f
Generic)

deriving instance Eq (DowngradeAlonzoPParams Identity)

deriving instance Show (DowngradeAlonzoPParams Identity)

instance NoThunks (DowngradeAlonzoPParams Identity)

instance NFData (DowngradeAlonzoPParams Identity)

-- | Returns a basic "empty" `PParams` structure with all zero values.
emptyAlonzoPParams :: forall era. Era era => AlonzoPParams Identity era
emptyAlonzoPParams :: forall era. Era era => AlonzoPParams Identity era
emptyAlonzoPParams =
  AlonzoPParams
    { appMinFeeA :: HKD Identity Coin
appMinFeeA = Integer -> Coin
Coin Integer
0
    , appMinFeeB :: HKD Identity Coin
appMinFeeB = Integer -> Coin
Coin Integer
0
    , appMaxBBSize :: HKD Identity Word32
appMaxBBSize = Word32
HKD Identity Word32
0
    , appMaxTxSize :: HKD Identity Word32
appMaxTxSize = Word32
HKD Identity Word32
2048
    , appMaxBHSize :: HKD Identity Word16
appMaxBHSize = Word16
HKD Identity Word16
0
    , appKeyDeposit :: HKD Identity Coin
appKeyDeposit = Integer -> Coin
Coin Integer
0
    , appPoolDeposit :: HKD Identity Coin
appPoolDeposit = Integer -> Coin
Coin Integer
0
    , appEMax :: HKD Identity EpochInterval
appEMax = Word32 -> EpochInterval
EpochInterval Word32
0
    , appNOpt :: HKD Identity Word16
appNOpt = Word16
HKD Identity Word16
100
    , appA0 :: HKD Identity NonNegativeInterval
appA0 = HKD Identity NonNegativeInterval
NonNegativeInterval
forall a. Bounded a => a
minBound
    , appRho :: HKD Identity UnitInterval
appRho = HKD Identity UnitInterval
UnitInterval
forall a. Bounded a => a
minBound
    , appTau :: HKD Identity UnitInterval
appTau = HKD Identity UnitInterval
UnitInterval
forall a. Bounded a => a
minBound
    , appD :: HKD Identity UnitInterval
appD = HKD Identity UnitInterval
UnitInterval
forall a. Bounded a => a
minBound
    , appExtraEntropy :: HKD Identity Nonce
appExtraEntropy = HKD Identity Nonce
Nonce
NeutralNonce
    , appProtocolVersion :: HKD Identity ProtVer
appProtocolVersion = Version -> Natural -> ProtVer
BT.ProtVer (forall era. Era era => Version
eraProtVerLow @era) Natural
0
    , appMinPoolCost :: HKD Identity Coin
appMinPoolCost = HKD Identity Coin
Coin
forall a. Monoid a => a
mempty
    , -- new/updated for alonzo
      appCoinsPerUTxOWord :: HKD Identity CoinPerWord
appCoinsPerUTxOWord = Coin -> CoinPerWord
CoinPerWord (Integer -> Coin
Coin Integer
0)
    , appCostModels :: HKD Identity CostModels
appCostModels = HKD Identity CostModels
CostModels
emptyCostModels
    , appPrices :: HKD Identity Prices
appPrices = NonNegativeInterval -> NonNegativeInterval -> Prices
Prices NonNegativeInterval
forall a. Bounded a => a
minBound NonNegativeInterval
forall a. Bounded a => a
minBound
    , appMaxTxExUnits :: HKD Identity OrdExUnits
appMaxTxExUnits = ExUnits -> OrdExUnits
OrdExUnits (ExUnits -> OrdExUnits) -> ExUnits -> OrdExUnits
forall a b. (a -> b) -> a -> b
$ Natural -> Natural -> ExUnits
ExUnits Natural
0 Natural
0
    , appMaxBlockExUnits :: HKD Identity OrdExUnits
appMaxBlockExUnits = ExUnits -> OrdExUnits
OrdExUnits (ExUnits -> OrdExUnits) -> ExUnits -> OrdExUnits
forall a b. (a -> b) -> a -> b
$ Natural -> Natural -> ExUnits
ExUnits Natural
0 Natural
0
    , appMaxValSize :: HKD Identity Natural
appMaxValSize = Natural
HKD Identity Natural
0
    , appCollateralPercentage :: HKD Identity Natural
appCollateralPercentage = Natural
HKD Identity Natural
150
    , appMaxCollateralInputs :: HKD Identity Natural
appMaxCollateralInputs = Natural
HKD Identity Natural
5
    }

emptyAlonzoPParamsUpdate :: AlonzoPParams StrictMaybe era
emptyAlonzoPParamsUpdate :: forall era. AlonzoPParams StrictMaybe era
emptyAlonzoPParamsUpdate =
  AlonzoPParams
    { appMinFeeA :: HKD StrictMaybe Coin
appMinFeeA = StrictMaybe Coin
HKD StrictMaybe Coin
forall a. StrictMaybe a
SNothing
    , appMinFeeB :: HKD StrictMaybe Coin
appMinFeeB = StrictMaybe Coin
HKD StrictMaybe Coin
forall a. StrictMaybe a
SNothing
    , appMaxBBSize :: HKD StrictMaybe Word32
appMaxBBSize = StrictMaybe Word32
HKD StrictMaybe Word32
forall a. StrictMaybe a
SNothing
    , appMaxTxSize :: HKD StrictMaybe Word32
appMaxTxSize = StrictMaybe Word32
HKD StrictMaybe Word32
forall a. StrictMaybe a
SNothing
    , appMaxBHSize :: HKD StrictMaybe Word16
appMaxBHSize = StrictMaybe Word16
HKD StrictMaybe Word16
forall a. StrictMaybe a
SNothing
    , appKeyDeposit :: HKD StrictMaybe Coin
appKeyDeposit = StrictMaybe Coin
HKD StrictMaybe Coin
forall a. StrictMaybe a
SNothing
    , appPoolDeposit :: HKD StrictMaybe Coin
appPoolDeposit = StrictMaybe Coin
HKD StrictMaybe Coin
forall a. StrictMaybe a
SNothing
    , appEMax :: HKD StrictMaybe EpochInterval
appEMax = StrictMaybe EpochInterval
HKD StrictMaybe EpochInterval
forall a. StrictMaybe a
SNothing
    , appNOpt :: HKD StrictMaybe Word16
appNOpt = StrictMaybe Word16
HKD StrictMaybe Word16
forall a. StrictMaybe a
SNothing
    , appA0 :: HKD StrictMaybe NonNegativeInterval
appA0 = StrictMaybe NonNegativeInterval
HKD StrictMaybe NonNegativeInterval
forall a. StrictMaybe a
SNothing
    , appRho :: HKD StrictMaybe UnitInterval
appRho = StrictMaybe UnitInterval
HKD StrictMaybe UnitInterval
forall a. StrictMaybe a
SNothing
    , appTau :: HKD StrictMaybe UnitInterval
appTau = StrictMaybe UnitInterval
HKD StrictMaybe UnitInterval
forall a. StrictMaybe a
SNothing
    , appD :: HKD StrictMaybe UnitInterval
appD = StrictMaybe UnitInterval
HKD StrictMaybe UnitInterval
forall a. StrictMaybe a
SNothing
    , appExtraEntropy :: HKD StrictMaybe Nonce
appExtraEntropy = StrictMaybe Nonce
HKD StrictMaybe Nonce
forall a. StrictMaybe a
SNothing
    , appProtocolVersion :: HKD StrictMaybe ProtVer
appProtocolVersion = StrictMaybe ProtVer
HKD StrictMaybe ProtVer
forall a. StrictMaybe a
SNothing
    , appMinPoolCost :: HKD StrictMaybe Coin
appMinPoolCost = StrictMaybe Coin
HKD StrictMaybe Coin
forall a. StrictMaybe a
SNothing
    , -- new/updated for alonzo
      appCoinsPerUTxOWord :: HKD StrictMaybe CoinPerWord
appCoinsPerUTxOWord = StrictMaybe CoinPerWord
HKD StrictMaybe CoinPerWord
forall a. StrictMaybe a
SNothing
    , appCostModels :: HKD StrictMaybe CostModels
appCostModels = StrictMaybe CostModels
HKD StrictMaybe CostModels
forall a. StrictMaybe a
SNothing
    , appPrices :: HKD StrictMaybe Prices
appPrices = StrictMaybe Prices
HKD StrictMaybe Prices
forall a. StrictMaybe a
SNothing
    , appMaxTxExUnits :: HKD StrictMaybe OrdExUnits
appMaxTxExUnits = StrictMaybe OrdExUnits
HKD StrictMaybe OrdExUnits
forall a. StrictMaybe a
SNothing
    , appMaxBlockExUnits :: HKD StrictMaybe OrdExUnits
appMaxBlockExUnits = StrictMaybe OrdExUnits
HKD StrictMaybe OrdExUnits
forall a. StrictMaybe a
SNothing
    , appMaxValSize :: HKD StrictMaybe Natural
appMaxValSize = StrictMaybe Natural
HKD StrictMaybe Natural
forall a. StrictMaybe a
SNothing
    , appCollateralPercentage :: HKD StrictMaybe Natural
appCollateralPercentage = StrictMaybe Natural
HKD StrictMaybe Natural
forall a. StrictMaybe a
SNothing
    , appMaxCollateralInputs :: HKD StrictMaybe Natural
appMaxCollateralInputs = StrictMaybe Natural
HKD StrictMaybe Natural
forall a. StrictMaybe a
SNothing
    }

-- ===================================================
-- Figure 1: "Definitions Used in Protocol Parameters"

-- The LangDepView is a key value pair. The key is the (canonically) encoded
-- language tag and the value is the (canonically) encoded set of relevant
-- protocol parameters
data LangDepView = LangDepView {LangDepView -> ByteString
tag :: ByteString, LangDepView -> ByteString
params :: ByteString}
  deriving (LangDepView -> LangDepView -> Bool
(LangDepView -> LangDepView -> Bool)
-> (LangDepView -> LangDepView -> Bool) -> Eq LangDepView
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LangDepView -> LangDepView -> Bool
== :: LangDepView -> LangDepView -> Bool
$c/= :: LangDepView -> LangDepView -> Bool
/= :: LangDepView -> LangDepView -> Bool
Eq, Int -> LangDepView -> ShowS
[LangDepView] -> ShowS
LangDepView -> String
(Int -> LangDepView -> ShowS)
-> (LangDepView -> String)
-> ([LangDepView] -> ShowS)
-> Show LangDepView
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LangDepView -> ShowS
showsPrec :: Int -> LangDepView -> ShowS
$cshow :: LangDepView -> String
show :: LangDepView -> String
$cshowList :: [LangDepView] -> ShowS
showList :: [LangDepView] -> ShowS
Show, Eq LangDepView
Eq LangDepView =>
(LangDepView -> LangDepView -> Ordering)
-> (LangDepView -> LangDepView -> Bool)
-> (LangDepView -> LangDepView -> Bool)
-> (LangDepView -> LangDepView -> Bool)
-> (LangDepView -> LangDepView -> Bool)
-> (LangDepView -> LangDepView -> LangDepView)
-> (LangDepView -> LangDepView -> LangDepView)
-> Ord LangDepView
LangDepView -> LangDepView -> Bool
LangDepView -> LangDepView -> Ordering
LangDepView -> LangDepView -> LangDepView
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LangDepView -> LangDepView -> Ordering
compare :: LangDepView -> LangDepView -> Ordering
$c< :: LangDepView -> LangDepView -> Bool
< :: LangDepView -> LangDepView -> Bool
$c<= :: LangDepView -> LangDepView -> Bool
<= :: LangDepView -> LangDepView -> Bool
$c> :: LangDepView -> LangDepView -> Bool
> :: LangDepView -> LangDepView -> Bool
$c>= :: LangDepView -> LangDepView -> Bool
>= :: LangDepView -> LangDepView -> Bool
$cmax :: LangDepView -> LangDepView -> LangDepView
max :: LangDepView -> LangDepView -> LangDepView
$cmin :: LangDepView -> LangDepView -> LangDepView
min :: LangDepView -> LangDepView -> LangDepView
Ord, (forall x. LangDepView -> Rep LangDepView x)
-> (forall x. Rep LangDepView x -> LangDepView)
-> Generic LangDepView
forall x. Rep LangDepView x -> LangDepView
forall x. LangDepView -> Rep LangDepView x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LangDepView -> Rep LangDepView x
from :: forall x. LangDepView -> Rep LangDepView x
$cto :: forall x. Rep LangDepView x -> LangDepView
to :: forall x. Rep LangDepView x -> LangDepView
Generic, Context -> LangDepView -> IO (Maybe ThunkInfo)
Proxy LangDepView -> String
(Context -> LangDepView -> IO (Maybe ThunkInfo))
-> (Context -> LangDepView -> IO (Maybe ThunkInfo))
-> (Proxy LangDepView -> String)
-> NoThunks LangDepView
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> LangDepView -> IO (Maybe ThunkInfo)
noThunks :: Context -> LangDepView -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> LangDepView -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> LangDepView -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy LangDepView -> String
showTypeOf :: Proxy LangDepView -> String
NoThunks)

encodeCostModel :: CostModel -> Encoding
encodeCostModel :: CostModel -> Encoding
encodeCostModel CostModel
cm =
  case CostModel -> Language
getCostModelLanguage CostModel
cm of
    -- In the Alonzo era, the map of languages to cost models was mistakenly encoded
    -- using an indefinite CBOR map (contrary to canonical CBOR, as intended) when
    -- computing the script integrity hash.
    -- For this reason, PlutusV1 remains with this encoding.
    -- Future versions of Plutus, starting with PlutusV2 in the Babbage era, will
    -- use the intended definite length encoding.
    Language
PlutusV1 -> (Int64 -> Encoding) -> [Int64] -> Encoding
forall (f :: * -> *) a.
Foldable f =>
(a -> Encoding) -> f a -> Encoding
encodeFoldableAsIndefLenList Int64 -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR ([Int64] -> Encoding) -> [Int64] -> Encoding
forall a b. (a -> b) -> a -> b
$ CostModel -> [Int64]
getCostModelParams CostModel
cm
    -- Since cost model serializations need to be independently reproduced,
    -- we use the 'canonical' serialization with definite list length.
    Language
PlutusV2 -> (Int64 -> Encoding) -> [Int64] -> Encoding
forall (f :: * -> *) a.
Foldable f =>
(a -> Encoding) -> f a -> Encoding
encodeFoldableAsDefLenList Int64 -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR ([Int64] -> Encoding) -> [Int64] -> Encoding
forall a b. (a -> b) -> a -> b
$ CostModel -> [Int64]
getCostModelParams CostModel
cm
    Language
PlutusV3 -> (Int64 -> Encoding) -> [Int64] -> Encoding
forall (f :: * -> *) a.
Foldable f =>
(a -> Encoding) -> f a -> Encoding
encodeFoldableAsDefLenList Int64 -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR ([Int64] -> Encoding) -> [Int64] -> Encoding
forall a b. (a -> b) -> a -> b
$ CostModel -> [Int64]
getCostModelParams CostModel
cm

getLanguageView ::
  AlonzoEraPParams era =>
  PParams era ->
  Language ->
  LangDepView
getLanguageView :: forall era.
AlonzoEraPParams era =>
PParams era -> Language -> LangDepView
getLanguageView PParams era
pp Language
lang =
  case Language
lang of
    Language
PlutusV1 ->
      ByteString -> ByteString -> LangDepView
LangDepView -- The silly double bagging is to keep compatibility with a past bug
        (Version -> ByteString -> ByteString
forall a. EncCBOR a => Version -> a -> ByteString
serialize' Version
version (Version -> Language -> ByteString
forall a. EncCBOR a => Version -> a -> ByteString
serialize' Version
version Language
lang))
        (Version -> ByteString -> ByteString
forall a. EncCBOR a => Version -> a -> ByteString
serialize' Version
version ByteString
costModelEncoding)
    Language
PlutusV2 -> LangDepView
latestLangDepView
    Language
PlutusV3 -> LangDepView
latestLangDepView
  where
    -- LangDepView for PlutusV1 differs from the rest
    latestLangDepView :: LangDepView
latestLangDepView = ByteString -> ByteString -> LangDepView
LangDepView (Version -> Language -> ByteString
forall a. EncCBOR a => Version -> a -> ByteString
serialize' Version
version Language
lang) ByteString
costModelEncoding
    costModel :: Maybe CostModel
costModel = Language -> Map Language CostModel -> Maybe CostModel
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Language
lang (CostModels -> Map Language CostModel
costModelsValid (CostModels -> Map Language CostModel)
-> CostModels -> Map Language CostModel
forall a b. (a -> b) -> a -> b
$ PParams era
pp PParams era
-> Getting CostModels (PParams era) CostModels -> CostModels
forall s a. s -> Getting a s a -> a
^. Getting CostModels (PParams era) CostModels
forall era. AlonzoEraPParams era => Lens' (PParams era) CostModels
Lens' (PParams era) CostModels
ppCostModelsL)
    costModelEncoding :: ByteString
costModelEncoding = Version -> Encoding -> ByteString
forall a. EncCBOR a => Version -> a -> ByteString
serialize' Version
version (Encoding -> ByteString) -> Encoding -> ByteString
forall a b. (a -> b) -> a -> b
$ Encoding -> (CostModel -> Encoding) -> Maybe CostModel -> Encoding
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Encoding
encodeNull CostModel -> Encoding
encodeCostModel Maybe CostModel
costModel
    version :: Version
version = ProtVer -> Version
BT.pvMajor (ProtVer -> Version) -> ProtVer -> Version
forall a b. (a -> b) -> a -> b
$ PParams era
pp PParams era -> Getting ProtVer (PParams era) ProtVer -> ProtVer
forall s a. s -> Getting a s a -> a
^. Getting ProtVer (PParams era) ProtVer
forall era. EraPParams era => Lens' (PParams era) ProtVer
Lens' (PParams era) ProtVer
ppProtocolVersionL

encodeLangViews :: Set LangDepView -> Encoding
encodeLangViews :: Set LangDepView -> Encoding
encodeLangViews Set LangDepView
views = Word -> Encoding
encodeMapLen Word
n Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> (LangDepView -> Encoding) -> [LangDepView] -> Encoding
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap LangDepView -> Encoding
encPair [LangDepView]
ascending
  where
    n :: Word
n = Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Set LangDepView -> Int
forall a. Set a -> Int
Set.size Set LangDepView
views) :: Word
    ascending :: [LangDepView]
ascending = (LangDepView -> LangDepView -> Ordering)
-> [LangDepView] -> [LangDepView]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy (ByteString -> ByteString -> Ordering
shortLex (ByteString -> ByteString -> Ordering)
-> (LangDepView -> ByteString)
-> LangDepView
-> LangDepView
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` LangDepView -> ByteString
tag) ([LangDepView] -> [LangDepView]) -> [LangDepView] -> [LangDepView]
forall a b. (a -> b) -> a -> b
$ Set LangDepView -> [LangDepView]
forall a. Set a -> [a]
Set.toList Set LangDepView
views
    encPair :: LangDepView -> Encoding
encPair (LangDepView ByteString
k ByteString
v) = ByteString -> Encoding
encodePreEncoded ByteString
k Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> ByteString -> Encoding
encodePreEncoded ByteString
v
    shortLex :: ByteString -> ByteString -> Ordering
    shortLex :: ByteString -> ByteString -> Ordering
shortLex ByteString
a ByteString
b
      | ByteString -> Int
BS.length ByteString
a Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< ByteString -> Int
BS.length ByteString
b = Ordering
LT
      | ByteString -> Int
BS.length ByteString
a Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> ByteString -> Int
BS.length ByteString
b = Ordering
GT
      | Bool
otherwise = ByteString -> ByteString -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ByteString
a ByteString
b

-- | Given the missing pieces, turn a ShelleyPParams into a AlonzoPParams
upgradeAlonzoPParams ::
  forall f era1 era2.
  HKDFunctor f =>
  UpgradeAlonzoPParams f ->
  ShelleyPParams f era1 ->
  AlonzoPParams f era2
upgradeAlonzoPParams :: forall (f :: * -> *) era1 era2.
HKDFunctor f =>
UpgradeAlonzoPParams f
-> ShelleyPParams f era1 -> AlonzoPParams f era2
upgradeAlonzoPParams UpgradeAlonzoPParams {HKD f Natural
HKD f Prices
HKD f ExUnits
HKD f CostModels
HKD f CoinPerWord
uappCoinsPerUTxOWord :: forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f CoinPerWord
uappCostModels :: forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f CostModels
uappPrices :: forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f Prices
uappMaxTxExUnits :: forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f ExUnits
uappMaxBlockExUnits :: forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f ExUnits
uappMaxValSize :: forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f Natural
uappCollateralPercentage :: forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f Natural
uappMaxCollateralInputs :: forall (f :: * -> *). UpgradeAlonzoPParams f -> HKD f Natural
uappCoinsPerUTxOWord :: HKD f CoinPerWord
uappCostModels :: HKD f CostModels
uappPrices :: HKD f Prices
uappMaxTxExUnits :: HKD f ExUnits
uappMaxBlockExUnits :: HKD f ExUnits
uappMaxValSize :: HKD f Natural
uappCollateralPercentage :: HKD f Natural
uappMaxCollateralInputs :: HKD f Natural
..} ShelleyPParams {HKD f Word16
HKD f Word32
HKD f EpochInterval
HKD f Nonce
HKD f UnitInterval
HKD f NonNegativeInterval
HKD f ProtVer
HKD f Coin
sppMinFeeA :: HKD f Coin
sppMinFeeB :: HKD f Coin
sppMaxBBSize :: HKD f Word32
sppMaxTxSize :: HKD f Word32
sppMaxBHSize :: HKD f Word16
sppKeyDeposit :: HKD f Coin
sppPoolDeposit :: HKD f Coin
sppEMax :: HKD f EpochInterval
sppNOpt :: HKD f Word16
sppA0 :: HKD f NonNegativeInterval
sppRho :: HKD f UnitInterval
sppTau :: HKD f UnitInterval
sppD :: HKD f UnitInterval
sppExtraEntropy :: HKD f Nonce
sppProtocolVersion :: HKD f ProtVer
sppMinUTxOValue :: HKD f Coin
sppMinPoolCost :: HKD f Coin
sppMinFeeA :: forall (f :: * -> *) era. ShelleyPParams f era -> HKD f Coin
sppMinFeeB :: forall (f :: * -> *) era. ShelleyPParams f era -> HKD f Coin
sppMaxBBSize :: forall (f :: * -> *) era. ShelleyPParams f era -> HKD f Word32
sppMaxTxSize :: forall (f :: * -> *) era. ShelleyPParams f era -> HKD f Word32
sppMaxBHSize :: forall (f :: * -> *) era. ShelleyPParams f era -> HKD f Word16
sppKeyDeposit :: forall (f :: * -> *) era. ShelleyPParams f era -> HKD f Coin
sppPoolDeposit :: forall (f :: * -> *) era. ShelleyPParams f era -> HKD f Coin
sppEMax :: forall (f :: * -> *) era.
ShelleyPParams f era -> HKD f EpochInterval
sppNOpt :: forall (f :: * -> *) era. ShelleyPParams f era -> HKD f Word16
sppA0 :: forall (f :: * -> *) era.
ShelleyPParams f era -> HKD f NonNegativeInterval
sppRho :: forall (f :: * -> *) era.
ShelleyPParams f era -> HKD f UnitInterval
sppTau :: forall (f :: * -> *) era.
ShelleyPParams f era -> HKD f UnitInterval
sppD :: forall (f :: * -> *) era.
ShelleyPParams f era -> HKD f UnitInterval
sppExtraEntropy :: forall (f :: * -> *) era. ShelleyPParams f era -> HKD f Nonce
sppProtocolVersion :: forall (f :: * -> *) era. ShelleyPParams f era -> HKD f ProtVer
sppMinUTxOValue :: forall (f :: * -> *) era. ShelleyPParams f era -> HKD f Coin
sppMinPoolCost :: forall (f :: * -> *) era. ShelleyPParams f era -> HKD f Coin
..} =
  AlonzoPParams
    { appMinFeeA :: HKD f Coin
appMinFeeA = HKD f Coin
sppMinFeeA
    , appMinFeeB :: HKD f Coin
appMinFeeB = HKD f Coin
sppMinFeeB
    , appMaxBBSize :: HKD f Word32
appMaxBBSize = HKD f Word32
sppMaxBBSize
    , appMaxTxSize :: HKD f Word32
appMaxTxSize = HKD f Word32
sppMaxTxSize
    , appMaxBHSize :: HKD f Word16
appMaxBHSize = HKD f Word16
sppMaxBHSize
    , appKeyDeposit :: HKD f Coin
appKeyDeposit = HKD f Coin
sppKeyDeposit
    , appPoolDeposit :: HKD f Coin
appPoolDeposit = HKD f Coin
sppPoolDeposit
    , appEMax :: HKD f EpochInterval
appEMax = HKD f EpochInterval
sppEMax
    , appNOpt :: HKD f Word16
appNOpt = HKD f Word16
sppNOpt
    , appA0 :: HKD f NonNegativeInterval
appA0 = HKD f NonNegativeInterval
sppA0
    , appRho :: HKD f UnitInterval
appRho = HKD f UnitInterval
sppRho
    , appTau :: HKD f UnitInterval
appTau = HKD f UnitInterval
sppTau
    , appD :: HKD f UnitInterval
appD = HKD f UnitInterval
sppD
    , appExtraEntropy :: HKD f Nonce
appExtraEntropy = HKD f Nonce
sppExtraEntropy
    , appProtocolVersion :: HKD f ProtVer
appProtocolVersion = HKD f ProtVer
sppProtocolVersion
    , appMinPoolCost :: HKD f Coin
appMinPoolCost = HKD f Coin
sppMinPoolCost
    , -- new in alonzo
      appCoinsPerUTxOWord :: HKD f CoinPerWord
appCoinsPerUTxOWord = HKD f CoinPerWord
uappCoinsPerUTxOWord
    , appCostModels :: HKD f CostModels
appCostModels = HKD f CostModels
uappCostModels
    , appPrices :: HKD f Prices
appPrices = HKD f Prices
uappPrices
    , appMaxTxExUnits :: HKD f OrdExUnits
appMaxTxExUnits = Proxy f
-> (ExUnits -> OrdExUnits) -> HKD f ExUnits -> HKD f OrdExUnits
forall (f :: * -> *) (proxy :: (* -> *) -> *) a b.
HKDFunctor f =>
proxy f -> (a -> b) -> HKD f a -> HKD f b
forall (proxy :: (* -> *) -> *) a b.
proxy f -> (a -> b) -> HKD f a -> HKD f b
hkdMap (forall {k} (t :: k). Proxy t
forall (t :: * -> *). Proxy t
Proxy @f) ExUnits -> OrdExUnits
OrdExUnits HKD f ExUnits
uappMaxTxExUnits
    , appMaxBlockExUnits :: HKD f OrdExUnits
appMaxBlockExUnits = Proxy f
-> (ExUnits -> OrdExUnits) -> HKD f ExUnits -> HKD f OrdExUnits
forall (f :: * -> *) (proxy :: (* -> *) -> *) a b.
HKDFunctor f =>
proxy f -> (a -> b) -> HKD f a -> HKD f b
forall (proxy :: (* -> *) -> *) a b.
proxy f -> (a -> b) -> HKD f a -> HKD f b
hkdMap (forall {k} (t :: k). Proxy t
forall (t :: * -> *). Proxy t
Proxy @f) ExUnits -> OrdExUnits
OrdExUnits HKD f ExUnits
uappMaxBlockExUnits
    , appMaxValSize :: HKD f Natural
appMaxValSize = HKD f Natural
uappMaxValSize
    , appCollateralPercentage :: HKD f Natural
appCollateralPercentage = HKD f Natural
uappCollateralPercentage
    , appMaxCollateralInputs :: HKD f Natural
appMaxCollateralInputs = HKD f Natural
uappMaxCollateralInputs
    }

-- | Turn an AlonzoPParams into a ShelleyParams
downgradeAlonzoPParams :: DowngradeAlonzoPParams f -> AlonzoPParams f era2 -> ShelleyPParams f era1
downgradeAlonzoPParams :: forall (f :: * -> *) era2 era1.
DowngradeAlonzoPParams f
-> AlonzoPParams f era2 -> ShelleyPParams f era1
downgradeAlonzoPParams DowngradeAlonzoPParams {HKD f Coin
dappMinUTxOValue :: forall (f :: * -> *). DowngradeAlonzoPParams f -> HKD f Coin
dappMinUTxOValue :: HKD f Coin
dappMinUTxOValue} AlonzoPParams {HKD f Natural
HKD f Word16
HKD f Word32
HKD f EpochInterval
HKD f Nonce
HKD f UnitInterval
HKD f NonNegativeInterval
HKD f ProtVer
HKD f Coin
HKD f Prices
HKD f CostModels
HKD f OrdExUnits
HKD f CoinPerWord
appMinFeeA :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appMinFeeB :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appMaxBBSize :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word32
appMaxTxSize :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word32
appMaxBHSize :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word16
appKeyDeposit :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appPoolDeposit :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appEMax :: forall (f :: * -> *) era.
AlonzoPParams f era -> HKD f EpochInterval
appNOpt :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Word16
appA0 :: forall (f :: * -> *) era.
AlonzoPParams f era -> HKD f NonNegativeInterval
appRho :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f UnitInterval
appTau :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f UnitInterval
appD :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f UnitInterval
appExtraEntropy :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Nonce
appProtocolVersion :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f ProtVer
appMinPoolCost :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Coin
appCoinsPerUTxOWord :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f CoinPerWord
appCostModels :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f CostModels
appPrices :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Prices
appMaxTxExUnits :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f OrdExUnits
appMaxBlockExUnits :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f OrdExUnits
appMaxValSize :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Natural
appCollateralPercentage :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Natural
appMaxCollateralInputs :: forall (f :: * -> *) era. AlonzoPParams f era -> HKD f Natural
appMinFeeA :: HKD f Coin
appMinFeeB :: HKD f Coin
appMaxBBSize :: HKD f Word32
appMaxTxSize :: HKD f Word32
appMaxBHSize :: HKD f Word16
appKeyDeposit :: HKD f Coin
appPoolDeposit :: HKD f Coin
appEMax :: HKD f EpochInterval
appNOpt :: HKD f Word16
appA0 :: HKD f NonNegativeInterval
appRho :: HKD f UnitInterval
appTau :: HKD f UnitInterval
appD :: HKD f UnitInterval
appExtraEntropy :: HKD f Nonce
appProtocolVersion :: HKD f ProtVer
appMinPoolCost :: HKD f Coin
appCoinsPerUTxOWord :: HKD f CoinPerWord
appCostModels :: HKD f CostModels
appPrices :: HKD f Prices
appMaxTxExUnits :: HKD f OrdExUnits
appMaxBlockExUnits :: HKD f OrdExUnits
appMaxValSize :: HKD f Natural
appCollateralPercentage :: HKD f Natural
appMaxCollateralInputs :: HKD f Natural
..} =
  ShelleyPParams
    { sppMinFeeA :: HKD f Coin
sppMinFeeA = HKD f Coin
appMinFeeA
    , sppMinFeeB :: HKD f Coin
sppMinFeeB = HKD f Coin
appMinFeeB
    , sppMaxBBSize :: HKD f Word32
sppMaxBBSize = HKD f Word32
appMaxBBSize
    , sppMaxTxSize :: HKD f Word32
sppMaxTxSize = HKD f Word32
appMaxTxSize
    , sppMaxBHSize :: HKD f Word16
sppMaxBHSize = HKD f Word16
appMaxBHSize
    , sppKeyDeposit :: HKD f Coin
sppKeyDeposit = HKD f Coin
appKeyDeposit
    , sppPoolDeposit :: HKD f Coin
sppPoolDeposit = HKD f Coin
appPoolDeposit
    , sppEMax :: HKD f EpochInterval
sppEMax = HKD f EpochInterval
appEMax
    , sppNOpt :: HKD f Word16
sppNOpt = HKD f Word16
appNOpt
    , sppA0 :: HKD f NonNegativeInterval
sppA0 = HKD f NonNegativeInterval
appA0
    , sppRho :: HKD f UnitInterval
sppRho = HKD f UnitInterval
appRho
    , sppTau :: HKD f UnitInterval
sppTau = HKD f UnitInterval
appTau
    , sppD :: HKD f UnitInterval
sppD = HKD f UnitInterval
appD
    , sppExtraEntropy :: HKD f Nonce
sppExtraEntropy = HKD f Nonce
appExtraEntropy
    , sppProtocolVersion :: HKD f ProtVer
sppProtocolVersion = HKD f ProtVer
appProtocolVersion
    , sppMinUTxOValue :: HKD f Coin
sppMinUTxOValue = HKD f Coin
dappMinUTxOValue -- <- parameter that was dropped in Alonzo
    , sppMinPoolCost :: HKD f Coin
sppMinPoolCost = HKD f Coin
appMinPoolCost
    }

ppCoinsPerUTxOWord :: (AlonzoEraPParams era, ExactEra AlonzoEra era) => PParam era
ppCoinsPerUTxOWord :: forall era.
(AlonzoEraPParams era, ExactEra AlonzoEra era) =>
PParam era
ppCoinsPerUTxOWord =
  PParam
    { ppName :: Text
ppName = Text
"utxoCostPerByte"
    , ppLens :: Lens' (PParams era) CoinPerWord
ppLens = (CoinPerWord -> f CoinPerWord) -> PParams era -> f (PParams era)
forall era.
(AlonzoEraPParams era, ExactEra AlonzoEra era) =>
Lens' (PParams era) CoinPerWord
Lens' (PParams era) CoinPerWord
ppCoinsPerUTxOWordL
    , ppUpdate :: Maybe (PParamUpdate era CoinPerWord)
ppUpdate = PParamUpdate era CoinPerWord
-> Maybe (PParamUpdate era CoinPerWord)
forall a. a -> Maybe a
Just (PParamUpdate era CoinPerWord
 -> Maybe (PParamUpdate era CoinPerWord))
-> PParamUpdate era CoinPerWord
-> Maybe (PParamUpdate era CoinPerWord)
forall a b. (a -> b) -> a -> b
$ Word
-> Lens' (PParamsUpdate era) (StrictMaybe CoinPerWord)
-> PParamUpdate era CoinPerWord
forall era t.
Word
-> Lens' (PParamsUpdate era) (StrictMaybe t) -> PParamUpdate era t
PParamUpdate Word
17 (StrictMaybe CoinPerWord -> f (StrictMaybe CoinPerWord))
-> PParamsUpdate era -> f (PParamsUpdate era)
forall era.
(AlonzoEraPParams era, ExactEra AlonzoEra era) =>
Lens' (PParamsUpdate era) (StrictMaybe CoinPerWord)
Lens' (PParamsUpdate era) (StrictMaybe CoinPerWord)
ppuCoinsPerUTxOWordL
    }

ppCostModels :: AlonzoEraPParams era => PParam era
ppCostModels :: forall era. AlonzoEraPParams era => PParam era
ppCostModels =
  PParam
    { ppName :: Text
ppName = Text
"costModels"
    , ppLens :: Lens' (PParams era) CostModels
ppLens = (CostModels -> f CostModels) -> PParams era -> f (PParams era)
forall era. AlonzoEraPParams era => Lens' (PParams era) CostModels
Lens' (PParams era) CostModels
ppCostModelsL
    , ppUpdate :: Maybe (PParamUpdate era CostModels)
ppUpdate = PParamUpdate era CostModels -> Maybe (PParamUpdate era CostModels)
forall a. a -> Maybe a
Just (PParamUpdate era CostModels
 -> Maybe (PParamUpdate era CostModels))
-> PParamUpdate era CostModels
-> Maybe (PParamUpdate era CostModels)
forall a b. (a -> b) -> a -> b
$ Word
-> Lens' (PParamsUpdate era) (StrictMaybe CostModels)
-> PParamUpdate era CostModels
forall era t.
Word
-> Lens' (PParamsUpdate era) (StrictMaybe t) -> PParamUpdate era t
PParamUpdate Word
18 (StrictMaybe CostModels -> f (StrictMaybe CostModels))
-> PParamsUpdate era -> f (PParamsUpdate era)
forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe CostModels)
Lens' (PParamsUpdate era) (StrictMaybe CostModels)
ppuCostModelsL
    }

ppPrices :: AlonzoEraPParams era => PParam era
ppPrices :: forall era. AlonzoEraPParams era => PParam era
ppPrices =
  PParam
    { ppName :: Text
ppName = Text
"executionUnitPrices"
    , ppLens :: Lens' (PParams era) Prices
ppLens = (Prices -> f Prices) -> PParams era -> f (PParams era)
forall era. AlonzoEraPParams era => Lens' (PParams era) Prices
Lens' (PParams era) Prices
ppPricesL
    , ppUpdate :: Maybe (PParamUpdate era Prices)
ppUpdate = PParamUpdate era Prices -> Maybe (PParamUpdate era Prices)
forall a. a -> Maybe a
Just (PParamUpdate era Prices -> Maybe (PParamUpdate era Prices))
-> PParamUpdate era Prices -> Maybe (PParamUpdate era Prices)
forall a b. (a -> b) -> a -> b
$ Word
-> Lens' (PParamsUpdate era) (StrictMaybe Prices)
-> PParamUpdate era Prices
forall era t.
Word
-> Lens' (PParamsUpdate era) (StrictMaybe t) -> PParamUpdate era t
PParamUpdate Word
19 (StrictMaybe Prices -> f (StrictMaybe Prices))
-> PParamsUpdate era -> f (PParamsUpdate era)
forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Prices)
Lens' (PParamsUpdate era) (StrictMaybe Prices)
ppuPricesL
    }

ppMaxTxExUnits :: AlonzoEraPParams era => PParam era
ppMaxTxExUnits :: forall era. AlonzoEraPParams era => PParam era
ppMaxTxExUnits =
  PParam
    { ppName :: Text
ppName = Text
"maxTxExecutionUnits"
    , ppLens :: Lens' (PParams era) ExUnits
ppLens = (ExUnits -> f ExUnits) -> PParams era -> f (PParams era)
forall era. AlonzoEraPParams era => Lens' (PParams era) ExUnits
Lens' (PParams era) ExUnits
ppMaxTxExUnitsL
    , ppUpdate :: Maybe (PParamUpdate era ExUnits)
ppUpdate = PParamUpdate era ExUnits -> Maybe (PParamUpdate era ExUnits)
forall a. a -> Maybe a
Just (PParamUpdate era ExUnits -> Maybe (PParamUpdate era ExUnits))
-> PParamUpdate era ExUnits -> Maybe (PParamUpdate era ExUnits)
forall a b. (a -> b) -> a -> b
$ Word
-> Lens' (PParamsUpdate era) (StrictMaybe ExUnits)
-> PParamUpdate era ExUnits
forall era t.
Word
-> Lens' (PParamsUpdate era) (StrictMaybe t) -> PParamUpdate era t
PParamUpdate Word
20 (StrictMaybe ExUnits -> f (StrictMaybe ExUnits))
-> PParamsUpdate era -> f (PParamsUpdate era)
forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe ExUnits)
Lens' (PParamsUpdate era) (StrictMaybe ExUnits)
ppuMaxTxExUnitsL
    }

ppMaxBlockExUnits :: AlonzoEraPParams era => PParam era
ppMaxBlockExUnits :: forall era. AlonzoEraPParams era => PParam era
ppMaxBlockExUnits =
  PParam
    { ppName :: Text
ppName = Text
"maxBlockExecutionUnits"
    , ppLens :: Lens' (PParams era) ExUnits
ppLens = (ExUnits -> f ExUnits) -> PParams era -> f (PParams era)
forall era. AlonzoEraPParams era => Lens' (PParams era) ExUnits
Lens' (PParams era) ExUnits
ppMaxBlockExUnitsL
    , ppUpdate :: Maybe (PParamUpdate era ExUnits)
ppUpdate = PParamUpdate era ExUnits -> Maybe (PParamUpdate era ExUnits)
forall a. a -> Maybe a
Just (PParamUpdate era ExUnits -> Maybe (PParamUpdate era ExUnits))
-> PParamUpdate era ExUnits -> Maybe (PParamUpdate era ExUnits)
forall a b. (a -> b) -> a -> b
$ Word
-> Lens' (PParamsUpdate era) (StrictMaybe ExUnits)
-> PParamUpdate era ExUnits
forall era t.
Word
-> Lens' (PParamsUpdate era) (StrictMaybe t) -> PParamUpdate era t
PParamUpdate Word
21 (StrictMaybe ExUnits -> f (StrictMaybe ExUnits))
-> PParamsUpdate era -> f (PParamsUpdate era)
forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe ExUnits)
Lens' (PParamsUpdate era) (StrictMaybe ExUnits)
ppuMaxBlockExUnitsL
    }

ppMaxValSize :: AlonzoEraPParams era => PParam era
ppMaxValSize :: forall era. AlonzoEraPParams era => PParam era
ppMaxValSize =
  PParam
    { ppName :: Text
ppName = Text
"maxValueSize"
    , ppLens :: Lens' (PParams era) Natural
ppLens = (Natural -> f Natural) -> PParams era -> f (PParams era)
forall era. AlonzoEraPParams era => Lens' (PParams era) Natural
Lens' (PParams era) Natural
ppMaxValSizeL
    , ppUpdate :: Maybe (PParamUpdate era Natural)
ppUpdate = PParamUpdate era Natural -> Maybe (PParamUpdate era Natural)
forall a. a -> Maybe a
Just (PParamUpdate era Natural -> Maybe (PParamUpdate era Natural))
-> PParamUpdate era Natural -> Maybe (PParamUpdate era Natural)
forall a b. (a -> b) -> a -> b
$ Word
-> Lens' (PParamsUpdate era) (StrictMaybe Natural)
-> PParamUpdate era Natural
forall era t.
Word
-> Lens' (PParamsUpdate era) (StrictMaybe t) -> PParamUpdate era t
PParamUpdate Word
22 (StrictMaybe Natural -> f (StrictMaybe Natural))
-> PParamsUpdate era -> f (PParamsUpdate era)
forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Natural)
Lens' (PParamsUpdate era) (StrictMaybe Natural)
ppuMaxValSizeL
    }

ppCollateralPercentage :: AlonzoEraPParams era => PParam era
ppCollateralPercentage :: forall era. AlonzoEraPParams era => PParam era
ppCollateralPercentage =
  PParam
    { ppName :: Text
ppName = Text
"collateralPercentage"
    , ppLens :: Lens' (PParams era) Natural
ppLens = (Natural -> f Natural) -> PParams era -> f (PParams era)
forall era. AlonzoEraPParams era => Lens' (PParams era) Natural
Lens' (PParams era) Natural
ppCollateralPercentageL
    , ppUpdate :: Maybe (PParamUpdate era Natural)
ppUpdate = PParamUpdate era Natural -> Maybe (PParamUpdate era Natural)
forall a. a -> Maybe a
Just (PParamUpdate era Natural -> Maybe (PParamUpdate era Natural))
-> PParamUpdate era Natural -> Maybe (PParamUpdate era Natural)
forall a b. (a -> b) -> a -> b
$ Word
-> Lens' (PParamsUpdate era) (StrictMaybe Natural)
-> PParamUpdate era Natural
forall era t.
Word
-> Lens' (PParamsUpdate era) (StrictMaybe t) -> PParamUpdate era t
PParamUpdate Word
23 (StrictMaybe Natural -> f (StrictMaybe Natural))
-> PParamsUpdate era -> f (PParamsUpdate era)
forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Natural)
Lens' (PParamsUpdate era) (StrictMaybe Natural)
ppuCollateralPercentageL
    }

ppMaxCollateralInputs :: AlonzoEraPParams era => PParam era
ppMaxCollateralInputs :: forall era. AlonzoEraPParams era => PParam era
ppMaxCollateralInputs =
  PParam
    { ppName :: Text
ppName = Text
"maxCollateralInputs"
    , ppLens :: Lens' (PParams era) Natural
ppLens = (Natural -> f Natural) -> PParams era -> f (PParams era)
forall era. AlonzoEraPParams era => Lens' (PParams era) Natural
Lens' (PParams era) Natural
ppMaxCollateralInputsL
    , ppUpdate :: Maybe (PParamUpdate era Natural)
ppUpdate = PParamUpdate era Natural -> Maybe (PParamUpdate era Natural)
forall a. a -> Maybe a
Just (PParamUpdate era Natural -> Maybe (PParamUpdate era Natural))
-> PParamUpdate era Natural -> Maybe (PParamUpdate era Natural)
forall a b. (a -> b) -> a -> b
$ Word
-> Lens' (PParamsUpdate era) (StrictMaybe Natural)
-> PParamUpdate era Natural
forall era t.
Word
-> Lens' (PParamsUpdate era) (StrictMaybe t) -> PParamUpdate era t
PParamUpdate Word
24 (StrictMaybe Natural -> f (StrictMaybe Natural))
-> PParamsUpdate era -> f (PParamsUpdate era)
forall era.
AlonzoEraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Natural)
Lens' (PParamsUpdate era) (StrictMaybe Natural)
ppuMaxCollateralInputsL
    }