{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}

{- HLINT ignore "Redundant ==" -}

-- | The various Cardano protocol parameters, including:
--
-- * the current values of updatable protocol parameters: 'ProtocolParameters'
-- * updates to protocol parameters: 'ProtocolParametersUpdate'
-- * update proposals that can be embedded in transactions: 'UpdateProposal'
-- * parameters fixed in the genesis file: 'GenesisParameters'
--
module Cardano.Api.ProtocolParameters (
    -- * The updatable protocol parameters
    ProtocolParameters(..),
    checkProtocolParameters,
    ProtocolParametersError(..),
    EpochNo,
    BundledProtocolParameters(..),
    bundleProtocolParams,
    unbundleProtocolParams,
    unbundleLedgerShelleyBasedProtocolParams,

    -- * Updates to the protocol parameters
    ProtocolParametersUpdate(..),

    -- * PraosNonce
    PraosNonce,
    makePraosNonce,

    -- * Execution units, prices and cost models,
    ExecutionUnits(..),
    ExecutionUnitPrices(..),
    CostModel(..),
    validateCostModel,
    fromAlonzoCostModels,

    -- * Update proposals to change the protocol parameters
    UpdateProposal(..),
    makeShelleyUpdateProposal,

    -- * Internal conversion functions
    toLedgerNonce,
    toLedgerUpdate,
    fromLedgerUpdate,
    toLedgerProposedPPUpdates,
    fromLedgerProposedPPUpdates,
    toLedgerPParams,
    fromLedgerPParams,
    fromShelleyPParams,
    toAlonzoPrices,
    fromAlonzoPrices,
    toAlonzoScriptLanguage,
    fromAlonzoScriptLanguage,
    toAlonzoCostModel,
    fromAlonzoCostModel,
    toAlonzoCostModels,
    toAlonzoPParams,
    toBabbagePParams,
    toConwayPParams,

    -- * Data family instances
    AsType(..),
  ) where

import           Control.Applicative ((<|>))
import           Control.Monad
import           Data.Aeson (FromJSON (..), ToJSON (..), object, withObject, (.!=), (.:), (.:?),
                   (.=))
import           Data.Bifunctor (bimap, first)
import           Data.ByteString (ByteString)
import           Data.Either.Combinators (maybeToRight)
import           Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import           Data.Maybe (fromMaybe, isJust)
import           Data.String (IsString)
import           Data.Text (Text)
import           GHC.Generics
import           Numeric.Natural

import           Cardano.Api.Json (toRationalJSON)
import qualified Cardano.Binary as CBOR
import qualified Cardano.Crypto.Hash.Class as Crypto
import           Cardano.Slotting.Slot (EpochNo)

import           Cardano.Ledger.Babbage.PParams (BabbagePParams, BabbagePParamsHKD (..),
                   BabbagePParamsUpdate)
import           Cardano.Ledger.BaseTypes (strictMaybeToMaybe)
import qualified Cardano.Ledger.BaseTypes as Ledger
import qualified Cardano.Ledger.Core as Ledger
import           Cardano.Ledger.Crypto (StandardCrypto)
import qualified Cardano.Ledger.Keys as Ledger

-- Some of the things from Cardano.Ledger.ShelleyPParams are generic across all
-- eras, and some are specific to the Shelley era (and other pre-Alonzo eras).
-- So we import in twice under different names.

import qualified Cardano.Ledger.Alonzo.Language as Alonzo
import           Cardano.Ledger.Alonzo.PParams (AlonzoPParams, AlonzoPParamsHKD (..),
                   AlonzoPParamsUpdate)
import qualified Cardano.Ledger.Alonzo.Scripts as Alonzo
import qualified Cardano.Ledger.Shelley.API as Ledger hiding (PParams)
import           Cardano.Ledger.Shelley.PParams (ShelleyPParams, ShelleyPParamsHKD (..),
                   ShelleyPParamsUpdate)

import           Text.PrettyBy.Default (display)

import           Cardano.Api.Address
import           Cardano.Api.Eras
import           Cardano.Api.Error
import           Cardano.Api.Hash
import           Cardano.Api.HasTypeProxy
import           Cardano.Api.Keys.Byron
import           Cardano.Api.Keys.Shelley
import           Cardano.Api.Script
import           Cardano.Api.SerialiseCBOR
import           Cardano.Api.SerialiseRaw
import           Cardano.Api.SerialiseTextEnvelope
import           Cardano.Api.SerialiseUsing
import           Cardano.Api.StakePoolMetadata
import           Cardano.Api.TxMetadata
import           Cardano.Api.Utils
import           Cardano.Api.Value

-- | The values of the set of /updatable/ protocol parameters. At any
-- particular point on the chain there is a current set of parameters in use.
--
-- These parameters can be updated (at epoch boundaries) via an
-- 'UpdateProposal', which contains a 'ProtocolParametersUpdate'.
--
-- The 'ProtocolParametersUpdate' is essentially a diff for the
-- 'ProtocolParameters'.
--
-- There are also parameters fixed in the Genesis file. See 'GenesisParameters'.
--
data ProtocolParameters =
     ProtocolParameters {

       -- | Protocol version, major and minor. Updating the major version is
       -- used to trigger hard forks.
       --                              (Major  , Minor  )
       ProtocolParameters -> (Natural, Natural)
protocolParamProtocolVersion :: (Natural, Natural),

       -- | The decentralization parameter. This is fraction of slots that
       -- belong to the BFT overlay schedule, rather than the Praos schedule.
       -- So 1 means fully centralised, while 0 means fully decentralised.
       --
       -- This is the \"d\" parameter from the design document.
       --
       -- /Deprecated in Babbage/
       ProtocolParameters -> Maybe Rational
protocolParamDecentralization :: Maybe Rational,

       -- | Extra entropy for the Praos per-epoch nonce.
       --
       -- This can be used to add extra entropy during the decentralisation
       -- process. If the extra entropy can be demonstrated to be generated
       -- randomly then this method can be used to show that the initial
       -- federated operators did not subtly bias the initial schedule so that
       -- they retain undue influence after decentralisation.
       --
       ProtocolParameters -> Maybe PraosNonce
protocolParamExtraPraosEntropy :: Maybe PraosNonce,

       -- | The maximum permitted size of a block header.
       --
       -- This must be at least as big as the largest legitimate block headers
       -- but should not be too much larger, to help prevent DoS attacks.
       --
       -- Caution: setting this to be smaller than legitimate block headers is
       -- a sure way to brick the system!
       --
       ProtocolParameters -> Natural
protocolParamMaxBlockHeaderSize :: Natural,

       -- | The maximum permitted size of the block body (that is, the block
       -- payload, without the block header).
       --
       -- This should be picked with the Praos network delta security parameter
       -- in mind. Making this too large can severely weaken the Praos
       -- consensus properties.
       --
       -- Caution: setting this to be smaller than a transaction that can
       -- change the protocol parameters is a sure way to brick the system!
       --
       ProtocolParameters -> Natural
protocolParamMaxBlockBodySize :: Natural,

       -- | The maximum permitted size of a transaction.
       --
       -- Typically this should not be too high a fraction of the block size,
       -- otherwise wastage from block fragmentation becomes a problem, and
       -- the current implementation does not use any sophisticated box packing
       -- algorithm.
       --
       ProtocolParameters -> Natural
protocolParamMaxTxSize :: Natural,

       -- | The constant factor for the minimum fee calculation.
       --
       ProtocolParameters -> Natural
protocolParamTxFeeFixed :: Natural,

       -- | The linear factor for the minimum fee calculation.
       --
       ProtocolParameters -> Natural
protocolParamTxFeePerByte :: Natural,

       -- | The minimum permitted value for new UTxO entries, ie for
       -- transaction outputs.
       --
       ProtocolParameters -> Maybe Lovelace
protocolParamMinUTxOValue :: Maybe Lovelace,

       -- | The deposit required to register a stake address.
       --
       ProtocolParameters -> Lovelace
protocolParamStakeAddressDeposit :: Lovelace,

       -- | The deposit required to register a stake pool.
       --
       ProtocolParameters -> Lovelace
protocolParamStakePoolDeposit :: Lovelace,

       -- | The minimum value that stake pools are permitted to declare for
       -- their cost parameter.
       --
       ProtocolParameters -> Lovelace
protocolParamMinPoolCost :: Lovelace,

       -- | The maximum number of epochs into the future that stake pools
       -- are permitted to schedule a retirement.
       --
       ProtocolParameters -> EpochNo
protocolParamPoolRetireMaxEpoch :: EpochNo,

       -- | The equilibrium target number of stake pools.
       --
       -- This is the \"k\" incentives parameter from the design document.
       --
       ProtocolParameters -> Natural
protocolParamStakePoolTargetNum :: Natural,

       -- | The influence of the pledge in stake pool rewards.
       --
       -- This is the \"a_0\" incentives parameter from the design document.
       --
       ProtocolParameters -> Rational
protocolParamPoolPledgeInfluence :: Rational,

       -- | The monetary expansion rate. This determines the fraction of the
       -- reserves that are added to the fee pot each epoch.
       --
       -- This is the \"rho\" incentives parameter from the design document.
       --
       ProtocolParameters -> Rational
protocolParamMonetaryExpansion :: Rational,

       -- | The fraction of the fee pot each epoch that goes to the treasury.
       --
       -- This is the \"tau\" incentives parameter from the design document.
       --
       ProtocolParameters -> Rational
protocolParamTreasuryCut :: Rational,

       -- | Cost in ada per word of UTxO storage.
       --
       -- /Introduced in Alonzo/
       ProtocolParameters -> Maybe Lovelace
protocolParamUTxOCostPerWord :: Maybe Lovelace,

       -- | Cost models for script languages that use them.
       --
       -- /Introduced in Alonzo/
       ProtocolParameters -> Map AnyPlutusScriptVersion CostModel
protocolParamCostModels :: Map AnyPlutusScriptVersion CostModel,

       -- | Price of execution units for script languages that use them.
       --
       -- /Introduced in Alonzo/
       ProtocolParameters -> Maybe ExecutionUnitPrices
protocolParamPrices :: Maybe ExecutionUnitPrices,

       -- | Max total script execution resources units allowed per tx
       --
       -- /Introduced in Alonzo/
       ProtocolParameters -> Maybe ExecutionUnits
protocolParamMaxTxExUnits :: Maybe ExecutionUnits,

       -- | Max total script execution resources units allowed per block
       --
       -- /Introduced in Alonzo/
       ProtocolParameters -> Maybe ExecutionUnits
protocolParamMaxBlockExUnits :: Maybe ExecutionUnits,

       -- | Max size of a Value in a tx output.
       --
       -- /Introduced in Alonzo/
       ProtocolParameters -> Maybe Natural
protocolParamMaxValueSize :: Maybe Natural,

       -- | The percentage of the script contribution to the txfee that must be
       -- provided as collateral inputs when including Plutus scripts.
       --
       -- /Introduced in Alonzo/
       ProtocolParameters -> Maybe Natural
protocolParamCollateralPercent :: Maybe Natural,

       -- | The maximum number of collateral inputs allowed in a transaction.
       --
       -- /Introduced in Alonzo/
       ProtocolParameters -> Maybe Natural
protocolParamMaxCollateralInputs :: Maybe Natural,

       -- | Cost in ada per byte of UTxO storage.
       --
       -- /Introduced in Babbage/
       ProtocolParameters -> Maybe Lovelace
protocolParamUTxOCostPerByte :: Maybe Lovelace

    }
  deriving (ProtocolParameters -> ProtocolParameters -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProtocolParameters -> ProtocolParameters -> Bool
$c/= :: ProtocolParameters -> ProtocolParameters -> Bool
== :: ProtocolParameters -> ProtocolParameters -> Bool
$c== :: ProtocolParameters -> ProtocolParameters -> Bool
Eq, forall x. Rep ProtocolParameters x -> ProtocolParameters
forall x. ProtocolParameters -> Rep ProtocolParameters x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProtocolParameters x -> ProtocolParameters
$cfrom :: forall x. ProtocolParameters -> Rep ProtocolParameters x
Generic, Int -> ProtocolParameters -> ShowS
[ProtocolParameters] -> ShowS
ProtocolParameters -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProtocolParameters] -> ShowS
$cshowList :: [ProtocolParameters] -> ShowS
show :: ProtocolParameters -> String
$cshow :: ProtocolParameters -> String
showsPrec :: Int -> ProtocolParameters -> ShowS
$cshowsPrec :: Int -> ProtocolParameters -> ShowS
Show)

instance FromJSON ProtocolParameters where
  parseJSON :: Value -> Parser ProtocolParameters
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ProtocolParameters" forall a b. (a -> b) -> a -> b
$ \Object
o -> do
      Object
v <- Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"protocolVersion"
      (Natural, Natural)
-> Maybe Rational
-> Maybe PraosNonce
-> Natural
-> Natural
-> Natural
-> Natural
-> Natural
-> Maybe Lovelace
-> Lovelace
-> Lovelace
-> Lovelace
-> EpochNo
-> Natural
-> Rational
-> Rational
-> Rational
-> Maybe Lovelace
-> Map AnyPlutusScriptVersion CostModel
-> Maybe ExecutionUnitPrices
-> Maybe ExecutionUnits
-> Maybe ExecutionUnits
-> Maybe Natural
-> Maybe Natural
-> Maybe Natural
-> Maybe Lovelace
-> ProtocolParameters
ProtocolParameters
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"major" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"minor")
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"decentralization"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"extraPraosEntropy"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"maxBlockHeaderSize"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"maxBlockBodySize"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"maxTxSize"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"txFeeFixed"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"txFeePerByte"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"minUTxOValue"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"stakeAddressDeposit"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"stakePoolDeposit"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"minPoolCost"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"poolRetireMaxEpoch"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"stakePoolTargetNum"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"poolPledgeInfluence"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"monetaryExpansion"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"treasuryCut"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"utxoCostPerWord"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"costModels" forall a. Parser (Maybe a) -> a -> Parser a
.!= forall k a. Map k a
Map.empty
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"executionUnitPrices"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"maxTxExecutionUnits"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"maxBlockExecutionUnits"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"maxValueSize"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"collateralPercentage"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"maxCollateralInputs"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"utxoCostPerByte"

instance ToJSON ProtocolParameters where
  toJSON :: ProtocolParameters -> Value
toJSON ProtocolParameters{Natural
Maybe Natural
Maybe Rational
Maybe ExecutionUnits
Maybe Lovelace
Maybe ExecutionUnitPrices
Maybe PraosNonce
Rational
(Natural, Natural)
Map AnyPlutusScriptVersion CostModel
EpochNo
Lovelace
protocolParamUTxOCostPerByte :: Maybe Lovelace
protocolParamMaxCollateralInputs :: Maybe Natural
protocolParamCollateralPercent :: Maybe Natural
protocolParamMaxValueSize :: Maybe Natural
protocolParamMaxBlockExUnits :: Maybe ExecutionUnits
protocolParamMaxTxExUnits :: Maybe ExecutionUnits
protocolParamPrices :: Maybe ExecutionUnitPrices
protocolParamCostModels :: Map AnyPlutusScriptVersion CostModel
protocolParamUTxOCostPerWord :: Maybe Lovelace
protocolParamTreasuryCut :: Rational
protocolParamMonetaryExpansion :: Rational
protocolParamPoolPledgeInfluence :: Rational
protocolParamStakePoolTargetNum :: Natural
protocolParamPoolRetireMaxEpoch :: EpochNo
protocolParamMinPoolCost :: Lovelace
protocolParamStakePoolDeposit :: Lovelace
protocolParamStakeAddressDeposit :: Lovelace
protocolParamMinUTxOValue :: Maybe Lovelace
protocolParamTxFeePerByte :: Natural
protocolParamTxFeeFixed :: Natural
protocolParamMaxTxSize :: Natural
protocolParamMaxBlockBodySize :: Natural
protocolParamMaxBlockHeaderSize :: Natural
protocolParamExtraPraosEntropy :: Maybe PraosNonce
protocolParamDecentralization :: Maybe Rational
protocolParamProtocolVersion :: (Natural, Natural)
protocolParamUTxOCostPerByte :: ProtocolParameters -> Maybe Lovelace
protocolParamMaxCollateralInputs :: ProtocolParameters -> Maybe Natural
protocolParamCollateralPercent :: ProtocolParameters -> Maybe Natural
protocolParamMaxValueSize :: ProtocolParameters -> Maybe Natural
protocolParamMaxBlockExUnits :: ProtocolParameters -> Maybe ExecutionUnits
protocolParamMaxTxExUnits :: ProtocolParameters -> Maybe ExecutionUnits
protocolParamPrices :: ProtocolParameters -> Maybe ExecutionUnitPrices
protocolParamCostModels :: ProtocolParameters -> Map AnyPlutusScriptVersion CostModel
protocolParamUTxOCostPerWord :: ProtocolParameters -> Maybe Lovelace
protocolParamTreasuryCut :: ProtocolParameters -> Rational
protocolParamMonetaryExpansion :: ProtocolParameters -> Rational
protocolParamPoolPledgeInfluence :: ProtocolParameters -> Rational
protocolParamStakePoolTargetNum :: ProtocolParameters -> Natural
protocolParamPoolRetireMaxEpoch :: ProtocolParameters -> EpochNo
protocolParamMinPoolCost :: ProtocolParameters -> Lovelace
protocolParamStakePoolDeposit :: ProtocolParameters -> Lovelace
protocolParamStakeAddressDeposit :: ProtocolParameters -> Lovelace
protocolParamMinUTxOValue :: ProtocolParameters -> Maybe Lovelace
protocolParamTxFeePerByte :: ProtocolParameters -> Natural
protocolParamTxFeeFixed :: ProtocolParameters -> Natural
protocolParamMaxTxSize :: ProtocolParameters -> Natural
protocolParamMaxBlockBodySize :: ProtocolParameters -> Natural
protocolParamMaxBlockHeaderSize :: ProtocolParameters -> Natural
protocolParamExtraPraosEntropy :: ProtocolParameters -> Maybe PraosNonce
protocolParamDecentralization :: ProtocolParameters -> Maybe Rational
protocolParamProtocolVersion :: ProtocolParameters -> (Natural, Natural)
..} =
    [Pair] -> Value
object
      [ Key
"extraPraosEntropy"   forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe PraosNonce
protocolParamExtraPraosEntropy
      , Key
"stakePoolTargetNum"  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Natural
protocolParamStakePoolTargetNum
      , Key
"minUTxOValue"        forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Lovelace
protocolParamMinUTxOValue
      , Key
"poolRetireMaxEpoch"  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= EpochNo
protocolParamPoolRetireMaxEpoch
      , Key
"decentralization"    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (Rational -> Value
toRationalJSON forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Rational
protocolParamDecentralization)
      , Key
"stakePoolDeposit"    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Lovelace
protocolParamStakePoolDeposit
      , Key
"maxBlockHeaderSize"  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Natural
protocolParamMaxBlockHeaderSize
      , Key
"maxBlockBodySize"    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Natural
protocolParamMaxBlockBodySize
      , Key
"maxTxSize"           forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Natural
protocolParamMaxTxSize
      , Key
"treasuryCut"         forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Rational -> Value
toRationalJSON Rational
protocolParamTreasuryCut
      , Key
"minPoolCost"         forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Lovelace
protocolParamMinPoolCost
      , Key
"monetaryExpansion"   forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Rational -> Value
toRationalJSON Rational
protocolParamMonetaryExpansion
      , Key
"stakeAddressDeposit" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Lovelace
protocolParamStakeAddressDeposit
      , Key
"poolPledgeInfluence" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Rational -> Value
toRationalJSON Rational
protocolParamPoolPledgeInfluence
      , Key
"protocolVersion"     forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= let (Natural
major, Natural
minor) = (Natural, Natural)
protocolParamProtocolVersion
                                  in [Pair] -> Value
object [Key
"major" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Natural
major, Key
"minor" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Natural
minor]
      , Key
"txFeeFixed"          forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Natural
protocolParamTxFeeFixed
      , Key
"txFeePerByte"        forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Natural
protocolParamTxFeePerByte
      -- Alonzo era:
      , Key
"utxoCostPerWord"        forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Lovelace
protocolParamUTxOCostPerWord
      , Key
"costModels"             forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Map AnyPlutusScriptVersion CostModel
protocolParamCostModels
      , Key
"executionUnitPrices"    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe ExecutionUnitPrices
protocolParamPrices
      , Key
"maxTxExecutionUnits"    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe ExecutionUnits
protocolParamMaxTxExUnits
      , Key
"maxBlockExecutionUnits" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe ExecutionUnits
protocolParamMaxBlockExUnits
      , Key
"maxValueSize"           forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Natural
protocolParamMaxValueSize
      , Key
"collateralPercentage"   forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Natural
protocolParamCollateralPercent
      , Key
"maxCollateralInputs"    forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Natural
protocolParamMaxCollateralInputs
      -- Babbage era:
      , Key
"utxoCostPerByte"        forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Lovelace
protocolParamUTxOCostPerByte
      ]


-- ----------------------------------------------------------------------------
-- Updates to the protocol parameters
--

-- | The representation of a change in the 'ProtocolParameters'.
--
data ProtocolParametersUpdate =
     ProtocolParametersUpdate {

       -- | Protocol version, major and minor. Updating the major version is
       -- used to trigger hard forks.
       --
       ProtocolParametersUpdate -> Maybe (Natural, Natural)
protocolUpdateProtocolVersion :: Maybe (Natural, Natural),

       -- | The decentralization parameter. This is fraction of slots that
       -- belong to the BFT overlay schedule, rather than the Praos schedule.
       -- So 1 means fully centralised, while 0 means fully decentralised.
       --
       -- This is the \"d\" parameter from the design document.
       --
       ProtocolParametersUpdate -> Maybe Rational
protocolUpdateDecentralization :: Maybe Rational,

       -- | Extra entropy for the Praos per-epoch nonce.
       --
       -- This can be used to add extra entropy during the decentralisation
       -- process. If the extra entropy can be demonstrated to be generated
       -- randomly then this method can be used to show that the initial
       -- federated operators did not subtly bias the initial schedule so that
       -- they retain undue influence after decentralisation.
       --
       ProtocolParametersUpdate -> Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy :: Maybe (Maybe PraosNonce),

       -- | The maximum permitted size of a block header.
       --
       -- This must be at least as big as the largest legitimate block headers
       -- but should not be too much larger, to help prevent DoS attacks.
       --
       -- Caution: setting this to be smaller than legitimate block headers is
       -- a sure way to brick the system!
       --
       ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxBlockHeaderSize :: Maybe Natural,

       -- | The maximum permitted size of the block body (that is, the block
       -- payload, without the block header).
       --
       -- This should be picked with the Praos network delta security parameter
       -- in mind. Making this too large can severely weaken the Praos
       -- consensus properties.
       --
       -- Caution: setting this to be smaller than a transaction that can
       -- change the protocol parameters is a sure way to brick the system!
       --
       ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxBlockBodySize :: Maybe Natural,

       -- | The maximum permitted size of a transaction.
       --
       -- Typically this should not be too high a fraction of the block size,
       -- otherwise wastage from block fragmentation becomes a problem, and
       -- the current implementation does not use any sophisticated box packing
       -- algorithm.
       --
       ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxTxSize :: Maybe Natural,

       -- | The constant factor for the minimum fee calculation.
       --
       ProtocolParametersUpdate -> Maybe Natural
protocolUpdateTxFeeFixed :: Maybe Natural,

       -- | The linear factor for the minimum fee calculation.
       --
       ProtocolParametersUpdate -> Maybe Natural
protocolUpdateTxFeePerByte :: Maybe Natural,

       -- | The minimum permitted value for new UTxO entries, ie for
       -- transaction outputs.
       --
       ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateMinUTxOValue :: Maybe Lovelace,

       -- | The deposit required to register a stake address.
       --
       ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateStakeAddressDeposit :: Maybe Lovelace,

       -- | The deposit required to register a stake pool.
       --
       ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateStakePoolDeposit :: Maybe Lovelace,

       -- | The minimum value that stake pools are permitted to declare for
       -- their cost parameter.
       --
       ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateMinPoolCost :: Maybe Lovelace,

       -- | The maximum number of epochs into the future that stake pools
       -- are permitted to schedule a retirement.
       --
       ProtocolParametersUpdate -> Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch :: Maybe EpochNo,

       -- | The equilibrium target number of stake pools.
       --
       -- This is the \"k\" incentives parameter from the design document.
       --
       ProtocolParametersUpdate -> Maybe Natural
protocolUpdateStakePoolTargetNum :: Maybe Natural,

       -- | The influence of the pledge in stake pool rewards.
       --
       -- This is the \"a_0\" incentives parameter from the design document.
       --
       ProtocolParametersUpdate -> Maybe Rational
protocolUpdatePoolPledgeInfluence :: Maybe Rational,

       -- | The monetary expansion rate. This determines the fraction of the
       -- reserves that are added to the fee pot each epoch.
       --
       -- This is the \"rho\" incentives parameter from the design document.
       --
       ProtocolParametersUpdate -> Maybe Rational
protocolUpdateMonetaryExpansion :: Maybe Rational,

       -- | The fraction of the fee pot each epoch that goes to the treasury.
       --
       -- This is the \"tau\" incentives parameter from the design document.
       --
       ProtocolParametersUpdate -> Maybe Rational
protocolUpdateTreasuryCut :: Maybe Rational,

       -- Introduced in Alonzo,

       -- | Cost in ada per word of UTxO storage.
       --
       -- /Introduced in Alonzo, obsoleted in Babbage by 'protocolUpdateUTxOCostPerByte'/
       ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateUTxOCostPerWord :: Maybe Lovelace,

       -- Introduced in Alonzo,

       -- | Cost models for script languages that use them.
       --
       -- /Introduced in Alonzo/
       ProtocolParametersUpdate -> Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels :: Map AnyPlutusScriptVersion CostModel,

       -- | Price of execution units for script languages that use them.
       --
       -- /Introduced in Alonzo/
       ProtocolParametersUpdate -> Maybe ExecutionUnitPrices
protocolUpdatePrices :: Maybe ExecutionUnitPrices,

       -- | Max total script execution resources units allowed per tx
       --
       -- /Introduced in Alonzo/
       ProtocolParametersUpdate -> Maybe ExecutionUnits
protocolUpdateMaxTxExUnits :: Maybe ExecutionUnits,

       -- | Max total script execution resources units allowed per block
       --
       -- /Introduced in Alonzo/
       ProtocolParametersUpdate -> Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits :: Maybe ExecutionUnits,

       -- | Max size of a 'Value' in a tx output.
       --
       -- /Introduced in Alonzo/
       ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxValueSize :: Maybe Natural,

       -- | The percentage of the script contribution to the txfee that must be
       -- provided as collateral inputs when including Plutus scripts.
       --
       -- /Introduced in Alonzo/
       ProtocolParametersUpdate -> Maybe Natural
protocolUpdateCollateralPercent :: Maybe Natural,

       -- | The maximum number of collateral inputs allowed in a transaction.
       --
       -- /Introduced in Alonzo/
       ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxCollateralInputs :: Maybe Natural,

       -- | Cost in ada per byte of UTxO storage.
       --
       -- /Introduced in Babbage.  Supercedes 'protocolUpdateUTxOCostPerWord'/
       ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateUTxOCostPerByte :: Maybe Lovelace
    }
  deriving (ProtocolParametersUpdate -> ProtocolParametersUpdate -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProtocolParametersUpdate -> ProtocolParametersUpdate -> Bool
$c/= :: ProtocolParametersUpdate -> ProtocolParametersUpdate -> Bool
== :: ProtocolParametersUpdate -> ProtocolParametersUpdate -> Bool
$c== :: ProtocolParametersUpdate -> ProtocolParametersUpdate -> Bool
Eq, Int -> ProtocolParametersUpdate -> ShowS
[ProtocolParametersUpdate] -> ShowS
ProtocolParametersUpdate -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProtocolParametersUpdate] -> ShowS
$cshowList :: [ProtocolParametersUpdate] -> ShowS
show :: ProtocolParametersUpdate -> String
$cshow :: ProtocolParametersUpdate -> String
showsPrec :: Int -> ProtocolParametersUpdate -> ShowS
$cshowsPrec :: Int -> ProtocolParametersUpdate -> ShowS
Show)

instance Semigroup ProtocolParametersUpdate where
    ProtocolParametersUpdate
ppu1 <> :: ProtocolParametersUpdate
-> ProtocolParametersUpdate -> ProtocolParametersUpdate
<> ProtocolParametersUpdate
ppu2 =
      ProtocolParametersUpdate {
        protocolUpdateProtocolVersion :: Maybe (Natural, Natural)
protocolUpdateProtocolVersion     = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe (Natural, Natural)
protocolUpdateProtocolVersion
      , protocolUpdateDecentralization :: Maybe Rational
protocolUpdateDecentralization    = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Rational
protocolUpdateDecentralization
      , protocolUpdateExtraPraosEntropy :: Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy   = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy
      , protocolUpdateMaxBlockHeaderSize :: Maybe Natural
protocolUpdateMaxBlockHeaderSize  = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxBlockHeaderSize
      , protocolUpdateMaxBlockBodySize :: Maybe Natural
protocolUpdateMaxBlockBodySize    = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxBlockBodySize
      , protocolUpdateMaxTxSize :: Maybe Natural
protocolUpdateMaxTxSize           = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxTxSize
      , protocolUpdateTxFeeFixed :: Maybe Natural
protocolUpdateTxFeeFixed          = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Natural
protocolUpdateTxFeeFixed
      , protocolUpdateTxFeePerByte :: Maybe Natural
protocolUpdateTxFeePerByte        = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Natural
protocolUpdateTxFeePerByte
      , protocolUpdateMinUTxOValue :: Maybe Lovelace
protocolUpdateMinUTxOValue        = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateMinUTxOValue
      , protocolUpdateStakeAddressDeposit :: Maybe Lovelace
protocolUpdateStakeAddressDeposit = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateStakeAddressDeposit
      , protocolUpdateStakePoolDeposit :: Maybe Lovelace
protocolUpdateStakePoolDeposit    = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateStakePoolDeposit
      , protocolUpdateMinPoolCost :: Maybe Lovelace
protocolUpdateMinPoolCost         = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateMinPoolCost
      , protocolUpdatePoolRetireMaxEpoch :: Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch  = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch
      , protocolUpdateStakePoolTargetNum :: Maybe Natural
protocolUpdateStakePoolTargetNum  = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Natural
protocolUpdateStakePoolTargetNum
      , protocolUpdatePoolPledgeInfluence :: Maybe Rational
protocolUpdatePoolPledgeInfluence = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Rational
protocolUpdatePoolPledgeInfluence
      , protocolUpdateMonetaryExpansion :: Maybe Rational
protocolUpdateMonetaryExpansion   = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Rational
protocolUpdateMonetaryExpansion
      , protocolUpdateTreasuryCut :: Maybe Rational
protocolUpdateTreasuryCut         = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Rational
protocolUpdateTreasuryCut
      -- Introduced in Alonzo below.
      , protocolUpdateUTxOCostPerWord :: Maybe Lovelace
protocolUpdateUTxOCostPerWord     = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateUTxOCostPerWord
      , protocolUpdateCostModels :: Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels          = forall k a.
Ord k =>
(ProtocolParametersUpdate -> Map k a) -> Map k a
mergeMap ProtocolParametersUpdate -> Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels
      , protocolUpdatePrices :: Maybe ExecutionUnitPrices
protocolUpdatePrices              = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe ExecutionUnitPrices
protocolUpdatePrices
      , protocolUpdateMaxTxExUnits :: Maybe ExecutionUnits
protocolUpdateMaxTxExUnits        = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe ExecutionUnits
protocolUpdateMaxTxExUnits
      , protocolUpdateMaxBlockExUnits :: Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits     = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits
      , protocolUpdateMaxValueSize :: Maybe Natural
protocolUpdateMaxValueSize        = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxValueSize
      , protocolUpdateCollateralPercent :: Maybe Natural
protocolUpdateCollateralPercent   = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Natural
protocolUpdateCollateralPercent
      , protocolUpdateMaxCollateralInputs :: Maybe Natural
protocolUpdateMaxCollateralInputs = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxCollateralInputs
      -- Introduced in Babbage below.
      , protocolUpdateUTxOCostPerByte :: Maybe Lovelace
protocolUpdateUTxOCostPerByte     = forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateUTxOCostPerByte
      }
      where
        -- prefer the right hand side:
        merge :: (ProtocolParametersUpdate -> Maybe a) -> Maybe a
        merge :: forall a. (ProtocolParametersUpdate -> Maybe a) -> Maybe a
merge ProtocolParametersUpdate -> Maybe a
f = ProtocolParametersUpdate -> Maybe a
f ProtocolParametersUpdate
ppu2 forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` ProtocolParametersUpdate -> Maybe a
f ProtocolParametersUpdate
ppu1

        -- prefer the right hand side:
        mergeMap :: Ord k => (ProtocolParametersUpdate -> Map k a) -> Map k a
        mergeMap :: forall k a.
Ord k =>
(ProtocolParametersUpdate -> Map k a) -> Map k a
mergeMap ProtocolParametersUpdate -> Map k a
f = ProtocolParametersUpdate -> Map k a
f ProtocolParametersUpdate
ppu2 forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union` ProtocolParametersUpdate -> Map k a
f ProtocolParametersUpdate
ppu1

instance Monoid ProtocolParametersUpdate where
    mempty :: ProtocolParametersUpdate
mempty =
      ProtocolParametersUpdate {
        protocolUpdateProtocolVersion :: Maybe (Natural, Natural)
protocolUpdateProtocolVersion     = forall a. Maybe a
Nothing
      , protocolUpdateDecentralization :: Maybe Rational
protocolUpdateDecentralization    = forall a. Maybe a
Nothing
      , protocolUpdateExtraPraosEntropy :: Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy   = forall a. Maybe a
Nothing
      , protocolUpdateMaxBlockHeaderSize :: Maybe Natural
protocolUpdateMaxBlockHeaderSize  = forall a. Maybe a
Nothing
      , protocolUpdateMaxBlockBodySize :: Maybe Natural
protocolUpdateMaxBlockBodySize    = forall a. Maybe a
Nothing
      , protocolUpdateMaxTxSize :: Maybe Natural
protocolUpdateMaxTxSize           = forall a. Maybe a
Nothing
      , protocolUpdateTxFeeFixed :: Maybe Natural
protocolUpdateTxFeeFixed          = forall a. Maybe a
Nothing
      , protocolUpdateTxFeePerByte :: Maybe Natural
protocolUpdateTxFeePerByte        = forall a. Maybe a
Nothing
      , protocolUpdateMinUTxOValue :: Maybe Lovelace
protocolUpdateMinUTxOValue        = forall a. Maybe a
Nothing
      , protocolUpdateStakeAddressDeposit :: Maybe Lovelace
protocolUpdateStakeAddressDeposit = forall a. Maybe a
Nothing
      , protocolUpdateStakePoolDeposit :: Maybe Lovelace
protocolUpdateStakePoolDeposit    = forall a. Maybe a
Nothing
      , protocolUpdateMinPoolCost :: Maybe Lovelace
protocolUpdateMinPoolCost         = forall a. Maybe a
Nothing
      , protocolUpdatePoolRetireMaxEpoch :: Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch  = forall a. Maybe a
Nothing
      , protocolUpdateStakePoolTargetNum :: Maybe Natural
protocolUpdateStakePoolTargetNum  = forall a. Maybe a
Nothing
      , protocolUpdatePoolPledgeInfluence :: Maybe Rational
protocolUpdatePoolPledgeInfluence = forall a. Maybe a
Nothing
      , protocolUpdateMonetaryExpansion :: Maybe Rational
protocolUpdateMonetaryExpansion   = forall a. Maybe a
Nothing
      , protocolUpdateTreasuryCut :: Maybe Rational
protocolUpdateTreasuryCut         = forall a. Maybe a
Nothing
      , protocolUpdateUTxOCostPerWord :: Maybe Lovelace
protocolUpdateUTxOCostPerWord     = forall a. Maybe a
Nothing
      , protocolUpdateCostModels :: Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels          = forall a. Monoid a => a
mempty
      , protocolUpdatePrices :: Maybe ExecutionUnitPrices
protocolUpdatePrices              = forall a. Maybe a
Nothing
      , protocolUpdateMaxTxExUnits :: Maybe ExecutionUnits
protocolUpdateMaxTxExUnits        = forall a. Maybe a
Nothing
      , protocolUpdateMaxBlockExUnits :: Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits     = forall a. Maybe a
Nothing
      , protocolUpdateMaxValueSize :: Maybe Natural
protocolUpdateMaxValueSize        = forall a. Maybe a
Nothing
      , protocolUpdateCollateralPercent :: Maybe Natural
protocolUpdateCollateralPercent   = forall a. Maybe a
Nothing
      , protocolUpdateMaxCollateralInputs :: Maybe Natural
protocolUpdateMaxCollateralInputs = forall a. Maybe a
Nothing
      , protocolUpdateUTxOCostPerByte :: Maybe Lovelace
protocolUpdateUTxOCostPerByte     = forall a. Maybe a
Nothing
      }

instance ToCBOR ProtocolParametersUpdate where
    toCBOR :: ProtocolParametersUpdate -> Encoding
toCBOR ProtocolParametersUpdate{Maybe Natural
Maybe (Maybe PraosNonce)
Maybe Rational
Maybe (Natural, Natural)
Maybe EpochNo
Maybe ExecutionUnits
Maybe Lovelace
Maybe ExecutionUnitPrices
Map AnyPlutusScriptVersion CostModel
protocolUpdateUTxOCostPerByte :: Maybe Lovelace
protocolUpdateMaxCollateralInputs :: Maybe Natural
protocolUpdateCollateralPercent :: Maybe Natural
protocolUpdateMaxValueSize :: Maybe Natural
protocolUpdateMaxBlockExUnits :: Maybe ExecutionUnits
protocolUpdateMaxTxExUnits :: Maybe ExecutionUnits
protocolUpdatePrices :: Maybe ExecutionUnitPrices
protocolUpdateCostModels :: Map AnyPlutusScriptVersion CostModel
protocolUpdateUTxOCostPerWord :: Maybe Lovelace
protocolUpdateTreasuryCut :: Maybe Rational
protocolUpdateMonetaryExpansion :: Maybe Rational
protocolUpdatePoolPledgeInfluence :: Maybe Rational
protocolUpdateStakePoolTargetNum :: Maybe Natural
protocolUpdatePoolRetireMaxEpoch :: Maybe EpochNo
protocolUpdateMinPoolCost :: Maybe Lovelace
protocolUpdateStakePoolDeposit :: Maybe Lovelace
protocolUpdateStakeAddressDeposit :: Maybe Lovelace
protocolUpdateMinUTxOValue :: Maybe Lovelace
protocolUpdateTxFeePerByte :: Maybe Natural
protocolUpdateTxFeeFixed :: Maybe Natural
protocolUpdateMaxTxSize :: Maybe Natural
protocolUpdateMaxBlockBodySize :: Maybe Natural
protocolUpdateMaxBlockHeaderSize :: Maybe Natural
protocolUpdateExtraPraosEntropy :: Maybe (Maybe PraosNonce)
protocolUpdateDecentralization :: Maybe Rational
protocolUpdateProtocolVersion :: Maybe (Natural, Natural)
protocolUpdateUTxOCostPerByte :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateMaxCollateralInputs :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateCollateralPercent :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxValueSize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxBlockExUnits :: ProtocolParametersUpdate -> Maybe ExecutionUnits
protocolUpdateMaxTxExUnits :: ProtocolParametersUpdate -> Maybe ExecutionUnits
protocolUpdatePrices :: ProtocolParametersUpdate -> Maybe ExecutionUnitPrices
protocolUpdateCostModels :: ProtocolParametersUpdate -> Map AnyPlutusScriptVersion CostModel
protocolUpdateUTxOCostPerWord :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateTreasuryCut :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdateMonetaryExpansion :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdatePoolPledgeInfluence :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdateStakePoolTargetNum :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdatePoolRetireMaxEpoch :: ProtocolParametersUpdate -> Maybe EpochNo
protocolUpdateMinPoolCost :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateStakePoolDeposit :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateStakeAddressDeposit :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateMinUTxOValue :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateTxFeePerByte :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateTxFeeFixed :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxTxSize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxBlockBodySize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxBlockHeaderSize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateExtraPraosEntropy :: ProtocolParametersUpdate -> Maybe (Maybe PraosNonce)
protocolUpdateDecentralization :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdateProtocolVersion :: ProtocolParametersUpdate -> Maybe (Natural, Natural)
..} =
        Word -> Encoding
CBOR.encodeListLen Word
26
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe (Natural, Natural)
protocolUpdateProtocolVersion
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Rational
protocolUpdateDecentralization
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Natural
protocolUpdateMaxBlockHeaderSize
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Natural
protocolUpdateMaxBlockBodySize
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Natural
protocolUpdateMaxTxSize
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Natural
protocolUpdateTxFeeFixed
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Natural
protocolUpdateTxFeePerByte
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Lovelace
protocolUpdateMinUTxOValue
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Lovelace
protocolUpdateStakeAddressDeposit
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Lovelace
protocolUpdateStakePoolDeposit
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Lovelace
protocolUpdateMinPoolCost
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Natural
protocolUpdateStakePoolTargetNum
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Rational
protocolUpdatePoolPledgeInfluence
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Rational
protocolUpdateMonetaryExpansion
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Rational
protocolUpdateTreasuryCut
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Lovelace
protocolUpdateUTxOCostPerWord
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe ExecutionUnitPrices
protocolUpdatePrices
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe ExecutionUnits
protocolUpdateMaxTxExUnits
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Natural
protocolUpdateMaxValueSize
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Natural
protocolUpdateCollateralPercent
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Natural
protocolUpdateMaxCollateralInputs
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Maybe Lovelace
protocolUpdateUTxOCostPerByte

instance FromCBOR ProtocolParametersUpdate where
    fromCBOR :: forall s. Decoder s ProtocolParametersUpdate
fromCBOR = do
      forall s. Text -> Int -> Decoder s ()
CBOR.enforceSize Text
"ProtocolParametersUpdate" Int
26
      Maybe (Natural, Natural)
-> Maybe Rational
-> Maybe (Maybe PraosNonce)
-> Maybe Natural
-> Maybe Natural
-> Maybe Natural
-> Maybe Natural
-> Maybe Natural
-> Maybe Lovelace
-> Maybe Lovelace
-> Maybe Lovelace
-> Maybe Lovelace
-> Maybe EpochNo
-> Maybe Natural
-> Maybe Rational
-> Maybe Rational
-> Maybe Rational
-> Maybe Lovelace
-> Map AnyPlutusScriptVersion CostModel
-> Maybe ExecutionUnitPrices
-> Maybe ExecutionUnits
-> Maybe ExecutionUnits
-> Maybe Natural
-> Maybe Natural
-> Maybe Natural
-> Maybe Lovelace
-> ProtocolParametersUpdate
ProtocolParametersUpdate
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR


-- ----------------------------------------------------------------------------
-- Praos nonce
--

newtype PraosNonce = PraosNonce (Ledger.Hash StandardCrypto ByteString)
  deriving stock (PraosNonce -> PraosNonce -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PraosNonce -> PraosNonce -> Bool
$c/= :: PraosNonce -> PraosNonce -> Bool
== :: PraosNonce -> PraosNonce -> Bool
$c== :: PraosNonce -> PraosNonce -> Bool
Eq, Eq PraosNonce
PraosNonce -> PraosNonce -> Bool
PraosNonce -> PraosNonce -> Ordering
PraosNonce -> PraosNonce -> PraosNonce
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
min :: PraosNonce -> PraosNonce -> PraosNonce
$cmin :: PraosNonce -> PraosNonce -> PraosNonce
max :: PraosNonce -> PraosNonce -> PraosNonce
$cmax :: PraosNonce -> PraosNonce -> PraosNonce
>= :: PraosNonce -> PraosNonce -> Bool
$c>= :: PraosNonce -> PraosNonce -> Bool
> :: PraosNonce -> PraosNonce -> Bool
$c> :: PraosNonce -> PraosNonce -> Bool
<= :: PraosNonce -> PraosNonce -> Bool
$c<= :: PraosNonce -> PraosNonce -> Bool
< :: PraosNonce -> PraosNonce -> Bool
$c< :: PraosNonce -> PraosNonce -> Bool
compare :: PraosNonce -> PraosNonce -> Ordering
$ccompare :: PraosNonce -> PraosNonce -> Ordering
Ord, forall x. Rep PraosNonce x -> PraosNonce
forall x. PraosNonce -> Rep PraosNonce x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PraosNonce x -> PraosNonce
$cfrom :: forall x. PraosNonce -> Rep PraosNonce x
Generic)
  deriving (Int -> PraosNonce -> ShowS
[PraosNonce] -> ShowS
PraosNonce -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PraosNonce] -> ShowS
$cshowList :: [PraosNonce] -> ShowS
show :: PraosNonce -> String
$cshow :: PraosNonce -> String
showsPrec :: Int -> PraosNonce -> ShowS
$cshowsPrec :: Int -> PraosNonce -> ShowS
Show, String -> PraosNonce
forall a. (String -> a) -> IsString a
fromString :: String -> PraosNonce
$cfromString :: String -> PraosNonce
IsString)   via UsingRawBytesHex PraosNonce
  deriving ([PraosNonce] -> Value
[PraosNonce] -> Encoding
PraosNonce -> Value
PraosNonce -> Encoding
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [PraosNonce] -> Encoding
$ctoEncodingList :: [PraosNonce] -> Encoding
toJSONList :: [PraosNonce] -> Value
$ctoJSONList :: [PraosNonce] -> Value
toEncoding :: PraosNonce -> Encoding
$ctoEncoding :: PraosNonce -> Encoding
toJSON :: PraosNonce -> Value
$ctoJSON :: PraosNonce -> Value
ToJSON, Value -> Parser [PraosNonce]
Value -> Parser PraosNonce
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [PraosNonce]
$cparseJSONList :: Value -> Parser [PraosNonce]
parseJSON :: Value -> Parser PraosNonce
$cparseJSON :: Value -> Parser PraosNonce
FromJSON) via UsingRawBytesHex PraosNonce
  deriving (Typeable PraosNonce
PraosNonce -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [PraosNonce] -> Size
(forall t. ToCBOR t => Proxy t -> Size) -> Proxy PraosNonce -> Size
forall a.
Typeable a
-> (a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [PraosNonce] -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [PraosNonce] -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy PraosNonce -> Size
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy PraosNonce -> Size
toCBOR :: PraosNonce -> Encoding
$ctoCBOR :: PraosNonce -> Encoding
ToCBOR, Typeable PraosNonce
Proxy PraosNonce -> Text
forall s. Decoder s PraosNonce
forall a.
Typeable a
-> (forall s. Decoder s a) -> (Proxy a -> Text) -> FromCBOR a
label :: Proxy PraosNonce -> Text
$clabel :: Proxy PraosNonce -> Text
fromCBOR :: forall s. Decoder s PraosNonce
$cfromCBOR :: forall s. Decoder s PraosNonce
FromCBOR) via UsingRawBytes    PraosNonce

instance HasTypeProxy PraosNonce where
    data AsType PraosNonce = AsPraosNonce
    proxyToAsType :: Proxy PraosNonce -> AsType PraosNonce
proxyToAsType Proxy PraosNonce
_ = AsType PraosNonce
AsPraosNonce

instance SerialiseAsRawBytes PraosNonce where
    serialiseToRawBytes :: PraosNonce -> ByteString
serialiseToRawBytes (PraosNonce Hash StandardCrypto ByteString
h) =
      forall h a. Hash h a -> ByteString
Crypto.hashToBytes Hash StandardCrypto ByteString
h

    deserialiseFromRawBytes :: AsType PraosNonce
-> ByteString -> Either SerialiseAsRawBytesError PraosNonce
deserialiseFromRawBytes AsType PraosNonce
R:AsTypePraosNonce
AsPraosNonce ByteString
bs =
      forall b a. b -> Maybe a -> Either b a
maybeToRight (String -> SerialiseAsRawBytesError
SerialiseAsRawBytesError String
"Unable to deserialise PraosNonce") forall a b. (a -> b) -> a -> b
$
        Hash StandardCrypto ByteString -> PraosNonce
PraosNonce forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall h a. HashAlgorithm h => ByteString -> Maybe (Hash h a)
Crypto.hashFromBytes ByteString
bs


makePraosNonce :: ByteString -> PraosNonce
makePraosNonce :: ByteString -> PraosNonce
makePraosNonce = Hash StandardCrypto ByteString -> PraosNonce
PraosNonce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall h a. HashAlgorithm h => (a -> ByteString) -> a -> Hash h a
Crypto.hashWith forall a. a -> a
id

toLedgerNonce :: Maybe PraosNonce -> Ledger.Nonce
toLedgerNonce :: Maybe PraosNonce -> Nonce
toLedgerNonce Maybe PraosNonce
Nothing               = Nonce
Ledger.NeutralNonce
toLedgerNonce (Just (PraosNonce Hash StandardCrypto ByteString
h)) = Hash Blake2b_256 Nonce -> Nonce
Ledger.Nonce (forall h a b. Hash h a -> Hash h b
Crypto.castHash Hash StandardCrypto ByteString
h)

fromLedgerNonce :: Ledger.Nonce -> Maybe PraosNonce
fromLedgerNonce :: Nonce -> Maybe PraosNonce
fromLedgerNonce Nonce
Ledger.NeutralNonce = forall a. Maybe a
Nothing
fromLedgerNonce (Ledger.Nonce Hash Blake2b_256 Nonce
h)    = forall a. a -> Maybe a
Just (Hash StandardCrypto ByteString -> PraosNonce
PraosNonce (forall h a b. Hash h a -> Hash h b
Crypto.castHash Hash Blake2b_256 Nonce
h))


-- ----------------------------------------------------------------------------
-- Script execution unit prices and cost models
--

-- | The prices for 'ExecutionUnits' as a fraction of a 'Lovelace'.
--
-- These are used to determine the fee for the use of a script within a
-- transaction, based on the 'ExecutionUnits' needed by the use of the script.
--
data ExecutionUnitPrices =
     ExecutionUnitPrices {
       ExecutionUnitPrices -> Rational
priceExecutionSteps  :: Rational,
       ExecutionUnitPrices -> Rational
priceExecutionMemory :: Rational
     }
  deriving (ExecutionUnitPrices -> ExecutionUnitPrices -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExecutionUnitPrices -> ExecutionUnitPrices -> Bool
$c/= :: ExecutionUnitPrices -> ExecutionUnitPrices -> Bool
== :: ExecutionUnitPrices -> ExecutionUnitPrices -> Bool
$c== :: ExecutionUnitPrices -> ExecutionUnitPrices -> Bool
Eq, Int -> ExecutionUnitPrices -> ShowS
[ExecutionUnitPrices] -> ShowS
ExecutionUnitPrices -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExecutionUnitPrices] -> ShowS
$cshowList :: [ExecutionUnitPrices] -> ShowS
show :: ExecutionUnitPrices -> String
$cshow :: ExecutionUnitPrices -> String
showsPrec :: Int -> ExecutionUnitPrices -> ShowS
$cshowsPrec :: Int -> ExecutionUnitPrices -> ShowS
Show)

instance ToCBOR ExecutionUnitPrices where
  toCBOR :: ExecutionUnitPrices -> Encoding
toCBOR ExecutionUnitPrices{Rational
priceExecutionSteps :: Rational
priceExecutionSteps :: ExecutionUnitPrices -> Rational
priceExecutionSteps, Rational
priceExecutionMemory :: Rational
priceExecutionMemory :: ExecutionUnitPrices -> Rational
priceExecutionMemory} =
      Word -> Encoding
CBOR.encodeListLen Word
2
   forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Rational
priceExecutionSteps
   forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Rational
priceExecutionMemory

instance FromCBOR ExecutionUnitPrices where
  fromCBOR :: forall s. Decoder s ExecutionUnitPrices
fromCBOR = do
    forall s. Text -> Int -> Decoder s ()
CBOR.enforceSize Text
"ExecutionUnitPrices" Int
2
    Rational -> Rational -> ExecutionUnitPrices
ExecutionUnitPrices
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a s. FromCBOR a => Decoder s a
fromCBOR
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR

instance ToJSON ExecutionUnitPrices where
  toJSON :: ExecutionUnitPrices -> Value
toJSON ExecutionUnitPrices{Rational
priceExecutionSteps :: Rational
priceExecutionSteps :: ExecutionUnitPrices -> Rational
priceExecutionSteps, Rational
priceExecutionMemory :: Rational
priceExecutionMemory :: ExecutionUnitPrices -> Rational
priceExecutionMemory} =
    [Pair] -> Value
object [ Key
"priceSteps"  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Rational -> Value
toRationalJSON Rational
priceExecutionSteps
           , Key
"priceMemory" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Rational -> Value
toRationalJSON Rational
priceExecutionMemory
           ]

instance FromJSON ExecutionUnitPrices where
  parseJSON :: Value -> Parser ExecutionUnitPrices
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ExecutionUnitPrices" forall a b. (a -> b) -> a -> b
$ \Object
o ->
      Rational -> Rational -> ExecutionUnitPrices
ExecutionUnitPrices
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"priceSteps"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"priceMemory"


toAlonzoPrices :: ExecutionUnitPrices -> Maybe Alonzo.Prices
toAlonzoPrices :: ExecutionUnitPrices -> Maybe Prices
toAlonzoPrices ExecutionUnitPrices {
                 Rational
priceExecutionSteps :: Rational
priceExecutionSteps :: ExecutionUnitPrices -> Rational
priceExecutionSteps,
                 Rational
priceExecutionMemory :: Rational
priceExecutionMemory :: ExecutionUnitPrices -> Rational
priceExecutionMemory
               } = do
  NonNegativeInterval
prSteps <- forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational Rational
priceExecutionSteps
  NonNegativeInterval
prMem   <- forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational Rational
priceExecutionMemory
  forall (m :: * -> *) a. Monad m => a -> m a
return Alonzo.Prices {
    NonNegativeInterval
prSteps :: NonNegativeInterval
prSteps :: NonNegativeInterval
Alonzo.prSteps,
    NonNegativeInterval
prMem :: NonNegativeInterval
prMem :: NonNegativeInterval
Alonzo.prMem
  }

fromAlonzoPrices :: Alonzo.Prices -> ExecutionUnitPrices
fromAlonzoPrices :: Prices -> ExecutionUnitPrices
fromAlonzoPrices Alonzo.Prices{NonNegativeInterval
prSteps :: NonNegativeInterval
prSteps :: Prices -> NonNegativeInterval
Alonzo.prSteps, NonNegativeInterval
prMem :: NonNegativeInterval
prMem :: Prices -> NonNegativeInterval
Alonzo.prMem} =
  ExecutionUnitPrices {
    priceExecutionSteps :: Rational
priceExecutionSteps  = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational NonNegativeInterval
prSteps,
    priceExecutionMemory :: Rational
priceExecutionMemory = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational NonNegativeInterval
prMem
  }


-- ----------------------------------------------------------------------------
-- Script cost models
--

newtype CostModel = CostModel (Map Text Integer)
  deriving (CostModel -> CostModel -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CostModel -> CostModel -> Bool
$c/= :: CostModel -> CostModel -> Bool
== :: CostModel -> CostModel -> Bool
$c== :: CostModel -> CostModel -> Bool
Eq, Int -> CostModel -> ShowS
[CostModel] -> ShowS
CostModel -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CostModel] -> ShowS
$cshowList :: [CostModel] -> ShowS
show :: CostModel -> String
$cshow :: CostModel -> String
showsPrec :: Int -> CostModel -> ShowS
$cshowsPrec :: Int -> CostModel -> ShowS
Show)
  deriving newtype ([CostModel] -> Value
[CostModel] -> Encoding
CostModel -> Value
CostModel -> Encoding
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [CostModel] -> Encoding
$ctoEncodingList :: [CostModel] -> Encoding
toJSONList :: [CostModel] -> Value
$ctoJSONList :: [CostModel] -> Value
toEncoding :: CostModel -> Encoding
$ctoEncoding :: CostModel -> Encoding
toJSON :: CostModel -> Value
$ctoJSON :: CostModel -> Value
ToJSON, Value -> Parser [CostModel]
Value -> Parser CostModel
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [CostModel]
$cparseJSONList :: Value -> Parser [CostModel]
parseJSON :: Value -> Parser CostModel
$cparseJSON :: Value -> Parser CostModel
FromJSON)
  deriving newtype (Typeable CostModel
CostModel -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [CostModel] -> Size
(forall t. ToCBOR t => Proxy t -> Size) -> Proxy CostModel -> Size
forall a.
Typeable a
-> (a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [CostModel] -> Size
$cencodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [CostModel] -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy CostModel -> Size
$cencodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size) -> Proxy CostModel -> Size
toCBOR :: CostModel -> Encoding
$ctoCBOR :: CostModel -> Encoding
ToCBOR, Typeable CostModel
Proxy CostModel -> Text
forall s. Decoder s CostModel
forall a.
Typeable a
-> (forall s. Decoder s a) -> (Proxy a -> Text) -> FromCBOR a
label :: Proxy CostModel -> Text
$clabel :: Proxy CostModel -> Text
fromCBOR :: forall s. Decoder s CostModel
$cfromCBOR :: forall s. Decoder s CostModel
FromCBOR)

validateCostModel :: PlutusScriptVersion lang
                  -> CostModel
                  -> Either InvalidCostModel ()
validateCostModel :: forall lang.
PlutusScriptVersion lang -> CostModel -> Either InvalidCostModel ()
validateCostModel PlutusScriptVersion lang
PlutusScriptV1 (CostModel Map Text Integer
m) =
    forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (CostModel -> CostModelApplyError -> InvalidCostModel
InvalidCostModel (Map Text Integer -> CostModel
CostModel Map Text Integer
m))
  forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *).
MonadError CostModelApplyError m =>
Map Text Integer -> m ()
Alonzo.assertWellFormedCostModelParams Map Text Integer
m
validateCostModel PlutusScriptVersion lang
PlutusScriptV2 (CostModel Map Text Integer
m) =
    forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (CostModel -> CostModelApplyError -> InvalidCostModel
InvalidCostModel (Map Text Integer -> CostModel
CostModel Map Text Integer
m))
  forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *).
MonadError CostModelApplyError m =>
Map Text Integer -> m ()
Alonzo.assertWellFormedCostModelParams Map Text Integer
m

-- TODO alonzo: it'd be nice if the library told us what was wrong
data InvalidCostModel = InvalidCostModel CostModel Alonzo.CostModelApplyError
  deriving Int -> InvalidCostModel -> ShowS
[InvalidCostModel] -> ShowS
InvalidCostModel -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InvalidCostModel] -> ShowS
$cshowList :: [InvalidCostModel] -> ShowS
show :: InvalidCostModel -> String
$cshow :: InvalidCostModel -> String
showsPrec :: Int -> InvalidCostModel -> ShowS
$cshowsPrec :: Int -> InvalidCostModel -> ShowS
Show

instance Error InvalidCostModel where
  displayError :: InvalidCostModel -> String
displayError (InvalidCostModel CostModel
cm CostModelApplyError
err) =
    String
"Invalid cost model: " forall a. [a] -> [a] -> [a]
++ forall str a. (Pretty a, Render str) => a -> str
display CostModelApplyError
err forall a. [a] -> [a] -> [a]
++
    String
" Cost model: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show CostModel
cm


toAlonzoCostModels
  :: Map AnyPlutusScriptVersion CostModel
  -> Either String Alonzo.CostModels
toAlonzoCostModels :: Map AnyPlutusScriptVersion CostModel -> Either String CostModels
toAlonzoCostModels Map AnyPlutusScriptVersion CostModel
m = do
  [(Language, CostModel)]
f <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (AnyPlutusScriptVersion, CostModel)
-> Either String (Language, CostModel)
conv forall a b. (a -> b) -> a -> b
$ forall k a. Map k a -> [(k, a)]
Map.toList Map AnyPlutusScriptVersion CostModel
m
  forall a b. b -> Either a b
Right forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Language CostModel -> CostModels
Alonzo.CostModels forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Language, CostModel)]
f
 where
  conv :: (AnyPlutusScriptVersion, CostModel) -> Either String (Alonzo.Language, Alonzo.CostModel)
  conv :: (AnyPlutusScriptVersion, CostModel)
-> Either String (Language, CostModel)
conv (AnyPlutusScriptVersion
anySVer, CostModel
cModel )= do
    -- TODO: Propagate InvalidCostModel further
    CostModel
alonzoCostModel <- forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first forall e. Error e => e -> String
displayError forall a b. (a -> b) -> a -> b
$ CostModel -> Language -> Either InvalidCostModel CostModel
toAlonzoCostModel CostModel
cModel (AnyPlutusScriptVersion -> Language
toAlonzoScriptLanguage AnyPlutusScriptVersion
anySVer)
    forall a b. b -> Either a b
Right (AnyPlutusScriptVersion -> Language
toAlonzoScriptLanguage AnyPlutusScriptVersion
anySVer, CostModel
alonzoCostModel)

fromAlonzoCostModels
  :: Alonzo.CostModels
  -> Map AnyPlutusScriptVersion CostModel
fromAlonzoCostModels :: CostModels -> Map AnyPlutusScriptVersion CostModel
fromAlonzoCostModels (Alonzo.CostModels Map Language CostModel
m)=
    forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap Language -> AnyPlutusScriptVersion
fromAlonzoScriptLanguage CostModel -> CostModel
fromAlonzoCostModel)
  forall a b. (a -> b) -> a -> b
$ forall k a. Map k a -> [(k, a)]
Map.toList Map Language CostModel
m

toAlonzoScriptLanguage :: AnyPlutusScriptVersion -> Alonzo.Language
toAlonzoScriptLanguage :: AnyPlutusScriptVersion -> Language
toAlonzoScriptLanguage (AnyPlutusScriptVersion PlutusScriptVersion lang
PlutusScriptV1) = Language
Alonzo.PlutusV1
toAlonzoScriptLanguage (AnyPlutusScriptVersion PlutusScriptVersion lang
PlutusScriptV2) = Language
Alonzo.PlutusV2

fromAlonzoScriptLanguage :: Alonzo.Language -> AnyPlutusScriptVersion
fromAlonzoScriptLanguage :: Language -> AnyPlutusScriptVersion
fromAlonzoScriptLanguage Language
Alonzo.PlutusV1 = forall era. PlutusScriptVersion era -> AnyPlutusScriptVersion
AnyPlutusScriptVersion PlutusScriptVersion PlutusScriptV1
PlutusScriptV1
fromAlonzoScriptLanguage Language
Alonzo.PlutusV2 = forall era. PlutusScriptVersion era -> AnyPlutusScriptVersion
AnyPlutusScriptVersion PlutusScriptVersion PlutusScriptV2
PlutusScriptV2

toAlonzoCostModel :: CostModel -> Alonzo.Language -> Either InvalidCostModel Alonzo.CostModel
toAlonzoCostModel :: CostModel -> Language -> Either InvalidCostModel CostModel
toAlonzoCostModel (CostModel Map Text Integer
m) Language
l = forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (CostModel -> CostModelApplyError -> InvalidCostModel
InvalidCostModel (Map Text Integer -> CostModel
CostModel Map Text Integer
m)) forall a b. (a -> b) -> a -> b
$ Language
-> Map Text Integer -> Either CostModelApplyError CostModel
Alonzo.mkCostModel Language
l Map Text Integer
m

fromAlonzoCostModel :: Alonzo.CostModel -> CostModel
fromAlonzoCostModel :: CostModel -> CostModel
fromAlonzoCostModel CostModel
m = Map Text Integer -> CostModel
CostModel forall a b. (a -> b) -> a -> b
$ CostModel -> Map Text Integer
Alonzo.getCostModelParams CostModel
m


-- ----------------------------------------------------------------------------
-- Proposals embedded in transactions to update protocol parameters
--

data UpdateProposal =
     UpdateProposal
       !(Map (Hash GenesisKey) ProtocolParametersUpdate)
       !EpochNo
    deriving stock (UpdateProposal -> UpdateProposal -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateProposal -> UpdateProposal -> Bool
$c/= :: UpdateProposal -> UpdateProposal -> Bool
== :: UpdateProposal -> UpdateProposal -> Bool
$c== :: UpdateProposal -> UpdateProposal -> Bool
Eq, Int -> UpdateProposal -> ShowS
[UpdateProposal] -> ShowS
UpdateProposal -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateProposal] -> ShowS
$cshowList :: [UpdateProposal] -> ShowS
show :: UpdateProposal -> String
$cshow :: UpdateProposal -> String
showsPrec :: Int -> UpdateProposal -> ShowS
$cshowsPrec :: Int -> UpdateProposal -> ShowS
Show)
    deriving anyclass HasTypeProxy UpdateProposal
AsType UpdateProposal
-> ByteString -> Either DecoderError UpdateProposal
UpdateProposal -> ByteString
forall a.
HasTypeProxy a
-> (a -> ByteString)
-> (AsType a -> ByteString -> Either DecoderError a)
-> SerialiseAsCBOR a
deserialiseFromCBOR :: AsType UpdateProposal
-> ByteString -> Either DecoderError UpdateProposal
$cdeserialiseFromCBOR :: AsType UpdateProposal
-> ByteString -> Either DecoderError UpdateProposal
serialiseToCBOR :: UpdateProposal -> ByteString
$cserialiseToCBOR :: UpdateProposal -> ByteString
SerialiseAsCBOR

instance HasTypeProxy UpdateProposal where
    data AsType UpdateProposal = AsUpdateProposal
    proxyToAsType :: Proxy UpdateProposal -> AsType UpdateProposal
proxyToAsType Proxy UpdateProposal
_ = AsType UpdateProposal
AsUpdateProposal

instance HasTextEnvelope UpdateProposal where
    textEnvelopeType :: AsType UpdateProposal -> TextEnvelopeType
textEnvelopeType AsType UpdateProposal
_ = TextEnvelopeType
"UpdateProposalShelley"

instance ToCBOR UpdateProposal where
    toCBOR :: UpdateProposal -> Encoding
toCBOR (UpdateProposal Map (Hash GenesisKey) ProtocolParametersUpdate
ppup EpochNo
epochno) =
        Word -> Encoding
CBOR.encodeListLen Word
2
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR Map (Hash GenesisKey) ProtocolParametersUpdate
ppup
     forall a. Semigroup a => a -> a -> a
<> forall a. ToCBOR a => a -> Encoding
toCBOR EpochNo
epochno

instance FromCBOR UpdateProposal where
    fromCBOR :: forall s. Decoder s UpdateProposal
fromCBOR = do
      forall s. Text -> Int -> Decoder s ()
CBOR.enforceSize Text
"ProtocolParametersUpdate" Int
2
      Map (Hash GenesisKey) ProtocolParametersUpdate
-> EpochNo -> UpdateProposal
UpdateProposal
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a s. FromCBOR a => Decoder s a
fromCBOR
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a s. FromCBOR a => Decoder s a
fromCBOR

makeShelleyUpdateProposal :: ProtocolParametersUpdate
                          -> [Hash GenesisKey]
                          -> EpochNo
                          -> UpdateProposal
makeShelleyUpdateProposal :: ProtocolParametersUpdate
-> [Hash GenesisKey] -> EpochNo -> UpdateProposal
makeShelleyUpdateProposal ProtocolParametersUpdate
params [Hash GenesisKey]
genesisKeyHashes =
    --TODO decide how to handle parameter validation
    --     for example we need to validate the Rational values can convert
    --     into the UnitInterval type ok.
    Map (Hash GenesisKey) ProtocolParametersUpdate
-> EpochNo -> UpdateProposal
UpdateProposal (forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [ (Hash GenesisKey
kh, ProtocolParametersUpdate
params) | Hash GenesisKey
kh <- [Hash GenesisKey]
genesisKeyHashes ])


-- ----------------------------------------------------------------------------
-- Conversion functions: updates to ledger types
--

toLedgerUpdate :: forall era ledgerera.
                  ShelleyLedgerEra era ~ ledgerera
               => Ledger.Crypto ledgerera ~ StandardCrypto
               => ShelleyBasedEra era
               -> UpdateProposal
               -> Ledger.Update ledgerera
toLedgerUpdate :: forall era ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Crypto ledgerera ~ StandardCrypto) =>
ShelleyBasedEra era -> UpdateProposal -> Update ledgerera
toLedgerUpdate ShelleyBasedEra era
era (UpdateProposal Map (Hash GenesisKey) ProtocolParametersUpdate
ppup EpochNo
epochno) =
    forall era. ProposedPPUpdates era -> EpochNo -> Update era
Ledger.Update (forall era ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Crypto ledgerera ~ StandardCrypto) =>
ShelleyBasedEra era
-> Map (Hash GenesisKey) ProtocolParametersUpdate
-> ProposedPPUpdates ledgerera
toLedgerProposedPPUpdates ShelleyBasedEra era
era Map (Hash GenesisKey) ProtocolParametersUpdate
ppup) EpochNo
epochno


toLedgerProposedPPUpdates :: forall era ledgerera.
                             ShelleyLedgerEra era ~ ledgerera
                          => Ledger.Crypto ledgerera ~ StandardCrypto
                          => ShelleyBasedEra era
                          -> Map (Hash GenesisKey) ProtocolParametersUpdate
                          -> Ledger.ProposedPPUpdates ledgerera
toLedgerProposedPPUpdates :: forall era ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Crypto ledgerera ~ StandardCrypto) =>
ShelleyBasedEra era
-> Map (Hash GenesisKey) ProtocolParametersUpdate
-> ProposedPPUpdates ledgerera
toLedgerProposedPPUpdates ShelleyBasedEra era
era =
    forall era.
Map (KeyHash 'Genesis (Crypto era)) (PParamsUpdate era)
-> ProposedPPUpdates era
Ledger.ProposedPPUpdates
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k1 k2 a. (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeysMonotonic (\(GenesisKeyHash KeyHash 'Genesis StandardCrypto
kh) -> KeyHash 'Genesis StandardCrypto
kh)
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (forall era.
ShelleyBasedEra era
-> ProtocolParametersUpdate -> PParamsUpdate (ShelleyLedgerEra era)
toLedgerPParamsUpdate ShelleyBasedEra era
era)


toLedgerPParamsUpdate :: ShelleyBasedEra era
                     -> ProtocolParametersUpdate
                     -> Ledger.PParamsUpdate (ShelleyLedgerEra era)
toLedgerPParamsUpdate :: forall era.
ShelleyBasedEra era
-> ProtocolParametersUpdate -> PParamsUpdate (ShelleyLedgerEra era)
toLedgerPParamsUpdate ShelleyBasedEra era
ShelleyBasedEraShelley = forall ledgerera.
ProtocolParametersUpdate -> ShelleyPParamsUpdate ledgerera
toShelleyPParamsUpdate
toLedgerPParamsUpdate ShelleyBasedEra era
ShelleyBasedEraAllegra = forall ledgerera.
ProtocolParametersUpdate -> ShelleyPParamsUpdate ledgerera
toShelleyPParamsUpdate
toLedgerPParamsUpdate ShelleyBasedEra era
ShelleyBasedEraMary    = forall ledgerera.
ProtocolParametersUpdate -> ShelleyPParamsUpdate ledgerera
toShelleyPParamsUpdate
toLedgerPParamsUpdate ShelleyBasedEra era
ShelleyBasedEraAlonzo  = forall ledgerera.
ProtocolParametersUpdate -> AlonzoPParamsUpdate ledgerera
toAlonzoPParamsUpdate
toLedgerPParamsUpdate ShelleyBasedEra era
ShelleyBasedEraBabbage = forall ledgerera.
ProtocolParametersUpdate -> BabbagePParamsUpdate ledgerera
toBabbagePParamsUpdate
toLedgerPParamsUpdate ShelleyBasedEra era
ShelleyBasedEraConway  = forall ledgerera.
ProtocolParametersUpdate -> BabbagePParamsUpdate ledgerera
toConwayPParamsUpdate


--TODO: we should do validation somewhere, not just silently drop changes that
-- are not valid. Specifically, see Ledger.boundRational below.
toShelleyPParamsUpdate :: ProtocolParametersUpdate
                       -> ShelleyPParamsUpdate ledgerera
toShelleyPParamsUpdate :: forall ledgerera.
ProtocolParametersUpdate -> ShelleyPParamsUpdate ledgerera
toShelleyPParamsUpdate
    ProtocolParametersUpdate {
      Maybe (Natural, Natural)
protocolUpdateProtocolVersion :: Maybe (Natural, Natural)
protocolUpdateProtocolVersion :: ProtocolParametersUpdate -> Maybe (Natural, Natural)
protocolUpdateProtocolVersion
    , Maybe Rational
protocolUpdateDecentralization :: Maybe Rational
protocolUpdateDecentralization :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdateDecentralization
    , Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy :: Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy :: ProtocolParametersUpdate -> Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy
    , Maybe Natural
protocolUpdateMaxBlockHeaderSize :: Maybe Natural
protocolUpdateMaxBlockHeaderSize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxBlockHeaderSize
    , Maybe Natural
protocolUpdateMaxBlockBodySize :: Maybe Natural
protocolUpdateMaxBlockBodySize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxBlockBodySize
    , Maybe Natural
protocolUpdateMaxTxSize :: Maybe Natural
protocolUpdateMaxTxSize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxTxSize
    , Maybe Natural
protocolUpdateTxFeeFixed :: Maybe Natural
protocolUpdateTxFeeFixed :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateTxFeeFixed
    , Maybe Natural
protocolUpdateTxFeePerByte :: Maybe Natural
protocolUpdateTxFeePerByte :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateTxFeePerByte
    , Maybe Lovelace
protocolUpdateMinUTxOValue :: Maybe Lovelace
protocolUpdateMinUTxOValue :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateMinUTxOValue
    , Maybe Lovelace
protocolUpdateStakeAddressDeposit :: Maybe Lovelace
protocolUpdateStakeAddressDeposit :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateStakeAddressDeposit
    , Maybe Lovelace
protocolUpdateStakePoolDeposit :: Maybe Lovelace
protocolUpdateStakePoolDeposit :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateStakePoolDeposit
    , Maybe Lovelace
protocolUpdateMinPoolCost :: Maybe Lovelace
protocolUpdateMinPoolCost :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateMinPoolCost
    , Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch :: Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch :: ProtocolParametersUpdate -> Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch
    , Maybe Natural
protocolUpdateStakePoolTargetNum :: Maybe Natural
protocolUpdateStakePoolTargetNum :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateStakePoolTargetNum
    , Maybe Rational
protocolUpdatePoolPledgeInfluence :: Maybe Rational
protocolUpdatePoolPledgeInfluence :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdatePoolPledgeInfluence
    , Maybe Rational
protocolUpdateMonetaryExpansion :: Maybe Rational
protocolUpdateMonetaryExpansion :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdateMonetaryExpansion
    , Maybe Rational
protocolUpdateTreasuryCut :: Maybe Rational
protocolUpdateTreasuryCut :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdateTreasuryCut
    } =
    ShelleyPParams {
      _minfeeA :: HKD StrictMaybe Natural
_minfeeA     = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateTxFeePerByte
    , _minfeeB :: HKD StrictMaybe Natural
_minfeeB     = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateTxFeeFixed
    , _maxBBSize :: HKD StrictMaybe Natural
_maxBBSize   = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateMaxBlockBodySize
    , _maxTxSize :: HKD StrictMaybe Natural
_maxTxSize   = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateMaxTxSize
    , _maxBHSize :: HKD StrictMaybe Natural
_maxBHSize   = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateMaxBlockHeaderSize
    , _keyDeposit :: HKD StrictMaybe Coin
_keyDeposit  = Lovelace -> Coin
toShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                       forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Lovelace
protocolUpdateStakeAddressDeposit
    , _poolDeposit :: HKD StrictMaybe Coin
_poolDeposit = Lovelace -> Coin
toShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                       forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Lovelace
protocolUpdateStakePoolDeposit
    , _eMax :: HKD StrictMaybe EpochNo
_eMax        = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch
    , _nOpt :: HKD StrictMaybe Natural
_nOpt        = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateStakePoolTargetNum
    , _a0 :: HKD StrictMaybe NonNegativeInterval
_a0          = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe forall a b. (a -> b) -> a -> b
$ forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
                      Maybe Rational
protocolUpdatePoolPledgeInfluence
    , _rho :: HKD StrictMaybe UnitInterval
_rho         = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe forall a b. (a -> b) -> a -> b
$ forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
                        Maybe Rational
protocolUpdateMonetaryExpansion
    , _tau :: HKD StrictMaybe UnitInterval
_tau         = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe forall a b. (a -> b) -> a -> b
$ forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
                        Maybe Rational
protocolUpdateTreasuryCut
    , _d :: HKD StrictMaybe UnitInterval
_d           = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe forall a b. (a -> b) -> a -> b
$ forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
                        Maybe Rational
protocolUpdateDecentralization
    , _extraEntropy :: HKD StrictMaybe Nonce
_extraEntropy    = Maybe PraosNonce -> Nonce
toLedgerNonce forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                           forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy
    , _protocolVersion :: HKD StrictMaybe ProtVer
_protocolVersion = forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Natural -> Natural -> ProtVer
Ledger.ProtVer forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                           forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe (Natural, Natural)
protocolUpdateProtocolVersion
    , _minUTxOValue :: HKD StrictMaybe Coin
_minUTxOValue    = Lovelace -> Coin
toShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                           forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Lovelace
protocolUpdateMinUTxOValue
    , _minPoolCost :: HKD StrictMaybe Coin
_minPoolCost     = Lovelace -> Coin
toShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                   forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Lovelace
protocolUpdateMinPoolCost
    }


toAlonzoPParamsUpdate :: ProtocolParametersUpdate
                      -> AlonzoPParamsUpdate ledgerera
toAlonzoPParamsUpdate :: forall ledgerera.
ProtocolParametersUpdate -> AlonzoPParamsUpdate ledgerera
toAlonzoPParamsUpdate
    ProtocolParametersUpdate {
      Maybe (Natural, Natural)
protocolUpdateProtocolVersion :: Maybe (Natural, Natural)
protocolUpdateProtocolVersion :: ProtocolParametersUpdate -> Maybe (Natural, Natural)
protocolUpdateProtocolVersion
    , Maybe Rational
protocolUpdateDecentralization :: Maybe Rational
protocolUpdateDecentralization :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdateDecentralization
    , Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy :: Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy :: ProtocolParametersUpdate -> Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy
    , Maybe Natural
protocolUpdateMaxBlockHeaderSize :: Maybe Natural
protocolUpdateMaxBlockHeaderSize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxBlockHeaderSize
    , Maybe Natural
protocolUpdateMaxBlockBodySize :: Maybe Natural
protocolUpdateMaxBlockBodySize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxBlockBodySize
    , Maybe Natural
protocolUpdateMaxTxSize :: Maybe Natural
protocolUpdateMaxTxSize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxTxSize
    , Maybe Natural
protocolUpdateTxFeeFixed :: Maybe Natural
protocolUpdateTxFeeFixed :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateTxFeeFixed
    , Maybe Natural
protocolUpdateTxFeePerByte :: Maybe Natural
protocolUpdateTxFeePerByte :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateTxFeePerByte
    , Maybe Lovelace
protocolUpdateStakeAddressDeposit :: Maybe Lovelace
protocolUpdateStakeAddressDeposit :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateStakeAddressDeposit
    , Maybe Lovelace
protocolUpdateStakePoolDeposit :: Maybe Lovelace
protocolUpdateStakePoolDeposit :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateStakePoolDeposit
    , Maybe Lovelace
protocolUpdateMinPoolCost :: Maybe Lovelace
protocolUpdateMinPoolCost :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateMinPoolCost
    , Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch :: Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch :: ProtocolParametersUpdate -> Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch
    , Maybe Natural
protocolUpdateStakePoolTargetNum :: Maybe Natural
protocolUpdateStakePoolTargetNum :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateStakePoolTargetNum
    , Maybe Rational
protocolUpdatePoolPledgeInfluence :: Maybe Rational
protocolUpdatePoolPledgeInfluence :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdatePoolPledgeInfluence
    , Maybe Rational
protocolUpdateMonetaryExpansion :: Maybe Rational
protocolUpdateMonetaryExpansion :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdateMonetaryExpansion
    , Maybe Rational
protocolUpdateTreasuryCut :: Maybe Rational
protocolUpdateTreasuryCut :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdateTreasuryCut
    , Maybe Lovelace
protocolUpdateUTxOCostPerWord :: Maybe Lovelace
protocolUpdateUTxOCostPerWord :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateUTxOCostPerWord
    , Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels :: Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels :: ProtocolParametersUpdate -> Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels
    , Maybe ExecutionUnitPrices
protocolUpdatePrices :: Maybe ExecutionUnitPrices
protocolUpdatePrices :: ProtocolParametersUpdate -> Maybe ExecutionUnitPrices
protocolUpdatePrices
    , Maybe ExecutionUnits
protocolUpdateMaxTxExUnits :: Maybe ExecutionUnits
protocolUpdateMaxTxExUnits :: ProtocolParametersUpdate -> Maybe ExecutionUnits
protocolUpdateMaxTxExUnits
    , Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits :: Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits :: ProtocolParametersUpdate -> Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits
    , Maybe Natural
protocolUpdateMaxValueSize :: Maybe Natural
protocolUpdateMaxValueSize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxValueSize
    , Maybe Natural
protocolUpdateCollateralPercent :: Maybe Natural
protocolUpdateCollateralPercent :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateCollateralPercent
    , Maybe Natural
protocolUpdateMaxCollateralInputs :: Maybe Natural
protocolUpdateMaxCollateralInputs :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxCollateralInputs
    } =
    AlonzoPParams {
      _minfeeA :: HKD StrictMaybe Natural
_minfeeA     = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateTxFeePerByte
    , _minfeeB :: HKD StrictMaybe Natural
_minfeeB     = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateTxFeeFixed
    , _maxBBSize :: HKD StrictMaybe Natural
_maxBBSize   = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateMaxBlockBodySize
    , _maxTxSize :: HKD StrictMaybe Natural
_maxTxSize   = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateMaxTxSize
    , _maxBHSize :: HKD StrictMaybe Natural
_maxBHSize   = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateMaxBlockHeaderSize
    , _keyDeposit :: HKD StrictMaybe Coin
_keyDeposit  = Lovelace -> Coin
toShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                       forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Lovelace
protocolUpdateStakeAddressDeposit
    , _poolDeposit :: HKD StrictMaybe Coin
_poolDeposit = Lovelace -> Coin
toShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                       forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Lovelace
protocolUpdateStakePoolDeposit
    , _eMax :: HKD StrictMaybe EpochNo
_eMax        = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch
    , _nOpt :: HKD StrictMaybe Natural
_nOpt        = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateStakePoolTargetNum
    , _a0 :: HKD StrictMaybe NonNegativeInterval
_a0          = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe forall a b. (a -> b) -> a -> b
$ forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
                       Maybe Rational
protocolUpdatePoolPledgeInfluence
    , _rho :: HKD StrictMaybe UnitInterval
_rho         = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe forall a b. (a -> b) -> a -> b
$ forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
                        Maybe Rational
protocolUpdateMonetaryExpansion
    , _tau :: HKD StrictMaybe UnitInterval
_tau         = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe forall a b. (a -> b) -> a -> b
$ forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
                        Maybe Rational
protocolUpdateTreasuryCut
    , _d :: HKD StrictMaybe UnitInterval
_d           = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe forall a b. (a -> b) -> a -> b
$ forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
                        Maybe Rational
protocolUpdateDecentralization
    , _extraEntropy :: HKD StrictMaybe Nonce
_extraEntropy    = Maybe PraosNonce -> Nonce
toLedgerNonce forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                           forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy
    , _protocolVersion :: HKD StrictMaybe ProtVer
_protocolVersion = forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Natural -> Natural -> ProtVer
Ledger.ProtVer forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                           forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe (Natural, Natural)
protocolUpdateProtocolVersion
    , _minPoolCost :: HKD StrictMaybe Coin
_minPoolCost     = Lovelace -> Coin
toShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                           forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Lovelace
protocolUpdateMinPoolCost
    , _coinsPerUTxOWord :: HKD StrictMaybe Coin
_coinsPerUTxOWord  = Lovelace -> Coin
toShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                           forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Lovelace
protocolUpdateUTxOCostPerWord
    , _costmdls :: HKD StrictMaybe CostModels
_costmdls        = if forall k a. Map k a -> Bool
Map.null Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels
                           then forall a. StrictMaybe a
Ledger.SNothing
                           else forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a b. a -> b -> a
const forall a. StrictMaybe a
Ledger.SNothing) forall a. a -> StrictMaybe a
Ledger.SJust
                                  (Map AnyPlutusScriptVersion CostModel -> Either String CostModels
toAlonzoCostModels Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels)
    , _prices :: HKD StrictMaybe Prices
_prices          = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe forall a b. (a -> b) -> a -> b
$
                           ExecutionUnitPrices -> Maybe Prices
toAlonzoPrices forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe ExecutionUnitPrices
protocolUpdatePrices
    , _maxTxExUnits :: HKD StrictMaybe ExUnits
_maxTxExUnits    = ExecutionUnits -> ExUnits
toAlonzoExUnits  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                           forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe ExecutionUnits
protocolUpdateMaxTxExUnits
    , _maxBlockExUnits :: HKD StrictMaybe ExUnits
_maxBlockExUnits = ExecutionUnits -> ExUnits
toAlonzoExUnits  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                           forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits
    , _maxValSize :: HKD StrictMaybe Natural
_maxValSize      = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateMaxValueSize
    , _collateralPercentage :: HKD StrictMaybe Natural
_collateralPercentage = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateCollateralPercent
    , _maxCollateralInputs :: HKD StrictMaybe Natural
_maxCollateralInputs  = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateMaxCollateralInputs
    }

-- Decentralization and extra entropy are deprecated in Babbage
toBabbagePParamsUpdate :: ProtocolParametersUpdate
                       -> BabbagePParamsUpdate ledgerera
toBabbagePParamsUpdate :: forall ledgerera.
ProtocolParametersUpdate -> BabbagePParamsUpdate ledgerera
toBabbagePParamsUpdate
    ProtocolParametersUpdate {
      Maybe (Natural, Natural)
protocolUpdateProtocolVersion :: Maybe (Natural, Natural)
protocolUpdateProtocolVersion :: ProtocolParametersUpdate -> Maybe (Natural, Natural)
protocolUpdateProtocolVersion
    , Maybe Natural
protocolUpdateMaxBlockHeaderSize :: Maybe Natural
protocolUpdateMaxBlockHeaderSize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxBlockHeaderSize
    , Maybe Natural
protocolUpdateMaxBlockBodySize :: Maybe Natural
protocolUpdateMaxBlockBodySize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxBlockBodySize
    , Maybe Natural
protocolUpdateMaxTxSize :: Maybe Natural
protocolUpdateMaxTxSize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxTxSize
    , Maybe Natural
protocolUpdateTxFeeFixed :: Maybe Natural
protocolUpdateTxFeeFixed :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateTxFeeFixed
    , Maybe Natural
protocolUpdateTxFeePerByte :: Maybe Natural
protocolUpdateTxFeePerByte :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateTxFeePerByte
    , Maybe Lovelace
protocolUpdateStakeAddressDeposit :: Maybe Lovelace
protocolUpdateStakeAddressDeposit :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateStakeAddressDeposit
    , Maybe Lovelace
protocolUpdateStakePoolDeposit :: Maybe Lovelace
protocolUpdateStakePoolDeposit :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateStakePoolDeposit
    , Maybe Lovelace
protocolUpdateMinPoolCost :: Maybe Lovelace
protocolUpdateMinPoolCost :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateMinPoolCost
    , Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch :: Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch :: ProtocolParametersUpdate -> Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch
    , Maybe Natural
protocolUpdateStakePoolTargetNum :: Maybe Natural
protocolUpdateStakePoolTargetNum :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateStakePoolTargetNum
    , Maybe Rational
protocolUpdatePoolPledgeInfluence :: Maybe Rational
protocolUpdatePoolPledgeInfluence :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdatePoolPledgeInfluence
    , Maybe Rational
protocolUpdateMonetaryExpansion :: Maybe Rational
protocolUpdateMonetaryExpansion :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdateMonetaryExpansion
    , Maybe Rational
protocolUpdateTreasuryCut :: Maybe Rational
protocolUpdateTreasuryCut :: ProtocolParametersUpdate -> Maybe Rational
protocolUpdateTreasuryCut
    , Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels :: Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels :: ProtocolParametersUpdate -> Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels
    , Maybe ExecutionUnitPrices
protocolUpdatePrices :: Maybe ExecutionUnitPrices
protocolUpdatePrices :: ProtocolParametersUpdate -> Maybe ExecutionUnitPrices
protocolUpdatePrices
    , Maybe ExecutionUnits
protocolUpdateMaxTxExUnits :: Maybe ExecutionUnits
protocolUpdateMaxTxExUnits :: ProtocolParametersUpdate -> Maybe ExecutionUnits
protocolUpdateMaxTxExUnits
    , Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits :: Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits :: ProtocolParametersUpdate -> Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits
    , Maybe Natural
protocolUpdateMaxValueSize :: Maybe Natural
protocolUpdateMaxValueSize :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxValueSize
    , Maybe Natural
protocolUpdateCollateralPercent :: Maybe Natural
protocolUpdateCollateralPercent :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateCollateralPercent
    , Maybe Natural
protocolUpdateMaxCollateralInputs :: Maybe Natural
protocolUpdateMaxCollateralInputs :: ProtocolParametersUpdate -> Maybe Natural
protocolUpdateMaxCollateralInputs
    , Maybe Lovelace
protocolUpdateUTxOCostPerByte :: Maybe Lovelace
protocolUpdateUTxOCostPerByte :: ProtocolParametersUpdate -> Maybe Lovelace
protocolUpdateUTxOCostPerByte
    } =
    BabbagePParams {
      _minfeeA :: HKD StrictMaybe Natural
_minfeeA     = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateTxFeePerByte
    , _minfeeB :: HKD StrictMaybe Natural
_minfeeB     = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateTxFeeFixed
    , _maxBBSize :: HKD StrictMaybe Natural
_maxBBSize   = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateMaxBlockBodySize
    , _maxTxSize :: HKD StrictMaybe Natural
_maxTxSize   = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateMaxTxSize
    , _maxBHSize :: HKD StrictMaybe Natural
_maxBHSize   = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateMaxBlockHeaderSize
    , _keyDeposit :: HKD StrictMaybe Coin
_keyDeposit  = Lovelace -> Coin
toShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                      forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Lovelace
protocolUpdateStakeAddressDeposit
    , _poolDeposit :: HKD StrictMaybe Coin
_poolDeposit = Lovelace -> Coin
toShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                      forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Lovelace
protocolUpdateStakePoolDeposit
    , _eMax :: HKD StrictMaybe EpochNo
_eMax        = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch
    , _nOpt :: HKD StrictMaybe Natural
_nOpt        = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateStakePoolTargetNum
    , _a0 :: HKD StrictMaybe NonNegativeInterval
_a0          = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe forall a b. (a -> b) -> a -> b
$ forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
                      Maybe Rational
protocolUpdatePoolPledgeInfluence
    , _rho :: HKD StrictMaybe UnitInterval
_rho         = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe forall a b. (a -> b) -> a -> b
$ forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
                       Maybe Rational
protocolUpdateMonetaryExpansion
    , _tau :: HKD StrictMaybe UnitInterval
_tau         = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe forall a b. (a -> b) -> a -> b
$ forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
                       Maybe Rational
protocolUpdateTreasuryCut
    , _protocolVersion :: HKD StrictMaybe ProtVer
_protocolVersion = forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Natural -> Natural -> ProtVer
Ledger.ProtVer forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                          forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe (Natural, Natural)
protocolUpdateProtocolVersion
    , _minPoolCost :: HKD StrictMaybe Coin
_minPoolCost     = Lovelace -> Coin
toShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                           forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Lovelace
protocolUpdateMinPoolCost
    , _costmdls :: HKD StrictMaybe CostModels
_costmdls        = if forall k a. Map k a -> Bool
Map.null Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels
                          then forall a. StrictMaybe a
Ledger.SNothing
                          else forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a b. a -> b -> a
const forall a. StrictMaybe a
Ledger.SNothing) forall a. a -> StrictMaybe a
Ledger.SJust
                                 (Map AnyPlutusScriptVersion CostModel -> Either String CostModels
toAlonzoCostModels Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels)
    , _prices :: HKD StrictMaybe Prices
_prices          = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe forall a b. (a -> b) -> a -> b
$
                          ExecutionUnitPrices -> Maybe Prices
toAlonzoPrices forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe ExecutionUnitPrices
protocolUpdatePrices
    , _maxTxExUnits :: HKD StrictMaybe ExUnits
_maxTxExUnits    = ExecutionUnits -> ExUnits
toAlonzoExUnits  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                          forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe ExecutionUnits
protocolUpdateMaxTxExUnits
    , _maxBlockExUnits :: HKD StrictMaybe ExUnits
_maxBlockExUnits = ExecutionUnits -> ExUnits
toAlonzoExUnits  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                          forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits
    , _maxValSize :: HKD StrictMaybe Natural
_maxValSize      = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateMaxValueSize
    , _collateralPercentage :: HKD StrictMaybe Natural
_collateralPercentage = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateCollateralPercent
    , _maxCollateralInputs :: HKD StrictMaybe Natural
_maxCollateralInputs  = forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Natural
protocolUpdateMaxCollateralInputs
    , _coinsPerUTxOByte :: HKD StrictMaybe Coin
_coinsPerUTxOByte = Lovelace -> Coin
toShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                    forall a. Maybe a -> StrictMaybe a
noInlineMaybeToStrictMaybe Maybe Lovelace
protocolUpdateUTxOCostPerByte
    }

-- Conway uses the same PParams as Babbage.
toConwayPParamsUpdate :: ProtocolParametersUpdate
                       -> BabbagePParamsUpdate ledgerera
toConwayPParamsUpdate :: forall ledgerera.
ProtocolParametersUpdate -> BabbagePParamsUpdate ledgerera
toConwayPParamsUpdate = forall ledgerera.
ProtocolParametersUpdate -> BabbagePParamsUpdate ledgerera
toBabbagePParamsUpdate

-- ----------------------------------------------------------------------------
-- Conversion functions: updates from ledger types
--

fromLedgerUpdate :: forall era ledgerera.
                    ShelleyLedgerEra era ~ ledgerera
                 => Ledger.Crypto ledgerera ~ StandardCrypto
                 => ShelleyBasedEra era
                 -> Ledger.Update ledgerera
                 -> UpdateProposal
fromLedgerUpdate :: forall era ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Crypto ledgerera ~ StandardCrypto) =>
ShelleyBasedEra era -> Update ledgerera -> UpdateProposal
fromLedgerUpdate ShelleyBasedEra era
era (Ledger.Update ProposedPPUpdates ledgerera
ppup EpochNo
epochno) =
    Map (Hash GenesisKey) ProtocolParametersUpdate
-> EpochNo -> UpdateProposal
UpdateProposal (forall era ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Crypto ledgerera ~ StandardCrypto) =>
ShelleyBasedEra era
-> ProposedPPUpdates ledgerera
-> Map (Hash GenesisKey) ProtocolParametersUpdate
fromLedgerProposedPPUpdates ShelleyBasedEra era
era ProposedPPUpdates ledgerera
ppup) EpochNo
epochno


fromLedgerProposedPPUpdates :: forall era ledgerera.
                               ShelleyLedgerEra era ~ ledgerera
                            => Ledger.Crypto ledgerera ~ StandardCrypto
                            => ShelleyBasedEra era
                            -> Ledger.ProposedPPUpdates ledgerera
                            -> Map (Hash GenesisKey) ProtocolParametersUpdate
fromLedgerProposedPPUpdates :: forall era ledgerera.
(ShelleyLedgerEra era ~ ledgerera,
 Crypto ledgerera ~ StandardCrypto) =>
ShelleyBasedEra era
-> ProposedPPUpdates ledgerera
-> Map (Hash GenesisKey) ProtocolParametersUpdate
fromLedgerProposedPPUpdates ShelleyBasedEra era
era =
    forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (forall era.
ShelleyBasedEra era
-> PParamsUpdate (ShelleyLedgerEra era) -> ProtocolParametersUpdate
fromLedgerPParamsUpdate ShelleyBasedEra era
era)
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k1 k2 a. (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeysMonotonic KeyHash 'Genesis StandardCrypto -> Hash GenesisKey
GenesisKeyHash
  forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\(Ledger.ProposedPPUpdates Map (KeyHash 'Genesis (Crypto ledgerera)) (PParamsUpdate ledgerera)
ppup) -> Map (KeyHash 'Genesis (Crypto ledgerera)) (PParamsUpdate ledgerera)
ppup)


fromLedgerPParamsUpdate :: ShelleyBasedEra era
                       -> Ledger.PParamsUpdate (ShelleyLedgerEra era)
                       -> ProtocolParametersUpdate
fromLedgerPParamsUpdate :: forall era.
ShelleyBasedEra era
-> PParamsUpdate (ShelleyLedgerEra era) -> ProtocolParametersUpdate
fromLedgerPParamsUpdate ShelleyBasedEra era
ShelleyBasedEraShelley = forall ledgerera.
ShelleyPParamsUpdate ledgerera -> ProtocolParametersUpdate
fromShelleyPParamsUpdate
fromLedgerPParamsUpdate ShelleyBasedEra era
ShelleyBasedEraAllegra = forall ledgerera.
ShelleyPParamsUpdate ledgerera -> ProtocolParametersUpdate
fromShelleyPParamsUpdate
fromLedgerPParamsUpdate ShelleyBasedEra era
ShelleyBasedEraMary    = forall ledgerera.
ShelleyPParamsUpdate ledgerera -> ProtocolParametersUpdate
fromShelleyPParamsUpdate
fromLedgerPParamsUpdate ShelleyBasedEra era
ShelleyBasedEraAlonzo  = forall ledgerera.
AlonzoPParamsUpdate ledgerera -> ProtocolParametersUpdate
fromAlonzoPParamsUpdate
fromLedgerPParamsUpdate ShelleyBasedEra era
ShelleyBasedEraBabbage = forall ledgerera.
BabbagePParamsUpdate ledgerera -> ProtocolParametersUpdate
fromBabbagePParamsUpdate
fromLedgerPParamsUpdate ShelleyBasedEra era
ShelleyBasedEraConway  = forall ledgerera.
BabbagePParamsUpdate ledgerera -> ProtocolParametersUpdate
fromConwayPParamsUpdate


fromShelleyPParamsUpdate :: ShelleyPParamsUpdate ledgerera
                         -> ProtocolParametersUpdate
fromShelleyPParamsUpdate :: forall ledgerera.
ShelleyPParamsUpdate ledgerera -> ProtocolParametersUpdate
fromShelleyPParamsUpdate
    ShelleyPParams {
      HKD StrictMaybe Natural
_minfeeA :: HKD StrictMaybe Natural
_minfeeA :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Natural
_minfeeA
    , HKD StrictMaybe Natural
_minfeeB :: HKD StrictMaybe Natural
_minfeeB :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Natural
_minfeeB
    , HKD StrictMaybe Natural
_maxBBSize :: HKD StrictMaybe Natural
_maxBBSize :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Natural
_maxBBSize
    , HKD StrictMaybe Natural
_maxTxSize :: HKD StrictMaybe Natural
_maxTxSize :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Natural
_maxTxSize
    , HKD StrictMaybe Natural
_maxBHSize :: HKD StrictMaybe Natural
_maxBHSize :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Natural
_maxBHSize
    , HKD StrictMaybe Coin
_keyDeposit :: HKD StrictMaybe Coin
_keyDeposit :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Coin
_keyDeposit
    , HKD StrictMaybe Coin
_poolDeposit :: HKD StrictMaybe Coin
_poolDeposit :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Coin
_poolDeposit
    , HKD StrictMaybe EpochNo
_eMax :: HKD StrictMaybe EpochNo
_eMax :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f EpochNo
_eMax
    , HKD StrictMaybe Natural
_nOpt :: HKD StrictMaybe Natural
_nOpt :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Natural
_nOpt
    , HKD StrictMaybe NonNegativeInterval
_a0 :: HKD StrictMaybe NonNegativeInterval
_a0 :: forall (f :: * -> *) era.
ShelleyPParamsHKD f era -> HKD f NonNegativeInterval
_a0
    , HKD StrictMaybe UnitInterval
_rho :: HKD StrictMaybe UnitInterval
_rho :: forall (f :: * -> *) era.
ShelleyPParamsHKD f era -> HKD f UnitInterval
_rho
    , HKD StrictMaybe UnitInterval
_tau :: HKD StrictMaybe UnitInterval
_tau :: forall (f :: * -> *) era.
ShelleyPParamsHKD f era -> HKD f UnitInterval
_tau
    , HKD StrictMaybe UnitInterval
_d :: HKD StrictMaybe UnitInterval
_d :: forall (f :: * -> *) era.
ShelleyPParamsHKD f era -> HKD f UnitInterval
_d
    , HKD StrictMaybe Nonce
_extraEntropy :: HKD StrictMaybe Nonce
_extraEntropy :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Nonce
_extraEntropy
    , HKD StrictMaybe ProtVer
_protocolVersion :: HKD StrictMaybe ProtVer
_protocolVersion :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f ProtVer
_protocolVersion
    , HKD StrictMaybe Coin
_minUTxOValue :: HKD StrictMaybe Coin
_minUTxOValue :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Coin
_minUTxOValue
    , HKD StrictMaybe Coin
_minPoolCost :: HKD StrictMaybe Coin
_minPoolCost :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Coin
_minPoolCost
    } =
    ProtocolParametersUpdate {
      protocolUpdateProtocolVersion :: Maybe (Natural, Natural)
protocolUpdateProtocolVersion     = (\(Ledger.ProtVer Natural
a Natural
b) -> (Natural
a,Natural
b)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                          forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe ProtVer
_protocolVersion
    , protocolUpdateDecentralization :: Maybe Rational
protocolUpdateDecentralization    = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe UnitInterval
_d
    , protocolUpdateExtraPraosEntropy :: Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy   = Nonce -> Maybe PraosNonce
fromLedgerNonce forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Nonce
_extraEntropy
    , protocolUpdateMaxBlockHeaderSize :: Maybe Natural
protocolUpdateMaxBlockHeaderSize  = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_maxBHSize
    , protocolUpdateMaxBlockBodySize :: Maybe Natural
protocolUpdateMaxBlockBodySize    = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_maxBBSize
    , protocolUpdateMaxTxSize :: Maybe Natural
protocolUpdateMaxTxSize           = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_maxTxSize
    , protocolUpdateTxFeeFixed :: Maybe Natural
protocolUpdateTxFeeFixed          = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_minfeeB
    , protocolUpdateTxFeePerByte :: Maybe Natural
protocolUpdateTxFeePerByte        = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_minfeeA
    , protocolUpdateMinUTxOValue :: Maybe Lovelace
protocolUpdateMinUTxOValue        = Coin -> Lovelace
fromShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Coin
_minUTxOValue
    , protocolUpdateStakeAddressDeposit :: Maybe Lovelace
protocolUpdateStakeAddressDeposit = Coin -> Lovelace
fromShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Coin
_keyDeposit
    , protocolUpdateStakePoolDeposit :: Maybe Lovelace
protocolUpdateStakePoolDeposit    = Coin -> Lovelace
fromShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Coin
_poolDeposit
    , protocolUpdateMinPoolCost :: Maybe Lovelace
protocolUpdateMinPoolCost         = Coin -> Lovelace
fromShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Coin
_minPoolCost
    , protocolUpdatePoolRetireMaxEpoch :: Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch  = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe EpochNo
_eMax
    , protocolUpdateStakePoolTargetNum :: Maybe Natural
protocolUpdateStakePoolTargetNum  = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_nOpt
    , protocolUpdatePoolPledgeInfluence :: Maybe Rational
protocolUpdatePoolPledgeInfluence = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe NonNegativeInterval
_a0
    , protocolUpdateMonetaryExpansion :: Maybe Rational
protocolUpdateMonetaryExpansion   = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe UnitInterval
_rho
    , protocolUpdateTreasuryCut :: Maybe Rational
protocolUpdateTreasuryCut         = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe UnitInterval
_tau
    , protocolUpdateUTxOCostPerWord :: Maybe Lovelace
protocolUpdateUTxOCostPerWord     = forall a. Maybe a
Nothing
    , protocolUpdateCostModels :: Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels          = forall a. Monoid a => a
mempty
    , protocolUpdatePrices :: Maybe ExecutionUnitPrices
protocolUpdatePrices              = forall a. Maybe a
Nothing
    , protocolUpdateMaxTxExUnits :: Maybe ExecutionUnits
protocolUpdateMaxTxExUnits        = forall a. Maybe a
Nothing
    , protocolUpdateMaxBlockExUnits :: Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits     = forall a. Maybe a
Nothing
    , protocolUpdateMaxValueSize :: Maybe Natural
protocolUpdateMaxValueSize        = forall a. Maybe a
Nothing
    , protocolUpdateCollateralPercent :: Maybe Natural
protocolUpdateCollateralPercent   = forall a. Maybe a
Nothing
    , protocolUpdateMaxCollateralInputs :: Maybe Natural
protocolUpdateMaxCollateralInputs = forall a. Maybe a
Nothing
    , protocolUpdateUTxOCostPerByte :: Maybe Lovelace
protocolUpdateUTxOCostPerByte     = forall a. Maybe a
Nothing
    }

fromAlonzoPParamsUpdate :: AlonzoPParamsUpdate ledgerera
                        -> ProtocolParametersUpdate
fromAlonzoPParamsUpdate :: forall ledgerera.
AlonzoPParamsUpdate ledgerera -> ProtocolParametersUpdate
fromAlonzoPParamsUpdate
    AlonzoPParams {
      HKD StrictMaybe Natural
_minfeeA :: HKD StrictMaybe Natural
_minfeeA :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_minfeeA
    , HKD StrictMaybe Natural
_minfeeB :: HKD StrictMaybe Natural
_minfeeB :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_minfeeB
    , HKD StrictMaybe Natural
_maxBBSize :: HKD StrictMaybe Natural
_maxBBSize :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_maxBBSize
    , HKD StrictMaybe Natural
_maxTxSize :: HKD StrictMaybe Natural
_maxTxSize :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_maxTxSize
    , HKD StrictMaybe Natural
_maxBHSize :: HKD StrictMaybe Natural
_maxBHSize :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_maxBHSize
    , HKD StrictMaybe Coin
_keyDeposit :: HKD StrictMaybe Coin
_keyDeposit :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Coin
_keyDeposit
    , HKD StrictMaybe Coin
_poolDeposit :: HKD StrictMaybe Coin
_poolDeposit :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Coin
_poolDeposit
    , HKD StrictMaybe EpochNo
_eMax :: HKD StrictMaybe EpochNo
_eMax :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f EpochNo
_eMax
    , HKD StrictMaybe Natural
_nOpt :: HKD StrictMaybe Natural
_nOpt :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_nOpt
    , HKD StrictMaybe NonNegativeInterval
_a0 :: HKD StrictMaybe NonNegativeInterval
_a0 :: forall (f :: * -> *) era.
AlonzoPParamsHKD f era -> HKD f NonNegativeInterval
_a0
    , HKD StrictMaybe UnitInterval
_rho :: HKD StrictMaybe UnitInterval
_rho :: forall (f :: * -> *) era.
AlonzoPParamsHKD f era -> HKD f UnitInterval
_rho
    , HKD StrictMaybe UnitInterval
_tau :: HKD StrictMaybe UnitInterval
_tau :: forall (f :: * -> *) era.
AlonzoPParamsHKD f era -> HKD f UnitInterval
_tau
    , HKD StrictMaybe UnitInterval
_d :: HKD StrictMaybe UnitInterval
_d :: forall (f :: * -> *) era.
AlonzoPParamsHKD f era -> HKD f UnitInterval
_d
    , HKD StrictMaybe Nonce
_extraEntropy :: HKD StrictMaybe Nonce
_extraEntropy :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Nonce
_extraEntropy
    , HKD StrictMaybe ProtVer
_protocolVersion :: HKD StrictMaybe ProtVer
_protocolVersion :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f ProtVer
_protocolVersion
    , HKD StrictMaybe Coin
_minPoolCost :: HKD StrictMaybe Coin
_minPoolCost :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Coin
_minPoolCost
    , HKD StrictMaybe Coin
_coinsPerUTxOWord :: HKD StrictMaybe Coin
_coinsPerUTxOWord :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Coin
_coinsPerUTxOWord
    , HKD StrictMaybe CostModels
_costmdls :: HKD StrictMaybe CostModels
_costmdls :: forall (f :: * -> *) era.
AlonzoPParamsHKD f era -> HKD f CostModels
_costmdls
    , HKD StrictMaybe Prices
_prices :: HKD StrictMaybe Prices
_prices :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Prices
_prices
    , HKD StrictMaybe ExUnits
_maxTxExUnits :: HKD StrictMaybe ExUnits
_maxTxExUnits :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f ExUnits
_maxTxExUnits
    , HKD StrictMaybe ExUnits
_maxBlockExUnits :: HKD StrictMaybe ExUnits
_maxBlockExUnits :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f ExUnits
_maxBlockExUnits
    , HKD StrictMaybe Natural
_maxValSize :: HKD StrictMaybe Natural
_maxValSize :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_maxValSize
    , HKD StrictMaybe Natural
_collateralPercentage :: HKD StrictMaybe Natural
_collateralPercentage :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_collateralPercentage
    , HKD StrictMaybe Natural
_maxCollateralInputs :: HKD StrictMaybe Natural
_maxCollateralInputs :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_maxCollateralInputs
    } =
    ProtocolParametersUpdate {
      protocolUpdateProtocolVersion :: Maybe (Natural, Natural)
protocolUpdateProtocolVersion     = (\(Ledger.ProtVer Natural
a Natural
b) -> (Natural
a,Natural
b)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                          forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe ProtVer
_protocolVersion
    , protocolUpdateDecentralization :: Maybe Rational
protocolUpdateDecentralization    = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe UnitInterval
_d
    , protocolUpdateExtraPraosEntropy :: Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy   = Nonce -> Maybe PraosNonce
fromLedgerNonce forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Nonce
_extraEntropy
    , protocolUpdateMaxBlockHeaderSize :: Maybe Natural
protocolUpdateMaxBlockHeaderSize  = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_maxBHSize
    , protocolUpdateMaxBlockBodySize :: Maybe Natural
protocolUpdateMaxBlockBodySize    = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_maxBBSize
    , protocolUpdateMaxTxSize :: Maybe Natural
protocolUpdateMaxTxSize           = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_maxTxSize
    , protocolUpdateTxFeeFixed :: Maybe Natural
protocolUpdateTxFeeFixed          = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_minfeeB
    , protocolUpdateTxFeePerByte :: Maybe Natural
protocolUpdateTxFeePerByte        = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_minfeeA
    , protocolUpdateMinUTxOValue :: Maybe Lovelace
protocolUpdateMinUTxOValue        = forall a. Maybe a
Nothing
    , protocolUpdateStakeAddressDeposit :: Maybe Lovelace
protocolUpdateStakeAddressDeposit = Coin -> Lovelace
fromShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Coin
_keyDeposit
    , protocolUpdateStakePoolDeposit :: Maybe Lovelace
protocolUpdateStakePoolDeposit    = Coin -> Lovelace
fromShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Coin
_poolDeposit
    , protocolUpdateMinPoolCost :: Maybe Lovelace
protocolUpdateMinPoolCost         = Coin -> Lovelace
fromShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Coin
_minPoolCost
    , protocolUpdatePoolRetireMaxEpoch :: Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch  = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe EpochNo
_eMax
    , protocolUpdateStakePoolTargetNum :: Maybe Natural
protocolUpdateStakePoolTargetNum  = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_nOpt
    , protocolUpdatePoolPledgeInfluence :: Maybe Rational
protocolUpdatePoolPledgeInfluence = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe NonNegativeInterval
_a0
    , protocolUpdateMonetaryExpansion :: Maybe Rational
protocolUpdateMonetaryExpansion   = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe UnitInterval
_rho
    , protocolUpdateTreasuryCut :: Maybe Rational
protocolUpdateTreasuryCut         = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe UnitInterval
_tau
    , protocolUpdateUTxOCostPerWord :: Maybe Lovelace
protocolUpdateUTxOCostPerWord     = Coin -> Lovelace
fromShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Coin
_coinsPerUTxOWord
    , protocolUpdateCostModels :: Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels          = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. Monoid a => a
mempty CostModels -> Map AnyPlutusScriptVersion CostModel
fromAlonzoCostModels
                                               (forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe CostModels
_costmdls)
    , protocolUpdatePrices :: Maybe ExecutionUnitPrices
protocolUpdatePrices              = Prices -> ExecutionUnitPrices
fromAlonzoPrices forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Prices
_prices
    , protocolUpdateMaxTxExUnits :: Maybe ExecutionUnits
protocolUpdateMaxTxExUnits        = ExUnits -> ExecutionUnits
fromAlonzoExUnits forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe ExUnits
_maxTxExUnits
    , protocolUpdateMaxBlockExUnits :: Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits     = ExUnits -> ExecutionUnits
fromAlonzoExUnits forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe ExUnits
_maxBlockExUnits
    , protocolUpdateMaxValueSize :: Maybe Natural
protocolUpdateMaxValueSize        = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_maxValSize
    , protocolUpdateCollateralPercent :: Maybe Natural
protocolUpdateCollateralPercent   = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_collateralPercentage
    , protocolUpdateMaxCollateralInputs :: Maybe Natural
protocolUpdateMaxCollateralInputs = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_maxCollateralInputs
    , protocolUpdateUTxOCostPerByte :: Maybe Lovelace
protocolUpdateUTxOCostPerByte     = forall a. Maybe a
Nothing
    }


fromBabbagePParamsUpdate :: BabbagePParamsUpdate ledgerera
                         -> ProtocolParametersUpdate
fromBabbagePParamsUpdate :: forall ledgerera.
BabbagePParamsUpdate ledgerera -> ProtocolParametersUpdate
fromBabbagePParamsUpdate
    BabbagePParams {
      HKD StrictMaybe Natural
_minfeeA :: HKD StrictMaybe Natural
_minfeeA :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_minfeeA
    , HKD StrictMaybe Natural
_minfeeB :: HKD StrictMaybe Natural
_minfeeB :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_minfeeB
    , HKD StrictMaybe Natural
_maxBBSize :: HKD StrictMaybe Natural
_maxBBSize :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_maxBBSize
    , HKD StrictMaybe Natural
_maxTxSize :: HKD StrictMaybe Natural
_maxTxSize :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_maxTxSize
    , HKD StrictMaybe Natural
_maxBHSize :: HKD StrictMaybe Natural
_maxBHSize :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_maxBHSize
    , HKD StrictMaybe Coin
_keyDeposit :: HKD StrictMaybe Coin
_keyDeposit :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Coin
_keyDeposit
    , HKD StrictMaybe Coin
_poolDeposit :: HKD StrictMaybe Coin
_poolDeposit :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Coin
_poolDeposit
    , HKD StrictMaybe EpochNo
_eMax :: HKD StrictMaybe EpochNo
_eMax :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f EpochNo
_eMax
    , HKD StrictMaybe Natural
_nOpt :: HKD StrictMaybe Natural
_nOpt :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_nOpt
    , HKD StrictMaybe NonNegativeInterval
_a0 :: HKD StrictMaybe NonNegativeInterval
_a0 :: forall (f :: * -> *) era.
BabbagePParamsHKD f era -> HKD f NonNegativeInterval
_a0
    , HKD StrictMaybe UnitInterval
_rho :: HKD StrictMaybe UnitInterval
_rho :: forall (f :: * -> *) era.
BabbagePParamsHKD f era -> HKD f UnitInterval
_rho
    , HKD StrictMaybe UnitInterval
_tau :: HKD StrictMaybe UnitInterval
_tau :: forall (f :: * -> *) era.
BabbagePParamsHKD f era -> HKD f UnitInterval
_tau
    , HKD StrictMaybe ProtVer
_protocolVersion :: HKD StrictMaybe ProtVer
_protocolVersion :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f ProtVer
_protocolVersion
    , HKD StrictMaybe Coin
_minPoolCost :: HKD StrictMaybe Coin
_minPoolCost :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Coin
_minPoolCost
    , HKD StrictMaybe Coin
_coinsPerUTxOByte :: HKD StrictMaybe Coin
_coinsPerUTxOByte :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Coin
_coinsPerUTxOByte
    , HKD StrictMaybe CostModels
_costmdls :: HKD StrictMaybe CostModels
_costmdls :: forall (f :: * -> *) era.
BabbagePParamsHKD f era -> HKD f CostModels
_costmdls
    , HKD StrictMaybe Prices
_prices :: HKD StrictMaybe Prices
_prices :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Prices
_prices
    , HKD StrictMaybe ExUnits
_maxTxExUnits :: HKD StrictMaybe ExUnits
_maxTxExUnits :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f ExUnits
_maxTxExUnits
    , HKD StrictMaybe ExUnits
_maxBlockExUnits :: HKD StrictMaybe ExUnits
_maxBlockExUnits :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f ExUnits
_maxBlockExUnits
    , HKD StrictMaybe Natural
_maxValSize :: HKD StrictMaybe Natural
_maxValSize :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_maxValSize
    , HKD StrictMaybe Natural
_collateralPercentage :: HKD StrictMaybe Natural
_collateralPercentage :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_collateralPercentage
    , HKD StrictMaybe Natural
_maxCollateralInputs :: HKD StrictMaybe Natural
_maxCollateralInputs :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_maxCollateralInputs
    } =
    ProtocolParametersUpdate {
      protocolUpdateProtocolVersion :: Maybe (Natural, Natural)
protocolUpdateProtocolVersion     = (\(Ledger.ProtVer Natural
a Natural
b) -> (Natural
a,Natural
b)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                          forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe ProtVer
_protocolVersion
    , protocolUpdateDecentralization :: Maybe Rational
protocolUpdateDecentralization    = forall a. Maybe a
Nothing
    , protocolUpdateExtraPraosEntropy :: Maybe (Maybe PraosNonce)
protocolUpdateExtraPraosEntropy   = forall a. Maybe a
Nothing
    , protocolUpdateMaxBlockHeaderSize :: Maybe Natural
protocolUpdateMaxBlockHeaderSize  = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_maxBHSize
    , protocolUpdateMaxBlockBodySize :: Maybe Natural
protocolUpdateMaxBlockBodySize    = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_maxBBSize
    , protocolUpdateMaxTxSize :: Maybe Natural
protocolUpdateMaxTxSize           = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_maxTxSize
    , protocolUpdateTxFeeFixed :: Maybe Natural
protocolUpdateTxFeeFixed          = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_minfeeB
    , protocolUpdateTxFeePerByte :: Maybe Natural
protocolUpdateTxFeePerByte        = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_minfeeA
    , protocolUpdateMinUTxOValue :: Maybe Lovelace
protocolUpdateMinUTxOValue        = forall a. Maybe a
Nothing
    , protocolUpdateStakeAddressDeposit :: Maybe Lovelace
protocolUpdateStakeAddressDeposit = Coin -> Lovelace
fromShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Coin
_keyDeposit
    , protocolUpdateStakePoolDeposit :: Maybe Lovelace
protocolUpdateStakePoolDeposit    = Coin -> Lovelace
fromShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Coin
_poolDeposit
    , protocolUpdateMinPoolCost :: Maybe Lovelace
protocolUpdateMinPoolCost         = Coin -> Lovelace
fromShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Coin
_minPoolCost
    , protocolUpdatePoolRetireMaxEpoch :: Maybe EpochNo
protocolUpdatePoolRetireMaxEpoch  = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe EpochNo
_eMax
    , protocolUpdateStakePoolTargetNum :: Maybe Natural
protocolUpdateStakePoolTargetNum  = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_nOpt
    , protocolUpdatePoolPledgeInfluence :: Maybe Rational
protocolUpdatePoolPledgeInfluence = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe NonNegativeInterval
_a0
    , protocolUpdateMonetaryExpansion :: Maybe Rational
protocolUpdateMonetaryExpansion   = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe UnitInterval
_rho
    , protocolUpdateTreasuryCut :: Maybe Rational
protocolUpdateTreasuryCut         = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe UnitInterval
_tau
    , protocolUpdateUTxOCostPerWord :: Maybe Lovelace
protocolUpdateUTxOCostPerWord     = forall a. Maybe a
Nothing
    , protocolUpdateCostModels :: Map AnyPlutusScriptVersion CostModel
protocolUpdateCostModels          = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. Monoid a => a
mempty CostModels -> Map AnyPlutusScriptVersion CostModel
fromAlonzoCostModels
                                               (forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe CostModels
_costmdls)
    , protocolUpdatePrices :: Maybe ExecutionUnitPrices
protocolUpdatePrices              = Prices -> ExecutionUnitPrices
fromAlonzoPrices forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Prices
_prices
    , protocolUpdateMaxTxExUnits :: Maybe ExecutionUnits
protocolUpdateMaxTxExUnits        = ExUnits -> ExecutionUnits
fromAlonzoExUnits forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe ExUnits
_maxTxExUnits
    , protocolUpdateMaxBlockExUnits :: Maybe ExecutionUnits
protocolUpdateMaxBlockExUnits     = ExUnits -> ExecutionUnits
fromAlonzoExUnits forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe ExUnits
_maxBlockExUnits
    , protocolUpdateMaxValueSize :: Maybe Natural
protocolUpdateMaxValueSize        = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_maxValSize
    , protocolUpdateCollateralPercent :: Maybe Natural
protocolUpdateCollateralPercent   = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_collateralPercentage
    , protocolUpdateMaxCollateralInputs :: Maybe Natural
protocolUpdateMaxCollateralInputs = forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Natural
_maxCollateralInputs
    , protocolUpdateUTxOCostPerByte :: Maybe Lovelace
protocolUpdateUTxOCostPerByte     = Coin -> Lovelace
fromShelleyLovelace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe HKD StrictMaybe Coin
_coinsPerUTxOByte
    }

fromConwayPParamsUpdate :: BabbagePParamsUpdate ledgerera
                         -> ProtocolParametersUpdate
fromConwayPParamsUpdate :: forall ledgerera.
BabbagePParamsUpdate ledgerera -> ProtocolParametersUpdate
fromConwayPParamsUpdate = forall ledgerera.
BabbagePParamsUpdate ledgerera -> ProtocolParametersUpdate
fromBabbagePParamsUpdate

-- | Bundle cardano-api representation and ledger representation of protocol parameters together so
-- they can be computed once and passed around rather than re-computed unecessarily.
--
-- The consructor arguments are intentionally lazy so that the values are not computed if not used
-- (which may be the case for some code paths).
data BundledProtocolParameters era where
  BundleAsByronProtocolParameters
    :: ProtocolParameters
    -> BundledProtocolParameters ByronEra
  BundleAsShelleyBasedProtocolParameters
    :: ShelleyBasedEra era
    -> ProtocolParameters
    -> Ledger.PParams (ShelleyLedgerEra era)
    -> BundledProtocolParameters era

bundleProtocolParams :: CardanoEra era -> ProtocolParameters -> BundledProtocolParameters era
bundleProtocolParams :: forall era.
CardanoEra era
-> ProtocolParameters -> BundledProtocolParameters era
bundleProtocolParams CardanoEra era
cEra ProtocolParameters
pp = case forall era. CardanoEra era -> CardanoEraStyle era
cardanoEraStyle CardanoEra era
cEra of
  CardanoEraStyle era
LegacyByronEra -> ProtocolParameters -> BundledProtocolParameters ByronEra
BundleAsByronProtocolParameters ProtocolParameters
pp
  ShelleyBasedEra ShelleyBasedEra era
sbe -> forall era.
ShelleyBasedEra era
-> ProtocolParameters
-> PParams (ShelleyLedgerEra era)
-> BundledProtocolParameters era
BundleAsShelleyBasedProtocolParameters ShelleyBasedEra era
sbe ProtocolParameters
pp (forall era.
ShelleyBasedEra era
-> ProtocolParameters -> PParams (ShelleyLedgerEra era)
toLedgerPParams ShelleyBasedEra era
sbe ProtocolParameters
pp)

unbundleLedgerShelleyBasedProtocolParams
  :: ShelleyBasedEra era
  -> BundledProtocolParameters era
  -> Ledger.PParams (ShelleyLedgerEra era)
unbundleLedgerShelleyBasedProtocolParams :: forall era.
ShelleyBasedEra era
-> BundledProtocolParameters era -> PParams (ShelleyLedgerEra era)
unbundleLedgerShelleyBasedProtocolParams = \case
  ShelleyBasedEra era
ShelleyBasedEraShelley -> \(BundleAsShelleyBasedProtocolParameters ShelleyBasedEra era
_ ProtocolParameters
_ PParams (ShelleyLedgerEra era)
lpp) -> PParams (ShelleyLedgerEra era)
lpp
  ShelleyBasedEra era
ShelleyBasedEraAllegra -> \(BundleAsShelleyBasedProtocolParameters ShelleyBasedEra era
_ ProtocolParameters
_ PParams (ShelleyLedgerEra era)
lpp) -> PParams (ShelleyLedgerEra era)
lpp
  ShelleyBasedEra era
ShelleyBasedEraMary -> \(BundleAsShelleyBasedProtocolParameters ShelleyBasedEra era
_ ProtocolParameters
_ PParams (ShelleyLedgerEra era)
lpp) -> PParams (ShelleyLedgerEra era)
lpp
  ShelleyBasedEra era
ShelleyBasedEraAlonzo -> \(BundleAsShelleyBasedProtocolParameters ShelleyBasedEra era
_ ProtocolParameters
_ PParams (ShelleyLedgerEra era)
lpp) -> PParams (ShelleyLedgerEra era)
lpp
  ShelleyBasedEra era
ShelleyBasedEraBabbage -> \(BundleAsShelleyBasedProtocolParameters ShelleyBasedEra era
_ ProtocolParameters
_ PParams (ShelleyLedgerEra era)
lpp) -> PParams (ShelleyLedgerEra era)
lpp
  ShelleyBasedEra era
ShelleyBasedEraConway -> \(BundleAsShelleyBasedProtocolParameters ShelleyBasedEra era
_ ProtocolParameters
_ PParams (ShelleyLedgerEra era)
lpp) -> PParams (ShelleyLedgerEra era)
lpp

unbundleProtocolParams :: BundledProtocolParameters era -> ProtocolParameters
unbundleProtocolParams :: forall era. BundledProtocolParameters era -> ProtocolParameters
unbundleProtocolParams (BundleAsByronProtocolParameters ProtocolParameters
pp) = ProtocolParameters
pp
unbundleProtocolParams (BundleAsShelleyBasedProtocolParameters ShelleyBasedEra era
_ ProtocolParameters
pp PParams (ShelleyLedgerEra era)
_) = ProtocolParameters
pp

-- ----------------------------------------------------------------------------
-- Conversion functions: protocol parameters to ledger types
--

--TODO: this has to be a Maybe or Either for some of the parameter validation.
-- Both parameters that must be present or absent in specific eras,
-- and parameter values that need validation, such as the Rational values
toLedgerPParams
  :: ShelleyBasedEra era
  -> ProtocolParameters
  -> Ledger.PParams (ShelleyLedgerEra era)
toLedgerPParams :: forall era.
ShelleyBasedEra era
-> ProtocolParameters -> PParams (ShelleyLedgerEra era)
toLedgerPParams ShelleyBasedEra era
ShelleyBasedEraShelley = forall ledgerera. ProtocolParameters -> ShelleyPParams ledgerera
toShelleyPParams
toLedgerPParams ShelleyBasedEra era
ShelleyBasedEraAllegra = forall ledgerera. ProtocolParameters -> ShelleyPParams ledgerera
toShelleyPParams
toLedgerPParams ShelleyBasedEra era
ShelleyBasedEraMary    = forall ledgerera. ProtocolParameters -> ShelleyPParams ledgerera
toShelleyPParams
toLedgerPParams ShelleyBasedEra era
ShelleyBasedEraAlonzo  = forall ledgerera. ProtocolParameters -> AlonzoPParams ledgerera
toAlonzoPParams
toLedgerPParams ShelleyBasedEra era
ShelleyBasedEraBabbage = forall ledgerera. ProtocolParameters -> BabbagePParams ledgerera
toBabbagePParams
toLedgerPParams ShelleyBasedEra era
ShelleyBasedEraConway  = forall ledgerera. ProtocolParameters -> BabbagePParams ledgerera
toConwayPParams

toShelleyPParams :: ProtocolParameters -> ShelleyPParams ledgerera
toShelleyPParams :: forall ledgerera. ProtocolParameters -> ShelleyPParams ledgerera
toShelleyPParams ProtocolParameters {
                   (Natural, Natural)
protocolParamProtocolVersion :: (Natural, Natural)
protocolParamProtocolVersion :: ProtocolParameters -> (Natural, Natural)
protocolParamProtocolVersion,
                   Maybe Rational
protocolParamDecentralization :: Maybe Rational
protocolParamDecentralization :: ProtocolParameters -> Maybe Rational
protocolParamDecentralization,
                   Maybe PraosNonce
protocolParamExtraPraosEntropy :: Maybe PraosNonce
protocolParamExtraPraosEntropy :: ProtocolParameters -> Maybe PraosNonce
protocolParamExtraPraosEntropy,
                   Natural
protocolParamMaxBlockHeaderSize :: Natural
protocolParamMaxBlockHeaderSize :: ProtocolParameters -> Natural
protocolParamMaxBlockHeaderSize,
                   Natural
protocolParamMaxBlockBodySize :: Natural
protocolParamMaxBlockBodySize :: ProtocolParameters -> Natural
protocolParamMaxBlockBodySize,
                   Natural
protocolParamMaxTxSize :: Natural
protocolParamMaxTxSize :: ProtocolParameters -> Natural
protocolParamMaxTxSize,
                   Natural
protocolParamTxFeeFixed :: Natural
protocolParamTxFeeFixed :: ProtocolParameters -> Natural
protocolParamTxFeeFixed,
                   Natural
protocolParamTxFeePerByte :: Natural
protocolParamTxFeePerByte :: ProtocolParameters -> Natural
protocolParamTxFeePerByte,
                   protocolParamMinUTxOValue :: ProtocolParameters -> Maybe Lovelace
protocolParamMinUTxOValue = Just Lovelace
minUTxOValue,
                   Lovelace
protocolParamStakeAddressDeposit :: Lovelace
protocolParamStakeAddressDeposit :: ProtocolParameters -> Lovelace
protocolParamStakeAddressDeposit,
                   Lovelace
protocolParamStakePoolDeposit :: Lovelace
protocolParamStakePoolDeposit :: ProtocolParameters -> Lovelace
protocolParamStakePoolDeposit,
                   Lovelace
protocolParamMinPoolCost :: Lovelace
protocolParamMinPoolCost :: ProtocolParameters -> Lovelace
protocolParamMinPoolCost,
                   EpochNo
protocolParamPoolRetireMaxEpoch :: EpochNo
protocolParamPoolRetireMaxEpoch :: ProtocolParameters -> EpochNo
protocolParamPoolRetireMaxEpoch,
                   Natural
protocolParamStakePoolTargetNum :: Natural
protocolParamStakePoolTargetNum :: ProtocolParameters -> Natural
protocolParamStakePoolTargetNum,
                   Rational
protocolParamPoolPledgeInfluence :: Rational
protocolParamPoolPledgeInfluence :: ProtocolParameters -> Rational
protocolParamPoolPledgeInfluence,
                   Rational
protocolParamMonetaryExpansion :: Rational
protocolParamMonetaryExpansion :: ProtocolParameters -> Rational
protocolParamMonetaryExpansion,
                   Rational
protocolParamTreasuryCut :: Rational
protocolParamTreasuryCut :: ProtocolParameters -> Rational
protocolParamTreasuryCut
                 } =
   ShelleyPParams
     { _protocolVersion :: HKD Identity ProtVer
_protocolVersion
                             = let (Natural
maj, Natural
minor) = (Natural, Natural)
protocolParamProtocolVersion
                                in Natural -> Natural -> ProtVer
Ledger.ProtVer Natural
maj Natural
minor
     , _d :: HKD Identity UnitInterval
_d            = case Maybe Rational
protocolParamDecentralization of
                                 -- The decentralization parameter is deprecated in Babbage
                                 -- so we default to 0 if no dentralization parameter is found
                                 -- in the api's 'ProtocolParameter' type. If we don't do this
                                 -- we won't be able to construct an Alonzo tx using the Babbage
                                 -- era's protocol parameter because our only other option is to
                                 -- error.
                                 Maybe Rational
Nothing -> forall a. Bounded a => a
minBound
                                 Just Rational
pDecentral ->
                                   forall a. a -> Maybe a -> a
fromMaybe
                                     (forall a. HasCallStack => String -> a
error String
"toShelleyPParams: invalid Decentralization value")
                                     (forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational Rational
pDecentral)
     , _extraEntropy :: HKD Identity Nonce
_extraEntropy = Maybe PraosNonce -> Nonce
toLedgerNonce Maybe PraosNonce
protocolParamExtraPraosEntropy
     , _maxBHSize :: HKD Identity Natural
_maxBHSize    = Natural
protocolParamMaxBlockHeaderSize
     , _maxBBSize :: HKD Identity Natural
_maxBBSize    = Natural
protocolParamMaxBlockBodySize
     , _maxTxSize :: HKD Identity Natural
_maxTxSize    = Natural
protocolParamMaxTxSize
     , _minfeeB :: HKD Identity Natural
_minfeeB      = Natural
protocolParamTxFeeFixed
     , _minfeeA :: HKD Identity Natural
_minfeeA      = Natural
protocolParamTxFeePerByte
     , _minUTxOValue :: HKD Identity Coin
_minUTxOValue = Lovelace -> Coin
toShelleyLovelace Lovelace
minUTxOValue
     , _keyDeposit :: HKD Identity Coin
_keyDeposit   = Lovelace -> Coin
toShelleyLovelace Lovelace
protocolParamStakeAddressDeposit
     , _poolDeposit :: HKD Identity Coin
_poolDeposit  = Lovelace -> Coin
toShelleyLovelace Lovelace
protocolParamStakePoolDeposit
     , _minPoolCost :: HKD Identity Coin
_minPoolCost  = Lovelace -> Coin
toShelleyLovelace Lovelace
protocolParamMinPoolCost
     , _eMax :: HKD Identity EpochNo
_eMax         = EpochNo
protocolParamPoolRetireMaxEpoch
     , _nOpt :: HKD Identity Natural
_nOpt         = Natural
protocolParamStakePoolTargetNum
     , _a0 :: HKD Identity NonNegativeInterval
_a0           = forall a. a -> Maybe a -> a
fromMaybe
                                 (forall a. HasCallStack => String -> a
error String
"toShelleyPParams: invalid PoolPledgeInfluence value")
                                 (forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational Rational
protocolParamPoolPledgeInfluence)
     , _rho :: HKD Identity UnitInterval
_rho          = forall a. a -> Maybe a -> a
fromMaybe
                                 (forall a. HasCallStack => String -> a
error String
"toShelleyPParams: invalid MonetaryExpansion value")
                                 (forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational Rational
protocolParamMonetaryExpansion)
     , _tau :: HKD Identity UnitInterval
_tau          = forall a. a -> Maybe a -> a
fromMaybe
                                 (forall a. HasCallStack => String -> a
error String
"toShelleyPParams: invalid TreasuryCut value")
                                 (forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational Rational
protocolParamTreasuryCut)
     }
toShelleyPParams ProtocolParameters { protocolParamMinUTxOValue :: ProtocolParameters -> Maybe Lovelace
protocolParamMinUTxOValue = Maybe Lovelace
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toShelleyPParams: must specify protocolParamMinUTxOValue"

toAlonzoPParams :: ProtocolParameters -> AlonzoPParams ledgerera
toAlonzoPParams :: forall ledgerera. ProtocolParameters -> AlonzoPParams ledgerera
toAlonzoPParams ProtocolParameters {
                   (Natural, Natural)
protocolParamProtocolVersion :: (Natural, Natural)
protocolParamProtocolVersion :: ProtocolParameters -> (Natural, Natural)
protocolParamProtocolVersion,
                   Maybe Rational
protocolParamDecentralization :: Maybe Rational
protocolParamDecentralization :: ProtocolParameters -> Maybe Rational
protocolParamDecentralization,
                   Maybe PraosNonce
protocolParamExtraPraosEntropy :: Maybe PraosNonce
protocolParamExtraPraosEntropy :: ProtocolParameters -> Maybe PraosNonce
protocolParamExtraPraosEntropy,
                   Natural
protocolParamMaxBlockHeaderSize :: Natural
protocolParamMaxBlockHeaderSize :: ProtocolParameters -> Natural
protocolParamMaxBlockHeaderSize,
                   Natural
protocolParamMaxBlockBodySize :: Natural
protocolParamMaxBlockBodySize :: ProtocolParameters -> Natural
protocolParamMaxBlockBodySize,
                   Natural
protocolParamMaxTxSize :: Natural
protocolParamMaxTxSize :: ProtocolParameters -> Natural
protocolParamMaxTxSize,
                   Natural
protocolParamTxFeeFixed :: Natural
protocolParamTxFeeFixed :: ProtocolParameters -> Natural
protocolParamTxFeeFixed,
                   Natural
protocolParamTxFeePerByte :: Natural
protocolParamTxFeePerByte :: ProtocolParameters -> Natural
protocolParamTxFeePerByte,
                   Lovelace
protocolParamStakeAddressDeposit :: Lovelace
protocolParamStakeAddressDeposit :: ProtocolParameters -> Lovelace
protocolParamStakeAddressDeposit,
                   Lovelace
protocolParamStakePoolDeposit :: Lovelace
protocolParamStakePoolDeposit :: ProtocolParameters -> Lovelace
protocolParamStakePoolDeposit,
                   Lovelace
protocolParamMinPoolCost :: Lovelace
protocolParamMinPoolCost :: ProtocolParameters -> Lovelace
protocolParamMinPoolCost,
                   EpochNo
protocolParamPoolRetireMaxEpoch :: EpochNo
protocolParamPoolRetireMaxEpoch :: ProtocolParameters -> EpochNo
protocolParamPoolRetireMaxEpoch,
                   Natural
protocolParamStakePoolTargetNum :: Natural
protocolParamStakePoolTargetNum :: ProtocolParameters -> Natural
protocolParamStakePoolTargetNum,
                   Rational
protocolParamPoolPledgeInfluence :: Rational
protocolParamPoolPledgeInfluence :: ProtocolParameters -> Rational
protocolParamPoolPledgeInfluence,
                   Rational
protocolParamMonetaryExpansion :: Rational
protocolParamMonetaryExpansion :: ProtocolParameters -> Rational
protocolParamMonetaryExpansion,
                   Rational
protocolParamTreasuryCut :: Rational
protocolParamTreasuryCut :: ProtocolParameters -> Rational
protocolParamTreasuryCut,
                   Maybe Lovelace
protocolParamUTxOCostPerWord :: Maybe Lovelace
protocolParamUTxOCostPerWord :: ProtocolParameters -> Maybe Lovelace
protocolParamUTxOCostPerWord,
                   Map AnyPlutusScriptVersion CostModel
protocolParamCostModels :: Map AnyPlutusScriptVersion CostModel
protocolParamCostModels :: ProtocolParameters -> Map AnyPlutusScriptVersion CostModel
protocolParamCostModels,
                   protocolParamPrices :: ProtocolParameters -> Maybe ExecutionUnitPrices
protocolParamPrices          = Just ExecutionUnitPrices
prices,
                   protocolParamMaxTxExUnits :: ProtocolParameters -> Maybe ExecutionUnits
protocolParamMaxTxExUnits    = Just ExecutionUnits
maxTxExUnits,
                   protocolParamMaxBlockExUnits :: ProtocolParameters -> Maybe ExecutionUnits
protocolParamMaxBlockExUnits = Just ExecutionUnits
maxBlockExUnits,
                   protocolParamMaxValueSize :: ProtocolParameters -> Maybe Natural
protocolParamMaxValueSize    = Just Natural
maxValueSize,
                   protocolParamCollateralPercent :: ProtocolParameters -> Maybe Natural
protocolParamCollateralPercent   = Just Natural
collateralPercentage,
                   protocolParamMaxCollateralInputs :: ProtocolParameters -> Maybe Natural
protocolParamMaxCollateralInputs = Just Natural
maxCollateralInputs,
                   Maybe Lovelace
protocolParamUTxOCostPerByte :: Maybe Lovelace
protocolParamUTxOCostPerByte :: ProtocolParameters -> Maybe Lovelace
protocolParamUTxOCostPerByte
                 } =
    let !coinsPerUTxOWord :: Lovelace
coinsPerUTxOWord = forall a. a -> Maybe a -> a
fromMaybe
          (forall a. HasCallStack => String -> a
error String
"toAlonzoPParams: must specify protocolParamUTxOCostPerWord or protocolParamUTxOCostPerByte") forall a b. (a -> b) -> a -> b
$
            Maybe Lovelace
protocolParamUTxOCostPerWord forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((forall a. Num a => a -> a -> a
* Lovelace
8) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Lovelace
protocolParamUTxOCostPerByte)
    in
    AlonzoPParams {
      _protocolVersion :: HKD Identity ProtVer
_protocolVersion
                           = let (Natural
maj, Natural
minor) = (Natural, Natural)
protocolParamProtocolVersion
                              in Natural -> Natural -> ProtVer
Ledger.ProtVer Natural
maj Natural
minor
    , _d :: HKD Identity UnitInterval
_d            = case Maybe Rational
protocolParamDecentralization of
                                 -- The decentralization parameter is deprecated in Babbage
                                 -- so we default to 0 if no dentralization parameter is found
                                 -- in the api's 'ProtocolParameter' type. If we don't do this
                                 -- we won't be able to construct an Alonzo tx using the Babbage
                                 -- era's protocol parameter because our only other option is to
                                 -- error.
                                 Maybe Rational
Nothing -> forall a. Bounded a => a
minBound
                                 Just Rational
pDecentral ->
                                   forall a. a -> Maybe a -> a
fromMaybe
                                     (forall a. HasCallStack => String -> a
error String
"toAlonzoPParams: invalid Decentralization value")
                                     (forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational Rational
pDecentral)
    , _extraEntropy :: HKD Identity Nonce
_extraEntropy = Maybe PraosNonce -> Nonce
toLedgerNonce Maybe PraosNonce
protocolParamExtraPraosEntropy
    , _maxBHSize :: HKD Identity Natural
_maxBHSize    = Natural
protocolParamMaxBlockHeaderSize
    , _maxBBSize :: HKD Identity Natural
_maxBBSize    = Natural
protocolParamMaxBlockBodySize
    , _maxTxSize :: HKD Identity Natural
_maxTxSize    = Natural
protocolParamMaxTxSize
    , _minfeeB :: HKD Identity Natural
_minfeeB      = Natural
protocolParamTxFeeFixed
    , _minfeeA :: HKD Identity Natural
_minfeeA      = Natural
protocolParamTxFeePerByte
    , _keyDeposit :: HKD Identity Coin
_keyDeposit   = Lovelace -> Coin
toShelleyLovelace Lovelace
protocolParamStakeAddressDeposit
    , _poolDeposit :: HKD Identity Coin
_poolDeposit  = Lovelace -> Coin
toShelleyLovelace Lovelace
protocolParamStakePoolDeposit
    , _minPoolCost :: HKD Identity Coin
_minPoolCost  = Lovelace -> Coin
toShelleyLovelace Lovelace
protocolParamMinPoolCost
    , _eMax :: HKD Identity EpochNo
_eMax         = EpochNo
protocolParamPoolRetireMaxEpoch
    , _nOpt :: HKD Identity Natural
_nOpt         = Natural
protocolParamStakePoolTargetNum
    , _a0 :: HKD Identity NonNegativeInterval
_a0           = forall a. a -> Maybe a -> a
fromMaybe
                               (forall a. HasCallStack => String -> a
error String
"toAlonzoPParams: invalid PoolPledgeInfluence value")
                               (forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational Rational
protocolParamPoolPledgeInfluence)
    , _rho :: HKD Identity UnitInterval
_rho          = forall a. a -> Maybe a -> a
fromMaybe
                               (forall a. HasCallStack => String -> a
error String
"toAlonzoPParams: invalid MonetaryExpansion value")
                               (forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational Rational
protocolParamMonetaryExpansion)
    , _tau :: HKD Identity UnitInterval
_tau          = forall a. a -> Maybe a -> a
fromMaybe
                               (forall a. HasCallStack => String -> a
error String
"toAlonzoPParams: invalid TreasuryCut value")
                               (forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational Rational
protocolParamTreasuryCut)

      -- New params in Alonzo:
    , _coinsPerUTxOWord :: HKD Identity Coin
_coinsPerUTxOWord  = Lovelace -> Coin
toShelleyLovelace Lovelace
coinsPerUTxOWord
    , _costmdls :: HKD Identity CostModels
_costmdls        = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
                                  (\String
e -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
"toAlonzoPParams: invalid cost models, error: " forall a. Semigroup a => a -> a -> a
<> String
e)
                                  forall a. a -> a
id
                                  (Map AnyPlutusScriptVersion CostModel -> Either String CostModels
toAlonzoCostModels Map AnyPlutusScriptVersion CostModel
protocolParamCostModels)
    , _prices :: HKD Identity Prices
_prices          = forall a. a -> Maybe a -> a
fromMaybe
                                  (forall a. HasCallStack => String -> a
error String
"toAlonzoPParams: invalid Price values")
                                  (ExecutionUnitPrices -> Maybe Prices
toAlonzoPrices ExecutionUnitPrices
prices)
    , _maxTxExUnits :: HKD Identity ExUnits
_maxTxExUnits    = ExecutionUnits -> ExUnits
toAlonzoExUnits ExecutionUnits
maxTxExUnits
    , _maxBlockExUnits :: HKD Identity ExUnits
_maxBlockExUnits = ExecutionUnits -> ExUnits
toAlonzoExUnits ExecutionUnits
maxBlockExUnits
    , _maxValSize :: HKD Identity Natural
_maxValSize      = Natural
maxValueSize
    , _collateralPercentage :: HKD Identity Natural
_collateralPercentage = Natural
collateralPercentage
    , _maxCollateralInputs :: HKD Identity Natural
_maxCollateralInputs  = Natural
maxCollateralInputs
    }
toAlonzoPParams ProtocolParameters { protocolParamUTxOCostPerWord :: ProtocolParameters -> Maybe Lovelace
protocolParamUTxOCostPerWord = Maybe Lovelace
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toAlonzoPParams: must specify protocolParamUTxOCostPerWord"
toAlonzoPParams ProtocolParameters { protocolParamPrices :: ProtocolParameters -> Maybe ExecutionUnitPrices
protocolParamPrices          = Maybe ExecutionUnitPrices
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toAlonzoPParams: must specify protocolParamPrices"
toAlonzoPParams ProtocolParameters { protocolParamMaxTxExUnits :: ProtocolParameters -> Maybe ExecutionUnits
protocolParamMaxTxExUnits    = Maybe ExecutionUnits
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toAlonzoPParams: must specify protocolParamMaxTxExUnits"
toAlonzoPParams ProtocolParameters { protocolParamMaxBlockExUnits :: ProtocolParameters -> Maybe ExecutionUnits
protocolParamMaxBlockExUnits = Maybe ExecutionUnits
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toAlonzoPParams: must specify protocolParamMaxBlockExUnits"
toAlonzoPParams ProtocolParameters { protocolParamMaxValueSize :: ProtocolParameters -> Maybe Natural
protocolParamMaxValueSize    = Maybe Natural
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toAlonzoPParams: must specify protocolParamMaxValueSize"
toAlonzoPParams ProtocolParameters { protocolParamCollateralPercent :: ProtocolParameters -> Maybe Natural
protocolParamCollateralPercent = Maybe Natural
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toAlonzoPParams: must specify protocolParamCollateralPercent"
toAlonzoPParams ProtocolParameters { protocolParamMaxCollateralInputs :: ProtocolParameters -> Maybe Natural
protocolParamMaxCollateralInputs = Maybe Natural
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toAlonzoPParams: must specify protocolParamMaxCollateralInputs"


toBabbagePParams :: ProtocolParameters -> BabbagePParams ledgerera
toBabbagePParams :: forall ledgerera. ProtocolParameters -> BabbagePParams ledgerera
toBabbagePParams ProtocolParameters {
                   (Natural, Natural)
protocolParamProtocolVersion :: (Natural, Natural)
protocolParamProtocolVersion :: ProtocolParameters -> (Natural, Natural)
protocolParamProtocolVersion,
                   Natural
protocolParamMaxBlockHeaderSize :: Natural
protocolParamMaxBlockHeaderSize :: ProtocolParameters -> Natural
protocolParamMaxBlockHeaderSize,
                   Natural
protocolParamMaxBlockBodySize :: Natural
protocolParamMaxBlockBodySize :: ProtocolParameters -> Natural
protocolParamMaxBlockBodySize,
                   Natural
protocolParamMaxTxSize :: Natural
protocolParamMaxTxSize :: ProtocolParameters -> Natural
protocolParamMaxTxSize,
                   Natural
protocolParamTxFeeFixed :: Natural
protocolParamTxFeeFixed :: ProtocolParameters -> Natural
protocolParamTxFeeFixed,
                   Natural
protocolParamTxFeePerByte :: Natural
protocolParamTxFeePerByte :: ProtocolParameters -> Natural
protocolParamTxFeePerByte,
                   Lovelace
protocolParamStakeAddressDeposit :: Lovelace
protocolParamStakeAddressDeposit :: ProtocolParameters -> Lovelace
protocolParamStakeAddressDeposit,
                   Lovelace
protocolParamStakePoolDeposit :: Lovelace
protocolParamStakePoolDeposit :: ProtocolParameters -> Lovelace
protocolParamStakePoolDeposit,
                   Lovelace
protocolParamMinPoolCost :: Lovelace
protocolParamMinPoolCost :: ProtocolParameters -> Lovelace
protocolParamMinPoolCost,
                   EpochNo
protocolParamPoolRetireMaxEpoch :: EpochNo
protocolParamPoolRetireMaxEpoch :: ProtocolParameters -> EpochNo
protocolParamPoolRetireMaxEpoch,
                   Natural
protocolParamStakePoolTargetNum :: Natural
protocolParamStakePoolTargetNum :: ProtocolParameters -> Natural
protocolParamStakePoolTargetNum,
                   Rational
protocolParamPoolPledgeInfluence :: Rational
protocolParamPoolPledgeInfluence :: ProtocolParameters -> Rational
protocolParamPoolPledgeInfluence,
                   Rational
protocolParamMonetaryExpansion :: Rational
protocolParamMonetaryExpansion :: ProtocolParameters -> Rational
protocolParamMonetaryExpansion,
                   Rational
protocolParamTreasuryCut :: Rational
protocolParamTreasuryCut :: ProtocolParameters -> Rational
protocolParamTreasuryCut,
                   protocolParamUTxOCostPerByte :: ProtocolParameters -> Maybe Lovelace
protocolParamUTxOCostPerByte = Just Lovelace
utxoCostPerByte,
                   Map AnyPlutusScriptVersion CostModel
protocolParamCostModels :: Map AnyPlutusScriptVersion CostModel
protocolParamCostModels :: ProtocolParameters -> Map AnyPlutusScriptVersion CostModel
protocolParamCostModels,
                   protocolParamPrices :: ProtocolParameters -> Maybe ExecutionUnitPrices
protocolParamPrices          = Just ExecutionUnitPrices
prices,
                   protocolParamMaxTxExUnits :: ProtocolParameters -> Maybe ExecutionUnits
protocolParamMaxTxExUnits    = Just ExecutionUnits
maxTxExUnits,
                   protocolParamMaxBlockExUnits :: ProtocolParameters -> Maybe ExecutionUnits
protocolParamMaxBlockExUnits = Just ExecutionUnits
maxBlockExUnits,
                   protocolParamMaxValueSize :: ProtocolParameters -> Maybe Natural
protocolParamMaxValueSize    = Just Natural
maxValueSize,
                   protocolParamCollateralPercent :: ProtocolParameters -> Maybe Natural
protocolParamCollateralPercent   = Just Natural
collateralPercentage,
                   protocolParamMaxCollateralInputs :: ProtocolParameters -> Maybe Natural
protocolParamMaxCollateralInputs = Just Natural
maxCollateralInputs
                 } =
    BabbagePParams {
      _protocolVersion :: HKD Identity ProtVer
_protocolVersion
                           = let (Natural
maj, Natural
minor) = (Natural, Natural)
protocolParamProtocolVersion
                              in Natural -> Natural -> ProtVer
Ledger.ProtVer Natural
maj Natural
minor
    , _maxBHSize :: HKD Identity Natural
_maxBHSize    = Natural
protocolParamMaxBlockHeaderSize
    , _maxBBSize :: HKD Identity Natural
_maxBBSize    = Natural
protocolParamMaxBlockBodySize
    , _maxTxSize :: HKD Identity Natural
_maxTxSize    = Natural
protocolParamMaxTxSize
    , _minfeeB :: HKD Identity Natural
_minfeeB      = Natural
protocolParamTxFeeFixed
    , _minfeeA :: HKD Identity Natural
_minfeeA      = Natural
protocolParamTxFeePerByte
    , _keyDeposit :: HKD Identity Coin
_keyDeposit   = Lovelace -> Coin
toShelleyLovelace Lovelace
protocolParamStakeAddressDeposit
    , _poolDeposit :: HKD Identity Coin
_poolDeposit  = Lovelace -> Coin
toShelleyLovelace Lovelace
protocolParamStakePoolDeposit
    , _minPoolCost :: HKD Identity Coin
_minPoolCost  = Lovelace -> Coin
toShelleyLovelace Lovelace
protocolParamMinPoolCost
    , _eMax :: HKD Identity EpochNo
_eMax         = EpochNo
protocolParamPoolRetireMaxEpoch
    , _nOpt :: HKD Identity Natural
_nOpt         = Natural
protocolParamStakePoolTargetNum
    , _a0 :: HKD Identity NonNegativeInterval
_a0           = forall a. a -> Maybe a -> a
fromMaybe
                               (forall a. HasCallStack => String -> a
error String
"toBabbagePParams: invalid PoolPledgeInfluence value")
                               (forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational Rational
protocolParamPoolPledgeInfluence)
    , _rho :: HKD Identity UnitInterval
_rho          = forall a. a -> Maybe a -> a
fromMaybe
                               (forall a. HasCallStack => String -> a
error String
"toBabbagePParams: invalid MonetaryExpansion value")
                               (forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational Rational
protocolParamMonetaryExpansion)
    , _tau :: HKD Identity UnitInterval
_tau          = forall a. a -> Maybe a -> a
fromMaybe
                               (forall a. HasCallStack => String -> a
error String
"toBabbagePParams: invalid TreasuryCut value")
                               (forall r. BoundedRational r => Rational -> Maybe r
Ledger.boundRational Rational
protocolParamTreasuryCut)

      -- New params in Babbage.
    , _coinsPerUTxOByte :: HKD Identity Coin
_coinsPerUTxOByte = Lovelace -> Coin
toShelleyLovelace Lovelace
utxoCostPerByte

    , _costmdls :: HKD Identity CostModels
_costmdls        = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
                                  (\String
e -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
"toBabbagePParams: invalid cost models, error: " forall a. Semigroup a => a -> a -> a
<> String
e)
                                  forall a. a -> a
id
                                  (Map AnyPlutusScriptVersion CostModel -> Either String CostModels
toAlonzoCostModels Map AnyPlutusScriptVersion CostModel
protocolParamCostModels)
    , _prices :: HKD Identity Prices
_prices          = forall a. a -> Maybe a -> a
fromMaybe
                                  (forall a. HasCallStack => String -> a
error String
"toBabbagePParams: invalid Price values")
                                  (ExecutionUnitPrices -> Maybe Prices
toAlonzoPrices ExecutionUnitPrices
prices)
    , _maxTxExUnits :: HKD Identity ExUnits
_maxTxExUnits    = ExecutionUnits -> ExUnits
toAlonzoExUnits ExecutionUnits
maxTxExUnits
    , _maxBlockExUnits :: HKD Identity ExUnits
_maxBlockExUnits = ExecutionUnits -> ExUnits
toAlonzoExUnits ExecutionUnits
maxBlockExUnits
    , _maxValSize :: HKD Identity Natural
_maxValSize      = Natural
maxValueSize
    , _collateralPercentage :: HKD Identity Natural
_collateralPercentage = Natural
collateralPercentage
    , _maxCollateralInputs :: HKD Identity Natural
_maxCollateralInputs  = Natural
maxCollateralInputs
    }
toBabbagePParams ProtocolParameters { protocolParamUTxOCostPerByte :: ProtocolParameters -> Maybe Lovelace
protocolParamUTxOCostPerByte = Maybe Lovelace
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toBabbagePParams: must specify protocolParamUTxOCostPerByte"
toBabbagePParams ProtocolParameters { protocolParamPrices :: ProtocolParameters -> Maybe ExecutionUnitPrices
protocolParamPrices          = Maybe ExecutionUnitPrices
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toBabbagePParams: must specify protocolParamPrices"
toBabbagePParams ProtocolParameters { protocolParamMaxTxExUnits :: ProtocolParameters -> Maybe ExecutionUnits
protocolParamMaxTxExUnits    = Maybe ExecutionUnits
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toBabbagePParams: must specify protocolParamMaxTxExUnits"
toBabbagePParams ProtocolParameters { protocolParamMaxBlockExUnits :: ProtocolParameters -> Maybe ExecutionUnits
protocolParamMaxBlockExUnits = Maybe ExecutionUnits
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toBabbagePParams: must specify protocolParamMaxBlockExUnits"
toBabbagePParams ProtocolParameters { protocolParamMaxValueSize :: ProtocolParameters -> Maybe Natural
protocolParamMaxValueSize    = Maybe Natural
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toBabbagePParams: must specify protocolParamMaxValueSize"
toBabbagePParams ProtocolParameters { protocolParamCollateralPercent :: ProtocolParameters -> Maybe Natural
protocolParamCollateralPercent = Maybe Natural
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toBabbagePParams: must specify protocolParamCollateralPercent"
toBabbagePParams ProtocolParameters { protocolParamMaxCollateralInputs :: ProtocolParameters -> Maybe Natural
protocolParamMaxCollateralInputs = Maybe Natural
Nothing } =
  forall a. HasCallStack => String -> a
error String
"toBabbagePParams: must specify protocolParamMaxCollateralInputs"

toConwayPParams :: ProtocolParameters -> BabbagePParams ledgerera
toConwayPParams :: forall ledgerera. ProtocolParameters -> BabbagePParams ledgerera
toConwayPParams = forall ledgerera. ProtocolParameters -> BabbagePParams ledgerera
toBabbagePParams

-- ----------------------------------------------------------------------------
-- Conversion functions: protocol parameters from ledger types
--

fromLedgerPParams
  :: ShelleyBasedEra era
  -> Ledger.PParams (ShelleyLedgerEra era)
  -> ProtocolParameters
fromLedgerPParams :: forall era.
ShelleyBasedEra era
-> PParams (ShelleyLedgerEra era) -> ProtocolParameters
fromLedgerPParams ShelleyBasedEra era
ShelleyBasedEraShelley = forall ledgerera. ShelleyPParams ledgerera -> ProtocolParameters
fromShelleyPParams
fromLedgerPParams ShelleyBasedEra era
ShelleyBasedEraAllegra = forall ledgerera. ShelleyPParams ledgerera -> ProtocolParameters
fromShelleyPParams
fromLedgerPParams ShelleyBasedEra era
ShelleyBasedEraMary    = forall ledgerera. ShelleyPParams ledgerera -> ProtocolParameters
fromShelleyPParams
fromLedgerPParams ShelleyBasedEra era
ShelleyBasedEraAlonzo  = forall ledgerera. AlonzoPParams ledgerera -> ProtocolParameters
fromAlonzoPParams
fromLedgerPParams ShelleyBasedEra era
ShelleyBasedEraBabbage = forall ledgerera. BabbagePParams ledgerera -> ProtocolParameters
fromBabbagePParams
fromLedgerPParams ShelleyBasedEra era
ShelleyBasedEraConway  = forall ledgerera. BabbagePParams ledgerera -> ProtocolParameters
fromConwayPParams


fromShelleyPParams :: ShelleyPParams ledgerera
                   -> ProtocolParameters
fromShelleyPParams :: forall ledgerera. ShelleyPParams ledgerera -> ProtocolParameters
fromShelleyPParams
    ShelleyPParams {
      HKD Identity Natural
_minfeeA :: HKD Identity Natural
_minfeeA :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Natural
_minfeeA
    , HKD Identity Natural
_minfeeB :: HKD Identity Natural
_minfeeB :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Natural
_minfeeB
    , HKD Identity Natural
_maxBBSize :: HKD Identity Natural
_maxBBSize :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Natural
_maxBBSize
    , HKD Identity Natural
_maxTxSize :: HKD Identity Natural
_maxTxSize :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Natural
_maxTxSize
    , HKD Identity Natural
_maxBHSize :: HKD Identity Natural
_maxBHSize :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Natural
_maxBHSize
    , HKD Identity Coin
_keyDeposit :: HKD Identity Coin
_keyDeposit :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Coin
_keyDeposit
    , HKD Identity Coin
_poolDeposit :: HKD Identity Coin
_poolDeposit :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Coin
_poolDeposit
    , HKD Identity EpochNo
_eMax :: HKD Identity EpochNo
_eMax :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f EpochNo
_eMax
    , HKD Identity Natural
_nOpt :: HKD Identity Natural
_nOpt :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Natural
_nOpt
    , HKD Identity NonNegativeInterval
_a0 :: HKD Identity NonNegativeInterval
_a0 :: forall (f :: * -> *) era.
ShelleyPParamsHKD f era -> HKD f NonNegativeInterval
_a0
    , HKD Identity UnitInterval
_rho :: HKD Identity UnitInterval
_rho :: forall (f :: * -> *) era.
ShelleyPParamsHKD f era -> HKD f UnitInterval
_rho
    , HKD Identity UnitInterval
_tau :: HKD Identity UnitInterval
_tau :: forall (f :: * -> *) era.
ShelleyPParamsHKD f era -> HKD f UnitInterval
_tau
    , HKD Identity UnitInterval
_d :: HKD Identity UnitInterval
_d :: forall (f :: * -> *) era.
ShelleyPParamsHKD f era -> HKD f UnitInterval
_d
    , HKD Identity Nonce
_extraEntropy :: HKD Identity Nonce
_extraEntropy :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Nonce
_extraEntropy
    , HKD Identity ProtVer
_protocolVersion :: HKD Identity ProtVer
_protocolVersion :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f ProtVer
_protocolVersion
    , HKD Identity Coin
_minUTxOValue :: HKD Identity Coin
_minUTxOValue :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Coin
_minUTxOValue
    , HKD Identity Coin
_minPoolCost :: HKD Identity Coin
_minPoolCost :: forall (f :: * -> *) era. ShelleyPParamsHKD f era -> HKD f Coin
_minPoolCost
    } =
    ProtocolParameters {
      protocolParamProtocolVersion :: (Natural, Natural)
protocolParamProtocolVersion     = (\(Ledger.ProtVer Natural
a Natural
b) -> (Natural
a,Natural
b))
                                           HKD Identity ProtVer
_protocolVersion
    , protocolParamDecentralization :: Maybe Rational
protocolParamDecentralization    = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall r. BoundedRational r => r -> Rational
Ledger.unboundRational HKD Identity UnitInterval
_d
    , protocolParamExtraPraosEntropy :: Maybe PraosNonce
protocolParamExtraPraosEntropy   = Nonce -> Maybe PraosNonce
fromLedgerNonce HKD Identity Nonce
_extraEntropy
    , protocolParamMaxBlockHeaderSize :: Natural
protocolParamMaxBlockHeaderSize  = HKD Identity Natural
_maxBHSize
    , protocolParamMaxBlockBodySize :: Natural
protocolParamMaxBlockBodySize    = HKD Identity Natural
_maxBBSize
    , protocolParamMaxTxSize :: Natural
protocolParamMaxTxSize           = HKD Identity Natural
_maxTxSize
    , protocolParamTxFeeFixed :: Natural
protocolParamTxFeeFixed          = HKD Identity Natural
_minfeeB
    , protocolParamTxFeePerByte :: Natural
protocolParamTxFeePerByte        = HKD Identity Natural
_minfeeA
    , protocolParamMinUTxOValue :: Maybe Lovelace
protocolParamMinUTxOValue        = forall a. a -> Maybe a
Just (Coin -> Lovelace
fromShelleyLovelace HKD Identity Coin
_minUTxOValue)
    , protocolParamStakeAddressDeposit :: Lovelace
protocolParamStakeAddressDeposit = Coin -> Lovelace
fromShelleyLovelace HKD Identity Coin
_keyDeposit
    , protocolParamStakePoolDeposit :: Lovelace
protocolParamStakePoolDeposit    = Coin -> Lovelace
fromShelleyLovelace HKD Identity Coin
_poolDeposit
    , protocolParamMinPoolCost :: Lovelace
protocolParamMinPoolCost         = Coin -> Lovelace
fromShelleyLovelace HKD Identity Coin
_minPoolCost
    , protocolParamPoolRetireMaxEpoch :: EpochNo
protocolParamPoolRetireMaxEpoch  = HKD Identity EpochNo
_eMax
    , protocolParamStakePoolTargetNum :: Natural
protocolParamStakePoolTargetNum  = HKD Identity Natural
_nOpt
    , protocolParamPoolPledgeInfluence :: Rational
protocolParamPoolPledgeInfluence = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational HKD Identity NonNegativeInterval
_a0
    , protocolParamMonetaryExpansion :: Rational
protocolParamMonetaryExpansion   = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational HKD Identity UnitInterval
_rho
    , protocolParamTreasuryCut :: Rational
protocolParamTreasuryCut         = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational HKD Identity UnitInterval
_tau
    , protocolParamUTxOCostPerWord :: Maybe Lovelace
protocolParamUTxOCostPerWord     = forall a. Maybe a
Nothing    -- Only in Alonzo
    , protocolParamCostModels :: Map AnyPlutusScriptVersion CostModel
protocolParamCostModels          = forall k a. Map k a
Map.empty  -- Only from Alonzo onwards
    , protocolParamPrices :: Maybe ExecutionUnitPrices
protocolParamPrices              = forall a. Maybe a
Nothing    -- Only from Alonzo onwards
    , protocolParamMaxTxExUnits :: Maybe ExecutionUnits
protocolParamMaxTxExUnits        = forall a. Maybe a
Nothing    -- Only from Alonzo onwards
    , protocolParamMaxBlockExUnits :: Maybe ExecutionUnits
protocolParamMaxBlockExUnits     = forall a. Maybe a
Nothing    -- Only from Alonzo onwards
    , protocolParamMaxValueSize :: Maybe Natural
protocolParamMaxValueSize        = forall a. Maybe a
Nothing    -- Only from Alonzo onwards
    , protocolParamCollateralPercent :: Maybe Natural
protocolParamCollateralPercent   = forall a. Maybe a
Nothing    -- Only from Alonzo onwards
    , protocolParamMaxCollateralInputs :: Maybe Natural
protocolParamMaxCollateralInputs = forall a. Maybe a
Nothing    -- Only from Alonzo onwards
    , protocolParamUTxOCostPerByte :: Maybe Lovelace
protocolParamUTxOCostPerByte     = forall a. Maybe a
Nothing    -- Only from babbage onwards
    }


fromAlonzoPParams :: AlonzoPParams ledgerera -> ProtocolParameters
fromAlonzoPParams :: forall ledgerera. AlonzoPParams ledgerera -> ProtocolParameters
fromAlonzoPParams
    AlonzoPParams {
      HKD Identity Natural
_minfeeA :: HKD Identity Natural
_minfeeA :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_minfeeA
    , HKD Identity Natural
_minfeeB :: HKD Identity Natural
_minfeeB :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_minfeeB
    , HKD Identity Natural
_maxBBSize :: HKD Identity Natural
_maxBBSize :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_maxBBSize
    , HKD Identity Natural
_maxTxSize :: HKD Identity Natural
_maxTxSize :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_maxTxSize
    , HKD Identity Natural
_maxBHSize :: HKD Identity Natural
_maxBHSize :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_maxBHSize
    , HKD Identity Coin
_keyDeposit :: HKD Identity Coin
_keyDeposit :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Coin
_keyDeposit
    , HKD Identity Coin
_poolDeposit :: HKD Identity Coin
_poolDeposit :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Coin
_poolDeposit
    , HKD Identity EpochNo
_eMax :: HKD Identity EpochNo
_eMax :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f EpochNo
_eMax
    , HKD Identity Natural
_nOpt :: HKD Identity Natural
_nOpt :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_nOpt
    , HKD Identity NonNegativeInterval
_a0 :: HKD Identity NonNegativeInterval
_a0 :: forall (f :: * -> *) era.
AlonzoPParamsHKD f era -> HKD f NonNegativeInterval
_a0
    , HKD Identity UnitInterval
_rho :: HKD Identity UnitInterval
_rho :: forall (f :: * -> *) era.
AlonzoPParamsHKD f era -> HKD f UnitInterval
_rho
    , HKD Identity UnitInterval
_tau :: HKD Identity UnitInterval
_tau :: forall (f :: * -> *) era.
AlonzoPParamsHKD f era -> HKD f UnitInterval
_tau
    , HKD Identity UnitInterval
_d :: HKD Identity UnitInterval
_d :: forall (f :: * -> *) era.
AlonzoPParamsHKD f era -> HKD f UnitInterval
_d
    , HKD Identity Nonce
_extraEntropy :: HKD Identity Nonce
_extraEntropy :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Nonce
_extraEntropy
    , HKD Identity ProtVer
_protocolVersion :: HKD Identity ProtVer
_protocolVersion :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f ProtVer
_protocolVersion
    , HKD Identity Coin
_minPoolCost :: HKD Identity Coin
_minPoolCost :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Coin
_minPoolCost
    , HKD Identity Coin
_coinsPerUTxOWord :: HKD Identity Coin
_coinsPerUTxOWord :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Coin
_coinsPerUTxOWord
    , HKD Identity CostModels
_costmdls :: HKD Identity CostModels
_costmdls :: forall (f :: * -> *) era.
AlonzoPParamsHKD f era -> HKD f CostModels
_costmdls
    , HKD Identity Prices
_prices :: HKD Identity Prices
_prices :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Prices
_prices
    , HKD Identity ExUnits
_maxTxExUnits :: HKD Identity ExUnits
_maxTxExUnits :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f ExUnits
_maxTxExUnits
    , HKD Identity ExUnits
_maxBlockExUnits :: HKD Identity ExUnits
_maxBlockExUnits :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f ExUnits
_maxBlockExUnits
    , HKD Identity Natural
_maxValSize :: HKD Identity Natural
_maxValSize :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_maxValSize
    , HKD Identity Natural
_collateralPercentage :: HKD Identity Natural
_collateralPercentage :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_collateralPercentage
    , HKD Identity Natural
_maxCollateralInputs :: HKD Identity Natural
_maxCollateralInputs :: forall (f :: * -> *) era. AlonzoPParamsHKD f era -> HKD f Natural
_maxCollateralInputs
    } =
    ProtocolParameters {
      protocolParamProtocolVersion :: (Natural, Natural)
protocolParamProtocolVersion     = (\(Ledger.ProtVer Natural
a Natural
b) -> (Natural
a,Natural
b))
                                           HKD Identity ProtVer
_protocolVersion
    , protocolParamDecentralization :: Maybe Rational
protocolParamDecentralization    = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall r. BoundedRational r => r -> Rational
Ledger.unboundRational HKD Identity UnitInterval
_d
    , protocolParamExtraPraosEntropy :: Maybe PraosNonce
protocolParamExtraPraosEntropy   = Nonce -> Maybe PraosNonce
fromLedgerNonce HKD Identity Nonce
_extraEntropy
    , protocolParamMaxBlockHeaderSize :: Natural
protocolParamMaxBlockHeaderSize  = HKD Identity Natural
_maxBHSize
    , protocolParamMaxBlockBodySize :: Natural
protocolParamMaxBlockBodySize    = HKD Identity Natural
_maxBBSize
    , protocolParamMaxTxSize :: Natural
protocolParamMaxTxSize           = HKD Identity Natural
_maxTxSize
    , protocolParamTxFeeFixed :: Natural
protocolParamTxFeeFixed          = HKD Identity Natural
_minfeeB
    , protocolParamTxFeePerByte :: Natural
protocolParamTxFeePerByte        = HKD Identity Natural
_minfeeA
    , protocolParamMinUTxOValue :: Maybe Lovelace
protocolParamMinUTxOValue        = forall a. Maybe a
Nothing
    , protocolParamStakeAddressDeposit :: Lovelace
protocolParamStakeAddressDeposit = Coin -> Lovelace
fromShelleyLovelace HKD Identity Coin
_keyDeposit
    , protocolParamStakePoolDeposit :: Lovelace
protocolParamStakePoolDeposit    = Coin -> Lovelace
fromShelleyLovelace HKD Identity Coin
_poolDeposit
    , protocolParamMinPoolCost :: Lovelace
protocolParamMinPoolCost         = Coin -> Lovelace
fromShelleyLovelace HKD Identity Coin
_minPoolCost
    , protocolParamPoolRetireMaxEpoch :: EpochNo
protocolParamPoolRetireMaxEpoch  = HKD Identity EpochNo
_eMax
    , protocolParamStakePoolTargetNum :: Natural
protocolParamStakePoolTargetNum  = HKD Identity Natural
_nOpt
    , protocolParamPoolPledgeInfluence :: Rational
protocolParamPoolPledgeInfluence = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational HKD Identity NonNegativeInterval
_a0
    , protocolParamMonetaryExpansion :: Rational
protocolParamMonetaryExpansion   = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational HKD Identity UnitInterval
_rho
    , protocolParamTreasuryCut :: Rational
protocolParamTreasuryCut         = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational HKD Identity UnitInterval
_tau
    , protocolParamUTxOCostPerWord :: Maybe Lovelace
protocolParamUTxOCostPerWord     = forall a. a -> Maybe a
Just (Coin -> Lovelace
fromShelleyLovelace HKD Identity Coin
_coinsPerUTxOWord)
    , protocolParamCostModels :: Map AnyPlutusScriptVersion CostModel
protocolParamCostModels          = CostModels -> Map AnyPlutusScriptVersion CostModel
fromAlonzoCostModels HKD Identity CostModels
_costmdls
    , protocolParamPrices :: Maybe ExecutionUnitPrices
protocolParamPrices              = forall a. a -> Maybe a
Just (Prices -> ExecutionUnitPrices
fromAlonzoPrices HKD Identity Prices
_prices)
    , protocolParamMaxTxExUnits :: Maybe ExecutionUnits
protocolParamMaxTxExUnits        = forall a. a -> Maybe a
Just (ExUnits -> ExecutionUnits
fromAlonzoExUnits HKD Identity ExUnits
_maxTxExUnits)
    , protocolParamMaxBlockExUnits :: Maybe ExecutionUnits
protocolParamMaxBlockExUnits     = forall a. a -> Maybe a
Just (ExUnits -> ExecutionUnits
fromAlonzoExUnits HKD Identity ExUnits
_maxBlockExUnits)
    , protocolParamMaxValueSize :: Maybe Natural
protocolParamMaxValueSize        = forall a. a -> Maybe a
Just HKD Identity Natural
_maxValSize
    , protocolParamCollateralPercent :: Maybe Natural
protocolParamCollateralPercent   = forall a. a -> Maybe a
Just HKD Identity Natural
_collateralPercentage
    , protocolParamMaxCollateralInputs :: Maybe Natural
protocolParamMaxCollateralInputs = forall a. a -> Maybe a
Just HKD Identity Natural
_maxCollateralInputs
    , protocolParamUTxOCostPerByte :: Maybe Lovelace
protocolParamUTxOCostPerByte     = forall a. Maybe a
Nothing    -- Only from babbage onwards
    }

fromBabbagePParams :: BabbagePParams ledgerera -> ProtocolParameters
fromBabbagePParams :: forall ledgerera. BabbagePParams ledgerera -> ProtocolParameters
fromBabbagePParams
    BabbagePParams {
      HKD Identity Natural
_minfeeA :: HKD Identity Natural
_minfeeA :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_minfeeA
    , HKD Identity Natural
_minfeeB :: HKD Identity Natural
_minfeeB :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_minfeeB
    , HKD Identity Natural
_maxBBSize :: HKD Identity Natural
_maxBBSize :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_maxBBSize
    , HKD Identity Natural
_maxTxSize :: HKD Identity Natural
_maxTxSize :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_maxTxSize
    , HKD Identity Natural
_maxBHSize :: HKD Identity Natural
_maxBHSize :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_maxBHSize
    , HKD Identity Coin
_keyDeposit :: HKD Identity Coin
_keyDeposit :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Coin
_keyDeposit
    , HKD Identity Coin
_poolDeposit :: HKD Identity Coin
_poolDeposit :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Coin
_poolDeposit
    , HKD Identity EpochNo
_eMax :: HKD Identity EpochNo
_eMax :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f EpochNo
_eMax
    , HKD Identity Natural
_nOpt :: HKD Identity Natural
_nOpt :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_nOpt
    , HKD Identity NonNegativeInterval
_a0 :: HKD Identity NonNegativeInterval
_a0 :: forall (f :: * -> *) era.
BabbagePParamsHKD f era -> HKD f NonNegativeInterval
_a0
    , HKD Identity UnitInterval
_rho :: HKD Identity UnitInterval
_rho :: forall (f :: * -> *) era.
BabbagePParamsHKD f era -> HKD f UnitInterval
_rho
    , HKD Identity UnitInterval
_tau :: HKD Identity UnitInterval
_tau :: forall (f :: * -> *) era.
BabbagePParamsHKD f era -> HKD f UnitInterval
_tau
    , HKD Identity ProtVer
_protocolVersion :: HKD Identity ProtVer
_protocolVersion :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f ProtVer
_protocolVersion
    , HKD Identity Coin
_minPoolCost :: HKD Identity Coin
_minPoolCost :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Coin
_minPoolCost
    , HKD Identity Coin
_coinsPerUTxOByte :: HKD Identity Coin
_coinsPerUTxOByte :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Coin
_coinsPerUTxOByte
    , HKD Identity CostModels
_costmdls :: HKD Identity CostModels
_costmdls :: forall (f :: * -> *) era.
BabbagePParamsHKD f era -> HKD f CostModels
_costmdls
    , HKD Identity Prices
_prices :: HKD Identity Prices
_prices :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Prices
_prices
    , HKD Identity ExUnits
_maxTxExUnits :: HKD Identity ExUnits
_maxTxExUnits :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f ExUnits
_maxTxExUnits
    , HKD Identity ExUnits
_maxBlockExUnits :: HKD Identity ExUnits
_maxBlockExUnits :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f ExUnits
_maxBlockExUnits
    , HKD Identity Natural
_maxValSize :: HKD Identity Natural
_maxValSize :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_maxValSize
    , HKD Identity Natural
_collateralPercentage :: HKD Identity Natural
_collateralPercentage :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_collateralPercentage
    , HKD Identity Natural
_maxCollateralInputs :: HKD Identity Natural
_maxCollateralInputs :: forall (f :: * -> *) era. BabbagePParamsHKD f era -> HKD f Natural
_maxCollateralInputs
    } =
    ProtocolParameters {
      protocolParamProtocolVersion :: (Natural, Natural)
protocolParamProtocolVersion     = (\(Ledger.ProtVer Natural
a Natural
b) -> (Natural
a,Natural
b))
                                           HKD Identity ProtVer
_protocolVersion
    , protocolParamDecentralization :: Maybe Rational
protocolParamDecentralization    = forall a. Maybe a
Nothing
    , protocolParamExtraPraosEntropy :: Maybe PraosNonce
protocolParamExtraPraosEntropy   = forall a. Maybe a
Nothing
    , protocolParamMaxBlockHeaderSize :: Natural
protocolParamMaxBlockHeaderSize  = HKD Identity Natural
_maxBHSize
    , protocolParamMaxBlockBodySize :: Natural
protocolParamMaxBlockBodySize    = HKD Identity Natural
_maxBBSize
    , protocolParamMaxTxSize :: Natural
protocolParamMaxTxSize           = HKD Identity Natural
_maxTxSize
    , protocolParamTxFeeFixed :: Natural
protocolParamTxFeeFixed          = HKD Identity Natural
_minfeeB
    , protocolParamTxFeePerByte :: Natural
protocolParamTxFeePerByte        = HKD Identity Natural
_minfeeA
    , protocolParamMinUTxOValue :: Maybe Lovelace
protocolParamMinUTxOValue        = forall a. Maybe a
Nothing
    , protocolParamStakeAddressDeposit :: Lovelace
protocolParamStakeAddressDeposit = Coin -> Lovelace
fromShelleyLovelace HKD Identity Coin
_keyDeposit
    , protocolParamStakePoolDeposit :: Lovelace
protocolParamStakePoolDeposit    = Coin -> Lovelace
fromShelleyLovelace HKD Identity Coin
_poolDeposit
    , protocolParamMinPoolCost :: Lovelace
protocolParamMinPoolCost         = Coin -> Lovelace
fromShelleyLovelace HKD Identity Coin
_minPoolCost
    , protocolParamPoolRetireMaxEpoch :: EpochNo
protocolParamPoolRetireMaxEpoch  = HKD Identity EpochNo
_eMax
    , protocolParamStakePoolTargetNum :: Natural
protocolParamStakePoolTargetNum  = HKD Identity Natural
_nOpt
    , protocolParamPoolPledgeInfluence :: Rational
protocolParamPoolPledgeInfluence = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational HKD Identity NonNegativeInterval
_a0
    , protocolParamMonetaryExpansion :: Rational
protocolParamMonetaryExpansion   = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational HKD Identity UnitInterval
_rho
    , protocolParamTreasuryCut :: Rational
protocolParamTreasuryCut         = forall r. BoundedRational r => r -> Rational
Ledger.unboundRational HKD Identity UnitInterval
_tau
    , protocolParamUTxOCostPerWord :: Maybe Lovelace
protocolParamUTxOCostPerWord     = forall a. Maybe a
Nothing    -- Obsolete from babbage onwards
    , protocolParamCostModels :: Map AnyPlutusScriptVersion CostModel
protocolParamCostModels          = CostModels -> Map AnyPlutusScriptVersion CostModel
fromAlonzoCostModels HKD Identity CostModels
_costmdls
    , protocolParamPrices :: Maybe ExecutionUnitPrices
protocolParamPrices              = forall a. a -> Maybe a
Just (Prices -> ExecutionUnitPrices
fromAlonzoPrices HKD Identity Prices
_prices)
    , protocolParamMaxTxExUnits :: Maybe ExecutionUnits
protocolParamMaxTxExUnits        = forall a. a -> Maybe a
Just (ExUnits -> ExecutionUnits
fromAlonzoExUnits HKD Identity ExUnits
_maxTxExUnits)
    , protocolParamMaxBlockExUnits :: Maybe ExecutionUnits
protocolParamMaxBlockExUnits     = forall a. a -> Maybe a
Just (ExUnits -> ExecutionUnits
fromAlonzoExUnits HKD Identity ExUnits
_maxBlockExUnits)
    , protocolParamMaxValueSize :: Maybe Natural
protocolParamMaxValueSize        = forall a. a -> Maybe a
Just HKD Identity Natural
_maxValSize
    , protocolParamCollateralPercent :: Maybe Natural
protocolParamCollateralPercent   = forall a. a -> Maybe a
Just HKD Identity Natural
_collateralPercentage
    , protocolParamMaxCollateralInputs :: Maybe Natural
protocolParamMaxCollateralInputs = forall a. a -> Maybe a
Just HKD Identity Natural
_maxCollateralInputs
    , protocolParamUTxOCostPerByte :: Maybe Lovelace
protocolParamUTxOCostPerByte     = forall a. a -> Maybe a
Just (Coin -> Lovelace
fromShelleyLovelace HKD Identity Coin
_coinsPerUTxOByte)
    }

fromConwayPParams :: BabbagePParams ledgerera -> ProtocolParameters
fromConwayPParams :: forall ledgerera. BabbagePParams ledgerera -> ProtocolParameters
fromConwayPParams = forall ledgerera. BabbagePParams ledgerera -> ProtocolParameters
fromBabbagePParams

data ProtocolParametersError =
    PParamsErrorMissingMinUTxoValue AnyCardanoEra
  | PParamsErrorMissingAlonzoProtocolParameter
  deriving Int -> ProtocolParametersError -> ShowS
[ProtocolParametersError] -> ShowS
ProtocolParametersError -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProtocolParametersError] -> ShowS
$cshowList :: [ProtocolParametersError] -> ShowS
show :: ProtocolParametersError -> String
$cshow :: ProtocolParametersError -> String
showsPrec :: Int -> ProtocolParametersError -> ShowS
$cshowsPrec :: Int -> ProtocolParametersError -> ShowS
Show

instance Error ProtocolParametersError where
  displayError :: ProtocolParametersError -> String
displayError (PParamsErrorMissingMinUTxoValue (AnyCardanoEra CardanoEra era
era)) = forall a. Monoid a => [a] -> a
mconcat
    [ String
"The " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show CardanoEra era
era forall a. Semigroup a => a -> a -> a
<> String
" protocol parameters value is missing the following "
    , String
"field: MinUTxoValue. Did you intend to use a " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show CardanoEra era
era forall a. Semigroup a => a -> a -> a
<> String
" protocol "
    , String
" parameters value?"
    ]
  displayError ProtocolParametersError
PParamsErrorMissingAlonzoProtocolParameter = forall a. Monoid a => [a] -> a
mconcat
    [ String
"The Alonzo era protocol parameters in use is missing one or more of the "
    , String
"following fields: UTxOCostPerWord, CostModels, Prices, MaxTxExUnits, "
    , String
"MaxBlockExUnits, MaxValueSize, CollateralPercent, MaxCollateralInputs. Did "
    , String
"you intend to use an Alonzo era protocol parameters value?"
    ]

checkProtocolParameters
  :: forall era. IsCardanoEra era
  => ShelleyBasedEra era
  -> ProtocolParameters
  -> Either ProtocolParametersError ()
checkProtocolParameters :: forall era.
IsCardanoEra era =>
ShelleyBasedEra era
-> ProtocolParameters -> Either ProtocolParametersError ()
checkProtocolParameters ShelleyBasedEra era
sbe ProtocolParameters{Natural
Maybe Natural
Maybe Rational
Maybe ExecutionUnits
Maybe Lovelace
Maybe ExecutionUnitPrices
Maybe PraosNonce
Rational
(Natural, Natural)
Map AnyPlutusScriptVersion CostModel
EpochNo
Lovelace
protocolParamUTxOCostPerByte :: Maybe Lovelace
protocolParamMaxCollateralInputs :: Maybe Natural
protocolParamCollateralPercent :: Maybe Natural
protocolParamMaxValueSize :: Maybe Natural
protocolParamMaxBlockExUnits :: Maybe ExecutionUnits
protocolParamMaxTxExUnits :: Maybe ExecutionUnits
protocolParamPrices :: Maybe ExecutionUnitPrices
protocolParamCostModels :: Map AnyPlutusScriptVersion CostModel
protocolParamUTxOCostPerWord :: Maybe Lovelace
protocolParamTreasuryCut :: Rational
protocolParamMonetaryExpansion :: Rational
protocolParamPoolPledgeInfluence :: Rational
protocolParamStakePoolTargetNum :: Natural
protocolParamPoolRetireMaxEpoch :: EpochNo
protocolParamMinPoolCost :: Lovelace
protocolParamStakePoolDeposit :: Lovelace
protocolParamStakeAddressDeposit :: Lovelace
protocolParamMinUTxOValue :: Maybe Lovelace
protocolParamTxFeePerByte :: Natural
protocolParamTxFeeFixed :: Natural
protocolParamMaxTxSize :: Natural
protocolParamMaxBlockBodySize :: Natural
protocolParamMaxBlockHeaderSize :: Natural
protocolParamExtraPraosEntropy :: Maybe PraosNonce
protocolParamDecentralization :: Maybe Rational
protocolParamProtocolVersion :: (Natural, Natural)
protocolParamUTxOCostPerByte :: ProtocolParameters -> Maybe Lovelace
protocolParamMaxCollateralInputs :: ProtocolParameters -> Maybe Natural
protocolParamCollateralPercent :: ProtocolParameters -> Maybe Natural
protocolParamMaxValueSize :: ProtocolParameters -> Maybe Natural
protocolParamMaxBlockExUnits :: ProtocolParameters -> Maybe ExecutionUnits
protocolParamMaxTxExUnits :: ProtocolParameters -> Maybe ExecutionUnits
protocolParamPrices :: ProtocolParameters -> Maybe ExecutionUnitPrices
protocolParamCostModels :: ProtocolParameters -> Map AnyPlutusScriptVersion CostModel
protocolParamUTxOCostPerWord :: ProtocolParameters -> Maybe Lovelace
protocolParamTreasuryCut :: ProtocolParameters -> Rational
protocolParamMonetaryExpansion :: ProtocolParameters -> Rational
protocolParamPoolPledgeInfluence :: ProtocolParameters -> Rational
protocolParamStakePoolTargetNum :: ProtocolParameters -> Natural
protocolParamPoolRetireMaxEpoch :: ProtocolParameters -> EpochNo
protocolParamMinPoolCost :: ProtocolParameters -> Lovelace
protocolParamStakePoolDeposit :: ProtocolParameters -> Lovelace
protocolParamStakeAddressDeposit :: ProtocolParameters -> Lovelace
protocolParamMinUTxOValue :: ProtocolParameters -> Maybe Lovelace
protocolParamTxFeePerByte :: ProtocolParameters -> Natural
protocolParamTxFeeFixed :: ProtocolParameters -> Natural
protocolParamMaxTxSize :: ProtocolParameters -> Natural
protocolParamMaxBlockBodySize :: ProtocolParameters -> Natural
protocolParamMaxBlockHeaderSize :: ProtocolParameters -> Natural
protocolParamExtraPraosEntropy :: ProtocolParameters -> Maybe PraosNonce
protocolParamDecentralization :: ProtocolParameters -> Maybe Rational
protocolParamProtocolVersion :: ProtocolParameters -> (Natural, Natural)
..} =
  case ShelleyBasedEra era
sbe of
    ShelleyBasedEra era
ShelleyBasedEraShelley -> Either ProtocolParametersError ()
checkMinUTxOVal
    ShelleyBasedEra era
ShelleyBasedEraAllegra -> Either ProtocolParametersError ()
checkMinUTxOVal
    ShelleyBasedEra era
ShelleyBasedEraMary -> Either ProtocolParametersError ()
checkMinUTxOVal
    ShelleyBasedEra era
ShelleyBasedEraAlonzo -> Either ProtocolParametersError ()
checkAlonzoParams
    ShelleyBasedEra era
ShelleyBasedEraBabbage -> Either ProtocolParametersError ()
checkBabbageParams
    ShelleyBasedEra era
ShelleyBasedEraConway -> Either ProtocolParametersError ()
checkBabbageParams
 where
   era :: CardanoEra era
   era :: CardanoEra era
era = forall era. ShelleyBasedEra era -> CardanoEra era
shelleyBasedToCardanoEra ShelleyBasedEra era
sbe

   costPerWord :: Bool
costPerWord = forall a. Maybe a -> Bool
isJust Maybe Lovelace
protocolParamUTxOCostPerWord
   cModel :: Bool
cModel = Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ forall k a. Map k a -> Bool
Map.null Map AnyPlutusScriptVersion CostModel
protocolParamCostModels
   prices :: Bool
prices = forall a. Maybe a -> Bool
isJust Maybe ExecutionUnitPrices
protocolParamPrices
   maxTxUnits :: Bool
maxTxUnits = forall a. Maybe a -> Bool
isJust Maybe ExecutionUnits
protocolParamMaxTxExUnits
   maxBlockExUnits :: Bool
maxBlockExUnits = forall a. Maybe a -> Bool
isJust Maybe ExecutionUnits
protocolParamMaxBlockExUnits
   maxValueSize :: Bool
maxValueSize = forall a. Maybe a -> Bool
isJust Maybe Natural
protocolParamMaxValueSize
   collateralPercent :: Bool
collateralPercent = forall a. Maybe a -> Bool
isJust Maybe Natural
protocolParamCollateralPercent
   maxCollateralInputs :: Bool
maxCollateralInputs = forall a. Maybe a -> Bool
isJust Maybe Natural
protocolParamMaxCollateralInputs
   costPerByte :: Bool
costPerByte = forall a. Maybe a -> Bool
isJust Maybe Lovelace
protocolParamUTxOCostPerByte
   decentralization :: Bool
decentralization = forall a. Maybe a -> Bool
isJust Maybe Rational
protocolParamDecentralization
   extraPraosEntropy :: Bool
extraPraosEntropy = forall a. Maybe a -> Bool
isJust Maybe PraosNonce
protocolParamExtraPraosEntropy

   alonzoPParamFieldsRequirements :: [Bool]
   alonzoPParamFieldsRequirements :: [Bool]
alonzoPParamFieldsRequirements =
     [     Bool
costPerWord
     ,     Bool
cModel
     ,     Bool
prices
     ,     Bool
maxTxUnits
     ,     Bool
maxBlockExUnits
     ,     Bool
maxValueSize
     ,     Bool
collateralPercent
     ,     Bool
maxCollateralInputs
     , Bool -> Bool
not Bool
costPerByte
     ]

   babbagePParamFieldsRequirements :: [Bool]
   babbagePParamFieldsRequirements :: [Bool]
babbagePParamFieldsRequirements =
     [ Bool -> Bool
not Bool
costPerWord
     ,     Bool
cModel
     ,     Bool
prices
     ,     Bool
maxTxUnits
     ,     Bool
maxBlockExUnits
     ,     Bool
maxValueSize
     ,     Bool
collateralPercent
     ,     Bool
maxCollateralInputs
     ,     Bool
costPerByte
     , Bool -> Bool
not Bool
decentralization
     , Bool -> Bool
not Bool
extraPraosEntropy
     ]

   checkAlonzoParams :: Either ProtocolParametersError ()
   checkAlonzoParams :: Either ProtocolParametersError ()
checkAlonzoParams = do
     if forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (forall a. Eq a => a -> a -> Bool
== Bool
True) [Bool]
alonzoPParamFieldsRequirements
     then forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else forall a b. a -> Either a b
Left ProtocolParametersError
PParamsErrorMissingAlonzoProtocolParameter

   checkBabbageParams :: Either ProtocolParametersError ()
   checkBabbageParams :: Either ProtocolParametersError ()
checkBabbageParams =
     if forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (forall a. Eq a => a -> a -> Bool
== Bool
True) [Bool]
babbagePParamFieldsRequirements
     then forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else forall a b. a -> Either a b
Left ProtocolParametersError
PParamsErrorMissingAlonzoProtocolParameter

   checkMinUTxOVal :: Either ProtocolParametersError ()
   checkMinUTxOVal :: Either ProtocolParametersError ()
checkMinUTxOVal =
     if forall a. Maybe a -> Bool
isJust Maybe Lovelace
protocolParamMinUTxOValue
     then forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else forall a b. a -> Either a b
Left forall b c a. (b -> c) -> (a -> b) -> a -> c
. AnyCardanoEra -> ProtocolParametersError
PParamsErrorMissingMinUTxoValue
               forall a b. (a -> b) -> a -> b
$ forall era. IsCardanoEra era => CardanoEra era -> AnyCardanoEra
AnyCardanoEra CardanoEra era
era