{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}

module Test.Cardano.Ledger.Constrained.Vars where

import Cardano.Crypto.Signing (SigningKey)
import Cardano.Ledger.Address (Addr (..), Withdrawals (..))
import Cardano.Ledger.Allegra.Scripts (ValidityInterval (..))
import Cardano.Ledger.Alonzo.PParams (AlonzoEraPParams, ppCollateralPercentageL, ppMaxTxExUnitsL)
import Cardano.Ledger.Alonzo.Tx (IsValid (..), ScriptIntegrityHash)
import Cardano.Ledger.Alonzo.TxWits (TxDats (..))
import Cardano.Ledger.Alonzo.UTxO (AlonzoScriptsNeeded (..))
import Cardano.Ledger.BaseTypes (
  BlocksMade (..),
  EpochNo,
  Globals (..),
  Network (..),
  ProtVer (..),
  SlotNo (..),
  StrictMaybe (..),
  UnitInterval,
  knownNonZero,
  mulNonZero,
  toIntegerNonZero,
  (%.),
 )
import qualified Cardano.Ledger.BaseTypes as Base (EpochInterval (..), Globals (..))
import Cardano.Ledger.Coin (Coin (..), CompactForm (CompactCoin), DeltaCoin)
import Cardano.Ledger.Conway.Governance hiding (GovState)
import Cardano.Ledger.Conway.PParams (
  ConwayEraPParams,
  ppDRepActivityL,
  ppDRepDepositL,
  ppGovActionDepositL,
 )
import Cardano.Ledger.Conway.State (
  ChainAccountState (..),
  CommitteeAuthorization,
  CommitteeState (..),
  ConwayCertState (..),
  ConwayEraCertState (..),
  EraStake (..),
  IndividualPoolStake (..),
  PoolDistr (..),
  ShelleyInstantStake (..),
  SnapShot (..),
  SnapShots (..),
  Stake (..),
  VState (..),
  casReservesL,
  casTreasuryL,
  chainAccountStateL,
  conwayCertDStateL,
  conwayCertPStateL,
  conwayCertVStateL,
  csCommitteeCredsL,
  instantStakeL,
  poolDistrDistrL,
  reservesL,
  shelleyCertDStateL,
  shelleyCertPStateL,
  treasuryL,
  vsCommitteeStateL,
  vsDRepsL,
  vsNumDormantEpochsL,
 )
import Cardano.Ledger.Core (
  Era,
  PParams,
  TxOut,
  TxWits,
  Value,
  addrTxOutL,
  coinTxOutL,
  ppEMaxL,
  ppKeyDepositL,
  ppMaxBBSizeL,
  ppMaxBHSizeL,
  ppMaxTxSizeL,
  ppMinFeeAL,
  ppMinFeeBL,
  ppPoolDepositL,
  ppProtocolVersionL,
  valueTxOutL,
 )
import Cardano.Ledger.Credential (Credential, Ptr)
import Cardano.Ledger.DRep (DRep (..), DRepState (..))
import Cardano.Ledger.Hashes (
  DataHash,
  EraIndependentScriptIntegrity,
  SafeHash,
  ScriptHash (..),
  TxAuxDataHash (..),
 )
import Cardano.Ledger.Keys (GenDelegPair, GenDelegs (..), KeyHash, KeyRole (..))
import Cardano.Ledger.Keys.Bootstrap (BootstrapWitness)
import Cardano.Ledger.Keys.WitVKey (WitVKey (..))
import Cardano.Ledger.Mary.Value (AssetName (..), MaryValue (..), MultiAsset (..), PolicyID (..))
import Cardano.Ledger.Plutus (ExUnits (..))
import Cardano.Ledger.Plutus.Data (Data (..), Datum (..))
import Cardano.Ledger.PoolParams (PoolParams)
import Cardano.Ledger.Shelley.Governance (FuturePParams (..))
import qualified Cardano.Ledger.Shelley.Governance as Gov
import Cardano.Ledger.Shelley.HardForks as HardForks (allowMIRTransfer)
import Cardano.Ledger.Shelley.LedgerState hiding (
  delegations,
  deltaReserves,
  deltaTreasury,
  rewards,
 )
import Cardano.Ledger.Shelley.PParams (ProposedPPUpdates (..))
import Cardano.Ledger.Shelley.PoolRank (NonMyopic (..))
import qualified Cardano.Ledger.Shelley.RewardUpdate as RU
import Cardano.Ledger.Shelley.Rewards (Reward (..))
import Cardano.Ledger.Shelley.TxBody (RewardAccount (..))
import Cardano.Ledger.Shelley.UTxO (EraUTxO (..), ShelleyScriptsNeeded (..))
import Cardano.Ledger.TxIn (TxIn (..))
import Cardano.Ledger.UMap (compactCoinOrError, fromCompact, ptrMap, rdPairMap, sPoolMap, unify)
import Cardano.Ledger.Val (Val (..))
import Control.Arrow (first)
import Data.Default (Default (def))
import Data.Foldable (toList)
import qualified Data.Foldable as F
import Data.Functor.Identity (Identity)
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import Data.Maybe.Strict (maybeToStrictMaybe, strictMaybeToMaybe)
import qualified Data.OMap.Strict as OMap
import qualified Data.Sequence.Strict as SS
import Data.Set (Set)
import qualified Data.VMap as VMap
import Data.Word (Word16, Word32, Word64)
import GHC.Stack (HasCallStack)
import Lens.Micro
import Numeric.Natural (Natural)
import Test.Cardano.Ledger.Babbage.Serialisation.Generators ()
import Test.Cardano.Ledger.Constrained.Ast
import Test.Cardano.Ledger.Constrained.Classes (
  CertStateF (..),
  GovState (..),
  PParamsF (..),
  PParamsUpdateF (..),
  PlutusPointerF (..),
  PlutusPurposeF (..),
  ScriptF (..),
  ScriptsNeededF (..),
  TxAuxDataF (..),
  TxBodyF (..),
  TxCertF (..),
  TxF (..),
  TxOutF (..),
  TxWitsF (..),
  ValueF (..),
  liftUTxO,
  pparamsWrapperL,
  unCertStateF,
  unPParamsUpdate,
  unPlutusPointerF,
  unPlutusPurposeF,
  unScriptF,
  unTxCertF,
  unTxOut,
  unValue,
 )
import Test.Cardano.Ledger.Constrained.Env (
  Access (..),
  AnyF (..),
  Field (..),
  Name (..),
  V (..),
  pV,
 )
import Test.Cardano.Ledger.Constrained.Lenses
import Test.Cardano.Ledger.Constrained.TypeRep (Rep (..), testEql, (:~:) (Refl))
import Test.Cardano.Ledger.Core.KeyPair (KeyPair (..))
import Test.Cardano.Ledger.Generic.Fields (TxBodyField (..), TxField (..), WitnessesField (..))
import qualified Test.Cardano.Ledger.Generic.Fields as Fields
import Test.Cardano.Ledger.Generic.Functions (protocolVersion)
import Test.Cardano.Ledger.Generic.GenState (mkRedeemers)
import Test.Cardano.Ledger.Generic.PrettyCore (ppString, withEraPParams)
import Test.Cardano.Ledger.Generic.Proof
import Test.Cardano.Ledger.Generic.Updaters (merge, newPParams, newTx, newTxBody, newWitnesses)
import Test.Cardano.Ledger.Shelley.Utils (testGlobals)
import qualified Test.Cardano.Ledger.Shelley.Utils as Utils (testGlobals)
import Type.Reflection (Typeable, typeRep)

-- =======================

-- | Used in Component constraints to turn a Var Term into a component (AnyF era s)
-- E.g.  (Component foo [ field fooRep fooPart1, field fooRep fooPart2])
-- Where fooPart1 :: Term era a, and fooPart2 :: Term era b
-- And fooPart1 has an (Access foo a)
-- And fooPart2 has an (Access foo b)
field :: Era era => Rep era s -> Term era t -> AnyF era s
field :: forall era s t. Era era => Rep era s -> Term era t -> AnyF era s
field Rep era s
repS1 (Var (V String
name Rep era t
rept (Yes Rep era s
repS2 Lens' s t
l))) = case Rep era s -> Rep era s -> Maybe (s :~: s)
forall i j. Rep era i -> Rep era j -> Maybe (i :~: j)
forall {k} (t :: k -> *) (i :: k) (j :: k).
Singleton t =>
t i -> t j -> Maybe (i :~: j)
testEql Rep era s
repS1 Rep era s
repS2 of
  Just s :~: s
Refl -> Field era s t -> AnyF era s
forall era s t. Field era s t -> AnyF era s
AnyF (String -> Rep era t -> Rep era s -> Lens' s t -> Field era s t
forall era t s.
Era era =>
String -> Rep era t -> Rep era s -> Lens' s t -> Field era s t
Field String
name Rep era t
rept Rep era s
Rep era s
repS2 (t -> f t) -> s -> f s
(t -> f t) -> s -> f s
Lens' s t
Lens' s t
l)
  Maybe (s :~: s)
Nothing ->
    String -> AnyF era s
forall a. HasCallStack => String -> a
error
      ( [String] -> String
unlines
          [ String
"Given rep and lens target do not match: "
          , String
"rep: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Rep era s -> String
forall a. Show a => a -> String
show Rep era s
repS1
          , String
"lens target: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Rep era s -> String
forall a. Show a => a -> String
show Rep era s
repS2
          ]
      )
field Rep era s
_ Term era t
term = String -> AnyF era s
forall a. HasCallStack => String -> a
error (String
"field can only be applied to variable terms: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Term era t -> String
forall a. Show a => a -> String
show Term era t
term)

getName :: Term era t -> Name era
getName :: forall era t. Term era t -> Name era
getName (Var V era t
v) = V era t -> Name era
forall era t. V era t -> Name era
Name V era t
v
getName Term era t
x = String -> Name era
forall a. HasCallStack => String -> a
error (String
"nameOf can't find the name in: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Term era t -> String
forall a. Show a => a -> String
show Term era t
x)

-- ==============================================================
-- NewEpochState fields

type NELens era t = Lens' (NewEpochState era) t

currentEpoch :: Era era => Term era EpochNo
currentEpoch :: forall era. Era era => Term era EpochNo
currentEpoch = V era EpochNo -> Term era EpochNo
forall era t. V era t -> Term era t
Var (String
-> Rep era EpochNo
-> Access era (NewEpochState era) EpochNo
-> V era EpochNo
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"currentEpoch" Rep era EpochNo
forall era. Rep era EpochNo
EpochR (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) EpochNo
-> Access era (NewEpochState era) EpochNo
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (EpochNo -> f EpochNo)
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochNo -> f EpochNo)
-> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) EpochNo
nesELL))

prevBlocksMade :: Era era => Term era (Map (KeyHash 'StakePool) Natural)
prevBlocksMade :: forall era. Era era => Term era (Map (KeyHash 'StakePool) Natural)
prevBlocksMade = V era (Map (KeyHash 'StakePool) Natural)
-> Term era (Map (KeyHash 'StakePool) Natural)
forall era t. V era t -> Term era t
Var (V era (Map (KeyHash 'StakePool) Natural)
 -> Term era (Map (KeyHash 'StakePool) Natural))
-> V era (Map (KeyHash 'StakePool) Natural)
-> Term era (Map (KeyHash 'StakePool) Natural)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (KeyHash 'StakePool) Natural)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
-> V era (Map (KeyHash 'StakePool) Natural)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"prevBlocksMade" (Rep era (KeyHash 'StakePool)
-> Rep era Natural -> Rep era (Map (KeyHash 'StakePool) Natural)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era Natural
forall era. Rep era Natural
NaturalR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (KeyHash 'StakePool) Natural
 -> f (Map (KeyHash 'StakePool) Natural))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) Natural
 -> f (Map (KeyHash 'StakePool) Natural))
-> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
nesBprevL)

currBlocksMade :: Era era => Term era (Map (KeyHash 'StakePool) Natural)
currBlocksMade :: forall era. Era era => Term era (Map (KeyHash 'StakePool) Natural)
currBlocksMade = V era (Map (KeyHash 'StakePool) Natural)
-> Term era (Map (KeyHash 'StakePool) Natural)
forall era t. V era t -> Term era t
Var (V era (Map (KeyHash 'StakePool) Natural)
 -> Term era (Map (KeyHash 'StakePool) Natural))
-> V era (Map (KeyHash 'StakePool) Natural)
-> Term era (Map (KeyHash 'StakePool) Natural)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (KeyHash 'StakePool) Natural)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
-> V era (Map (KeyHash 'StakePool) Natural)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"currBlocksMade" (Rep era (KeyHash 'StakePool)
-> Rep era Natural -> Rep era (Map (KeyHash 'StakePool) Natural)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era Natural
forall era. Rep era Natural
NaturalR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (KeyHash 'StakePool) Natural
 -> f (Map (KeyHash 'StakePool) Natural))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) Natural
 -> f (Map (KeyHash 'StakePool) Natural))
-> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
nesBcurL)

poolDistr ::
  Era era => Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
poolDistr :: forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
poolDistr = V era (Map (KeyHash 'StakePool) IndividualPoolStake)
-> Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era t. V era t -> Term era t
Var (V era (Map (KeyHash 'StakePool) IndividualPoolStake)
 -> Term era (Map (KeyHash 'StakePool) IndividualPoolStake))
-> V era (Map (KeyHash 'StakePool) IndividualPoolStake)
-> Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (KeyHash 'StakePool) IndividualPoolStake)
-> Access
     era
     (NewEpochState era)
     (Map (KeyHash 'StakePool) IndividualPoolStake)
-> V era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"poolDistr" (Rep era (KeyHash 'StakePool)
-> Rep era IndividualPoolStake
-> Rep era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era IndividualPoolStake
forall era. Era era => Rep era IndividualPoolStake
IPoolStakeR) (Rep era (NewEpochState era)
-> Lens'
     (NewEpochState era) (Map (KeyHash 'StakePool) IndividualPoolStake)
-> Access
     era
     (NewEpochState era)
     (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (KeyHash 'StakePool) IndividualPoolStake
 -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) IndividualPoolStake
 -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> NewEpochState era -> f (NewEpochState era)
Lens'
  (NewEpochState era) (Map (KeyHash 'StakePool) IndividualPoolStake)
poolDistrL)

-- | For tests only, Like PoolDistr but has a Rational (rather than a IndividualPoolStake).
mockPoolDistr :: Era era => Term era (Map (KeyHash 'StakePool) Rational)
mockPoolDistr :: forall era. Era era => Term era (Map (KeyHash 'StakePool) Rational)
mockPoolDistr = V era (Map (KeyHash 'StakePool) Rational)
-> Term era (Map (KeyHash 'StakePool) Rational)
forall era t. V era t -> Term era t
Var (V era (Map (KeyHash 'StakePool) Rational)
 -> Term era (Map (KeyHash 'StakePool) Rational))
-> V era (Map (KeyHash 'StakePool) Rational)
-> Term era (Map (KeyHash 'StakePool) Rational)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (KeyHash 'StakePool) Rational)
-> Access era Any (Map (KeyHash 'StakePool) Rational)
-> V era (Map (KeyHash 'StakePool) Rational)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"mockPoolDistr" (Rep era (KeyHash 'StakePool)
-> Rep era Rational -> Rep era (Map (KeyHash 'StakePool) Rational)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era Rational
forall era. Rep era Rational
RationalR) Access era Any (Map (KeyHash 'StakePool) Rational)
forall era s t. Access era s t
No

poolDistrL ::
  NELens era (Map (KeyHash 'StakePool) IndividualPoolStake)
poolDistrL :: forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) IndividualPoolStake
 -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> NewEpochState era -> f (NewEpochState era)
poolDistrL = (PoolDistr -> f PoolDistr)
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(PoolDistr -> f PoolDistr)
-> NewEpochState era -> f (NewEpochState era)
nesPdL ((PoolDistr -> f PoolDistr)
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (KeyHash 'StakePool) IndividualPoolStake
     -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
    -> PoolDistr -> f PoolDistr)
-> (Map (KeyHash 'StakePool) IndividualPoolStake
    -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) IndividualPoolStake
 -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> PoolDistr -> f PoolDistr
Lens' PoolDistr (Map (KeyHash 'StakePool) IndividualPoolStake)
poolDistrDistrL

-- CertState - DState

rewards :: EraCertState era => Term era (Map (Credential 'Staking) Coin)
rewards :: forall era.
EraCertState era =>
Term era (Map (Credential 'Staking) Coin)
rewards = V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'Staking) Coin)
 -> Term era (Map (Credential 'Staking) Coin))
-> V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
-> V era (Map (Credential 'Staking) Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"rewards" (Rep era (Credential 'Staking)
-> Rep era Coin -> Rep era (Map (Credential 'Staking) Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era Coin
forall era. Rep era Coin
CoinR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era -> f (NewEpochState era)
forall era.
EraCertState era =>
NELens era (Map (Credential 'Staking) Coin)
Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
rewardsL)

rewardsL :: EraCertState era => NELens era (Map (Credential 'Staking) Coin)
rewardsL :: forall era.
EraCertState era =>
NELens era (Map (Credential 'Staking) Coin)
rewardsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> EpochState era -> f (EpochState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> LedgerState era -> f (LedgerState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> CertState era -> f (CertState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DState era -> f (DState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens' (CertState era) (DState era)
certDStateL ((DState era -> f (DState era))
 -> CertState era -> f (CertState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> DState era -> f (DState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UMap -> f UMap) -> DState era -> f (DState era)
forall era (f :: * -> *).
Functor f =>
(UMap -> f UMap) -> DState era -> f (DState era)
dsUnifiedL ((UMap -> f UMap) -> DState era -> f (DState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> UMap -> f UMap)
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> DState era
-> f (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> UMap -> f UMap
Lens' UMap (Map (Credential 'Staking) Coin)
rewardsUMapL

delegations ::
  EraCertState era => Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
delegations :: forall era.
EraCertState era =>
Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
delegations = V era (Map (Credential 'Staking) (KeyHash 'StakePool))
-> Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'Staking) (KeyHash 'StakePool))
 -> Term era (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> V era (Map (Credential 'Staking) (KeyHash 'StakePool))
-> Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (Credential 'Staking) (KeyHash 'StakePool))
-> Access
     era
     (NewEpochState era)
     (Map (Credential 'Staking) (KeyHash 'StakePool))
-> V era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"delegations" (Rep era (Credential 'Staking)
-> Rep era (KeyHash 'StakePool)
-> Rep era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR) (Rep era (NewEpochState era)
-> Lens'
     (NewEpochState era)
     (Map (Credential 'Staking) (KeyHash 'StakePool))
-> Access
     era
     (NewEpochState era)
     (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'Staking) (KeyHash 'StakePool)
 -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> NewEpochState era -> f (NewEpochState era)
forall era.
EraCertState era =>
NELens era (Map (Credential 'Staking) (KeyHash 'StakePool))
Lens'
  (NewEpochState era)
  (Map (Credential 'Staking) (KeyHash 'StakePool))
delegationsL)

delegationsL ::
  EraCertState era => NELens era (Map (Credential 'Staking) (KeyHash 'StakePool))
delegationsL :: forall era.
EraCertState era =>
NELens era (Map (Credential 'Staking) (KeyHash 'StakePool))
delegationsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> EpochState era -> f (EpochState era))
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> LedgerState era -> f (LedgerState era))
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> CertState era -> f (CertState era))
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DState era -> f (DState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens' (CertState era) (DState era)
certDStateL ((DState era -> f (DState era))
 -> CertState era -> f (CertState era))
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> DState era -> f (DState era))
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UMap -> f UMap) -> DState era -> f (DState era)
forall era (f :: * -> *).
Functor f =>
(UMap -> f UMap) -> DState era -> f (DState era)
dsUnifiedL ((UMap -> f UMap) -> DState era -> f (DState era))
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> UMap -> f UMap)
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> DState era
-> f (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) (KeyHash 'StakePool)
 -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> UMap -> f UMap
Lens' UMap (Map (Credential 'Staking) (KeyHash 'StakePool))
delegationsUMapL

stakeDeposits :: EraCertState era => Term era (Map (Credential 'Staking) Coin)
stakeDeposits :: forall era.
EraCertState era =>
Term era (Map (Credential 'Staking) Coin)
stakeDeposits = V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'Staking) Coin)
 -> Term era (Map (Credential 'Staking) Coin))
-> V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
-> V era (Map (Credential 'Staking) Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"stakeDeposits" (Rep era (Credential 'Staking)
-> Rep era Coin -> Rep era (Map (Credential 'Staking) Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era Coin
forall era. Rep era Coin
CoinR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era -> f (NewEpochState era)
forall era.
EraCertState era =>
NELens era (Map (Credential 'Staking) Coin)
Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
stakeDepositsL)

stakeDepositsL :: EraCertState era => NELens era (Map (Credential 'Staking) Coin)
stakeDepositsL :: forall era.
EraCertState era =>
NELens era (Map (Credential 'Staking) Coin)
stakeDepositsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> EpochState era -> f (EpochState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> LedgerState era -> f (LedgerState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> CertState era -> f (CertState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DState era -> f (DState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens' (CertState era) (DState era)
certDStateL ((DState era -> f (DState era))
 -> CertState era -> f (CertState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> DState era -> f (DState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UMap -> f UMap) -> DState era -> f (DState era)
forall era (f :: * -> *).
Functor f =>
(UMap -> f UMap) -> DState era -> f (DState era)
dsUnifiedL ((UMap -> f UMap) -> DState era -> f (DState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> UMap -> f UMap)
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> DState era
-> f (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> UMap -> f UMap
Lens' UMap (Map (Credential 'Staking) Coin)
stakeDepositsUMapL

ptrs :: EraCertState era => Term era (Map Ptr (Credential 'Staking))
ptrs :: forall era.
EraCertState era =>
Term era (Map Ptr (Credential 'Staking))
ptrs = V era (Map Ptr (Credential 'Staking))
-> Term era (Map Ptr (Credential 'Staking))
forall era t. V era t -> Term era t
Var (V era (Map Ptr (Credential 'Staking))
 -> Term era (Map Ptr (Credential 'Staking)))
-> V era (Map Ptr (Credential 'Staking))
-> Term era (Map Ptr (Credential 'Staking))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map Ptr (Credential 'Staking))
-> Access era (NewEpochState era) (Map Ptr (Credential 'Staking))
-> V era (Map Ptr (Credential 'Staking))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"ptrs" (Rep era Ptr
-> Rep era (Credential 'Staking)
-> Rep era (Map Ptr (Credential 'Staking))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era Ptr
forall era. Rep era Ptr
PtrR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map Ptr (Credential 'Staking))
-> Access era (NewEpochState era) (Map Ptr (Credential 'Staking))
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map Ptr (Credential 'Staking)
 -> f (Map Ptr (Credential 'Staking)))
-> NewEpochState era -> f (NewEpochState era)
forall era.
EraCertState era =>
NELens era (Map Ptr (Credential 'Staking))
Lens' (NewEpochState era) (Map Ptr (Credential 'Staking))
ptrsL)

ptrsL :: EraCertState era => NELens era (Map Ptr (Credential 'Staking))
ptrsL :: forall era.
EraCertState era =>
NELens era (Map Ptr (Credential 'Staking))
ptrsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map Ptr (Credential 'Staking)
     -> f (Map Ptr (Credential 'Staking)))
    -> EpochState era -> f (EpochState era))
-> (Map Ptr (Credential 'Staking)
    -> f (Map Ptr (Credential 'Staking)))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map Ptr (Credential 'Staking)
     -> f (Map Ptr (Credential 'Staking)))
    -> LedgerState era -> f (LedgerState era))
-> (Map Ptr (Credential 'Staking)
    -> f (Map Ptr (Credential 'Staking)))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map Ptr (Credential 'Staking)
     -> f (Map Ptr (Credential 'Staking)))
    -> CertState era -> f (CertState era))
-> (Map Ptr (Credential 'Staking)
    -> f (Map Ptr (Credential 'Staking)))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DState era -> f (DState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens' (CertState era) (DState era)
certDStateL ((DState era -> f (DState era))
 -> CertState era -> f (CertState era))
-> ((Map Ptr (Credential 'Staking)
     -> f (Map Ptr (Credential 'Staking)))
    -> DState era -> f (DState era))
-> (Map Ptr (Credential 'Staking)
    -> f (Map Ptr (Credential 'Staking)))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UMap -> f UMap) -> DState era -> f (DState era)
forall era (f :: * -> *).
Functor f =>
(UMap -> f UMap) -> DState era -> f (DState era)
dsUnifiedL ((UMap -> f UMap) -> DState era -> f (DState era))
-> ((Map Ptr (Credential 'Staking)
     -> f (Map Ptr (Credential 'Staking)))
    -> UMap -> f UMap)
-> (Map Ptr (Credential 'Staking)
    -> f (Map Ptr (Credential 'Staking)))
-> DState era
-> f (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map Ptr (Credential 'Staking)
 -> f (Map Ptr (Credential 'Staking)))
-> UMap -> f UMap
Lens' UMap (Map Ptr (Credential 'Staking))
ptrsUMapL

currentDRepState ::
  ConwayEraCertState era => Term era (Map (Credential 'DRepRole) DRepState)
currentDRepState :: forall era.
ConwayEraCertState era =>
Term era (Map (Credential 'DRepRole) DRepState)
currentDRepState = V era (Map (Credential 'DRepRole) DRepState)
-> Term era (Map (Credential 'DRepRole) DRepState)
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'DRepRole) DRepState)
 -> Term era (Map (Credential 'DRepRole) DRepState))
-> V era (Map (Credential 'DRepRole) DRepState)
-> Term era (Map (Credential 'DRepRole) DRepState)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (Credential 'DRepRole) DRepState)
-> Access
     era (NewEpochState era) (Map (Credential 'DRepRole) DRepState)
-> V era (Map (Credential 'DRepRole) DRepState)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"currentDRepState" (Rep era (Credential 'DRepRole)
-> Rep era DRepState
-> Rep era (Map (Credential 'DRepRole) DRepState)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'DRepRole)
forall era. Era era => Rep era (Credential 'DRepRole)
VCredR Rep era DRepState
forall era. Era era => Rep era DRepState
DRepStateR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (Credential 'DRepRole) DRepState)
-> Access
     era (NewEpochState era) (Map (Credential 'DRepRole) DRepState)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'DRepRole) DRepState
 -> f (Map (Credential 'DRepRole) DRepState))
-> NewEpochState era -> f (NewEpochState era)
forall era.
ConwayEraCertState era =>
NELens era (Map (Credential 'DRepRole) DRepState)
Lens' (NewEpochState era) (Map (Credential 'DRepRole) DRepState)
drepsL)

drepsL :: ConwayEraCertState era => NELens era (Map (Credential 'DRepRole) DRepState)
drepsL :: forall era.
ConwayEraCertState era =>
NELens era (Map (Credential 'DRepRole) DRepState)
drepsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'DRepRole) DRepState
     -> f (Map (Credential 'DRepRole) DRepState))
    -> EpochState era -> f (EpochState era))
-> (Map (Credential 'DRepRole) DRepState
    -> f (Map (Credential 'DRepRole) DRepState))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map (Credential 'DRepRole) DRepState
     -> f (Map (Credential 'DRepRole) DRepState))
    -> LedgerState era -> f (LedgerState era))
-> (Map (Credential 'DRepRole) DRepState
    -> f (Map (Credential 'DRepRole) DRepState))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map (Credential 'DRepRole) DRepState
     -> f (Map (Credential 'DRepRole) DRepState))
    -> CertState era -> f (CertState era))
-> (Map (Credential 'DRepRole) DRepState
    -> f (Map (Credential 'DRepRole) DRepState))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VState era -> f (VState era))
-> CertState era -> f (CertState era)
forall era.
ConwayEraCertState era =>
Lens' (CertState era) (VState era)
Lens' (CertState era) (VState era)
certVStateL ((VState era -> f (VState era))
 -> CertState era -> f (CertState era))
-> ((Map (Credential 'DRepRole) DRepState
     -> f (Map (Credential 'DRepRole) DRepState))
    -> VState era -> f (VState era))
-> (Map (Credential 'DRepRole) DRepState
    -> f (Map (Credential 'DRepRole) DRepState))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'DRepRole) DRepState
 -> f (Map (Credential 'DRepRole) DRepState))
-> VState era -> f (VState era)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'DRepRole) DRepState
 -> f (Map (Credential 'DRepRole) DRepState))
-> VState era -> f (VState era)
vsDRepsL

drepDelegation ::
  EraCertState era => Term era (Map (Credential 'Staking) DRep)
drepDelegation :: forall era.
EraCertState era =>
Term era (Map (Credential 'Staking) DRep)
drepDelegation = V era (Map (Credential 'Staking) DRep)
-> Term era (Map (Credential 'Staking) DRep)
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'Staking) DRep)
 -> Term era (Map (Credential 'Staking) DRep))
-> V era (Map (Credential 'Staking) DRep)
-> Term era (Map (Credential 'Staking) DRep)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (Credential 'Staking) DRep)
-> Access era (NewEpochState era) (Map (Credential 'Staking) DRep)
-> V era (Map (Credential 'Staking) DRep)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"drepDelegation" (Rep era (Credential 'Staking)
-> Rep era DRep -> Rep era (Map (Credential 'Staking) DRep)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era DRep
forall era. Era era => Rep era DRep
DRepR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (Credential 'Staking) DRep)
-> Access era (NewEpochState era) (Map (Credential 'Staking) DRep)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'Staking) DRep
 -> f (Map (Credential 'Staking) DRep))
-> NewEpochState era -> f (NewEpochState era)
forall era.
EraCertState era =>
NELens era (Map (Credential 'Staking) DRep)
Lens' (NewEpochState era) (Map (Credential 'Staking) DRep)
drepDelegationL)

drepDelegationL :: EraCertState era => NELens era (Map (Credential 'Staking) DRep)
drepDelegationL :: forall era.
EraCertState era =>
NELens era (Map (Credential 'Staking) DRep)
drepDelegationL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'Staking) DRep
     -> f (Map (Credential 'Staking) DRep))
    -> EpochState era -> f (EpochState era))
-> (Map (Credential 'Staking) DRep
    -> f (Map (Credential 'Staking) DRep))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map (Credential 'Staking) DRep
     -> f (Map (Credential 'Staking) DRep))
    -> LedgerState era -> f (LedgerState era))
-> (Map (Credential 'Staking) DRep
    -> f (Map (Credential 'Staking) DRep))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map (Credential 'Staking) DRep
     -> f (Map (Credential 'Staking) DRep))
    -> CertState era -> f (CertState era))
-> (Map (Credential 'Staking) DRep
    -> f (Map (Credential 'Staking) DRep))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DState era -> f (DState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens' (CertState era) (DState era)
certDStateL ((DState era -> f (DState era))
 -> CertState era -> f (CertState era))
-> ((Map (Credential 'Staking) DRep
     -> f (Map (Credential 'Staking) DRep))
    -> DState era -> f (DState era))
-> (Map (Credential 'Staking) DRep
    -> f (Map (Credential 'Staking) DRep))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UMap -> f UMap) -> DState era -> f (DState era)
forall era (f :: * -> *).
Functor f =>
(UMap -> f UMap) -> DState era -> f (DState era)
dsUnifiedL ((UMap -> f UMap) -> DState era -> f (DState era))
-> ((Map (Credential 'Staking) DRep
     -> f (Map (Credential 'Staking) DRep))
    -> UMap -> f UMap)
-> (Map (Credential 'Staking) DRep
    -> f (Map (Credential 'Staking) DRep))
-> DState era
-> f (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) DRep
 -> f (Map (Credential 'Staking) DRep))
-> UMap -> f UMap
Lens' UMap (Map (Credential 'Staking) DRep)
drepUMapL

futureGenDelegs ::
  EraCertState era => Term era (Map FutureGenDeleg GenDelegPair)
futureGenDelegs :: forall era.
EraCertState era =>
Term era (Map FutureGenDeleg GenDelegPair)
futureGenDelegs =
  V era (Map FutureGenDeleg GenDelegPair)
-> Term era (Map FutureGenDeleg GenDelegPair)
forall era t. V era t -> Term era t
Var (V era (Map FutureGenDeleg GenDelegPair)
 -> Term era (Map FutureGenDeleg GenDelegPair))
-> V era (Map FutureGenDeleg GenDelegPair)
-> Term era (Map FutureGenDeleg GenDelegPair)
forall a b. (a -> b) -> a -> b
$
    String
-> Rep era (Map FutureGenDeleg GenDelegPair)
-> Access era (NewEpochState era) (Map FutureGenDeleg GenDelegPair)
-> V era (Map FutureGenDeleg GenDelegPair)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V
      String
"futureGenDelegs"
      (Rep era FutureGenDeleg
-> Rep era GenDelegPair
-> Rep era (Map FutureGenDeleg GenDelegPair)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era FutureGenDeleg
forall era. Era era => Rep era FutureGenDeleg
FutureGenDelegR Rep era GenDelegPair
forall era. Era era => Rep era GenDelegPair
GenDelegPairR)
      (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map FutureGenDeleg GenDelegPair)
-> Access era (NewEpochState era) (Map FutureGenDeleg GenDelegPair)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map FutureGenDeleg GenDelegPair
 -> f (Map FutureGenDeleg GenDelegPair))
-> NewEpochState era -> f (NewEpochState era)
forall era.
EraCertState era =>
NELens era (Map FutureGenDeleg GenDelegPair)
Lens' (NewEpochState era) (Map FutureGenDeleg GenDelegPair)
futureGenDelegsL)

futureGenDelegsL :: EraCertState era => NELens era (Map FutureGenDeleg GenDelegPair)
futureGenDelegsL :: forall era.
EraCertState era =>
NELens era (Map FutureGenDeleg GenDelegPair)
futureGenDelegsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map FutureGenDeleg GenDelegPair
     -> f (Map FutureGenDeleg GenDelegPair))
    -> EpochState era -> f (EpochState era))
-> (Map FutureGenDeleg GenDelegPair
    -> f (Map FutureGenDeleg GenDelegPair))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map FutureGenDeleg GenDelegPair
     -> f (Map FutureGenDeleg GenDelegPair))
    -> LedgerState era -> f (LedgerState era))
-> (Map FutureGenDeleg GenDelegPair
    -> f (Map FutureGenDeleg GenDelegPair))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map FutureGenDeleg GenDelegPair
     -> f (Map FutureGenDeleg GenDelegPair))
    -> CertState era -> f (CertState era))
-> (Map FutureGenDeleg GenDelegPair
    -> f (Map FutureGenDeleg GenDelegPair))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DState era -> f (DState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens' (CertState era) (DState era)
certDStateL ((DState era -> f (DState era))
 -> CertState era -> f (CertState era))
-> ((Map FutureGenDeleg GenDelegPair
     -> f (Map FutureGenDeleg GenDelegPair))
    -> DState era -> f (DState era))
-> (Map FutureGenDeleg GenDelegPair
    -> f (Map FutureGenDeleg GenDelegPair))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map FutureGenDeleg GenDelegPair
 -> f (Map FutureGenDeleg GenDelegPair))
-> DState era -> f (DState era)
forall era (f :: * -> *).
Functor f =>
(Map FutureGenDeleg GenDelegPair
 -> f (Map FutureGenDeleg GenDelegPair))
-> DState era -> f (DState era)
dsFutureGenDelegsL

genDelegs ::
  EraCertState era => Term era (Map (KeyHash 'Genesis) GenDelegPair)
genDelegs :: forall era.
EraCertState era =>
Term era (Map (KeyHash 'Genesis) GenDelegPair)
genDelegs = V era (Map (KeyHash 'Genesis) GenDelegPair)
-> Term era (Map (KeyHash 'Genesis) GenDelegPair)
forall era t. V era t -> Term era t
Var (V era (Map (KeyHash 'Genesis) GenDelegPair)
 -> Term era (Map (KeyHash 'Genesis) GenDelegPair))
-> V era (Map (KeyHash 'Genesis) GenDelegPair)
-> Term era (Map (KeyHash 'Genesis) GenDelegPair)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (KeyHash 'Genesis) GenDelegPair)
-> Access
     era (NewEpochState era) (Map (KeyHash 'Genesis) GenDelegPair)
-> V era (Map (KeyHash 'Genesis) GenDelegPair)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"genDelegs" (Rep era (KeyHash 'Genesis)
-> Rep era GenDelegPair
-> Rep era (Map (KeyHash 'Genesis) GenDelegPair)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'Genesis)
forall era. Era era => Rep era (KeyHash 'Genesis)
GenHashR Rep era GenDelegPair
forall era. Era era => Rep era GenDelegPair
GenDelegPairR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (KeyHash 'Genesis) GenDelegPair)
-> Access
     era (NewEpochState era) (Map (KeyHash 'Genesis) GenDelegPair)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (KeyHash 'Genesis) GenDelegPair
 -> f (Map (KeyHash 'Genesis) GenDelegPair))
-> NewEpochState era -> f (NewEpochState era)
forall era.
EraCertState era =>
NELens era (Map (KeyHash 'Genesis) GenDelegPair)
Lens' (NewEpochState era) (Map (KeyHash 'Genesis) GenDelegPair)
genDelegsL)

genDelegsL :: EraCertState era => NELens era (Map (KeyHash 'Genesis) GenDelegPair)
genDelegsL :: forall era.
EraCertState era =>
NELens era (Map (KeyHash 'Genesis) GenDelegPair)
genDelegsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (KeyHash 'Genesis) GenDelegPair
     -> f (Map (KeyHash 'Genesis) GenDelegPair))
    -> EpochState era -> f (EpochState era))
-> (Map (KeyHash 'Genesis) GenDelegPair
    -> f (Map (KeyHash 'Genesis) GenDelegPair))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map (KeyHash 'Genesis) GenDelegPair
     -> f (Map (KeyHash 'Genesis) GenDelegPair))
    -> LedgerState era -> f (LedgerState era))
-> (Map (KeyHash 'Genesis) GenDelegPair
    -> f (Map (KeyHash 'Genesis) GenDelegPair))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map (KeyHash 'Genesis) GenDelegPair
     -> f (Map (KeyHash 'Genesis) GenDelegPair))
    -> CertState era -> f (CertState era))
-> (Map (KeyHash 'Genesis) GenDelegPair
    -> f (Map (KeyHash 'Genesis) GenDelegPair))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DState era -> f (DState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens' (CertState era) (DState era)
certDStateL ((DState era -> f (DState era))
 -> CertState era -> f (CertState era))
-> ((Map (KeyHash 'Genesis) GenDelegPair
     -> f (Map (KeyHash 'Genesis) GenDelegPair))
    -> DState era -> f (DState era))
-> (Map (KeyHash 'Genesis) GenDelegPair
    -> f (Map (KeyHash 'Genesis) GenDelegPair))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GenDelegs -> f GenDelegs) -> DState era -> f (DState era)
forall era (f :: * -> *).
Functor f =>
(GenDelegs -> f GenDelegs) -> DState era -> f (DState era)
dsGenDelegsL ((GenDelegs -> f GenDelegs) -> DState era -> f (DState era))
-> ((Map (KeyHash 'Genesis) GenDelegPair
     -> f (Map (KeyHash 'Genesis) GenDelegPair))
    -> GenDelegs -> f GenDelegs)
-> (Map (KeyHash 'Genesis) GenDelegPair
    -> f (Map (KeyHash 'Genesis) GenDelegPair))
-> DState era
-> f (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'Genesis) GenDelegPair
 -> f (Map (KeyHash 'Genesis) GenDelegPair))
-> GenDelegs -> f GenDelegs
Lens' GenDelegs (Map (KeyHash 'Genesis) GenDelegPair)
unGenDelegsL

-- DState - InstantaneousRewards

instanReserves :: EraCertState era => Term era (Map (Credential 'Staking) Coin)
instanReserves :: forall era.
EraCertState era =>
Term era (Map (Credential 'Staking) Coin)
instanReserves = V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'Staking) Coin)
 -> Term era (Map (Credential 'Staking) Coin))
-> V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
-> V era (Map (Credential 'Staking) Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"instanReserves" (Rep era (Credential 'Staking)
-> Rep era Coin -> Rep era (Map (Credential 'Staking) Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era Coin
forall era. Rep era Coin
CoinR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era -> f (NewEpochState era)
forall era.
EraCertState era =>
NELens era (Map (Credential 'Staking) Coin)
Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
instanReservesL)

instanReservesL :: EraCertState era => NELens era (Map (Credential 'Staking) Coin)
instanReservesL :: forall era.
EraCertState era =>
NELens era (Map (Credential 'Staking) Coin)
instanReservesL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> EpochState era -> f (EpochState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> LedgerState era -> f (LedgerState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> CertState era -> f (CertState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DState era -> f (DState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens' (CertState era) (DState era)
certDStateL ((DState era -> f (DState era))
 -> CertState era -> f (CertState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> DState era -> f (DState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (InstantaneousRewards -> f InstantaneousRewards)
-> DState era -> f (DState era)
forall era (f :: * -> *).
Functor f =>
(InstantaneousRewards -> f InstantaneousRewards)
-> DState era -> f (DState era)
dsIRewardsL ((InstantaneousRewards -> f InstantaneousRewards)
 -> DState era -> f (DState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> InstantaneousRewards -> f InstantaneousRewards)
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> DState era
-> f (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> InstantaneousRewards -> f InstantaneousRewards
Lens' InstantaneousRewards (Map (Credential 'Staking) Coin)
iRReservesL

instanReservesSum :: Era era => Term era Coin
instanReservesSum :: forall era. Era era => Term era Coin
instanReservesSum = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"instanReservesSum" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No)

instanTreasury :: EraCertState era => Term era (Map (Credential 'Staking) Coin)
instanTreasury :: forall era.
EraCertState era =>
Term era (Map (Credential 'Staking) Coin)
instanTreasury = V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'Staking) Coin)
 -> Term era (Map (Credential 'Staking) Coin))
-> V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
-> V era (Map (Credential 'Staking) Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"instanTreasury" (Rep era (Credential 'Staking)
-> Rep era Coin -> Rep era (Map (Credential 'Staking) Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era Coin
forall era. Rep era Coin
CoinR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era -> f (NewEpochState era)
forall era.
EraCertState era =>
NELens era (Map (Credential 'Staking) Coin)
Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
instanTreasuryL)

instanTreasuryL :: EraCertState era => NELens era (Map (Credential 'Staking) Coin)
instanTreasuryL :: forall era.
EraCertState era =>
NELens era (Map (Credential 'Staking) Coin)
instanTreasuryL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> EpochState era -> f (EpochState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> LedgerState era -> f (LedgerState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> CertState era -> f (CertState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DState era -> f (DState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens' (CertState era) (DState era)
certDStateL ((DState era -> f (DState era))
 -> CertState era -> f (CertState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> DState era -> f (DState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (InstantaneousRewards -> f InstantaneousRewards)
-> DState era -> f (DState era)
forall era (f :: * -> *).
Functor f =>
(InstantaneousRewards -> f InstantaneousRewards)
-> DState era -> f (DState era)
dsIRewardsL ((InstantaneousRewards -> f InstantaneousRewards)
 -> DState era -> f (DState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> InstantaneousRewards -> f InstantaneousRewards)
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> DState era
-> f (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> InstantaneousRewards -> f InstantaneousRewards
Lens' InstantaneousRewards (Map (Credential 'Staking) Coin)
iRTreasuryL

instanTreasurySum :: Era era => Term era Coin
instanTreasurySum :: forall era. Era era => Term era Coin
instanTreasurySum = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"instanTreasurySum" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No)

deltaReserves :: EraCertState era => Term era DeltaCoin
deltaReserves :: forall era. EraCertState era => Term era DeltaCoin
deltaReserves = V era DeltaCoin -> Term era DeltaCoin
forall era t. V era t -> Term era t
Var (V era DeltaCoin -> Term era DeltaCoin)
-> V era DeltaCoin -> Term era DeltaCoin
forall a b. (a -> b) -> a -> b
$ String
-> Rep era DeltaCoin
-> Access era (NewEpochState era) DeltaCoin
-> V era DeltaCoin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"deltaReserves" Rep era DeltaCoin
forall era. Rep era DeltaCoin
DeltaCoinR (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) DeltaCoin
-> Access era (NewEpochState era) DeltaCoin
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (DeltaCoin -> f DeltaCoin)
-> NewEpochState era -> f (NewEpochState era)
forall era. EraCertState era => NELens era DeltaCoin
Lens' (NewEpochState era) DeltaCoin
deltaReservesNEL)

deltaReservesNEL :: EraCertState era => NELens era DeltaCoin
deltaReservesNEL :: forall era. EraCertState era => NELens era DeltaCoin
deltaReservesNEL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((DeltaCoin -> f DeltaCoin)
    -> EpochState era -> f (EpochState era))
-> (DeltaCoin -> f DeltaCoin)
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((DeltaCoin -> f DeltaCoin)
    -> LedgerState era -> f (LedgerState era))
-> (DeltaCoin -> f DeltaCoin)
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((DeltaCoin -> f DeltaCoin)
    -> CertState era -> f (CertState era))
-> (DeltaCoin -> f DeltaCoin)
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DState era -> f (DState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens' (CertState era) (DState era)
certDStateL ((DState era -> f (DState era))
 -> CertState era -> f (CertState era))
-> ((DeltaCoin -> f DeltaCoin) -> DState era -> f (DState era))
-> (DeltaCoin -> f DeltaCoin)
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (InstantaneousRewards -> f InstantaneousRewards)
-> DState era -> f (DState era)
forall era (f :: * -> *).
Functor f =>
(InstantaneousRewards -> f InstantaneousRewards)
-> DState era -> f (DState era)
dsIRewardsL ((InstantaneousRewards -> f InstantaneousRewards)
 -> DState era -> f (DState era))
-> ((DeltaCoin -> f DeltaCoin)
    -> InstantaneousRewards -> f InstantaneousRewards)
-> (DeltaCoin -> f DeltaCoin)
-> DState era
-> f (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DeltaCoin -> f DeltaCoin)
-> InstantaneousRewards -> f InstantaneousRewards
Lens' InstantaneousRewards DeltaCoin
deltaReservesL

deltaTreasury :: EraCertState era => Term era DeltaCoin
deltaTreasury :: forall era. EraCertState era => Term era DeltaCoin
deltaTreasury = V era DeltaCoin -> Term era DeltaCoin
forall era t. V era t -> Term era t
Var (V era DeltaCoin -> Term era DeltaCoin)
-> V era DeltaCoin -> Term era DeltaCoin
forall a b. (a -> b) -> a -> b
$ String
-> Rep era DeltaCoin
-> Access era (NewEpochState era) DeltaCoin
-> V era DeltaCoin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"deltaTreasury" Rep era DeltaCoin
forall era. Rep era DeltaCoin
DeltaCoinR (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) DeltaCoin
-> Access era (NewEpochState era) DeltaCoin
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (DeltaCoin -> f DeltaCoin)
-> NewEpochState era -> f (NewEpochState era)
forall era. EraCertState era => NELens era DeltaCoin
Lens' (NewEpochState era) DeltaCoin
deltaTreasuryNEL)

deltaTreasuryNEL :: EraCertState era => NELens era DeltaCoin
deltaTreasuryNEL :: forall era. EraCertState era => NELens era DeltaCoin
deltaTreasuryNEL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((DeltaCoin -> f DeltaCoin)
    -> EpochState era -> f (EpochState era))
-> (DeltaCoin -> f DeltaCoin)
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((DeltaCoin -> f DeltaCoin)
    -> LedgerState era -> f (LedgerState era))
-> (DeltaCoin -> f DeltaCoin)
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((DeltaCoin -> f DeltaCoin)
    -> CertState era -> f (CertState era))
-> (DeltaCoin -> f DeltaCoin)
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DState era -> f (DState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens' (CertState era) (DState era)
certDStateL ((DState era -> f (DState era))
 -> CertState era -> f (CertState era))
-> ((DeltaCoin -> f DeltaCoin) -> DState era -> f (DState era))
-> (DeltaCoin -> f DeltaCoin)
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (InstantaneousRewards -> f InstantaneousRewards)
-> DState era -> f (DState era)
forall era (f :: * -> *).
Functor f =>
(InstantaneousRewards -> f InstantaneousRewards)
-> DState era -> f (DState era)
dsIRewardsL ((InstantaneousRewards -> f InstantaneousRewards)
 -> DState era -> f (DState era))
-> ((DeltaCoin -> f DeltaCoin)
    -> InstantaneousRewards -> f InstantaneousRewards)
-> (DeltaCoin -> f DeltaCoin)
-> DState era
-> f (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DeltaCoin -> f DeltaCoin)
-> InstantaneousRewards -> f InstantaneousRewards
Lens' InstantaneousRewards DeltaCoin
deltaTreasuryL

-- CertState - PState

regPools :: EraCertState era => Term era (Map (KeyHash 'StakePool) PoolParams)
regPools :: forall era.
EraCertState era =>
Term era (Map (KeyHash 'StakePool) PoolParams)
regPools = V era (Map (KeyHash 'StakePool) PoolParams)
-> Term era (Map (KeyHash 'StakePool) PoolParams)
forall era t. V era t -> Term era t
Var (V era (Map (KeyHash 'StakePool) PoolParams)
 -> Term era (Map (KeyHash 'StakePool) PoolParams))
-> V era (Map (KeyHash 'StakePool) PoolParams)
-> Term era (Map (KeyHash 'StakePool) PoolParams)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (KeyHash 'StakePool) PoolParams)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
-> V era (Map (KeyHash 'StakePool) PoolParams)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"regPools" (Rep era (KeyHash 'StakePool)
-> Rep era PoolParams
-> Rep era (Map (KeyHash 'StakePool) PoolParams)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era PoolParams
forall era. Era era => Rep era PoolParams
PoolParamsR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era -> f (NewEpochState era)
forall era.
EraCertState era =>
NELens era (Map (KeyHash 'StakePool) PoolParams)
Lens' (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
regPoolsL)

regPoolsL :: EraCertState era => NELens era (Map (KeyHash 'StakePool) PoolParams)
regPoolsL :: forall era.
EraCertState era =>
NELens era (Map (KeyHash 'StakePool) PoolParams)
regPoolsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> EpochState era -> f (EpochState era))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> LedgerState era -> f (LedgerState era))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> CertState era -> f (CertState era))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PState era -> f (PState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (PState era)
Lens' (CertState era) (PState era)
certPStateL ((PState era -> f (PState era))
 -> CertState era -> f (CertState era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> PState era -> f (PState era))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> PState era -> f (PState era)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> PState era -> f (PState era)
psStakePoolParamsL

futureRegPools :: EraCertState era => Term era (Map (KeyHash 'StakePool) PoolParams)
futureRegPools :: forall era.
EraCertState era =>
Term era (Map (KeyHash 'StakePool) PoolParams)
futureRegPools = V era (Map (KeyHash 'StakePool) PoolParams)
-> Term era (Map (KeyHash 'StakePool) PoolParams)
forall era t. V era t -> Term era t
Var (V era (Map (KeyHash 'StakePool) PoolParams)
 -> Term era (Map (KeyHash 'StakePool) PoolParams))
-> V era (Map (KeyHash 'StakePool) PoolParams)
-> Term era (Map (KeyHash 'StakePool) PoolParams)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (KeyHash 'StakePool) PoolParams)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
-> V era (Map (KeyHash 'StakePool) PoolParams)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"futureRegPools" (Rep era (KeyHash 'StakePool)
-> Rep era PoolParams
-> Rep era (Map (KeyHash 'StakePool) PoolParams)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era PoolParams
forall era. Era era => Rep era PoolParams
PoolParamsR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era -> f (NewEpochState era)
forall era.
EraCertState era =>
NELens era (Map (KeyHash 'StakePool) PoolParams)
Lens' (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
futureRegPoolsL)

futureRegPoolsL :: EraCertState era => NELens era (Map (KeyHash 'StakePool) PoolParams)
futureRegPoolsL :: forall era.
EraCertState era =>
NELens era (Map (KeyHash 'StakePool) PoolParams)
futureRegPoolsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> EpochState era -> f (EpochState era))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> LedgerState era -> f (LedgerState era))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> CertState era -> f (CertState era))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PState era -> f (PState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (PState era)
Lens' (CertState era) (PState era)
certPStateL ((PState era -> f (PState era))
 -> CertState era -> f (CertState era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> PState era -> f (PState era))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> PState era -> f (PState era)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> PState era -> f (PState era)
psFutureStakePoolParamsL

retiring :: EraCertState era => Term era (Map (KeyHash 'StakePool) EpochNo)
retiring :: forall era.
EraCertState era =>
Term era (Map (KeyHash 'StakePool) EpochNo)
retiring = V era (Map (KeyHash 'StakePool) EpochNo)
-> Term era (Map (KeyHash 'StakePool) EpochNo)
forall era t. V era t -> Term era t
Var (V era (Map (KeyHash 'StakePool) EpochNo)
 -> Term era (Map (KeyHash 'StakePool) EpochNo))
-> V era (Map (KeyHash 'StakePool) EpochNo)
-> Term era (Map (KeyHash 'StakePool) EpochNo)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (KeyHash 'StakePool) EpochNo)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) EpochNo)
-> V era (Map (KeyHash 'StakePool) EpochNo)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"retiring" (Rep era (KeyHash 'StakePool)
-> Rep era EpochNo -> Rep era (Map (KeyHash 'StakePool) EpochNo)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era EpochNo
forall era. Rep era EpochNo
EpochR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (KeyHash 'StakePool) EpochNo)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) EpochNo)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (KeyHash 'StakePool) EpochNo
 -> f (Map (KeyHash 'StakePool) EpochNo))
-> NewEpochState era -> f (NewEpochState era)
forall era.
EraCertState era =>
NELens era (Map (KeyHash 'StakePool) EpochNo)
Lens' (NewEpochState era) (Map (KeyHash 'StakePool) EpochNo)
retiringL)

retiringL :: EraCertState era => NELens era (Map (KeyHash 'StakePool) EpochNo)
retiringL :: forall era.
EraCertState era =>
NELens era (Map (KeyHash 'StakePool) EpochNo)
retiringL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (KeyHash 'StakePool) EpochNo
     -> f (Map (KeyHash 'StakePool) EpochNo))
    -> EpochState era -> f (EpochState era))
-> (Map (KeyHash 'StakePool) EpochNo
    -> f (Map (KeyHash 'StakePool) EpochNo))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map (KeyHash 'StakePool) EpochNo
     -> f (Map (KeyHash 'StakePool) EpochNo))
    -> LedgerState era -> f (LedgerState era))
-> (Map (KeyHash 'StakePool) EpochNo
    -> f (Map (KeyHash 'StakePool) EpochNo))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map (KeyHash 'StakePool) EpochNo
     -> f (Map (KeyHash 'StakePool) EpochNo))
    -> CertState era -> f (CertState era))
-> (Map (KeyHash 'StakePool) EpochNo
    -> f (Map (KeyHash 'StakePool) EpochNo))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PState era -> f (PState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (PState era)
Lens' (CertState era) (PState era)
certPStateL ((PState era -> f (PState era))
 -> CertState era -> f (CertState era))
-> ((Map (KeyHash 'StakePool) EpochNo
     -> f (Map (KeyHash 'StakePool) EpochNo))
    -> PState era -> f (PState era))
-> (Map (KeyHash 'StakePool) EpochNo
    -> f (Map (KeyHash 'StakePool) EpochNo))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) EpochNo
 -> f (Map (KeyHash 'StakePool) EpochNo))
-> PState era -> f (PState era)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) EpochNo
 -> f (Map (KeyHash 'StakePool) EpochNo))
-> PState era -> f (PState era)
psRetiringL

poolDeposits :: EraCertState era => Term era (Map (KeyHash 'StakePool) Coin)
poolDeposits :: forall era.
EraCertState era =>
Term era (Map (KeyHash 'StakePool) Coin)
poolDeposits = V era (Map (KeyHash 'StakePool) Coin)
-> Term era (Map (KeyHash 'StakePool) Coin)
forall era t. V era t -> Term era t
Var (V era (Map (KeyHash 'StakePool) Coin)
 -> Term era (Map (KeyHash 'StakePool) Coin))
-> V era (Map (KeyHash 'StakePool) Coin)
-> Term era (Map (KeyHash 'StakePool) Coin)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (KeyHash 'StakePool) Coin)
-> Access era (NewEpochState era) (Map (KeyHash 'StakePool) Coin)
-> V era (Map (KeyHash 'StakePool) Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"poolDeposits" (Rep era (KeyHash 'StakePool)
-> Rep era Coin -> Rep era (Map (KeyHash 'StakePool) Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era Coin
forall era. Rep era Coin
CoinR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (KeyHash 'StakePool) Coin)
-> Access era (NewEpochState era) (Map (KeyHash 'StakePool) Coin)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (KeyHash 'StakePool) Coin
 -> f (Map (KeyHash 'StakePool) Coin))
-> NewEpochState era -> f (NewEpochState era)
forall era.
EraCertState era =>
NELens era (Map (KeyHash 'StakePool) Coin)
Lens' (NewEpochState era) (Map (KeyHash 'StakePool) Coin)
poolDepositsL)

poolDepositsL :: EraCertState era => NELens era (Map (KeyHash 'StakePool) Coin)
poolDepositsL :: forall era.
EraCertState era =>
NELens era (Map (KeyHash 'StakePool) Coin)
poolDepositsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (KeyHash 'StakePool) Coin
     -> f (Map (KeyHash 'StakePool) Coin))
    -> EpochState era -> f (EpochState era))
-> (Map (KeyHash 'StakePool) Coin
    -> f (Map (KeyHash 'StakePool) Coin))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map (KeyHash 'StakePool) Coin
     -> f (Map (KeyHash 'StakePool) Coin))
    -> LedgerState era -> f (LedgerState era))
-> (Map (KeyHash 'StakePool) Coin
    -> f (Map (KeyHash 'StakePool) Coin))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map (KeyHash 'StakePool) Coin
     -> f (Map (KeyHash 'StakePool) Coin))
    -> CertState era -> f (CertState era))
-> (Map (KeyHash 'StakePool) Coin
    -> f (Map (KeyHash 'StakePool) Coin))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PState era -> f (PState era))
-> CertState era -> f (CertState era)
forall era. EraCertState era => Lens' (CertState era) (PState era)
Lens' (CertState era) (PState era)
certPStateL ((PState era -> f (PState era))
 -> CertState era -> f (CertState era))
-> ((Map (KeyHash 'StakePool) Coin
     -> f (Map (KeyHash 'StakePool) Coin))
    -> PState era -> f (PState era))
-> (Map (KeyHash 'StakePool) Coin
    -> f (Map (KeyHash 'StakePool) Coin))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) Coin
 -> f (Map (KeyHash 'StakePool) Coin))
-> PState era -> f (PState era)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) Coin
 -> f (Map (KeyHash 'StakePool) Coin))
-> PState era -> f (PState era)
psDepositsL

committeeState ::
  ConwayEraCertState era =>
  Term era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
committeeState :: forall era.
ConwayEraCertState era =>
Term
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
committeeState =
  V era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> Term
     era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
 -> Term
      era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> V era
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> Term
     era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall a b. (a -> b) -> a -> b
$
    String
-> Rep
     era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> Access
     era
     (NewEpochState era)
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> V era
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"committeeState" (Rep era (Credential 'ColdCommitteeRole)
-> Rep era CommitteeAuthorization
-> Rep
     era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'ColdCommitteeRole)
forall era. Era era => Rep era (Credential 'ColdCommitteeRole)
CommColdCredR Rep era CommitteeAuthorization
forall era. Era era => Rep era CommitteeAuthorization
CommitteeAuthorizationR) (Rep era (NewEpochState era)
-> Lens'
     (NewEpochState era)
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> Access
     era
     (NewEpochState era)
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
 -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> NewEpochState era -> f (NewEpochState era)
forall era.
ConwayEraCertState era =>
NELens
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
Lens'
  (NewEpochState era)
  (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
committeeStateL)

committeeStateL ::
  ConwayEraCertState era => NELens era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
committeeStateL :: forall era.
ConwayEraCertState era =>
NELens
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
committeeStateL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
     -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
    -> EpochState era -> f (EpochState era))
-> (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
    -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
     -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
    -> LedgerState era -> f (LedgerState era))
-> (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
    -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
     -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
    -> CertState era -> f (CertState era))
-> (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
    -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VState era -> f (VState era))
-> CertState era -> f (CertState era)
forall era.
ConwayEraCertState era =>
Lens' (CertState era) (VState era)
Lens' (CertState era) (VState era)
certVStateL ((VState era -> f (VState era))
 -> CertState era -> f (CertState era))
-> ((Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
     -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
    -> VState era -> f (VState era))
-> (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
    -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CommitteeState era -> f (CommitteeState era))
-> VState era -> f (VState era)
forall era (f :: * -> *).
Functor f =>
(CommitteeState era -> f (CommitteeState era))
-> VState era -> f (VState era)
vsCommitteeStateL ((CommitteeState era -> f (CommitteeState era))
 -> VState era -> f (VState era))
-> ((Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
     -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
    -> CommitteeState era -> f (CommitteeState era))
-> (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
    -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> VState era
-> f (VState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
 -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> CommitteeState era -> f (CommitteeState era)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
 -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> CommitteeState era -> f (CommitteeState era)
csCommitteeCredsL

numDormantEpochs :: ConwayEraCertState era => Term era EpochNo
numDormantEpochs :: forall era. ConwayEraCertState era => Term era EpochNo
numDormantEpochs = V era EpochNo -> Term era EpochNo
forall era t. V era t -> Term era t
Var (V era EpochNo -> Term era EpochNo)
-> V era EpochNo -> Term era EpochNo
forall a b. (a -> b) -> a -> b
$ String
-> Rep era EpochNo
-> Access era (NewEpochState era) EpochNo
-> V era EpochNo
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"numDormantEpochs" Rep era EpochNo
forall era. Rep era EpochNo
EpochR (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) EpochNo
-> Access era (NewEpochState era) EpochNo
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (EpochNo -> f EpochNo)
-> NewEpochState era -> f (NewEpochState era)
forall era. ConwayEraCertState era => NELens era EpochNo
Lens' (NewEpochState era) EpochNo
numDormantEpochsL)

numDormantEpochsL :: ConwayEraCertState era => NELens era EpochNo
numDormantEpochsL :: forall era. ConwayEraCertState era => NELens era EpochNo
numDormantEpochsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((EpochNo -> f EpochNo) -> EpochState era -> f (EpochState era))
-> (EpochNo -> f EpochNo)
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((EpochNo -> f EpochNo)
    -> LedgerState era -> f (LedgerState era))
-> (EpochNo -> f EpochNo)
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((EpochNo -> f EpochNo) -> CertState era -> f (CertState era))
-> (EpochNo -> f EpochNo)
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VState era -> f (VState era))
-> CertState era -> f (CertState era)
forall era.
ConwayEraCertState era =>
Lens' (CertState era) (VState era)
Lens' (CertState era) (VState era)
certVStateL ((VState era -> f (VState era))
 -> CertState era -> f (CertState era))
-> ((EpochNo -> f EpochNo) -> VState era -> f (VState era))
-> (EpochNo -> f EpochNo)
-> CertState era
-> f (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (EpochNo -> f EpochNo) -> VState era -> f (VState era)
forall era (f :: * -> *).
Functor f =>
(EpochNo -> f EpochNo) -> VState era -> f (VState era)
vsNumDormantEpochsL

-- UTxOState

utxo :: Era era => Proof era -> Term era (Map TxIn (TxOutF era))
utxo :: forall era.
Era era =>
Proof era -> Term era (Map TxIn (TxOutF era))
utxo Proof era
p = V era (Map TxIn (TxOutF era)) -> Term era (Map TxIn (TxOutF era))
forall era t. V era t -> Term era t
Var (V era (Map TxIn (TxOutF era)) -> Term era (Map TxIn (TxOutF era)))
-> V era (Map TxIn (TxOutF era))
-> Term era (Map TxIn (TxOutF era))
forall a b. (a -> b) -> a -> b
$ Proof era
-> String
-> Rep era (Map TxIn (TxOutF era))
-> Access era (NewEpochState era) (Map TxIn (TxOutF era))
-> V era (Map TxIn (TxOutF era))
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV Proof era
p String
"utxo" (Rep era TxIn
-> Rep era (TxOutF era) -> Rep era (Map TxIn (TxOutF era))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era TxIn
forall era. Era era => Rep era TxIn
TxInR (Proof era -> Rep era (TxOutF era)
forall era. Era era => Proof era -> Rep era (TxOutF era)
TxOutR Proof era
p)) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map TxIn (TxOutF era))
-> Access era (NewEpochState era) (Map TxIn (TxOutF era))
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Proof era -> Lens' (NewEpochState era) (Map TxIn (TxOutF era))
forall era. Proof era -> NELens era (Map TxIn (TxOutF era))
utxoL' Proof era
p))

utxoL' :: Proof era -> NELens era (Map TxIn (TxOutF era))
utxoL' :: forall era. Proof era -> NELens era (Map TxIn (TxOutF era))
utxoL' Proof era
proof = (UTxO era -> f (UTxO era))
-> NewEpochState era -> f (NewEpochState era)
forall era. Lens' (NewEpochState era) (UTxO era)
forall (t :: * -> *) era. CanSetUTxO t => Lens' (t era) (UTxO era)
utxoL ((UTxO era -> f (UTxO era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map TxIn (TxOutF era) -> f (Map TxIn (TxOutF era)))
    -> UTxO era -> f (UTxO era))
-> (Map TxIn (TxOutF era) -> f (Map TxIn (TxOutF era)))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proof era -> Lens' (UTxO era) (Map TxIn (TxOutF era))
forall era. Proof era -> Lens' (UTxO era) (Map TxIn (TxOutF era))
unUtxoL Proof era
proof

unUtxoL :: Proof era -> Lens' (UTxO era) (Map TxIn (TxOutF era))
unUtxoL :: forall era. Proof era -> Lens' (UTxO era) (Map TxIn (TxOutF era))
unUtxoL Proof era
p = (UTxO era -> Map TxIn (TxOutF era))
-> (UTxO era -> Map TxIn (TxOutF era) -> UTxO era)
-> Lens
     (UTxO era)
     (UTxO era)
     (Map TxIn (TxOutF era))
     (Map TxIn (TxOutF era))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ((TxOut era -> TxOutF era)
-> Map TxIn (TxOut era) -> Map TxIn (TxOutF era)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (Proof era -> TxOut era -> TxOutF era
forall era. Proof era -> TxOut era -> TxOutF era
TxOutF Proof era
p) (Map TxIn (TxOut era) -> Map TxIn (TxOutF era))
-> (UTxO era -> Map TxIn (TxOut era))
-> UTxO era
-> Map TxIn (TxOutF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut era)
forall era. UTxO era -> Map TxIn (TxOut era)
unUTxO) (\(UTxO Map TxIn (TxOut era)
_) Map TxIn (TxOutF era)
new -> Map TxIn (TxOutF era) -> UTxO era
forall era. Map TxIn (TxOutF era) -> UTxO era
liftUTxO Map TxIn (TxOutF era)
new)

deposits :: Era era => Term era Coin
deposits :: forall era. Era era => Term era Coin
deposits = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String
-> Rep era Coin
-> Access era (NewEpochState era) Coin
-> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"deposits" Rep era Coin
forall era. Rep era Coin
CoinR (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) Coin
-> Access era (NewEpochState era) Coin
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Coin -> f Coin) -> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin) -> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) Coin
depositsL)

depositsL :: NELens era Coin
depositsL :: forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin) -> NewEpochState era -> f (NewEpochState era)
depositsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Coin -> f Coin) -> EpochState era -> f (EpochState era))
-> (Coin -> f Coin)
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Coin -> f Coin) -> LedgerState era -> f (LedgerState era))
-> (Coin -> f Coin)
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
lsUTxOStateL ((UTxOState era -> f (UTxOState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Coin -> f Coin) -> UTxOState era -> f (UTxOState era))
-> (Coin -> f Coin)
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Coin -> f Coin) -> UTxOState era -> f (UTxOState era)
forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin) -> UTxOState era -> f (UTxOState era)
utxosDepositedL

fees :: Era era => Term era Coin
fees :: forall era. Era era => Term era Coin
fees = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String
-> Rep era Coin
-> Access era (NewEpochState era) Coin
-> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"fees" Rep era Coin
forall era. Rep era Coin
CoinR (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) Coin
-> Access era (NewEpochState era) Coin
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Coin -> f Coin) -> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin) -> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) Coin
feesL)

feesL :: NELens era Coin
feesL :: forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin) -> NewEpochState era -> f (NewEpochState era)
feesL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Coin -> f Coin) -> EpochState era -> f (EpochState era))
-> (Coin -> f Coin)
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Coin -> f Coin) -> LedgerState era -> f (LedgerState era))
-> (Coin -> f Coin)
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
lsUTxOStateL ((UTxOState era -> f (UTxOState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Coin -> f Coin) -> UTxOState era -> f (UTxOState era))
-> (Coin -> f Coin)
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Coin -> f Coin) -> UTxOState era -> f (UTxOState era)
forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin) -> UTxOState era -> f (UTxOState era)
utxosFeesL

donation :: Era era => Term era Coin
donation :: forall era. Era era => Term era Coin
donation = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String
-> Rep era Coin
-> Access era (NewEpochState era) Coin
-> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"donation" Rep era Coin
forall era. Rep era Coin
CoinR (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) Coin
-> Access era (NewEpochState era) Coin
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Coin -> f Coin) -> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin) -> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) Coin
donationL)

donationL :: NELens era Coin
donationL :: forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin) -> NewEpochState era -> f (NewEpochState era)
donationL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Coin -> f Coin) -> EpochState era -> f (EpochState era))
-> (Coin -> f Coin)
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((Coin -> f Coin) -> LedgerState era -> f (LedgerState era))
-> (Coin -> f Coin)
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
lsUTxOStateL ((UTxOState era -> f (UTxOState era))
 -> LedgerState era -> f (LedgerState era))
-> ((Coin -> f Coin) -> UTxOState era -> f (UTxOState era))
-> (Coin -> f Coin)
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Coin -> f Coin) -> UTxOState era -> f (UTxOState era)
forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin) -> UTxOState era -> f (UTxOState era)
utxosDonationL

ppup :: Era era => Proof era -> Term era (ShelleyGovState era)
ppup :: forall era. Era era => Proof era -> Term era (ShelleyGovState era)
ppup Proof era
p = V era (ShelleyGovState era) -> Term era (ShelleyGovState era)
forall era t. V era t -> Term era t
Var (V era (ShelleyGovState era) -> Term era (ShelleyGovState era))
-> V era (ShelleyGovState era) -> Term era (ShelleyGovState era)
forall a b. (a -> b) -> a -> b
$ Proof era
-> String
-> Rep era (ShelleyGovState era)
-> Access era (NewEpochState era) (ShelleyGovState era)
-> V era (ShelleyGovState era)
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV Proof era
p String
"ppup" (Proof era -> Rep era (ShelleyGovState era)
forall era. Era era => Proof era -> Rep era (ShelleyGovState era)
PPUPStateR Proof era
p) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (ShelleyGovState era)
-> Access era (NewEpochState era) (ShelleyGovState era)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Proof era -> Lens' (NewEpochState era) (ShelleyGovState era)
forall era. Proof era -> NELens era (ShelleyGovState era)
ppupsL Proof era
p))

ppupsL :: Proof era -> NELens era (ShelleyGovState era)
ppupsL :: forall era. Proof era -> NELens era (ShelleyGovState era)
ppupsL Proof era
Shelley = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> EpochState era -> f (EpochState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> LedgerState era -> f (LedgerState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
lsUTxOStateL ((UTxOState era -> f (UTxOState era))
 -> LedgerState era -> f (LedgerState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> UTxOState era -> f (UTxOState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GovState era -> f (GovState era))
-> UTxOState era -> f (UTxOState era)
(ShelleyGovState era -> f (ShelleyGovState era))
-> UTxOState era -> f (UTxOState era)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> UTxOState era -> f (UTxOState era)
utxosGovStateL
ppupsL Proof era
Allegra = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> EpochState era -> f (EpochState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> LedgerState era -> f (LedgerState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
lsUTxOStateL ((UTxOState era -> f (UTxOState era))
 -> LedgerState era -> f (LedgerState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> UTxOState era -> f (UTxOState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GovState era -> f (GovState era))
-> UTxOState era -> f (UTxOState era)
(ShelleyGovState era -> f (ShelleyGovState era))
-> UTxOState era -> f (UTxOState era)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> UTxOState era -> f (UTxOState era)
utxosGovStateL
ppupsL Proof era
Mary = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> EpochState era -> f (EpochState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> LedgerState era -> f (LedgerState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
lsUTxOStateL ((UTxOState era -> f (UTxOState era))
 -> LedgerState era -> f (LedgerState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> UTxOState era -> f (UTxOState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GovState era -> f (GovState era))
-> UTxOState era -> f (UTxOState era)
(ShelleyGovState era -> f (ShelleyGovState era))
-> UTxOState era -> f (UTxOState era)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> UTxOState era -> f (UTxOState era)
utxosGovStateL
ppupsL Proof era
Alonzo = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> EpochState era -> f (EpochState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> LedgerState era -> f (LedgerState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
lsUTxOStateL ((UTxOState era -> f (UTxOState era))
 -> LedgerState era -> f (LedgerState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> UTxOState era -> f (UTxOState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GovState era -> f (GovState era))
-> UTxOState era -> f (UTxOState era)
(ShelleyGovState era -> f (ShelleyGovState era))
-> UTxOState era -> f (UTxOState era)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> UTxOState era -> f (UTxOState era)
utxosGovStateL
ppupsL Proof era
Babbage = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> EpochState era -> f (EpochState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> f (LedgerState era))
 -> EpochState era -> f (EpochState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> LedgerState era -> f (LedgerState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
lsUTxOStateL ((UTxOState era -> f (UTxOState era))
 -> LedgerState era -> f (LedgerState era))
-> ((ShelleyGovState era -> f (ShelleyGovState era))
    -> UTxOState era -> f (UTxOState era))
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GovState era -> f (GovState era))
-> UTxOState era -> f (UTxOState era)
(ShelleyGovState era -> f (ShelleyGovState era))
-> UTxOState era -> f (UTxOState era)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> UTxOState era -> f (UTxOState era)
utxosGovStateL
ppupsL Proof era
Conway = String
-> (ShelleyGovState era -> f (ShelleyGovState era))
-> NewEpochState era
-> f (NewEpochState era)
forall a. HasCallStack => String -> a
error String
"Conway era does not have a PPUPState, in ppupsL"

pparamProposals ::
  Era era => Proof era -> Term era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
pparamProposals :: forall era.
Era era =>
Proof era -> Term era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
pparamProposals Proof era
p = V era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
-> Term era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall era t. V era t -> Term era t
Var (Proof era
-> String
-> Rep era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
-> Access era Any (Map (KeyHash 'Genesis) (PParamsUpdateF era))
-> V era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV Proof era
p String
"pparamProposals" (Rep era (KeyHash 'Genesis)
-> Rep era (PParamsUpdateF era)
-> Rep era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'Genesis)
forall era. Era era => Rep era (KeyHash 'Genesis)
GenHashR (Proof era -> Rep era (PParamsUpdateF era)
forall era. Era era => Proof era -> Rep era (PParamsUpdateF era)
PParamsUpdateR Proof era
p)) Access era Any (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall era s t. Access era s t
No)

futurePParamProposals ::
  Era era => Proof era -> Term era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
futurePParamProposals :: forall era.
Era era =>
Proof era -> Term era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
futurePParamProposals Proof era
p = V era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
-> Term era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall era t. V era t -> Term era t
Var (Proof era
-> String
-> Rep era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
-> Access era Any (Map (KeyHash 'Genesis) (PParamsUpdateF era))
-> V era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV Proof era
p String
"futurePParamProposals" (Rep era (KeyHash 'Genesis)
-> Rep era (PParamsUpdateF era)
-> Rep era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'Genesis)
forall era. Era era => Rep era (KeyHash 'Genesis)
GenHashR (Proof era -> Rep era (PParamsUpdateF era)
forall era. Era era => Proof era -> Rep era (PParamsUpdateF era)
PParamsUpdateR Proof era
p)) Access era Any (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall era s t. Access era s t
No)

currPParams :: Era era => Proof era -> Term era (PParamsF era)
currPParams :: forall era. Era era => Proof era -> Term era (PParamsF era)
currPParams Proof era
p = V era (PParamsF era) -> Term era (PParamsF era)
forall era t. V era t -> Term era t
Var (Proof era
-> String
-> Rep era (PParamsF era)
-> Access era Any (PParamsF era)
-> V era (PParamsF era)
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV Proof era
p String
"currPParams" (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
p) Access era Any (PParamsF era)
forall era s t. Access era s t
No)

futurePParams :: Era era => Proof era -> Term era (FuturePParams era)
futurePParams :: forall era. Era era => Proof era -> Term era (FuturePParams era)
futurePParams Proof era
p = V era (FuturePParams era) -> Term era (FuturePParams era)
forall era t. V era t -> Term era t
Var (Proof era
-> String
-> Rep era (FuturePParams era)
-> Access era Any (FuturePParams era)
-> V era (FuturePParams era)
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV Proof era
p String
"futurePParams" (Proof era -> Rep era (FuturePParams era)
forall era. Era era => Proof era -> Rep era (FuturePParams era)
FuturePParamsR Proof era
p) Access era Any (FuturePParams era)
forall era s t. Access era s t
No)

prevPParams :: Gov.EraGov era => Proof era -> Term era (PParamsF era)
prevPParams :: forall era. EraGov era => Proof era -> Term era (PParamsF era)
prevPParams Proof era
p =
  V era (PParamsF era) -> Term era (PParamsF era)
forall era t. V era t -> Term era t
Var (String
-> Rep era (PParamsF era)
-> Access era (NewEpochState era) (PParamsF era)
-> V era (PParamsF era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"prevPParams" (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
p) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (PParamsF era)
-> Access era (NewEpochState era) (PParamsF era)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR ((EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((PParamsF era -> f (PParamsF era))
    -> EpochState era -> f (EpochState era))
-> (PParamsF era -> f (PParamsF era))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PParams era -> f (PParams era))
-> EpochState era -> f (EpochState era)
forall era. EraGov era => Lens' (EpochState era) (PParams era)
Lens' (EpochState era) (PParams era)
prevPParamsEpochStateL ((PParams era -> f (PParams era))
 -> EpochState era -> f (EpochState era))
-> ((PParamsF era -> f (PParamsF era))
    -> PParams era -> f (PParams era))
-> (PParamsF era -> f (PParamsF era))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proof era -> Lens' (PParams era) (PParamsF era)
forall era. Proof era -> Lens' (PParams era) (PParamsF era)
ppFL Proof era
p)))

proposalsL :: Lens' (ShelleyGovState era) (ProposedPPUpdates era)
proposalsL :: forall era (f :: * -> *).
Functor f =>
(ProposedPPUpdates era -> f (ProposedPPUpdates era))
-> ShelleyGovState era -> f (ShelleyGovState era)
proposalsL = (ShelleyGovState era -> ProposedPPUpdates era)
-> (ShelleyGovState era
    -> ProposedPPUpdates era -> ShelleyGovState era)
-> Lens
     (ShelleyGovState era)
     (ShelleyGovState era)
     (ProposedPPUpdates era)
     (ProposedPPUpdates era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ShelleyGovState era -> ProposedPPUpdates era
forall era. ShelleyGovState era -> ProposedPPUpdates era
sgsCurProposals (\ShelleyGovState era
sgov ProposedPPUpdates era
x -> ShelleyGovState era
sgov {sgsCurProposals = x})

futureProposalsL :: Lens' (ShelleyGovState era) (ProposedPPUpdates era)
futureProposalsL :: forall era (f :: * -> *).
Functor f =>
(ProposedPPUpdates era -> f (ProposedPPUpdates era))
-> ShelleyGovState era -> f (ShelleyGovState era)
futureProposalsL = (ShelleyGovState era -> ProposedPPUpdates era)
-> (ShelleyGovState era
    -> ProposedPPUpdates era -> ShelleyGovState era)
-> Lens
     (ShelleyGovState era)
     (ShelleyGovState era)
     (ProposedPPUpdates era)
     (ProposedPPUpdates era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ShelleyGovState era -> ProposedPPUpdates era
forall era. ShelleyGovState era -> ProposedPPUpdates era
sgsFutureProposals (\ShelleyGovState era
sgov ProposedPPUpdates era
x -> ShelleyGovState era
sgov {sgsFutureProposals = x})

ppupStateT ::
  forall era.
  ( Gov.GovState era ~ ShelleyGovState era
  , Gov.EraGov era
  ) =>
  Proof era ->
  RootTarget era (ShelleyGovState era) (ShelleyGovState era)
ppupStateT :: forall era.
(GovState era ~ ShelleyGovState era, EraGov era) =>
Proof era
-> RootTarget era (ShelleyGovState era) (ShelleyGovState era)
ppupStateT Proof era
p =
  String
-> TypeRep (ShelleyGovState era)
-> (Map (KeyHash 'Genesis) (PParamsUpdateF era)
    -> Map (KeyHash 'Genesis) (PParamsUpdateF era)
    -> PParamsF era
    -> PParamsF era
    -> FuturePParams era
    -> ShelleyGovState era)
-> RootTarget
     era
     (ShelleyGovState era)
     (Map (KeyHash 'Genesis) (PParamsUpdateF era)
      -> Map (KeyHash 'Genesis) (PParamsUpdateF era)
      -> PParamsF era
      -> PParamsF era
      -> FuturePParams era
      -> ShelleyGovState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"PPUPState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(ShelleyGovState era)) Map (KeyHash 'Genesis) (PParamsUpdateF era)
-> Map (KeyHash 'Genesis) (PParamsUpdateF era)
-> PParamsF era
-> PParamsF era
-> FuturePParams era
-> ShelleyGovState era
forall {era}.
Map (KeyHash 'Genesis) (PParamsUpdateF era)
-> Map (KeyHash 'Genesis) (PParamsUpdateF era)
-> PParamsF era
-> PParamsF era
-> FuturePParams era
-> ShelleyGovState era
ppupfun
    RootTarget
  era
  (ShelleyGovState era)
  (Map (KeyHash 'Genesis) (PParamsUpdateF era)
   -> Map (KeyHash 'Genesis) (PParamsUpdateF era)
   -> PParamsF era
   -> PParamsF era
   -> FuturePParams era
   -> ShelleyGovState era)
-> RootTarget
     era
     (ShelleyGovState era)
     (Map (KeyHash 'Genesis) (PParamsUpdateF era))
-> RootTarget
     era
     (ShelleyGovState era)
     (Map (KeyHash 'Genesis) (PParamsUpdateF era)
      -> PParamsF era
      -> PParamsF era
      -> FuturePParams era
      -> ShelleyGovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
-> SimpleGetter
     (ShelleyGovState era) (Map (KeyHash 'Genesis) (PParamsUpdateF era))
-> RootTarget
     era
     (ShelleyGovState era)
     (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Proof era -> Term era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall era.
Era era =>
Proof era -> Term era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
pparamProposals Proof era
p) ((ProposedPPUpdates era -> Const r (ProposedPPUpdates era))
-> ShelleyGovState era -> Const r (ShelleyGovState era)
forall era (f :: * -> *).
Functor f =>
(ProposedPPUpdates era -> f (ProposedPPUpdates era))
-> ShelleyGovState era -> f (ShelleyGovState era)
proposalsL ((ProposedPPUpdates era -> Const r (ProposedPPUpdates era))
 -> ShelleyGovState era -> Const r (ShelleyGovState era))
-> ((Map (KeyHash 'Genesis) (PParamsUpdateF era)
     -> Const r (Map (KeyHash 'Genesis) (PParamsUpdateF era)))
    -> ProposedPPUpdates era -> Const r (ProposedPPUpdates era))
-> (Map (KeyHash 'Genesis) (PParamsUpdateF era)
    -> Const r (Map (KeyHash 'Genesis) (PParamsUpdateF era)))
-> ShelleyGovState era
-> Const r (ShelleyGovState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proof era
-> Lens'
     (ProposedPPUpdates era)
     (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall era.
Proof era
-> Lens'
     (ProposedPPUpdates era)
     (Map (KeyHash 'Genesis) (PParamsUpdateF era))
proposedMapL Proof era
p)
    RootTarget
  era
  (ShelleyGovState era)
  (Map (KeyHash 'Genesis) (PParamsUpdateF era)
   -> PParamsF era
   -> PParamsF era
   -> FuturePParams era
   -> ShelleyGovState era)
-> RootTarget
     era
     (ShelleyGovState era)
     (Map (KeyHash 'Genesis) (PParamsUpdateF era))
-> RootTarget
     era
     (ShelleyGovState era)
     (PParamsF era
      -> PParamsF era -> FuturePParams era -> ShelleyGovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
-> SimpleGetter
     (ShelleyGovState era) (Map (KeyHash 'Genesis) (PParamsUpdateF era))
-> RootTarget
     era
     (ShelleyGovState era)
     (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Proof era -> Term era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall era.
Era era =>
Proof era -> Term era (Map (KeyHash 'Genesis) (PParamsUpdateF era))
futurePParamProposals Proof era
p) ((ProposedPPUpdates era -> Const r (ProposedPPUpdates era))
-> ShelleyGovState era -> Const r (ShelleyGovState era)
forall era (f :: * -> *).
Functor f =>
(ProposedPPUpdates era -> f (ProposedPPUpdates era))
-> ShelleyGovState era -> f (ShelleyGovState era)
futureProposalsL ((ProposedPPUpdates era -> Const r (ProposedPPUpdates era))
 -> ShelleyGovState era -> Const r (ShelleyGovState era))
-> ((Map (KeyHash 'Genesis) (PParamsUpdateF era)
     -> Const r (Map (KeyHash 'Genesis) (PParamsUpdateF era)))
    -> ProposedPPUpdates era -> Const r (ProposedPPUpdates era))
-> (Map (KeyHash 'Genesis) (PParamsUpdateF era)
    -> Const r (Map (KeyHash 'Genesis) (PParamsUpdateF era)))
-> ShelleyGovState era
-> Const r (ShelleyGovState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proof era
-> Lens'
     (ProposedPPUpdates era)
     (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall era.
Proof era
-> Lens'
     (ProposedPPUpdates era)
     (Map (KeyHash 'Genesis) (PParamsUpdateF era))
proposedMapL Proof era
p)
    RootTarget
  era
  (ShelleyGovState era)
  (PParamsF era
   -> PParamsF era -> FuturePParams era -> ShelleyGovState era)
-> RootTarget era (ShelleyGovState era) (PParamsF era)
-> RootTarget
     era
     (ShelleyGovState era)
     (PParamsF era -> FuturePParams era -> ShelleyGovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (PParamsF era)
-> SimpleGetter (ShelleyGovState era) (PParamsF era)
-> RootTarget era (ShelleyGovState era) (PParamsF era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Proof era -> Term era (PParamsF era)
forall era. Era era => Proof era -> Term era (PParamsF era)
currPParams Proof era
p) ((PParams era -> Const r (PParams era))
-> GovState era -> Const r (GovState era)
(PParams era -> Const r (PParams era))
-> ShelleyGovState era -> Const r (ShelleyGovState era)
forall era. EraGov era => Lens' (GovState era) (PParams era)
Lens' (GovState era) (PParams era)
Gov.curPParamsGovStateL ((PParams era -> Const r (PParams era))
 -> ShelleyGovState era -> Const r (ShelleyGovState era))
-> ((PParamsF era -> Const r (PParamsF era))
    -> PParams era -> Const r (PParams era))
-> (PParamsF era -> Const r (PParamsF era))
-> ShelleyGovState era
-> Const r (ShelleyGovState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proof era -> Lens' (PParams era) (PParamsF era)
forall era. Proof era -> Lens' (PParams era) (PParamsF era)
pparamsFL Proof era
p)
    RootTarget
  era
  (ShelleyGovState era)
  (PParamsF era -> FuturePParams era -> ShelleyGovState era)
-> RootTarget era (ShelleyGovState era) (PParamsF era)
-> RootTarget
     era
     (ShelleyGovState era)
     (FuturePParams era -> ShelleyGovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (PParamsF era)
-> SimpleGetter (ShelleyGovState era) (PParamsF era)
-> RootTarget era (ShelleyGovState era) (PParamsF era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Proof era -> Term era (PParamsF era)
forall era. EraGov era => Proof era -> Term era (PParamsF era)
prevPParams Proof era
p) ((PParams era -> Const r (PParams era))
-> GovState era -> Const r (GovState era)
(PParams era -> Const r (PParams era))
-> ShelleyGovState era -> Const r (ShelleyGovState era)
forall era. EraGov era => Lens' (GovState era) (PParams era)
Lens' (GovState era) (PParams era)
Gov.prevPParamsGovStateL ((PParams era -> Const r (PParams era))
 -> ShelleyGovState era -> Const r (ShelleyGovState era))
-> ((PParamsF era -> Const r (PParamsF era))
    -> PParams era -> Const r (PParams era))
-> (PParamsF era -> Const r (PParamsF era))
-> ShelleyGovState era
-> Const r (ShelleyGovState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proof era -> Lens' (PParams era) (PParamsF era)
forall era. Proof era -> Lens' (PParams era) (PParamsF era)
pparamsFL Proof era
p)
    RootTarget
  era
  (ShelleyGovState era)
  (FuturePParams era -> ShelleyGovState era)
-> RootTarget era (ShelleyGovState era) (FuturePParams era)
-> RootTarget era (ShelleyGovState era) (ShelleyGovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (FuturePParams era)
-> SimpleGetter (ShelleyGovState era) (FuturePParams era)
-> RootTarget era (ShelleyGovState era) (FuturePParams era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Proof era -> Term era (FuturePParams era)
forall era. Era era => Proof era -> Term era (FuturePParams era)
futurePParams Proof era
p) ((FuturePParams era -> Const r (FuturePParams era))
-> GovState era -> Const r (GovState era)
(FuturePParams era -> Const r (FuturePParams era))
-> ShelleyGovState era -> Const r (ShelleyGovState era)
forall era. EraGov era => Lens' (GovState era) (FuturePParams era)
Lens' (GovState era) (FuturePParams era)
Gov.futurePParamsGovStateL)
  where
    ppupfun :: Map (KeyHash 'Genesis) (PParamsUpdateF era)
-> Map (KeyHash 'Genesis) (PParamsUpdateF era)
-> PParamsF era
-> PParamsF era
-> FuturePParams era
-> ShelleyGovState era
ppupfun Map (KeyHash 'Genesis) (PParamsUpdateF era)
x Map (KeyHash 'Genesis) (PParamsUpdateF era)
y (PParamsF Proof era
_ PParams era
pp) (PParamsF Proof era
_ PParams era
prev) FuturePParams era
z =
      ProposedPPUpdates era
-> ProposedPPUpdates era
-> PParams era
-> PParams era
-> FuturePParams era
-> ShelleyGovState era
forall era.
ProposedPPUpdates era
-> ProposedPPUpdates era
-> PParams era
-> PParams era
-> FuturePParams era
-> ShelleyGovState era
ShelleyGovState
        (Map (KeyHash 'Genesis) (PParamsUpdate era) -> ProposedPPUpdates era
forall era.
Map (KeyHash 'Genesis) (PParamsUpdate era) -> ProposedPPUpdates era
ProposedPPUpdates ((PParamsUpdateF era -> PParamsUpdate era)
-> Map (KeyHash 'Genesis) (PParamsUpdateF era)
-> Map (KeyHash 'Genesis) (PParamsUpdate era)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map PParamsUpdateF era -> PParamsUpdate era
forall era. PParamsUpdateF era -> PParamsUpdate era
unPParamsUpdate Map (KeyHash 'Genesis) (PParamsUpdateF era)
x))
        (Map (KeyHash 'Genesis) (PParamsUpdate era) -> ProposedPPUpdates era
forall era.
Map (KeyHash 'Genesis) (PParamsUpdate era) -> ProposedPPUpdates era
ProposedPPUpdates ((PParamsUpdateF era -> PParamsUpdate era)
-> Map (KeyHash 'Genesis) (PParamsUpdateF era)
-> Map (KeyHash 'Genesis) (PParamsUpdate era)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map PParamsUpdateF era -> PParamsUpdate era
forall era. PParamsUpdateF era -> PParamsUpdate era
unPParamsUpdate Map (KeyHash 'Genesis) (PParamsUpdateF era)
y))
        PParams era
pp
        PParams era
prev
        FuturePParams era
z

govL :: Lens' (GovState era) (Gov.GovState era)
govL :: forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> GovState era -> f (GovState era)
govL = (GovState era -> GovState era)
-> (GovState era -> GovState era -> GovState era)
-> Lens (GovState era) (GovState era) (GovState era) (GovState era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens GovState era -> GovState era
forall era. GovState era -> GovState era
f GovState era -> GovState era -> GovState era
forall era. GovState era -> GovState era -> GovState era
g
  where
    f :: GovState era -> Gov.GovState era
    f :: forall era. GovState era -> GovState era
f (GovState Proof era
Shelley GovState era
x) = GovState era
x
    f (GovState Proof era
Allegra GovState era
x) = GovState era
x
    f (GovState Proof era
Mary GovState era
x) = GovState era
x
    f (GovState Proof era
Alonzo GovState era
x) = GovState era
x
    f (GovState Proof era
Babbage GovState era
x) = GovState era
x
    f (GovState Proof era
Conway GovState era
x) = GovState era
x
    g :: GovState era -> Gov.GovState era -> GovState era
    g :: forall era. GovState era -> GovState era -> GovState era
g (GovState p :: Proof era
p@Proof era
Shelley GovState era
_) GovState era
y = Proof era -> GovState era -> GovState era
forall era. Proof era -> GovState era -> GovState era
GovState Proof era
p GovState era
y
    g (GovState p :: Proof era
p@Proof era
Allegra GovState era
_) GovState era
y = Proof era -> GovState era -> GovState era
forall era. Proof era -> GovState era -> GovState era
GovState Proof era
p GovState era
y
    g (GovState p :: Proof era
p@Proof era
Mary GovState era
_) GovState era
y = Proof era -> GovState era -> GovState era
forall era. Proof era -> GovState era -> GovState era
GovState Proof era
p GovState era
y
    g (GovState p :: Proof era
p@Proof era
Alonzo GovState era
_) GovState era
y = Proof era -> GovState era -> GovState era
forall era. Proof era -> GovState era -> GovState era
GovState Proof era
p GovState era
y
    g (GovState p :: Proof era
p@Proof era
Babbage GovState era
_) GovState era
y = Proof era -> GovState era -> GovState era
forall era. Proof era -> GovState era -> GovState era
GovState Proof era
p GovState era
y
    g (GovState p :: Proof era
p@Proof era
Conway GovState era
_) GovState era
y = Proof era -> GovState era -> GovState era
forall era. Proof era -> GovState era -> GovState era
GovState Proof era
p GovState era
y

govStateT :: forall era. Era era => Proof era -> RootTarget era (GovState era) (GovState era)
govStateT :: forall era.
Era era =>
Proof era -> RootTarget era (GovState era) (GovState era)
govStateT p :: Proof era
p@Proof era
Shelley = String
-> TypeRep (GovState era)
-> (ShelleyGovState era -> GovState era)
-> RootTarget
     era (GovState era) (ShelleyGovState era -> GovState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"GovState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(GovState era)) (Proof era -> GovState era -> GovState era
forall era. Proof era -> GovState era -> GovState era
GovState Proof era
p) RootTarget era (GovState era) (ShelleyGovState era -> GovState era)
-> RootTarget era (GovState era) (ShelleyGovState era)
-> RootTarget era (GovState era) (GovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (ShelleyGovState era) (ShelleyGovState era)
-> Lens' (GovState era) (ShelleyGovState era)
-> RootTarget era (GovState era) (ShelleyGovState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift (Proof era
-> RootTarget era (ShelleyGovState era) (ShelleyGovState era)
forall era.
(GovState era ~ ShelleyGovState era, EraGov era) =>
Proof era
-> RootTarget era (ShelleyGovState era) (ShelleyGovState era)
ppupStateT Proof era
p) (GovState era -> f (GovState era))
-> GovState era -> f (GovState era)
(ShelleyGovState era -> f (ShelleyGovState era))
-> GovState era -> f (GovState era)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> GovState era -> f (GovState era)
Lens' (GovState era) (ShelleyGovState era)
govL
govStateT p :: Proof era
p@Proof era
Allegra = String
-> TypeRep (GovState era)
-> (ShelleyGovState era -> GovState era)
-> RootTarget
     era (GovState era) (ShelleyGovState era -> GovState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"GovState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(GovState era)) (Proof era -> GovState era -> GovState era
forall era. Proof era -> GovState era -> GovState era
GovState Proof era
p) RootTarget era (GovState era) (ShelleyGovState era -> GovState era)
-> RootTarget era (GovState era) (ShelleyGovState era)
-> RootTarget era (GovState era) (GovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (ShelleyGovState era) (ShelleyGovState era)
-> Lens' (GovState era) (ShelleyGovState era)
-> RootTarget era (GovState era) (ShelleyGovState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift (Proof era
-> RootTarget era (ShelleyGovState era) (ShelleyGovState era)
forall era.
(GovState era ~ ShelleyGovState era, EraGov era) =>
Proof era
-> RootTarget era (ShelleyGovState era) (ShelleyGovState era)
ppupStateT Proof era
p) (GovState era -> f (GovState era))
-> GovState era -> f (GovState era)
(ShelleyGovState era -> f (ShelleyGovState era))
-> GovState era -> f (GovState era)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> GovState era -> f (GovState era)
Lens' (GovState era) (ShelleyGovState era)
govL
govStateT p :: Proof era
p@Proof era
Mary = String
-> TypeRep (GovState era)
-> (ShelleyGovState era -> GovState era)
-> RootTarget
     era (GovState era) (ShelleyGovState era -> GovState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"GovState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(GovState era)) (Proof era -> GovState era -> GovState era
forall era. Proof era -> GovState era -> GovState era
GovState Proof era
p) RootTarget era (GovState era) (ShelleyGovState era -> GovState era)
-> RootTarget era (GovState era) (ShelleyGovState era)
-> RootTarget era (GovState era) (GovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (ShelleyGovState era) (ShelleyGovState era)
-> Lens' (GovState era) (ShelleyGovState era)
-> RootTarget era (GovState era) (ShelleyGovState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift (Proof era
-> RootTarget era (ShelleyGovState era) (ShelleyGovState era)
forall era.
(GovState era ~ ShelleyGovState era, EraGov era) =>
Proof era
-> RootTarget era (ShelleyGovState era) (ShelleyGovState era)
ppupStateT Proof era
p) (GovState era -> f (GovState era))
-> GovState era -> f (GovState era)
(ShelleyGovState era -> f (ShelleyGovState era))
-> GovState era -> f (GovState era)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> GovState era -> f (GovState era)
Lens' (GovState era) (ShelleyGovState era)
govL
govStateT p :: Proof era
p@Proof era
Alonzo = String
-> TypeRep (GovState era)
-> (ShelleyGovState era -> GovState era)
-> RootTarget
     era (GovState era) (ShelleyGovState era -> GovState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"GovState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(GovState era)) (Proof era -> GovState era -> GovState era
forall era. Proof era -> GovState era -> GovState era
GovState Proof era
p) RootTarget era (GovState era) (ShelleyGovState era -> GovState era)
-> RootTarget era (GovState era) (ShelleyGovState era)
-> RootTarget era (GovState era) (GovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (ShelleyGovState era) (ShelleyGovState era)
-> Lens' (GovState era) (ShelleyGovState era)
-> RootTarget era (GovState era) (ShelleyGovState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift (Proof era
-> RootTarget era (ShelleyGovState era) (ShelleyGovState era)
forall era.
(GovState era ~ ShelleyGovState era, EraGov era) =>
Proof era
-> RootTarget era (ShelleyGovState era) (ShelleyGovState era)
ppupStateT Proof era
p) (GovState era -> f (GovState era))
-> GovState era -> f (GovState era)
(ShelleyGovState era -> f (ShelleyGovState era))
-> GovState era -> f (GovState era)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> GovState era -> f (GovState era)
Lens' (GovState era) (ShelleyGovState era)
govL
govStateT p :: Proof era
p@Proof era
Babbage = String
-> TypeRep (GovState era)
-> (ShelleyGovState era -> GovState era)
-> RootTarget
     era (GovState era) (ShelleyGovState era -> GovState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"GovState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(GovState era)) (Proof era -> GovState era -> GovState era
forall era. Proof era -> GovState era -> GovState era
GovState Proof era
p) RootTarget era (GovState era) (ShelleyGovState era -> GovState era)
-> RootTarget era (GovState era) (ShelleyGovState era)
-> RootTarget era (GovState era) (GovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (ShelleyGovState era) (ShelleyGovState era)
-> Lens' (GovState era) (ShelleyGovState era)
-> RootTarget era (GovState era) (ShelleyGovState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift (Proof era
-> RootTarget era (ShelleyGovState era) (ShelleyGovState era)
forall era.
(GovState era ~ ShelleyGovState era, EraGov era) =>
Proof era
-> RootTarget era (ShelleyGovState era) (ShelleyGovState era)
ppupStateT Proof era
p) (GovState era -> f (GovState era))
-> GovState era -> f (GovState era)
(ShelleyGovState era -> f (ShelleyGovState era))
-> GovState era -> f (GovState era)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> GovState era -> f (GovState era)
Lens' (GovState era) (ShelleyGovState era)
govL
govStateT p :: Proof era
p@Proof era
Conway =
  String
-> TypeRep (GovState era)
-> (ConwayGovState ConwayEra -> GovState era)
-> RootTarget
     era (GovState era) (ConwayGovState ConwayEra -> GovState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"GovState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(GovState era)) (Proof era -> GovState era -> GovState era
forall era. Proof era -> GovState era -> GovState era
GovState Proof era
p) RootTarget
  era (GovState era) (ConwayGovState ConwayEra -> GovState era)
-> RootTarget era (GovState era) (ConwayGovState ConwayEra)
-> RootTarget era (GovState era) (GovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget
  era (ConwayGovState ConwayEra) (ConwayGovState ConwayEra)
-> Lens' (GovState era) (ConwayGovState ConwayEra)
-> RootTarget era (GovState era) (ConwayGovState ConwayEra)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift ((Reflect era =>
 Proof era
 -> RootTarget
      era (ConwayGovState ConwayEra) (ConwayGovState ConwayEra))
-> Proof era
-> RootTarget
     era (ConwayGovState ConwayEra) (ConwayGovState ConwayEra)
forall era a. (Reflect era => Proof era -> a) -> Proof era -> a
unReflect Reflect era =>
Proof era
-> RootTarget
     era (ConwayGovState ConwayEra) (ConwayGovState ConwayEra)
Proof era
-> RootTarget era (ConwayGovState era) (ConwayGovState era)
Proof era
-> RootTarget
     era (ConwayGovState ConwayEra) (ConwayGovState ConwayEra)
forall era.
(RunConwayRatify era, Reflect era, ConwayEraCertState era) =>
Proof era
-> RootTarget era (ConwayGovState era) (ConwayGovState era)
conwayGovStateT Proof era
p) (GovState era -> f (GovState era))
-> GovState era -> f (GovState era)
(ConwayGovState ConwayEra -> f (ConwayGovState ConwayEra))
-> GovState era -> f (GovState era)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> GovState era -> f (GovState era)
Lens' (GovState era) (ConwayGovState ConwayEra)
govL

individualPoolStakeL :: Lens' IndividualPoolStake Rational
individualPoolStakeL :: Lens' IndividualPoolStake Rational
individualPoolStakeL = (IndividualPoolStake -> Rational)
-> (IndividualPoolStake -> Rational -> IndividualPoolStake)
-> Lens' IndividualPoolStake Rational
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens IndividualPoolStake -> Rational
individualPoolStake (\IndividualPoolStake
ds Rational
u -> IndividualPoolStake
ds {individualPoolStake = u})

-- Incremental Stake

isPtrMapT :: (Era era, InstantStake era ~ ShelleyInstantStake era) => Term era (Map Ptr Coin)
isPtrMapT :: forall era.
(Era era, InstantStake era ~ ShelleyInstantStake era) =>
Term era (Map Ptr Coin)
isPtrMapT = V era (Map Ptr Coin) -> Term era (Map Ptr Coin)
forall era t. V era t -> Term era t
Var (V era (Map Ptr Coin) -> Term era (Map Ptr Coin))
-> V era (Map Ptr Coin) -> Term era (Map Ptr Coin)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map Ptr Coin)
-> Access era (NewEpochState era) (Map Ptr Coin)
-> V era (Map Ptr Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"ptrMap" (Rep era Ptr -> Rep era Coin -> Rep era (Map Ptr Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era Ptr
forall era. Rep era Ptr
PtrR Rep era Coin
forall era. Rep era Coin
CoinR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map Ptr Coin)
-> Access era (NewEpochState era) (Map Ptr Coin)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map Ptr Coin -> f (Map Ptr Coin))
-> NewEpochState era -> f (NewEpochState era)
forall era.
(InstantStake era ~ ShelleyInstantStake era) =>
Lens' (NewEpochState era) (Map Ptr Coin)
Lens' (NewEpochState era) (Map Ptr Coin)
ptrMapL)

ptrMapL :: InstantStake era ~ ShelleyInstantStake era => Lens' (NewEpochState era) (Map Ptr Coin)
ptrMapL :: forall era.
(InstantStake era ~ ShelleyInstantStake era) =>
Lens' (NewEpochState era) (Map Ptr Coin)
ptrMapL = (InstantStake era -> f (InstantStake era))
-> NewEpochState era -> f (NewEpochState era)
(ShelleyInstantStake era -> f (ShelleyInstantStake era))
-> NewEpochState era -> f (NewEpochState era)
forall era. Lens' (NewEpochState era) (InstantStake era)
forall (t :: * -> *) era.
CanSetInstantStake t =>
Lens' (t era) (InstantStake era)
instantStakeL ((ShelleyInstantStake era -> f (ShelleyInstantStake era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map Ptr Coin -> f (Map Ptr Coin))
    -> ShelleyInstantStake era -> f (ShelleyInstantStake era))
-> (Map Ptr Coin -> f (Map Ptr Coin))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map Ptr Coin -> f (Map Ptr Coin))
-> ShelleyInstantStake era -> f (ShelleyInstantStake era)
forall era (f :: * -> *).
Functor f =>
(Map Ptr Coin -> f (Map Ptr Coin))
-> ShelleyInstantStake era -> f (ShelleyInstantStake era)
isPtrMapL

isCredMapT :: EraStake era => Term era (Map (Credential 'Staking) Coin)
isCredMapT :: forall era.
EraStake era =>
Term era (Map (Credential 'Staking) Coin)
isCredMapT = V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'Staking) Coin)
 -> Term era (Map (Credential 'Staking) Coin))
-> V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
-> V era (Map (Credential 'Staking) Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"credMap" (Rep era (Credential 'Staking)
-> Rep era Coin -> Rep era (Map (Credential 'Staking) Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era Coin
forall era. Rep era Coin
CoinR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era -> f (NewEpochState era)
forall era.
EraStake era =>
Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
credMapL)

credMapL :: EraStake era => Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
credMapL :: forall era.
EraStake era =>
Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
credMapL = (InstantStake era -> f (InstantStake era))
-> NewEpochState era -> f (NewEpochState era)
forall era. Lens' (NewEpochState era) (InstantStake era)
forall (t :: * -> *) era.
CanSetInstantStake t =>
Lens' (t era) (InstantStake era)
instantStakeL ((InstantStake era -> f (InstantStake era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> InstantStake era -> f (InstantStake era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> InstantStake era -> f (InstantStake era)
forall era.
EraStake era =>
Lens' (InstantStake era) (Map (Credential 'Staking) Coin)
Lens' (InstantStake era) (Map (Credential 'Staking) Coin)
isCredMapL

-- | This variable is computed from the UTxO and the PParams,
--   It represents the instant stake that is computed by 'smartUTxO'
--   in the UTxOState Target UTxOStateT
--   The domain of this map is the complete set of credentials used to delegate Coin
--   in the TxOuts in the UTxO.
instantStakeTerm :: Era era => Term era (Map (Credential 'Staking) Coin)
instantStakeTerm :: forall era. Era era => Term era (Map (Credential 'Staking) Coin)
instantStakeTerm = V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'Staking) Coin)
 -> Term era (Map (Credential 'Staking) Coin))
-> V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (Credential 'Staking) Coin)
-> Access era Any (Map (Credential 'Staking) Coin)
-> V era (Map (Credential 'Staking) Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"instantStake" (Rep era (Credential 'Staking)
-> Rep era Coin -> Rep era (Map (Credential 'Staking) Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era Coin
forall era. Rep era Coin
CoinR) Access era Any (Map (Credential 'Staking) Coin)
forall era s t. Access era s t
No

instantStakeTarget ::
  Reflect era => Proof era -> Target era (Map (Credential 'Staking) Coin)
instantStakeTarget :: forall era.
Reflect era =>
Proof era -> Target era (Map (Credential 'Staking) Coin)
instantStakeTarget Proof era
proof = String
-> (Map TxIn (TxOutF era) -> Map (Credential 'Staking) Coin)
-> RootTarget
     era Void (Map TxIn (TxOutF era) -> Map (Credential 'Staking) Coin)
forall a b era. String -> (a -> b) -> RootTarget era Void (a -> b)
Constr String
"computeInstantStake" Map TxIn (TxOutF era) -> Map (Credential 'Staking) Coin
forall {era}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 EraStake era) =>
Map TxIn (TxOutF era) -> Map (Credential 'Staking) Coin
get RootTarget
  era Void (Map TxIn (TxOutF era) -> Map (Credential 'Staking) Coin)
-> Term era (Map TxIn (TxOutF era))
-> Target era (Map (Credential 'Staking) Coin)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Proof era -> Term era (Map TxIn (TxOutF era))
forall era.
Era era =>
Proof era -> Term era (Map TxIn (TxOutF era))
utxo Proof era
proof
  where
    get :: Map TxIn (TxOutF era) -> Map (Credential 'Staking) Coin
get Map TxIn (TxOutF era)
utxom =
      let instantStakeMap :: Map (Credential 'Staking) (CompactForm Coin)
instantStakeMap = UTxO era -> InstantStake era -> InstantStake era
forall era.
EraStake era =>
UTxO era -> InstantStake era -> InstantStake era
addInstantStake (Map TxIn (TxOutF era) -> UTxO era
forall era. Map TxIn (TxOutF era) -> UTxO era
liftUTxO Map TxIn (TxOutF era)
utxom) InstantStake era
forall a. Monoid a => a
mempty InstantStake era
-> Getting
     (Map (Credential 'Staking) (CompactForm Coin))
     (InstantStake era)
     (Map (Credential 'Staking) (CompactForm Coin))
-> Map (Credential 'Staking) (CompactForm Coin)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map (Credential 'Staking) (CompactForm Coin))
  (InstantStake era)
  (Map (Credential 'Staking) (CompactForm Coin))
forall era.
EraStake era =>
Lens'
  (InstantStake era) (Map (Credential 'Staking) (CompactForm Coin))
Lens'
  (InstantStake era) (Map (Credential 'Staking) (CompactForm Coin))
instantStakeCredentialsL
       in (CompactForm Coin -> Coin)
-> Map (Credential 'Staking) (CompactForm Coin)
-> Map (Credential 'Staking) Coin
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map CompactForm Coin -> Coin
forall a. Compactible a => CompactForm a -> a
fromCompact Map (Credential 'Staking) (CompactForm Coin)
instantStakeMap

-- ==========================
-- ChainAccountState

treasury :: Era era => Term era Coin
treasury :: forall era. Era era => Term era Coin
treasury = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String
-> Rep era Coin
-> Access era (NewEpochState era) Coin
-> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"treasury" Rep era Coin
forall era. Rep era Coin
CoinR (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) Coin
-> Access era (NewEpochState era) Coin
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Coin -> f Coin) -> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) Coin
forall (t :: * -> *) era.
CanSetChainAccountState t =>
Lens' (t era) Coin
treasuryL)

reserves :: Era era => Term era Coin
reserves :: forall era. Era era => Term era Coin
reserves = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String
-> Rep era Coin
-> Access era (NewEpochState era) Coin
-> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"reserves" Rep era Coin
forall era. Rep era Coin
CoinR (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) Coin
-> Access era (NewEpochState era) Coin
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Coin -> f Coin) -> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) Coin
forall (t :: * -> *) era.
CanSetChainAccountState t =>
Lens' (t era) Coin
reservesL)

-- | The Coin availabe for a MIR transfer to/from the Treasury
--   Computed from 'treasury' + 'deltaTreasury' - sum('instanTreasury')
mirAvailTreasury :: Era era => Term era Coin
mirAvailTreasury :: forall era. Era era => Term era Coin
mirAvailTreasury = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"mirAvailTreasury" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No)

-- | The Coin availabe for a MIR transfer to/from the Reserves
--   Computed from 'reserves' + 'deltaReserves' - sum('instanReserves')
mirAvailReserves :: Era era => Term era Coin
mirAvailReserves :: forall era. Era era => Term era Coin
mirAvailReserves = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"mirAvailReserves" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No)

-- EpochState

snapshots :: Era era => Term era SnapShots
snapshots :: forall era. Era era => Term era SnapShots
snapshots = V era SnapShots -> Term era SnapShots
forall era t. V era t -> Term era t
Var (String
-> Rep era SnapShots
-> Access era (NewEpochState era) SnapShots
-> V era SnapShots
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"snapshots" Rep era SnapShots
forall era. Era era => Rep era SnapShots
SnapShotsR (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) SnapShots
-> Access era (NewEpochState era) SnapShots
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (SnapShots -> f SnapShots)
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(SnapShots -> f SnapShots)
-> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) SnapShots
snapshotsL))

snapshotsL :: NELens era SnapShots
snapshotsL :: forall era (f :: * -> *).
Functor f =>
(SnapShots -> f SnapShots)
-> NewEpochState era -> f (NewEpochState era)
snapshotsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((SnapShots -> f SnapShots)
    -> EpochState era -> f (EpochState era))
-> (SnapShots -> f SnapShots)
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
esSnapshotsL

-- TODO: remove this duplication of `pparamsFL`

-- | Lens' from the Core PParams to the Model PParamsF which embeds a (Proof era)
ppFL :: Proof era -> Lens' (PParams era) (PParamsF era)
ppFL :: forall era. Proof era -> Lens' (PParams era) (PParamsF era)
ppFL Proof era
p = (PParams era -> PParamsF era)
-> (PParams era -> PParamsF era -> PParams era)
-> Lens (PParams era) (PParams era) (PParamsF era) (PParamsF era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (\PParams era
pp -> Proof era -> PParams era -> PParamsF era
forall era. Proof era -> PParams era -> PParamsF era
PParamsF Proof era
p PParams era
pp) (\PParams era
_ (PParamsF Proof era
_ PParams era
qq) -> PParams era
qq)

pparamsVar :: Gov.EraGov era => Proof era -> V era (PParamsF era)
pparamsVar :: forall era. EraGov era => Proof era -> V era (PParamsF era)
pparamsVar Proof era
p = (String
-> Rep era (PParamsF era)
-> Access era (NewEpochState era) (PParamsF era)
-> V era (PParamsF era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"pparams" (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
p) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (PParamsF era)
-> Access era (NewEpochState era) (PParamsF era)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR ((EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((PParamsF era -> f (PParamsF era))
    -> EpochState era -> f (EpochState era))
-> (PParamsF era -> f (PParamsF era))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PParams era -> f (PParams era))
-> EpochState era -> f (EpochState era)
forall era. EraGov era => Lens' (EpochState era) (PParams era)
Lens' (EpochState era) (PParams era)
curPParamsEpochStateL ((PParams era -> f (PParams era))
 -> EpochState era -> f (EpochState era))
-> ((PParamsF era -> f (PParamsF era))
    -> PParams era -> f (PParams era))
-> (PParamsF era -> f (PParamsF era))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proof era -> Lens' (PParams era) (PParamsF era)
forall era. Proof era -> Lens' (PParams era) (PParamsF era)
ppFL Proof era
p)))

pparams :: Gov.EraGov era => Proof era -> Term era (PParamsF era)
pparams :: forall era. EraGov era => Proof era -> Term era (PParamsF era)
pparams Proof era
p = V era (PParamsF era) -> Term era (PParamsF era)
forall era t. V era t -> Term era t
Var (V era (PParamsF era) -> Term era (PParamsF era))
-> V era (PParamsF era) -> Term era (PParamsF era)
forall a b. (a -> b) -> a -> b
$ Proof era -> V era (PParamsF era)
forall era. EraGov era => Proof era -> V era (PParamsF era)
pparamsVar Proof era
p

nmLikelihoodsT :: Era era => Term era (Map (KeyHash 'StakePool) [Float])
nmLikelihoodsT :: forall era. Era era => Term era (Map (KeyHash 'StakePool) [Float])
nmLikelihoodsT =
  V era (Map (KeyHash 'StakePool) [Float])
-> Term era (Map (KeyHash 'StakePool) [Float])
forall era t. V era t -> Term era t
Var
    ( String
-> Rep era (Map (KeyHash 'StakePool) [Float])
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) [Float])
-> V era (Map (KeyHash 'StakePool) [Float])
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V
        String
"likelihoodsNM"
        (Rep era (KeyHash 'StakePool)
-> Rep era [Float] -> Rep era (Map (KeyHash 'StakePool) [Float])
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR (Rep era Float -> Rep era [Float]
forall era a. Rep era a -> Rep era [a]
ListR Rep era Float
forall era. Rep era Float
FloatR))
        (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (KeyHash 'StakePool) [Float])
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) [Float])
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR ((EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (KeyHash 'StakePool) [Float]
     -> f (Map (KeyHash 'StakePool) [Float]))
    -> EpochState era -> f (EpochState era))
-> (Map (KeyHash 'StakePool) [Float]
    -> f (Map (KeyHash 'StakePool) [Float]))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (NonMyopic -> f NonMyopic) -> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(NonMyopic -> f NonMyopic) -> EpochState era -> f (EpochState era)
esNonMyopicL ((NonMyopic -> f NonMyopic)
 -> EpochState era -> f (EpochState era))
-> ((Map (KeyHash 'StakePool) [Float]
     -> f (Map (KeyHash 'StakePool) [Float]))
    -> NonMyopic -> f NonMyopic)
-> (Map (KeyHash 'StakePool) [Float]
    -> f (Map (KeyHash 'StakePool) [Float]))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) [Float]
 -> f (Map (KeyHash 'StakePool) [Float]))
-> NonMyopic -> f NonMyopic
Lens' NonMyopic (Map (KeyHash 'StakePool) [Float])
nmLikelihoodsL))
    )

nmRewardPotT :: Era era => Term era Coin
nmRewardPotT :: forall era. Era era => Term era Coin
nmRewardPotT = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String
-> Rep era Coin
-> Access era (NewEpochState era) Coin
-> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"rewardPotNM" Rep era Coin
forall era. Rep era Coin
CoinR (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) Coin
-> Access era (NewEpochState era) Coin
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR ((EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Coin -> f Coin) -> EpochState era -> f (EpochState era))
-> (Coin -> f Coin)
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (NonMyopic -> f NonMyopic) -> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(NonMyopic -> f NonMyopic) -> EpochState era -> f (EpochState era)
esNonMyopicL ((NonMyopic -> f NonMyopic)
 -> EpochState era -> f (EpochState era))
-> ((Coin -> f Coin) -> NonMyopic -> f NonMyopic)
-> (Coin -> f Coin)
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Coin -> f Coin) -> NonMyopic -> f NonMyopic
Lens' NonMyopic Coin
nmRewardPotL))

-- ===== SnapShots

-- | Helper lens that deals with the Stake newtype, and the shift from Map to VMap
stakeL :: Lens' Stake (Map (Credential 'Staking) Coin)
stakeL :: Lens' Stake (Map (Credential 'Staking) Coin)
stakeL =
  (Stake -> Map (Credential 'Staking) Coin)
-> (Stake -> Map (Credential 'Staking) Coin -> Stake)
-> Lens' Stake (Map (Credential 'Staking) Coin)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    ((CompactForm Coin -> Coin)
-> Map (Credential 'Staking) (CompactForm Coin)
-> Map (Credential 'Staking) Coin
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map CompactForm Coin -> Coin
forall a. Compactible a => CompactForm a -> a
fromCompact (Map (Credential 'Staking) (CompactForm Coin)
 -> Map (Credential 'Staking) Coin)
-> (Stake -> Map (Credential 'Staking) (CompactForm Coin))
-> Stake
-> Map (Credential 'Staking) Coin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VMap VB VP (Credential 'Staking) (CompactForm Coin)
-> Map (Credential 'Staking) (CompactForm Coin)
forall (kv :: * -> *) k (vv :: * -> *) v.
(Vector kv k, Vector vv v) =>
VMap kv vv k v -> Map k v
VMap.toMap (VMap VB VP (Credential 'Staking) (CompactForm Coin)
 -> Map (Credential 'Staking) (CompactForm Coin))
-> (Stake -> VMap VB VP (Credential 'Staking) (CompactForm Coin))
-> Stake
-> Map (Credential 'Staking) (CompactForm Coin)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stake -> VMap VB VP (Credential 'Staking) (CompactForm Coin)
unStake)
    (\Stake
_ Map (Credential 'Staking) Coin
u -> VMap VB VP (Credential 'Staking) (CompactForm Coin) -> Stake
Stake (VMap VB VP (Credential 'Staking) (CompactForm Coin) -> Stake)
-> (Map (Credential 'Staking) Coin
    -> VMap VB VP (Credential 'Staking) (CompactForm Coin))
-> Map (Credential 'Staking) Coin
-> Stake
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map (Credential 'Staking) (CompactForm Coin)
-> VMap VB VP (Credential 'Staking) (CompactForm Coin)
forall (kv :: * -> *) k (vv :: * -> *) v.
(Vector kv k, Vector vv v) =>
Map k v -> VMap kv vv k v
VMap.fromMap (Map (Credential 'Staking) (CompactForm Coin)
 -> VMap VB VP (Credential 'Staking) (CompactForm Coin))
-> (Map (Credential 'Staking) Coin
    -> Map (Credential 'Staking) (CompactForm Coin))
-> Map (Credential 'Staking) Coin
-> VMap VB VP (Credential 'Staking) (CompactForm Coin)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Coin -> CompactForm Coin)
-> Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) (CompactForm Coin)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map HasCallStack => Coin -> CompactForm Coin
Coin -> CompactForm Coin
compactCoinOrError (Map (Credential 'Staking) Coin -> Stake)
-> Map (Credential 'Staking) Coin -> Stake
forall a b. (a -> b) -> a -> b
$ Map (Credential 'Staking) Coin
u)

-- | Helper lens that deals with the shift from Map to VMap
vmapL :: Lens' (VMap.VMap VMap.VB VMap.VB k v) (Map k v)
vmapL :: forall k v (f :: * -> *).
Functor f =>
(Map k v -> f (Map k v)) -> VMap VB VB k v -> f (VMap VB VB k v)
vmapL = (VMap VB VB k v -> Map k v)
-> (VMap VB VB k v -> Map k v -> VMap VB VB k v)
-> Lens (VMap VB VB k v) (VMap VB VB k v) (Map k v) (Map k v)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens VMap VB VB k v -> Map k v
forall (kv :: * -> *) k (vv :: * -> *) v.
(Vector kv k, Vector vv v) =>
VMap kv vv k v -> Map k v
VMap.toMap (\VMap VB VB k v
_ Map k v
u -> Map k v -> VMap VB VB k v
forall (kv :: * -> *) k (vv :: * -> *) v.
(Vector kv k, Vector vv v) =>
Map k v -> VMap kv vv k v
VMap.fromMap Map k v
u)

markStakeL :: NELens era (Map (Credential 'Staking) Coin)
markStakeL :: forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era -> f (NewEpochState era)
markStakeL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> EpochState era -> f (EpochState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
esSnapshotsL ((SnapShots -> f SnapShots)
 -> EpochState era -> f (EpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> SnapShots -> f SnapShots)
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShot -> f SnapShot) -> SnapShots -> f SnapShots
Lens' SnapShots SnapShot
ssStakeMarkL ((SnapShot -> f SnapShot) -> SnapShots -> f SnapShots)
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> SnapShot -> f SnapShot)
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> SnapShots
-> f SnapShots
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Stake -> f Stake) -> SnapShot -> f SnapShot
Lens' SnapShot Stake
ssStakeL ((Stake -> f Stake) -> SnapShot -> f SnapShot)
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> Stake -> f Stake)
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> SnapShot
-> f SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> Stake -> f Stake
Lens' Stake (Map (Credential 'Staking) Coin)
stakeL

markStake :: Era era => Term era (Map (Credential 'Staking) Coin)
markStake :: forall era. Era era => Term era (Map (Credential 'Staking) Coin)
markStake = V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
-> V era (Map (Credential 'Staking) Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"markStake" (Rep era (Credential 'Staking)
-> Rep era Coin -> Rep era (Map (Credential 'Staking) Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era Coin
forall era. Rep era Coin
CoinR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
markStakeL))

markDelegs ::
  Era era => Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
markDelegs :: forall era.
Era era =>
Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
markDelegs = V era (Map (Credential 'Staking) (KeyHash 'StakePool))
-> Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (Credential 'Staking) (KeyHash 'StakePool))
-> Access
     era
     (NewEpochState era)
     (Map (Credential 'Staking) (KeyHash 'StakePool))
-> V era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"markDelegs" (Rep era (Credential 'Staking)
-> Rep era (KeyHash 'StakePool)
-> Rep era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR) (Rep era (NewEpochState era)
-> Lens'
     (NewEpochState era)
     (Map (Credential 'Staking) (KeyHash 'StakePool))
-> Access
     era
     (NewEpochState era)
     (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'Staking) (KeyHash 'StakePool)
 -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) (KeyHash 'StakePool)
 -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> NewEpochState era -> f (NewEpochState era)
Lens'
  (NewEpochState era)
  (Map (Credential 'Staking) (KeyHash 'StakePool))
markDelegsL))

markDelegsL ::
  NELens era (Map (Credential 'Staking) (KeyHash 'StakePool))
markDelegsL :: forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) (KeyHash 'StakePool)
 -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> NewEpochState era -> f (NewEpochState era)
markDelegsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> EpochState era -> f (EpochState era))
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
esSnapshotsL ((SnapShots -> f SnapShots)
 -> EpochState era -> f (EpochState era))
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> SnapShots -> f SnapShots)
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShot -> f SnapShot) -> SnapShots -> f SnapShots
Lens' SnapShots SnapShot
ssStakeMarkL ((SnapShot -> f SnapShot) -> SnapShots -> f SnapShots)
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> SnapShot -> f SnapShot)
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShots
-> f SnapShots
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
 -> f (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShot -> f SnapShot
Lens'
  SnapShot (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool))
ssDelegationsL ((VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
  -> f (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
 -> SnapShot -> f SnapShot)
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
    -> f (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShot
-> f SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) (KeyHash 'StakePool)
 -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
-> f (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool))
forall k v (f :: * -> *).
Functor f =>
(Map k v -> f (Map k v)) -> VMap VB VB k v -> f (VMap VB VB k v)
vmapL

markPools ::
  Era era => Term era (Map (KeyHash 'StakePool) PoolParams)
markPools :: forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) PoolParams)
markPools = V era (Map (KeyHash 'StakePool) PoolParams)
-> Term era (Map (KeyHash 'StakePool) PoolParams)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (KeyHash 'StakePool) PoolParams)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
-> V era (Map (KeyHash 'StakePool) PoolParams)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"markPools" (Rep era (KeyHash 'StakePool)
-> Rep era PoolParams
-> Rep era (Map (KeyHash 'StakePool) PoolParams)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era PoolParams
forall era. Era era => Rep era PoolParams
PoolParamsR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
markPoolsL))

markPoolsL :: NELens era (Map (KeyHash 'StakePool) PoolParams)
markPoolsL :: forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era -> f (NewEpochState era)
markPoolsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> EpochState era -> f (EpochState era))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
esSnapshotsL ((SnapShots -> f SnapShots)
 -> EpochState era -> f (EpochState era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> SnapShots -> f SnapShots)
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShot -> f SnapShot) -> SnapShots -> f SnapShots
Lens' SnapShots SnapShot
ssStakeMarkL ((SnapShot -> f SnapShot) -> SnapShots -> f SnapShots)
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> SnapShot -> f SnapShot)
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> SnapShots
-> f SnapShots
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VMap VB VB (KeyHash 'StakePool) PoolParams
 -> f (VMap VB VB (KeyHash 'StakePool) PoolParams))
-> SnapShot -> f SnapShot
Lens' SnapShot (VMap VB VB (KeyHash 'StakePool) PoolParams)
ssPoolParamsL ((VMap VB VB (KeyHash 'StakePool) PoolParams
  -> f (VMap VB VB (KeyHash 'StakePool) PoolParams))
 -> SnapShot -> f SnapShot)
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> VMap VB VB (KeyHash 'StakePool) PoolParams
    -> f (VMap VB VB (KeyHash 'StakePool) PoolParams))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> SnapShot
-> f SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> VMap VB VB (KeyHash 'StakePool) PoolParams
-> f (VMap VB VB (KeyHash 'StakePool) PoolParams)
forall k v (f :: * -> *).
Functor f =>
(Map k v -> f (Map k v)) -> VMap VB VB k v -> f (VMap VB VB k v)
vmapL

markSnapShotT ::
  forall era. Era era => RootTarget era SnapShot SnapShot
markSnapShotT :: forall era. Era era => RootTarget era SnapShot SnapShot
markSnapShotT =
  String
-> TypeRep SnapShot
-> (Map (Credential 'Staking) Coin
    -> Map (Credential 'Staking) (KeyHash 'StakePool)
    -> Map (KeyHash 'StakePool) PoolParams
    -> SnapShot)
-> RootTarget
     era
     SnapShot
     (Map (Credential 'Staking) Coin
      -> Map (Credential 'Staking) (KeyHash 'StakePool)
      -> Map (KeyHash 'StakePool) PoolParams
      -> SnapShot)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"SnapShot" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @SnapShot) Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (KeyHash 'StakePool) PoolParams
-> SnapShot
snapfun
    RootTarget
  era
  SnapShot
  (Map (Credential 'Staking) Coin
   -> Map (Credential 'Staking) (KeyHash 'StakePool)
   -> Map (KeyHash 'StakePool) PoolParams
   -> SnapShot)
-> RootTarget era SnapShot (Map (Credential 'Staking) Coin)
-> RootTarget
     era
     SnapShot
     (Map (Credential 'Staking) (KeyHash 'StakePool)
      -> Map (KeyHash 'StakePool) PoolParams -> SnapShot)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) Coin)
-> SimpleGetter SnapShot (Map (Credential 'Staking) Coin)
-> RootTarget era SnapShot (Map (Credential 'Staking) Coin)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'Staking) Coin)
forall era. Era era => Term era (Map (Credential 'Staking) Coin)
markStake ((Stake -> Const r Stake) -> SnapShot -> Const r SnapShot
Lens' SnapShot Stake
ssStakeL ((Stake -> Const r Stake) -> SnapShot -> Const r SnapShot)
-> ((Map (Credential 'Staking) Coin
     -> Const r (Map (Credential 'Staking) Coin))
    -> Stake -> Const r Stake)
-> (Map (Credential 'Staking) Coin
    -> Const r (Map (Credential 'Staking) Coin))
-> SnapShot
-> Const r SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) Coin
 -> Const r (Map (Credential 'Staking) Coin))
-> Stake -> Const r Stake
Lens' Stake (Map (Credential 'Staking) Coin)
stakeL)
    RootTarget
  era
  SnapShot
  (Map (Credential 'Staking) (KeyHash 'StakePool)
   -> Map (KeyHash 'StakePool) PoolParams -> SnapShot)
-> RootTarget
     era SnapShot (Map (Credential 'Staking) (KeyHash 'StakePool))
-> RootTarget
     era SnapShot (Map (KeyHash 'StakePool) PoolParams -> SnapShot)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
-> SimpleGetter
     SnapShot (Map (Credential 'Staking) (KeyHash 'StakePool))
-> RootTarget
     era SnapShot (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era.
Era era =>
Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
markDelegs ((VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
 -> Const r (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShot -> Const r SnapShot
Lens'
  SnapShot (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool))
ssDelegationsL ((VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
  -> Const r (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
 -> SnapShot -> Const r SnapShot)
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> Const r (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
    -> Const r (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> Const r (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShot
-> Const r SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) (KeyHash 'StakePool)
 -> Const r (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
-> Const r (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool))
forall k v (f :: * -> *).
Functor f =>
(Map k v -> f (Map k v)) -> VMap VB VB k v -> f (VMap VB VB k v)
vmapL)
    RootTarget
  era SnapShot (Map (KeyHash 'StakePool) PoolParams -> SnapShot)
-> RootTarget era SnapShot (Map (KeyHash 'StakePool) PoolParams)
-> RootTarget era SnapShot SnapShot
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) PoolParams)
-> SimpleGetter SnapShot (Map (KeyHash 'StakePool) PoolParams)
-> RootTarget era SnapShot (Map (KeyHash 'StakePool) PoolParams)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (KeyHash 'StakePool) PoolParams)
forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) PoolParams)
markPools ((VMap VB VB (KeyHash 'StakePool) PoolParams
 -> Const r (VMap VB VB (KeyHash 'StakePool) PoolParams))
-> SnapShot -> Const r SnapShot
Lens' SnapShot (VMap VB VB (KeyHash 'StakePool) PoolParams)
ssPoolParamsL ((VMap VB VB (KeyHash 'StakePool) PoolParams
  -> Const r (VMap VB VB (KeyHash 'StakePool) PoolParams))
 -> SnapShot -> Const r SnapShot)
-> ((Map (KeyHash 'StakePool) PoolParams
     -> Const r (Map (KeyHash 'StakePool) PoolParams))
    -> VMap VB VB (KeyHash 'StakePool) PoolParams
    -> Const r (VMap VB VB (KeyHash 'StakePool) PoolParams))
-> (Map (KeyHash 'StakePool) PoolParams
    -> Const r (Map (KeyHash 'StakePool) PoolParams))
-> SnapShot
-> Const r SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) PoolParams
 -> Const r (Map (KeyHash 'StakePool) PoolParams))
-> VMap VB VB (KeyHash 'StakePool) PoolParams
-> Const r (VMap VB VB (KeyHash 'StakePool) PoolParams)
forall k v (f :: * -> *).
Functor f =>
(Map k v -> f (Map k v)) -> VMap VB VB k v -> f (VMap VB VB k v)
vmapL)
  where
    snapfun :: Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (KeyHash 'StakePool) PoolParams
-> SnapShot
snapfun Map (Credential 'Staking) Coin
x Map (Credential 'Staking) (KeyHash 'StakePool)
y Map (KeyHash 'StakePool) PoolParams
z =
      Stake
-> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
-> VMap VB VB (KeyHash 'StakePool) PoolParams
-> SnapShot
SnapShot
        (VMap VB VP (Credential 'Staking) (CompactForm Coin) -> Stake
Stake (Map (Credential 'Staking) (CompactForm Coin)
-> VMap VB VP (Credential 'Staking) (CompactForm Coin)
forall (kv :: * -> *) k (vv :: * -> *) v.
(Vector kv k, Vector vv v) =>
Map k v -> VMap kv vv k v
VMap.fromMap ((Coin -> CompactForm Coin)
-> Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) (CompactForm Coin)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map HasCallStack => Coin -> CompactForm Coin
Coin -> CompactForm Coin
compactCoinOrError Map (Credential 'Staking) Coin
x)))
        (Map (Credential 'Staking) (KeyHash 'StakePool)
-> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
forall (kv :: * -> *) k (vv :: * -> *) v.
(Vector kv k, Vector vv v) =>
Map k v -> VMap kv vv k v
VMap.fromMap Map (Credential 'Staking) (KeyHash 'StakePool)
y)
        (Map (KeyHash 'StakePool) PoolParams
-> VMap VB VB (KeyHash 'StakePool) PoolParams
forall (kv :: * -> *) k (vv :: * -> *) v.
(Vector kv k, Vector vv v) =>
Map k v -> VMap kv vv k v
VMap.fromMap Map (KeyHash 'StakePool) PoolParams
z)

setStake :: Era era => Term era (Map (Credential 'Staking) Coin)
setStake :: forall era. Era era => Term era (Map (Credential 'Staking) Coin)
setStake = V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
-> V era (Map (Credential 'Staking) Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"setStake" (Rep era (Credential 'Staking)
-> Rep era Coin -> Rep era (Map (Credential 'Staking) Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era Coin
forall era. Rep era Coin
CoinR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
setStakeL))

setStakeL :: NELens era (Map (Credential 'Staking) Coin)
setStakeL :: forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era -> f (NewEpochState era)
setStakeL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> EpochState era -> f (EpochState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
esSnapshotsL ((SnapShots -> f SnapShots)
 -> EpochState era -> f (EpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> SnapShots -> f SnapShots)
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShot -> f SnapShot) -> SnapShots -> f SnapShots
Lens' SnapShots SnapShot
ssStakeSetL ((SnapShot -> f SnapShot) -> SnapShots -> f SnapShots)
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> SnapShot -> f SnapShot)
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> SnapShots
-> f SnapShots
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Stake -> f Stake) -> SnapShot -> f SnapShot
Lens' SnapShot Stake
ssStakeL ((Stake -> f Stake) -> SnapShot -> f SnapShot)
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> Stake -> f Stake)
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> SnapShot
-> f SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> Stake -> f Stake
Lens' Stake (Map (Credential 'Staking) Coin)
stakeL

setDelegs ::
  Era era => Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
setDelegs :: forall era.
Era era =>
Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
setDelegs = V era (Map (Credential 'Staking) (KeyHash 'StakePool))
-> Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (Credential 'Staking) (KeyHash 'StakePool))
-> Access
     era
     (NewEpochState era)
     (Map (Credential 'Staking) (KeyHash 'StakePool))
-> V era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"setDelegs" (Rep era (Credential 'Staking)
-> Rep era (KeyHash 'StakePool)
-> Rep era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR) (Rep era (NewEpochState era)
-> Lens'
     (NewEpochState era)
     (Map (Credential 'Staking) (KeyHash 'StakePool))
-> Access
     era
     (NewEpochState era)
     (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'Staking) (KeyHash 'StakePool)
 -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) (KeyHash 'StakePool)
 -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> NewEpochState era -> f (NewEpochState era)
Lens'
  (NewEpochState era)
  (Map (Credential 'Staking) (KeyHash 'StakePool))
setDelegsL))

setDelegsL ::
  NELens era (Map (Credential 'Staking) (KeyHash 'StakePool))
setDelegsL :: forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) (KeyHash 'StakePool)
 -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> NewEpochState era -> f (NewEpochState era)
setDelegsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> EpochState era -> f (EpochState era))
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
esSnapshotsL ((SnapShots -> f SnapShots)
 -> EpochState era -> f (EpochState era))
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> SnapShots -> f SnapShots)
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShot -> f SnapShot) -> SnapShots -> f SnapShots
Lens' SnapShots SnapShot
ssStakeSetL ((SnapShot -> f SnapShot) -> SnapShots -> f SnapShots)
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> SnapShot -> f SnapShot)
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShots
-> f SnapShots
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
 -> f (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShot -> f SnapShot
Lens'
  SnapShot (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool))
ssDelegationsL ((VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
  -> f (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
 -> SnapShot -> f SnapShot)
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
    -> f (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShot
-> f SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) (KeyHash 'StakePool)
 -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
-> f (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool))
forall k v (f :: * -> *).
Functor f =>
(Map k v -> f (Map k v)) -> VMap VB VB k v -> f (VMap VB VB k v)
vmapL

setPools ::
  Era era => Term era (Map (KeyHash 'StakePool) PoolParams)
setPools :: forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) PoolParams)
setPools = V era (Map (KeyHash 'StakePool) PoolParams)
-> Term era (Map (KeyHash 'StakePool) PoolParams)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (KeyHash 'StakePool) PoolParams)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
-> V era (Map (KeyHash 'StakePool) PoolParams)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"setPools" (Rep era (KeyHash 'StakePool)
-> Rep era PoolParams
-> Rep era (Map (KeyHash 'StakePool) PoolParams)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era PoolParams
forall era. Era era => Rep era PoolParams
PoolParamsR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
setPoolsL))

setPoolsL :: NELens era (Map (KeyHash 'StakePool) PoolParams)
setPoolsL :: forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era -> f (NewEpochState era)
setPoolsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> EpochState era -> f (EpochState era))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
esSnapshotsL ((SnapShots -> f SnapShots)
 -> EpochState era -> f (EpochState era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> SnapShots -> f SnapShots)
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShot -> f SnapShot) -> SnapShots -> f SnapShots
Lens' SnapShots SnapShot
ssStakeSetL ((SnapShot -> f SnapShot) -> SnapShots -> f SnapShots)
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> SnapShot -> f SnapShot)
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> SnapShots
-> f SnapShots
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VMap VB VB (KeyHash 'StakePool) PoolParams
 -> f (VMap VB VB (KeyHash 'StakePool) PoolParams))
-> SnapShot -> f SnapShot
Lens' SnapShot (VMap VB VB (KeyHash 'StakePool) PoolParams)
ssPoolParamsL ((VMap VB VB (KeyHash 'StakePool) PoolParams
  -> f (VMap VB VB (KeyHash 'StakePool) PoolParams))
 -> SnapShot -> f SnapShot)
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> VMap VB VB (KeyHash 'StakePool) PoolParams
    -> f (VMap VB VB (KeyHash 'StakePool) PoolParams))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> SnapShot
-> f SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> VMap VB VB (KeyHash 'StakePool) PoolParams
-> f (VMap VB VB (KeyHash 'StakePool) PoolParams)
forall k v (f :: * -> *).
Functor f =>
(Map k v -> f (Map k v)) -> VMap VB VB k v -> f (VMap VB VB k v)
vmapL

setSnapShotT ::
  forall era. Era era => RootTarget era SnapShot SnapShot
setSnapShotT :: forall era. Era era => RootTarget era SnapShot SnapShot
setSnapShotT =
  String
-> TypeRep SnapShot
-> (Map (Credential 'Staking) Coin
    -> Map (Credential 'Staking) (KeyHash 'StakePool)
    -> Map (KeyHash 'StakePool) PoolParams
    -> SnapShot)
-> RootTarget
     era
     SnapShot
     (Map (Credential 'Staking) Coin
      -> Map (Credential 'Staking) (KeyHash 'StakePool)
      -> Map (KeyHash 'StakePool) PoolParams
      -> SnapShot)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"SnapShot" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @SnapShot) Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (KeyHash 'StakePool) PoolParams
-> SnapShot
snapfun
    RootTarget
  era
  SnapShot
  (Map (Credential 'Staking) Coin
   -> Map (Credential 'Staking) (KeyHash 'StakePool)
   -> Map (KeyHash 'StakePool) PoolParams
   -> SnapShot)
-> RootTarget era SnapShot (Map (Credential 'Staking) Coin)
-> RootTarget
     era
     SnapShot
     (Map (Credential 'Staking) (KeyHash 'StakePool)
      -> Map (KeyHash 'StakePool) PoolParams -> SnapShot)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) Coin)
-> SimpleGetter SnapShot (Map (Credential 'Staking) Coin)
-> RootTarget era SnapShot (Map (Credential 'Staking) Coin)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'Staking) Coin)
forall era. Era era => Term era (Map (Credential 'Staking) Coin)
setStake ((Stake -> Const r Stake) -> SnapShot -> Const r SnapShot
Lens' SnapShot Stake
ssStakeL ((Stake -> Const r Stake) -> SnapShot -> Const r SnapShot)
-> ((Map (Credential 'Staking) Coin
     -> Const r (Map (Credential 'Staking) Coin))
    -> Stake -> Const r Stake)
-> (Map (Credential 'Staking) Coin
    -> Const r (Map (Credential 'Staking) Coin))
-> SnapShot
-> Const r SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) Coin
 -> Const r (Map (Credential 'Staking) Coin))
-> Stake -> Const r Stake
Lens' Stake (Map (Credential 'Staking) Coin)
stakeL)
    RootTarget
  era
  SnapShot
  (Map (Credential 'Staking) (KeyHash 'StakePool)
   -> Map (KeyHash 'StakePool) PoolParams -> SnapShot)
-> RootTarget
     era SnapShot (Map (Credential 'Staking) (KeyHash 'StakePool))
-> RootTarget
     era SnapShot (Map (KeyHash 'StakePool) PoolParams -> SnapShot)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
-> SimpleGetter
     SnapShot (Map (Credential 'Staking) (KeyHash 'StakePool))
-> RootTarget
     era SnapShot (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era.
Era era =>
Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
setDelegs ((VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
 -> Const r (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShot -> Const r SnapShot
Lens'
  SnapShot (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool))
ssDelegationsL ((VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
  -> Const r (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
 -> SnapShot -> Const r SnapShot)
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> Const r (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
    -> Const r (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> Const r (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShot
-> Const r SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) (KeyHash 'StakePool)
 -> Const r (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
-> Const r (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool))
forall k v (f :: * -> *).
Functor f =>
(Map k v -> f (Map k v)) -> VMap VB VB k v -> f (VMap VB VB k v)
vmapL)
    RootTarget
  era SnapShot (Map (KeyHash 'StakePool) PoolParams -> SnapShot)
-> RootTarget era SnapShot (Map (KeyHash 'StakePool) PoolParams)
-> RootTarget era SnapShot SnapShot
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) PoolParams)
-> SimpleGetter SnapShot (Map (KeyHash 'StakePool) PoolParams)
-> RootTarget era SnapShot (Map (KeyHash 'StakePool) PoolParams)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (KeyHash 'StakePool) PoolParams)
forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) PoolParams)
setPools ((VMap VB VB (KeyHash 'StakePool) PoolParams
 -> Const r (VMap VB VB (KeyHash 'StakePool) PoolParams))
-> SnapShot -> Const r SnapShot
Lens' SnapShot (VMap VB VB (KeyHash 'StakePool) PoolParams)
ssPoolParamsL ((VMap VB VB (KeyHash 'StakePool) PoolParams
  -> Const r (VMap VB VB (KeyHash 'StakePool) PoolParams))
 -> SnapShot -> Const r SnapShot)
-> ((Map (KeyHash 'StakePool) PoolParams
     -> Const r (Map (KeyHash 'StakePool) PoolParams))
    -> VMap VB VB (KeyHash 'StakePool) PoolParams
    -> Const r (VMap VB VB (KeyHash 'StakePool) PoolParams))
-> (Map (KeyHash 'StakePool) PoolParams
    -> Const r (Map (KeyHash 'StakePool) PoolParams))
-> SnapShot
-> Const r SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) PoolParams
 -> Const r (Map (KeyHash 'StakePool) PoolParams))
-> VMap VB VB (KeyHash 'StakePool) PoolParams
-> Const r (VMap VB VB (KeyHash 'StakePool) PoolParams)
forall k v (f :: * -> *).
Functor f =>
(Map k v -> f (Map k v)) -> VMap VB VB k v -> f (VMap VB VB k v)
vmapL)
  where
    snapfun :: Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (KeyHash 'StakePool) PoolParams
-> SnapShot
snapfun Map (Credential 'Staking) Coin
x Map (Credential 'Staking) (KeyHash 'StakePool)
y Map (KeyHash 'StakePool) PoolParams
z =
      Stake
-> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
-> VMap VB VB (KeyHash 'StakePool) PoolParams
-> SnapShot
SnapShot
        (VMap VB VP (Credential 'Staking) (CompactForm Coin) -> Stake
Stake (Map (Credential 'Staking) (CompactForm Coin)
-> VMap VB VP (Credential 'Staking) (CompactForm Coin)
forall (kv :: * -> *) k (vv :: * -> *) v.
(Vector kv k, Vector vv v) =>
Map k v -> VMap kv vv k v
VMap.fromMap ((Coin -> CompactForm Coin)
-> Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) (CompactForm Coin)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map HasCallStack => Coin -> CompactForm Coin
Coin -> CompactForm Coin
compactCoinOrError Map (Credential 'Staking) Coin
x)))
        (Map (Credential 'Staking) (KeyHash 'StakePool)
-> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
forall (kv :: * -> *) k (vv :: * -> *) v.
(Vector kv k, Vector vv v) =>
Map k v -> VMap kv vv k v
VMap.fromMap Map (Credential 'Staking) (KeyHash 'StakePool)
y)
        (Map (KeyHash 'StakePool) PoolParams
-> VMap VB VB (KeyHash 'StakePool) PoolParams
forall (kv :: * -> *) k (vv :: * -> *) v.
(Vector kv k, Vector vv v) =>
Map k v -> VMap kv vv k v
VMap.fromMap Map (KeyHash 'StakePool) PoolParams
z)

goStake :: Era era => Term era (Map (Credential 'Staking) Coin)
goStake :: forall era. Era era => Term era (Map (Credential 'Staking) Coin)
goStake = V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
-> V era (Map (Credential 'Staking) Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"goStake" (Rep era (Credential 'Staking)
-> Rep era Coin -> Rep era (Map (Credential 'Staking) Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era Coin
forall era. Rep era Coin
CoinR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
-> Access era (NewEpochState era) (Map (Credential 'Staking) Coin)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) (Map (Credential 'Staking) Coin)
goStakeL))

goStakeL :: NELens era (Map (Credential 'Staking) Coin)
goStakeL :: forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era -> f (NewEpochState era)
goStakeL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> EpochState era -> f (EpochState era))
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
esSnapshotsL ((SnapShots -> f SnapShots)
 -> EpochState era -> f (EpochState era))
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> SnapShots -> f SnapShots)
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShot -> f SnapShot) -> SnapShots -> f SnapShots
Lens' SnapShots SnapShot
ssStakeGoL ((SnapShot -> f SnapShot) -> SnapShots -> f SnapShots)
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> SnapShot -> f SnapShot)
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> SnapShots
-> f SnapShots
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Stake -> f Stake) -> SnapShot -> f SnapShot
Lens' SnapShot Stake
ssStakeL ((Stake -> f Stake) -> SnapShot -> f SnapShot)
-> ((Map (Credential 'Staking) Coin
     -> f (Map (Credential 'Staking) Coin))
    -> Stake -> f Stake)
-> (Map (Credential 'Staking) Coin
    -> f (Map (Credential 'Staking) Coin))
-> SnapShot
-> f SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> Stake -> f Stake
Lens' Stake (Map (Credential 'Staking) Coin)
stakeL

goDelegs ::
  Era era => Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
goDelegs :: forall era.
Era era =>
Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
goDelegs = V era (Map (Credential 'Staking) (KeyHash 'StakePool))
-> Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (Credential 'Staking) (KeyHash 'StakePool))
-> Access
     era
     (NewEpochState era)
     (Map (Credential 'Staking) (KeyHash 'StakePool))
-> V era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"goDelegs" (Rep era (Credential 'Staking)
-> Rep era (KeyHash 'StakePool)
-> Rep era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR) (Rep era (NewEpochState era)
-> Lens'
     (NewEpochState era)
     (Map (Credential 'Staking) (KeyHash 'StakePool))
-> Access
     era
     (NewEpochState era)
     (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (Credential 'Staking) (KeyHash 'StakePool)
 -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) (KeyHash 'StakePool)
 -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> NewEpochState era -> f (NewEpochState era)
Lens'
  (NewEpochState era)
  (Map (Credential 'Staking) (KeyHash 'StakePool))
goDelegsL))

goDelegsL ::
  NELens era (Map (Credential 'Staking) (KeyHash 'StakePool))
goDelegsL :: forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) (KeyHash 'StakePool)
 -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> NewEpochState era -> f (NewEpochState era)
goDelegsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> EpochState era -> f (EpochState era))
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
esSnapshotsL ((SnapShots -> f SnapShots)
 -> EpochState era -> f (EpochState era))
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> SnapShots -> f SnapShots)
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShot -> f SnapShot) -> SnapShots -> f SnapShots
Lens' SnapShots SnapShot
ssStakeGoL ((SnapShot -> f SnapShot) -> SnapShots -> f SnapShots)
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> SnapShot -> f SnapShot)
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShots
-> f SnapShots
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
 -> f (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShot -> f SnapShot
Lens'
  SnapShot (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool))
ssDelegationsL ((VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
  -> f (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
 -> SnapShot -> f SnapShot)
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
    -> f (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShot
-> f SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) (KeyHash 'StakePool)
 -> f (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
-> f (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool))
forall k v (f :: * -> *).
Functor f =>
(Map k v -> f (Map k v)) -> VMap VB VB k v -> f (VMap VB VB k v)
vmapL

goPools ::
  Era era => Term era (Map (KeyHash 'StakePool) PoolParams)
goPools :: forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) PoolParams)
goPools = V era (Map (KeyHash 'StakePool) PoolParams)
-> Term era (Map (KeyHash 'StakePool) PoolParams)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (KeyHash 'StakePool) PoolParams)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
-> V era (Map (KeyHash 'StakePool) PoolParams)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"goPools" (Rep era (KeyHash 'StakePool)
-> Rep era PoolParams
-> Rep era (Map (KeyHash 'StakePool) PoolParams)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era PoolParams
forall era. Era era => Rep era PoolParams
PoolParamsR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
-> Access
     era (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) (Map (KeyHash 'StakePool) PoolParams)
goPoolsL))

goPoolsL :: NELens era (Map (KeyHash 'StakePool) PoolParams)
goPoolsL :: forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era -> f (NewEpochState era)
goPoolsL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> EpochState era -> f (EpochState era))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
esSnapshotsL ((SnapShots -> f SnapShots)
 -> EpochState era -> f (EpochState era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> SnapShots -> f SnapShots)
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShot -> f SnapShot) -> SnapShots -> f SnapShots
Lens' SnapShots SnapShot
ssStakeGoL ((SnapShot -> f SnapShot) -> SnapShots -> f SnapShots)
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> SnapShot -> f SnapShot)
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> SnapShots
-> f SnapShots
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VMap VB VB (KeyHash 'StakePool) PoolParams
 -> f (VMap VB VB (KeyHash 'StakePool) PoolParams))
-> SnapShot -> f SnapShot
Lens' SnapShot (VMap VB VB (KeyHash 'StakePool) PoolParams)
ssPoolParamsL ((VMap VB VB (KeyHash 'StakePool) PoolParams
  -> f (VMap VB VB (KeyHash 'StakePool) PoolParams))
 -> SnapShot -> f SnapShot)
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> VMap VB VB (KeyHash 'StakePool) PoolParams
    -> f (VMap VB VB (KeyHash 'StakePool) PoolParams))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> SnapShot
-> f SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> VMap VB VB (KeyHash 'StakePool) PoolParams
-> f (VMap VB VB (KeyHash 'StakePool) PoolParams)
forall k v (f :: * -> *).
Functor f =>
(Map k v -> f (Map k v)) -> VMap VB VB k v -> f (VMap VB VB k v)
vmapL

goSnapShotT ::
  forall era. Era era => RootTarget era SnapShot SnapShot
goSnapShotT :: forall era. Era era => RootTarget era SnapShot SnapShot
goSnapShotT =
  String
-> TypeRep SnapShot
-> (Map (Credential 'Staking) Coin
    -> Map (Credential 'Staking) (KeyHash 'StakePool)
    -> Map (KeyHash 'StakePool) PoolParams
    -> SnapShot)
-> RootTarget
     era
     SnapShot
     (Map (Credential 'Staking) Coin
      -> Map (Credential 'Staking) (KeyHash 'StakePool)
      -> Map (KeyHash 'StakePool) PoolParams
      -> SnapShot)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"SnapShot" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @SnapShot) Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (KeyHash 'StakePool) PoolParams
-> SnapShot
snapfun
    RootTarget
  era
  SnapShot
  (Map (Credential 'Staking) Coin
   -> Map (Credential 'Staking) (KeyHash 'StakePool)
   -> Map (KeyHash 'StakePool) PoolParams
   -> SnapShot)
-> RootTarget era SnapShot (Map (Credential 'Staking) Coin)
-> RootTarget
     era
     SnapShot
     (Map (Credential 'Staking) (KeyHash 'StakePool)
      -> Map (KeyHash 'StakePool) PoolParams -> SnapShot)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) Coin)
-> SimpleGetter SnapShot (Map (Credential 'Staking) Coin)
-> RootTarget era SnapShot (Map (Credential 'Staking) Coin)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'Staking) Coin)
forall era. Era era => Term era (Map (Credential 'Staking) Coin)
goStake ((Stake -> Const r Stake) -> SnapShot -> Const r SnapShot
Lens' SnapShot Stake
ssStakeL ((Stake -> Const r Stake) -> SnapShot -> Const r SnapShot)
-> ((Map (Credential 'Staking) Coin
     -> Const r (Map (Credential 'Staking) Coin))
    -> Stake -> Const r Stake)
-> (Map (Credential 'Staking) Coin
    -> Const r (Map (Credential 'Staking) Coin))
-> SnapShot
-> Const r SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) Coin
 -> Const r (Map (Credential 'Staking) Coin))
-> Stake -> Const r Stake
Lens' Stake (Map (Credential 'Staking) Coin)
stakeL)
    RootTarget
  era
  SnapShot
  (Map (Credential 'Staking) (KeyHash 'StakePool)
   -> Map (KeyHash 'StakePool) PoolParams -> SnapShot)
-> RootTarget
     era SnapShot (Map (Credential 'Staking) (KeyHash 'StakePool))
-> RootTarget
     era SnapShot (Map (KeyHash 'StakePool) PoolParams -> SnapShot)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
-> SimpleGetter
     SnapShot (Map (Credential 'Staking) (KeyHash 'StakePool))
-> RootTarget
     era SnapShot (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era.
Era era =>
Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
goDelegs ((VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
 -> Const r (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShot -> Const r SnapShot
Lens'
  SnapShot (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool))
ssDelegationsL ((VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
  -> Const r (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
 -> SnapShot -> Const r SnapShot)
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> Const r (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
    -> Const r (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)))
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> Const r (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> SnapShot
-> Const r SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) (KeyHash 'StakePool)
 -> Const r (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
-> Const r (VMap VB VB (Credential 'Staking) (KeyHash 'StakePool))
forall k v (f :: * -> *).
Functor f =>
(Map k v -> f (Map k v)) -> VMap VB VB k v -> f (VMap VB VB k v)
vmapL)
    RootTarget
  era SnapShot (Map (KeyHash 'StakePool) PoolParams -> SnapShot)
-> RootTarget era SnapShot (Map (KeyHash 'StakePool) PoolParams)
-> RootTarget era SnapShot SnapShot
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) PoolParams)
-> SimpleGetter SnapShot (Map (KeyHash 'StakePool) PoolParams)
-> RootTarget era SnapShot (Map (KeyHash 'StakePool) PoolParams)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (KeyHash 'StakePool) PoolParams)
forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) PoolParams)
goPools ((VMap VB VB (KeyHash 'StakePool) PoolParams
 -> Const r (VMap VB VB (KeyHash 'StakePool) PoolParams))
-> SnapShot -> Const r SnapShot
Lens' SnapShot (VMap VB VB (KeyHash 'StakePool) PoolParams)
ssPoolParamsL ((VMap VB VB (KeyHash 'StakePool) PoolParams
  -> Const r (VMap VB VB (KeyHash 'StakePool) PoolParams))
 -> SnapShot -> Const r SnapShot)
-> ((Map (KeyHash 'StakePool) PoolParams
     -> Const r (Map (KeyHash 'StakePool) PoolParams))
    -> VMap VB VB (KeyHash 'StakePool) PoolParams
    -> Const r (VMap VB VB (KeyHash 'StakePool) PoolParams))
-> (Map (KeyHash 'StakePool) PoolParams
    -> Const r (Map (KeyHash 'StakePool) PoolParams))
-> SnapShot
-> Const r SnapShot
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) PoolParams
 -> Const r (Map (KeyHash 'StakePool) PoolParams))
-> VMap VB VB (KeyHash 'StakePool) PoolParams
-> Const r (VMap VB VB (KeyHash 'StakePool) PoolParams)
forall k v (f :: * -> *).
Functor f =>
(Map k v -> f (Map k v)) -> VMap VB VB k v -> f (VMap VB VB k v)
vmapL)
  where
    snapfun :: Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (KeyHash 'StakePool) PoolParams
-> SnapShot
snapfun Map (Credential 'Staking) Coin
x Map (Credential 'Staking) (KeyHash 'StakePool)
y Map (KeyHash 'StakePool) PoolParams
z =
      Stake
-> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
-> VMap VB VB (KeyHash 'StakePool) PoolParams
-> SnapShot
SnapShot
        (VMap VB VP (Credential 'Staking) (CompactForm Coin) -> Stake
Stake (Map (Credential 'Staking) (CompactForm Coin)
-> VMap VB VP (Credential 'Staking) (CompactForm Coin)
forall (kv :: * -> *) k (vv :: * -> *) v.
(Vector kv k, Vector vv v) =>
Map k v -> VMap kv vv k v
VMap.fromMap ((Coin -> CompactForm Coin)
-> Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) (CompactForm Coin)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map HasCallStack => Coin -> CompactForm Coin
Coin -> CompactForm Coin
compactCoinOrError Map (Credential 'Staking) Coin
x)))
        (Map (Credential 'Staking) (KeyHash 'StakePool)
-> VMap VB VB (Credential 'Staking) (KeyHash 'StakePool)
forall (kv :: * -> *) k (vv :: * -> *) v.
(Vector kv k, Vector vv v) =>
Map k v -> VMap kv vv k v
VMap.fromMap Map (Credential 'Staking) (KeyHash 'StakePool)
y)
        (Map (KeyHash 'StakePool) PoolParams
-> VMap VB VB (KeyHash 'StakePool) PoolParams
forall (kv :: * -> *) k (vv :: * -> *) v.
(Vector kv k, Vector vv v) =>
Map k v -> VMap kv vv k v
VMap.fromMap Map (KeyHash 'StakePool) PoolParams
z)

markPoolDistr ::
  Era era => Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
markPoolDistr :: forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
markPoolDistr = V era (Map (KeyHash 'StakePool) IndividualPoolStake)
-> Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (KeyHash 'StakePool) IndividualPoolStake)
-> Access era Any (Map (KeyHash 'StakePool) IndividualPoolStake)
-> V era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"markPoolDistr" (Rep era (KeyHash 'StakePool)
-> Rep era IndividualPoolStake
-> Rep era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era IndividualPoolStake
forall era. Era era => Rep era IndividualPoolStake
IPoolStakeR) Access era Any (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era s t. Access era s t
No)

markPoolDistrL ::
  NELens era (Map (KeyHash 'StakePool) IndividualPoolStake)
markPoolDistrL :: forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) IndividualPoolStake
 -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> NewEpochState era -> f (NewEpochState era)
markPoolDistrL = (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> f (EpochState era))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Map (KeyHash 'StakePool) IndividualPoolStake
     -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
    -> EpochState era -> f (EpochState era))
-> (Map (KeyHash 'StakePool) IndividualPoolStake
    -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
esSnapshotsL ((SnapShots -> f SnapShots)
 -> EpochState era -> f (EpochState era))
-> ((Map (KeyHash 'StakePool) IndividualPoolStake
     -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
    -> SnapShots -> f SnapShots)
-> (Map (KeyHash 'StakePool) IndividualPoolStake
    -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> EpochState era
-> f (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PoolDistr -> f PoolDistr) -> SnapShots -> f SnapShots
Lens' SnapShots PoolDistr
ssStakeMarkPoolDistrL ((PoolDistr -> f PoolDistr) -> SnapShots -> f SnapShots)
-> ((Map (KeyHash 'StakePool) IndividualPoolStake
     -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
    -> PoolDistr -> f PoolDistr)
-> (Map (KeyHash 'StakePool) IndividualPoolStake
    -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> SnapShots
-> f SnapShots
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) IndividualPoolStake
 -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> PoolDistr -> f PoolDistr
Lens' PoolDistr (Map (KeyHash 'StakePool) IndividualPoolStake)
poolDistrDistrL

snapShotFee :: Era era => Term era Coin
snapShotFee :: forall era. Era era => Term era Coin
snapShotFee = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"snapShotFee" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No)

snapShotsT ::
  forall era. Era era => RootTarget era SnapShots SnapShots
snapShotsT :: forall era. Era era => RootTarget era SnapShots SnapShots
snapShotsT =
  String
-> TypeRep SnapShots
-> (SnapShot
    -> Map (KeyHash 'StakePool) IndividualPoolStake
    -> SnapShot
    -> SnapShot
    -> Coin
    -> SnapShots)
-> RootTarget
     era
     SnapShots
     (SnapShot
      -> Map (KeyHash 'StakePool) IndividualPoolStake
      -> SnapShot
      -> SnapShot
      -> Coin
      -> SnapShots)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"SnapShots" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @SnapShots) SnapShot
-> Map (KeyHash 'StakePool) IndividualPoolStake
-> SnapShot
-> SnapShot
-> Coin
-> SnapShots
shotsfun
    RootTarget
  era
  SnapShots
  (SnapShot
   -> Map (KeyHash 'StakePool) IndividualPoolStake
   -> SnapShot
   -> SnapShot
   -> Coin
   -> SnapShots)
-> RootTarget era SnapShots SnapShot
-> RootTarget
     era
     SnapShots
     (Map (KeyHash 'StakePool) IndividualPoolStake
      -> SnapShot -> SnapShot -> Coin -> SnapShots)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era SnapShot SnapShot
-> Lens' SnapShots SnapShot -> RootTarget era SnapShots SnapShot
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era SnapShot SnapShot
forall era. Era era => RootTarget era SnapShot SnapShot
markSnapShotT (SnapShot -> f SnapShot) -> SnapShots -> f SnapShots
Lens' SnapShots SnapShot
ssStakeMarkL
    RootTarget
  era
  SnapShots
  (Map (KeyHash 'StakePool) IndividualPoolStake
   -> SnapShot -> SnapShot -> Coin -> SnapShots)
-> RootTarget
     era SnapShots (Map (KeyHash 'StakePool) IndividualPoolStake)
-> RootTarget
     era SnapShots (SnapShot -> SnapShot -> Coin -> SnapShots)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
-> SimpleGetter
     SnapShots (Map (KeyHash 'StakePool) IndividualPoolStake)
-> RootTarget
     era SnapShots (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
markPoolDistr ((PoolDistr -> Const r PoolDistr) -> SnapShots -> Const r SnapShots
Lens' SnapShots PoolDistr
ssStakeMarkPoolDistrL ((PoolDistr -> Const r PoolDistr)
 -> SnapShots -> Const r SnapShots)
-> ((Map (KeyHash 'StakePool) IndividualPoolStake
     -> Const r (Map (KeyHash 'StakePool) IndividualPoolStake))
    -> PoolDistr -> Const r PoolDistr)
-> (Map (KeyHash 'StakePool) IndividualPoolStake
    -> Const r (Map (KeyHash 'StakePool) IndividualPoolStake))
-> SnapShots
-> Const r SnapShots
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) IndividualPoolStake
 -> Const r (Map (KeyHash 'StakePool) IndividualPoolStake))
-> PoolDistr -> Const r PoolDistr
Lens' PoolDistr (Map (KeyHash 'StakePool) IndividualPoolStake)
poolDistrDistrL)
    RootTarget
  era SnapShots (SnapShot -> SnapShot -> Coin -> SnapShots)
-> RootTarget era SnapShots SnapShot
-> RootTarget era SnapShots (SnapShot -> Coin -> SnapShots)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era SnapShot SnapShot
-> Lens' SnapShots SnapShot -> RootTarget era SnapShots SnapShot
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era SnapShot SnapShot
forall era. Era era => RootTarget era SnapShot SnapShot
setSnapShotT (SnapShot -> f SnapShot) -> SnapShots -> f SnapShots
Lens' SnapShots SnapShot
ssStakeSetL
    RootTarget era SnapShots (SnapShot -> Coin -> SnapShots)
-> RootTarget era SnapShots SnapShot
-> RootTarget era SnapShots (Coin -> SnapShots)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era SnapShot SnapShot
-> Lens' SnapShots SnapShot -> RootTarget era SnapShots SnapShot
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era SnapShot SnapShot
forall era. Era era => RootTarget era SnapShot SnapShot
goSnapShotT (SnapShot -> f SnapShot) -> SnapShots -> f SnapShots
Lens' SnapShots SnapShot
ssStakeGoL
    RootTarget era SnapShots (Coin -> SnapShots)
-> RootTarget era SnapShots Coin
-> RootTarget era SnapShots SnapShots
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era Coin
-> SimpleGetter SnapShots Coin -> RootTarget era SnapShots Coin
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era Coin
forall era. Era era => Term era Coin
snapShotFee (Coin -> Const r Coin) -> SnapShots -> Const r SnapShots
SimpleGetter SnapShots Coin
Lens' SnapShots Coin
ssFeeL
  where
    shotsfun :: SnapShot
-> Map (KeyHash 'StakePool) IndividualPoolStake
-> SnapShot
-> SnapShot
-> Coin
-> SnapShots
shotsfun SnapShot
w Map (KeyHash 'StakePool) IndividualPoolStake
x = SnapShot -> PoolDistr -> SnapShot -> SnapShot -> Coin -> SnapShots
SnapShots SnapShot
w (Map (KeyHash 'StakePool) IndividualPoolStake
-> CompactForm Coin -> PoolDistr
PoolDistr Map (KeyHash 'StakePool) IndividualPoolStake
x (CompactForm Coin -> PoolDistr) -> CompactForm Coin -> PoolDistr
forall a b. (a -> b) -> a -> b
$ Word64 -> CompactForm Coin
CompactCoin Word64
1)

-- ==================================================================
-- RewardUpdate

deltaT :: Era era => Term era (Maybe DeltaCoin)
deltaT :: forall era. Era era => Term era (Maybe DeltaCoin)
deltaT = V era (Maybe DeltaCoin) -> Term era (Maybe DeltaCoin)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Maybe DeltaCoin)
-> Access era (NewEpochState era) (Maybe DeltaCoin)
-> V era (Maybe DeltaCoin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"deltaT" (Rep era DeltaCoin -> Rep era (Maybe DeltaCoin)
forall era t1. Rep era t1 -> Rep era (Maybe t1)
MaybeR Rep era DeltaCoin
forall era. Rep era DeltaCoin
DeltaCoinR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Maybe DeltaCoin)
-> Access era (NewEpochState era) (Maybe DeltaCoin)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) (Maybe DeltaCoin)
deltaTL))

deltaTL :: NELens era (Maybe DeltaCoin)
deltaTL :: forall era (f :: * -> *).
Functor f =>
(Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> NewEpochState era -> f (NewEpochState era)
deltaTL = (StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate))
-> NewEpochState era -> f (NewEpochState era)
nesRuL ((StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Maybe DeltaCoin -> f (Maybe DeltaCoin))
    -> StrictMaybe PulsingRewUpdate
    -> f (StrictMaybe PulsingRewUpdate))
-> (Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate)
Lens' (StrictMaybe PulsingRewUpdate) (Maybe DeltaCoin)
help
  where
    help :: Lens' (StrictMaybe PulsingRewUpdate) (Maybe DeltaCoin)
    help :: Lens' (StrictMaybe PulsingRewUpdate) (Maybe DeltaCoin)
help = (StrictMaybe PulsingRewUpdate -> Maybe DeltaCoin)
-> (StrictMaybe PulsingRewUpdate
    -> Maybe DeltaCoin -> StrictMaybe PulsingRewUpdate)
-> Lens' (StrictMaybe PulsingRewUpdate) (Maybe DeltaCoin)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens StrictMaybe PulsingRewUpdate -> Maybe DeltaCoin
view StrictMaybe PulsingRewUpdate
-> Maybe DeltaCoin -> StrictMaybe PulsingRewUpdate
update
      where
        view :: StrictMaybe PulsingRewUpdate -> Maybe DeltaCoin
view StrictMaybe PulsingRewUpdate
SNothing = Maybe DeltaCoin
forall a. Maybe a
Nothing
        view (SJust (Complete RewardUpdate
x)) = DeltaCoin -> Maybe DeltaCoin
forall a. a -> Maybe a
Just (RewardUpdate -> DeltaCoin
RU.deltaT RewardUpdate
x)
        view (SJust PulsingRewUpdate
_) = Maybe DeltaCoin
forall a. Maybe a
Nothing
        update :: StrictMaybe PulsingRewUpdate
-> Maybe DeltaCoin -> StrictMaybe PulsingRewUpdate
update (SJust (Complete RewardUpdate
ru)) (Just DeltaCoin
change) = PulsingRewUpdate -> StrictMaybe PulsingRewUpdate
forall a. a -> StrictMaybe a
SJust (RewardUpdate -> PulsingRewUpdate
Complete (RewardUpdate
ru {RU.deltaT = change}))
        update StrictMaybe PulsingRewUpdate
_ Maybe DeltaCoin
_ = StrictMaybe PulsingRewUpdate
forall a. StrictMaybe a
SNothing

deltaR :: Era era => Term era (Maybe DeltaCoin)
deltaR :: forall era. Era era => Term era (Maybe DeltaCoin)
deltaR = V era (Maybe DeltaCoin) -> Term era (Maybe DeltaCoin)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Maybe DeltaCoin)
-> Access era (NewEpochState era) (Maybe DeltaCoin)
-> V era (Maybe DeltaCoin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"deltaR" (Rep era DeltaCoin -> Rep era (Maybe DeltaCoin)
forall era t1. Rep era t1 -> Rep era (Maybe t1)
MaybeR Rep era DeltaCoin
forall era. Rep era DeltaCoin
DeltaCoinR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Maybe DeltaCoin)
-> Access era (NewEpochState era) (Maybe DeltaCoin)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) (Maybe DeltaCoin)
deltaRL))

deltaRL :: NELens era (Maybe DeltaCoin)
deltaRL :: forall era (f :: * -> *).
Functor f =>
(Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> NewEpochState era -> f (NewEpochState era)
deltaRL = (StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate))
-> NewEpochState era -> f (NewEpochState era)
nesRuL ((StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Maybe DeltaCoin -> f (Maybe DeltaCoin))
    -> StrictMaybe PulsingRewUpdate
    -> f (StrictMaybe PulsingRewUpdate))
-> (Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate)
Lens' (StrictMaybe PulsingRewUpdate) (Maybe DeltaCoin)
help
  where
    help :: Lens' (StrictMaybe PulsingRewUpdate) (Maybe DeltaCoin)
    help :: Lens' (StrictMaybe PulsingRewUpdate) (Maybe DeltaCoin)
help = (StrictMaybe PulsingRewUpdate -> Maybe DeltaCoin)
-> (StrictMaybe PulsingRewUpdate
    -> Maybe DeltaCoin -> StrictMaybe PulsingRewUpdate)
-> Lens' (StrictMaybe PulsingRewUpdate) (Maybe DeltaCoin)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens StrictMaybe PulsingRewUpdate -> Maybe DeltaCoin
view StrictMaybe PulsingRewUpdate
-> Maybe DeltaCoin -> StrictMaybe PulsingRewUpdate
update
      where
        view :: StrictMaybe PulsingRewUpdate -> Maybe DeltaCoin
view StrictMaybe PulsingRewUpdate
SNothing = Maybe DeltaCoin
forall a. Maybe a
Nothing
        view (SJust (Complete RewardUpdate
x)) = DeltaCoin -> Maybe DeltaCoin
forall a. a -> Maybe a
Just (RewardUpdate -> DeltaCoin
RU.deltaR RewardUpdate
x)
        view (SJust PulsingRewUpdate
_) = Maybe DeltaCoin
forall a. Maybe a
Nothing
        update :: StrictMaybe PulsingRewUpdate
-> Maybe DeltaCoin -> StrictMaybe PulsingRewUpdate
update (SJust (Complete RewardUpdate
ru)) (Just DeltaCoin
change) = PulsingRewUpdate -> StrictMaybe PulsingRewUpdate
forall a. a -> StrictMaybe a
SJust (RewardUpdate -> PulsingRewUpdate
Complete (RewardUpdate
ru {RU.deltaR = change}))
        update StrictMaybe PulsingRewUpdate
_ Maybe DeltaCoin
_ = StrictMaybe PulsingRewUpdate
forall a. StrictMaybe a
SNothing

deltaF :: Era era => Term era (Maybe DeltaCoin)
deltaF :: forall era. Era era => Term era (Maybe DeltaCoin)
deltaF = V era (Maybe DeltaCoin) -> Term era (Maybe DeltaCoin)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Maybe DeltaCoin)
-> Access era (NewEpochState era) (Maybe DeltaCoin)
-> V era (Maybe DeltaCoin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"deltaF" (Rep era DeltaCoin -> Rep era (Maybe DeltaCoin)
forall era t1. Rep era t1 -> Rep era (Maybe t1)
MaybeR Rep era DeltaCoin
forall era. Rep era DeltaCoin
DeltaCoinR) (Rep era (NewEpochState era)
-> Lens' (NewEpochState era) (Maybe DeltaCoin)
-> Access era (NewEpochState era) (Maybe DeltaCoin)
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes Rep era (NewEpochState era)
forall era. Era era => Rep era (NewEpochState era)
NewEpochStateR (Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) (Maybe DeltaCoin)
deltaFL))

deltaFL :: NELens era (Maybe DeltaCoin)
deltaFL :: forall era (f :: * -> *).
Functor f =>
(Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> NewEpochState era -> f (NewEpochState era)
deltaFL = (StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate))
-> NewEpochState era -> f (NewEpochState era)
nesRuL ((StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Maybe DeltaCoin -> f (Maybe DeltaCoin))
    -> StrictMaybe PulsingRewUpdate
    -> f (StrictMaybe PulsingRewUpdate))
-> (Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe DeltaCoin -> f (Maybe DeltaCoin))
-> StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate)
Lens' (StrictMaybe PulsingRewUpdate) (Maybe DeltaCoin)
help
  where
    help :: Lens' (StrictMaybe PulsingRewUpdate) (Maybe DeltaCoin)
    help :: Lens' (StrictMaybe PulsingRewUpdate) (Maybe DeltaCoin)
help = (StrictMaybe PulsingRewUpdate -> Maybe DeltaCoin)
-> (StrictMaybe PulsingRewUpdate
    -> Maybe DeltaCoin -> StrictMaybe PulsingRewUpdate)
-> Lens' (StrictMaybe PulsingRewUpdate) (Maybe DeltaCoin)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens StrictMaybe PulsingRewUpdate -> Maybe DeltaCoin
view StrictMaybe PulsingRewUpdate
-> Maybe DeltaCoin -> StrictMaybe PulsingRewUpdate
update
      where
        view :: StrictMaybe PulsingRewUpdate -> Maybe DeltaCoin
view StrictMaybe PulsingRewUpdate
SNothing = Maybe DeltaCoin
forall a. Maybe a
Nothing
        view (SJust (Complete RewardUpdate
x)) = DeltaCoin -> Maybe DeltaCoin
forall a. a -> Maybe a
Just (RewardUpdate -> DeltaCoin
RU.deltaF RewardUpdate
x)
        view (SJust PulsingRewUpdate
_) = Maybe DeltaCoin
forall a. Maybe a
Nothing
        update :: StrictMaybe PulsingRewUpdate
-> Maybe DeltaCoin -> StrictMaybe PulsingRewUpdate
update (SJust (Complete RewardUpdate
ru)) (Just DeltaCoin
change) = PulsingRewUpdate -> StrictMaybe PulsingRewUpdate
forall a. a -> StrictMaybe a
SJust (RewardUpdate -> PulsingRewUpdate
Complete (RewardUpdate
ru {RU.deltaF = change}))
        update StrictMaybe PulsingRewUpdate
_ Maybe DeltaCoin
_ = StrictMaybe PulsingRewUpdate
forall a. StrictMaybe a
SNothing

rewardSet ::
  Era era => Term era (Map (Credential 'Staking) (Set Reward))
rewardSet :: forall era.
Era era =>
Term era (Map (Credential 'Staking) (Set Reward))
rewardSet = V era (Map (Credential 'Staking) (Set Reward))
-> Term era (Map (Credential 'Staking) (Set Reward))
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (Credential 'Staking) (Set Reward))
-> Access era Any (Map (Credential 'Staking) (Set Reward))
-> V era (Map (Credential 'Staking) (Set Reward))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"rewardSet" (Rep era (Credential 'Staking)
-> Rep era (Set Reward)
-> Rep era (Map (Credential 'Staking) (Set Reward))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR (Rep era Reward -> Rep era (Set Reward)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era Reward
forall era. Era era => Rep era Reward
RewardR)) Access era Any (Map (Credential 'Staking) (Set Reward))
forall era s t. Access era s t
No)

rewardSetL ::
  NELens era (Maybe (Map (Credential 'Staking) (Set Reward)))
rewardSetL :: forall era (f :: * -> *).
Functor f =>
(Maybe (Map (Credential 'Staking) (Set Reward))
 -> f (Maybe (Map (Credential 'Staking) (Set Reward))))
-> NewEpochState era -> f (NewEpochState era)
rewardSetL = (StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate))
-> NewEpochState era -> f (NewEpochState era)
nesRuL ((StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate))
 -> NewEpochState era -> f (NewEpochState era))
-> ((Maybe (Map (Credential 'Staking) (Set Reward))
     -> f (Maybe (Map (Credential 'Staking) (Set Reward))))
    -> StrictMaybe PulsingRewUpdate
    -> f (StrictMaybe PulsingRewUpdate))
-> (Maybe (Map (Credential 'Staking) (Set Reward))
    -> f (Maybe (Map (Credential 'Staking) (Set Reward))))
-> NewEpochState era
-> f (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe (Map (Credential 'Staking) (Set Reward))
 -> f (Maybe (Map (Credential 'Staking) (Set Reward))))
-> StrictMaybe PulsingRewUpdate -> f (StrictMaybe PulsingRewUpdate)
Lens'
  (StrictMaybe PulsingRewUpdate)
  (Maybe (Map (Credential 'Staking) (Set Reward)))
help
  where
    help ::
      Lens' (StrictMaybe PulsingRewUpdate) (Maybe (Map (Credential 'Staking) (Set Reward)))
    help :: Lens'
  (StrictMaybe PulsingRewUpdate)
  (Maybe (Map (Credential 'Staking) (Set Reward)))
help = (StrictMaybe PulsingRewUpdate
 -> Maybe (Map (Credential 'Staking) (Set Reward)))
-> (StrictMaybe PulsingRewUpdate
    -> Maybe (Map (Credential 'Staking) (Set Reward))
    -> StrictMaybe PulsingRewUpdate)
-> Lens'
     (StrictMaybe PulsingRewUpdate)
     (Maybe (Map (Credential 'Staking) (Set Reward)))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens StrictMaybe PulsingRewUpdate
-> Maybe (Map (Credential 'Staking) (Set Reward))
view StrictMaybe PulsingRewUpdate
-> Maybe (Map (Credential 'Staking) (Set Reward))
-> StrictMaybe PulsingRewUpdate
update
      where
        view :: StrictMaybe PulsingRewUpdate
-> Maybe (Map (Credential 'Staking) (Set Reward))
view StrictMaybe PulsingRewUpdate
SNothing = Maybe (Map (Credential 'Staking) (Set Reward))
forall a. Maybe a
Nothing
        view (SJust (Complete RewardUpdate
x)) = Map (Credential 'Staking) (Set Reward)
-> Maybe (Map (Credential 'Staking) (Set Reward))
forall a. a -> Maybe a
Just (RewardUpdate -> Map (Credential 'Staking) (Set Reward)
RU.rs RewardUpdate
x)
        view (SJust PulsingRewUpdate
_) = Maybe (Map (Credential 'Staking) (Set Reward))
forall a. Maybe a
Nothing
        update :: StrictMaybe PulsingRewUpdate
-> Maybe (Map (Credential 'Staking) (Set Reward))
-> StrictMaybe PulsingRewUpdate
update (SJust (Complete RewardUpdate
ru)) (Just Map (Credential 'Staking) (Set Reward)
change) = PulsingRewUpdate -> StrictMaybe PulsingRewUpdate
forall a. a -> StrictMaybe a
SJust (RewardUpdate -> PulsingRewUpdate
Complete (RewardUpdate
ru {RU.rs = change}))
        update StrictMaybe PulsingRewUpdate
_ Maybe (Map (Credential 'Staking) (Set Reward))
_ = StrictMaybe PulsingRewUpdate
forall a. StrictMaybe a
SNothing

-- ===================================================================
-- Non Access variables

totalAda :: Era era => Term era Coin
totalAda :: forall era. Era era => Term era Coin
totalAda = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"totalAda" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No

utxoCoin :: Era era => Term era Coin
utxoCoin :: forall era. Era era => Term era Coin
utxoCoin = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"utxoCoin" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No

-- | The universe of Staking Credentials. A credential is either KeyHash of a ScriptHash
--   Any Plutus scripts in this Universe are NOT Spending scripts, so they do not need a Redeemer
credsUniv :: Era era => Term era (Set (Credential 'Staking))
credsUniv :: forall era. Era era => Term era (Set (Credential 'Staking))
credsUniv = V era (Set (Credential 'Staking))
-> Term era (Set (Credential 'Staking))
forall era t. V era t -> Term era t
Var (V era (Set (Credential 'Staking))
 -> Term era (Set (Credential 'Staking)))
-> V era (Set (Credential 'Staking))
-> Term era (Set (Credential 'Staking))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set (Credential 'Staking))
-> Access era Any (Set (Credential 'Staking))
-> V era (Set (Credential 'Staking))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"credsUniv" (Rep era (Credential 'Staking)
-> Rep era (Set (Credential 'Staking))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR) Access era Any (Set (Credential 'Staking))
forall era s t. Access era s t
No

-- | The universe of Staking Credentials. A credential is either KeyHash of a ScriptHash
--   All Plutus scripts in this Universe are SPENDING scripts, so they will need a Redeemer
--   Use this ONLY in the Pay-part of an Address (Do not use this in the Stake-part of an Address)
spendCredsUniv :: Era era => Term era (Set (Credential 'Payment))
spendCredsUniv :: forall era. Era era => Term era (Set (Credential 'Payment))
spendCredsUniv = V era (Set (Credential 'Payment))
-> Term era (Set (Credential 'Payment))
forall era t. V era t -> Term era t
Var (V era (Set (Credential 'Payment))
 -> Term era (Set (Credential 'Payment)))
-> V era (Set (Credential 'Payment))
-> Term era (Set (Credential 'Payment))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set (Credential 'Payment))
-> Access era Any (Set (Credential 'Payment))
-> V era (Set (Credential 'Payment))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"spendCredsUniv" (Rep era (Credential 'Payment)
-> Rep era (Set (Credential 'Payment))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era (Credential 'Payment)
forall era. Era era => Rep era (Credential 'Payment)
PCredR) Access era Any (Set (Credential 'Payment))
forall era s t. Access era s t
No

-- | The universe of Voting Credentials. A credential is either KeyHash of a ScriptHash
voteUniv :: Era era => Term era (Set (Credential 'DRepRole))
voteUniv :: forall era. Era era => Term era (Set (Credential 'DRepRole))
voteUniv = V era (Set (Credential 'DRepRole))
-> Term era (Set (Credential 'DRepRole))
forall era t. V era t -> Term era t
Var (V era (Set (Credential 'DRepRole))
 -> Term era (Set (Credential 'DRepRole)))
-> V era (Set (Credential 'DRepRole))
-> Term era (Set (Credential 'DRepRole))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set (Credential 'DRepRole))
-> Access era Any (Set (Credential 'DRepRole))
-> V era (Set (Credential 'DRepRole))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"voteUniv" (Rep era (Credential 'DRepRole)
-> Rep era (Set (Credential 'DRepRole))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era (Credential 'DRepRole)
forall era. Era era => Rep era (Credential 'DRepRole)
VCredR) Access era Any (Set (Credential 'DRepRole))
forall era s t. Access era s t
No

-- | The universe of DReps
drepUniv :: Era era => Term era (Set DRep)
drepUniv :: forall era. Era era => Term era (Set DRep)
drepUniv = V era (Set DRep) -> Term era (Set DRep)
forall era t. V era t -> Term era t
Var (V era (Set DRep) -> Term era (Set DRep))
-> V era (Set DRep) -> Term era (Set DRep)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set DRep)
-> Access era Any (Set DRep)
-> V era (Set DRep)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"drepUniv" (Rep era DRep -> Rep era (Set DRep)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era DRep
forall era. Era era => Rep era DRep
DRepR) Access era Any (Set DRep)
forall era s t. Access era s t
No

-- | The universe of Credentials used in voting for constitutional committee changes.
hotCommitteeCredsUniv :: Era era => Term era (Set (Credential 'HotCommitteeRole))
hotCommitteeCredsUniv :: forall era.
Era era =>
Term era (Set (Credential 'HotCommitteeRole))
hotCommitteeCredsUniv = V era (Set (Credential 'HotCommitteeRole))
-> Term era (Set (Credential 'HotCommitteeRole))
forall era t. V era t -> Term era t
Var (V era (Set (Credential 'HotCommitteeRole))
 -> Term era (Set (Credential 'HotCommitteeRole)))
-> V era (Set (Credential 'HotCommitteeRole))
-> Term era (Set (Credential 'HotCommitteeRole))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set (Credential 'HotCommitteeRole))
-> Access era Any (Set (Credential 'HotCommitteeRole))
-> V era (Set (Credential 'HotCommitteeRole))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"hotCommitteeCredsUniv" (Rep era (Credential 'HotCommitteeRole)
-> Rep era (Set (Credential 'HotCommitteeRole))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era (Credential 'HotCommitteeRole)
forall era. Era era => Rep era (Credential 'HotCommitteeRole)
CommHotCredR) Access era Any (Set (Credential 'HotCommitteeRole))
forall era s t. Access era s t
No

-- | The universe of Credentials used in voting for constitutional committee changes.
coldCommitteeCredsUniv :: Era era => Term era (Set (Credential 'ColdCommitteeRole))
coldCommitteeCredsUniv :: forall era.
Era era =>
Term era (Set (Credential 'ColdCommitteeRole))
coldCommitteeCredsUniv = V era (Set (Credential 'ColdCommitteeRole))
-> Term era (Set (Credential 'ColdCommitteeRole))
forall era t. V era t -> Term era t
Var (V era (Set (Credential 'ColdCommitteeRole))
 -> Term era (Set (Credential 'ColdCommitteeRole)))
-> V era (Set (Credential 'ColdCommitteeRole))
-> Term era (Set (Credential 'ColdCommitteeRole))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set (Credential 'ColdCommitteeRole))
-> Access era Any (Set (Credential 'ColdCommitteeRole))
-> V era (Set (Credential 'ColdCommitteeRole))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"coldCommitteeCredsUniv" (Rep era (Credential 'ColdCommitteeRole)
-> Rep era (Set (Credential 'ColdCommitteeRole))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era (Credential 'ColdCommitteeRole)
forall era. Era era => Rep era (Credential 'ColdCommitteeRole)
CommColdCredR) Access era Any (Set (Credential 'ColdCommitteeRole))
forall era s t. Access era s t
No

-- | The universe of Payment Credentials. A credential is either KeyHash of a ScriptHash
--   We only find payment credentials in the Payment part of an Addr.
payUniv :: Era era => Term era (Set (Credential 'Payment))
payUniv :: forall era. Era era => Term era (Set (Credential 'Payment))
payUniv = V era (Set (Credential 'Payment))
-> Term era (Set (Credential 'Payment))
forall era t. V era t -> Term era t
Var (V era (Set (Credential 'Payment))
 -> Term era (Set (Credential 'Payment)))
-> V era (Set (Credential 'Payment))
-> Term era (Set (Credential 'Payment))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set (Credential 'Payment))
-> Access era Any (Set (Credential 'Payment))
-> V era (Set (Credential 'Payment))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"payUniv" (Rep era (Credential 'Payment)
-> Rep era (Set (Credential 'Payment))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era (Credential 'Payment)
forall era. Era era => Rep era (Credential 'Payment)
PCredR) Access era Any (Set (Credential 'Payment))
forall era s t. Access era s t
No

-- | The universe of Scripts (and their hashes) useable in spending contexts
--  That means if they are Plutus scripts then they will be passed an additional
--  argument (the TxInfo context)
spendscriptUniv :: Era era => Proof era -> Term era (Map ScriptHash (ScriptF era))
spendscriptUniv :: forall era.
Era era =>
Proof era -> Term era (Map ScriptHash (ScriptF era))
spendscriptUniv Proof era
p = V era (Map ScriptHash (ScriptF era))
-> Term era (Map ScriptHash (ScriptF era))
forall era t. V era t -> Term era t
Var (Proof era
-> String
-> Rep era (Map ScriptHash (ScriptF era))
-> Access era Any (Map ScriptHash (ScriptF era))
-> V era (Map ScriptHash (ScriptF era))
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV Proof era
p String
"spendscriptUniv" (Rep era ScriptHash
-> Rep era (ScriptF era) -> Rep era (Map ScriptHash (ScriptF era))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era ScriptHash
forall era. Era era => Rep era ScriptHash
ScriptHashR (Proof era -> Rep era (ScriptF era)
forall era. Era era => Proof era -> Rep era (ScriptF era)
ScriptR Proof era
p)) Access era Any (Map ScriptHash (ScriptF era))
forall era s t. Access era s t
No)

-- | The universe of Scripts (and their hashes) useable in contexts other than Spending
nonSpendScriptUniv ::
  Era era => Proof era -> Term era (Map ScriptHash (ScriptF era))
nonSpendScriptUniv :: forall era.
Era era =>
Proof era -> Term era (Map ScriptHash (ScriptF era))
nonSpendScriptUniv Proof era
p = V era (Map ScriptHash (ScriptF era))
-> Term era (Map ScriptHash (ScriptF era))
forall era t. V era t -> Term era t
Var (Proof era
-> String
-> Rep era (Map ScriptHash (ScriptF era))
-> Access era Any (Map ScriptHash (ScriptF era))
-> V era (Map ScriptHash (ScriptF era))
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV Proof era
p String
"nonSpendScriptUniv" (Rep era ScriptHash
-> Rep era (ScriptF era) -> Rep era (Map ScriptHash (ScriptF era))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era ScriptHash
forall era. Era era => Rep era ScriptHash
ScriptHashR (Proof era -> Rep era (ScriptF era)
forall era. Era era => Proof era -> Rep era (ScriptF era)
ScriptR Proof era
p)) Access era Any (Map ScriptHash (ScriptF era))
forall era s t. Access era s t
No)

-- | The union of 'spendscriptUniv' and 'nonSpendScriptUniv'. All possible scripts in any context
allScriptUniv :: Era era => Proof era -> Term era (Map ScriptHash (ScriptF era))
allScriptUniv :: forall era.
Era era =>
Proof era -> Term era (Map ScriptHash (ScriptF era))
allScriptUniv Proof era
p = V era (Map ScriptHash (ScriptF era))
-> Term era (Map ScriptHash (ScriptF era))
forall era t. V era t -> Term era t
Var (Proof era
-> String
-> Rep era (Map ScriptHash (ScriptF era))
-> Access era Any (Map ScriptHash (ScriptF era))
-> V era (Map ScriptHash (ScriptF era))
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV Proof era
p String
"allScriptUniv" (Rep era ScriptHash
-> Rep era (ScriptF era) -> Rep era (Map ScriptHash (ScriptF era))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era ScriptHash
forall era. Era era => Rep era ScriptHash
ScriptHashR (Proof era -> Rep era (ScriptF era)
forall era. Era era => Proof era -> Rep era (ScriptF era)
ScriptR Proof era
p)) Access era Any (Map ScriptHash (ScriptF era))
forall era s t. Access era s t
No)

-- | The universe of Data (and their hashes)
dataUniv :: Era era => Term era (Map DataHash (Data era))
dataUniv :: forall era. Era era => Term era (Map DataHash (Data era))
dataUniv = V era (Map DataHash (Data era))
-> Term era (Map DataHash (Data era))
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map DataHash (Data era))
-> Access era Any (Map DataHash (Data era))
-> V era (Map DataHash (Data era))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"dataUniv" (Rep era DataHash
-> Rep era (Data era) -> Rep era (Map DataHash (Data era))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era DataHash
forall era. Era era => Rep era DataHash
DataHashR Rep era (Data era)
forall era. Era era => Rep era (Data era)
DataR) Access era Any (Map DataHash (Data era))
forall era s t. Access era s t
No)

-- | The universe of StakePool key hashes. These hashes hash the cold key of the
--   Pool operators.
poolHashUniv :: Era era => Term era (Set (KeyHash 'StakePool))
poolHashUniv :: forall era. Era era => Term era (Set (KeyHash 'StakePool))
poolHashUniv = V era (Set (KeyHash 'StakePool))
-> Term era (Set (KeyHash 'StakePool))
forall era t. V era t -> Term era t
Var (V era (Set (KeyHash 'StakePool))
 -> Term era (Set (KeyHash 'StakePool)))
-> V era (Set (KeyHash 'StakePool))
-> Term era (Set (KeyHash 'StakePool))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set (KeyHash 'StakePool))
-> Access era Any (Set (KeyHash 'StakePool))
-> V era (Set (KeyHash 'StakePool))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"poolHashUniv" (Rep era (KeyHash 'StakePool) -> Rep era (Set (KeyHash 'StakePool))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR) Access era Any (Set (KeyHash 'StakePool))
forall era s t. Access era s t
No

-- | The universe of StakePool key hashes. These hashes hash are hashes of the Owners of a PoolParam
stakeHashUniv :: Era era => Term era (Set (KeyHash 'Staking))
stakeHashUniv :: forall era. Era era => Term era (Set (KeyHash 'Staking))
stakeHashUniv = V era (Set (KeyHash 'Staking)) -> Term era (Set (KeyHash 'Staking))
forall era t. V era t -> Term era t
Var (V era (Set (KeyHash 'Staking))
 -> Term era (Set (KeyHash 'Staking)))
-> V era (Set (KeyHash 'Staking))
-> Term era (Set (KeyHash 'Staking))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set (KeyHash 'Staking))
-> Access era Any (Set (KeyHash 'Staking))
-> V era (Set (KeyHash 'Staking))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"stakeHashUniv" (Rep era (KeyHash 'Staking) -> Rep era (Set (KeyHash 'Staking))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era (KeyHash 'Staking)
forall era. Era era => Rep era (KeyHash 'Staking)
StakeHashR) Access era Any (Set (KeyHash 'Staking))
forall era s t. Access era s t
No

-- | The universe of DRep key hashes. These hashes hash are hashes of the DReps
drepHashUniv :: Era era => Term era (Set (KeyHash 'DRepRole))
drepHashUniv :: forall era. Era era => Term era (Set (KeyHash 'DRepRole))
drepHashUniv = V era (Set (KeyHash 'DRepRole))
-> Term era (Set (KeyHash 'DRepRole))
forall era t. V era t -> Term era t
Var (V era (Set (KeyHash 'DRepRole))
 -> Term era (Set (KeyHash 'DRepRole)))
-> V era (Set (KeyHash 'DRepRole))
-> Term era (Set (KeyHash 'DRepRole))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set (KeyHash 'DRepRole))
-> Access era Any (Set (KeyHash 'DRepRole))
-> V era (Set (KeyHash 'DRepRole))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"drepHashUniv" (Rep era (KeyHash 'DRepRole) -> Rep era (Set (KeyHash 'DRepRole))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era (KeyHash 'DRepRole)
forall era. Era era => Rep era (KeyHash 'DRepRole)
DRepHashR) Access era Any (Set (KeyHash 'DRepRole))
forall era s t. Access era s t
No

-- | The universe of the Genesis key hashes and their signing and validating GenDelegPairs
genesisHashUniv ::
  Era era => Term era (Map (KeyHash 'Genesis) GenDelegPair)
genesisHashUniv :: forall era.
Era era =>
Term era (Map (KeyHash 'Genesis) GenDelegPair)
genesisHashUniv = V era (Map (KeyHash 'Genesis) GenDelegPair)
-> Term era (Map (KeyHash 'Genesis) GenDelegPair)
forall era t. V era t -> Term era t
Var (V era (Map (KeyHash 'Genesis) GenDelegPair)
 -> Term era (Map (KeyHash 'Genesis) GenDelegPair))
-> V era (Map (KeyHash 'Genesis) GenDelegPair)
-> Term era (Map (KeyHash 'Genesis) GenDelegPair)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (KeyHash 'Genesis) GenDelegPair)
-> Access era Any (Map (KeyHash 'Genesis) GenDelegPair)
-> V era (Map (KeyHash 'Genesis) GenDelegPair)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"genesisHashUniv" (Rep era (KeyHash 'Genesis)
-> Rep era GenDelegPair
-> Rep era (Map (KeyHash 'Genesis) GenDelegPair)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'Genesis)
forall era. Era era => Rep era (KeyHash 'Genesis)
GenHashR Rep era GenDelegPair
forall era. Era era => Rep era GenDelegPair
GenDelegPairR) Access era Any (Map (KeyHash 'Genesis) GenDelegPair)
forall era s t. Access era s t
No

voteCredUniv :: Era era => Term era (Set (Credential 'ColdCommitteeRole))
voteCredUniv :: forall era.
Era era =>
Term era (Set (Credential 'ColdCommitteeRole))
voteCredUniv = V era (Set (Credential 'ColdCommitteeRole))
-> Term era (Set (Credential 'ColdCommitteeRole))
forall era t. V era t -> Term era t
Var (V era (Set (Credential 'ColdCommitteeRole))
 -> Term era (Set (Credential 'ColdCommitteeRole)))
-> V era (Set (Credential 'ColdCommitteeRole))
-> Term era (Set (Credential 'ColdCommitteeRole))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set (Credential 'ColdCommitteeRole))
-> Access era Any (Set (Credential 'ColdCommitteeRole))
-> V era (Set (Credential 'ColdCommitteeRole))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"voteHashUniv" (Rep era (Credential 'ColdCommitteeRole)
-> Rep era (Set (Credential 'ColdCommitteeRole))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era (Credential 'ColdCommitteeRole)
forall era. Era era => Rep era (Credential 'ColdCommitteeRole)
CommColdCredR) Access era Any (Set (Credential 'ColdCommitteeRole))
forall era s t. Access era s t
No

-- | The universe of TxIns. Pairs of TxId: hashes of previously run transaction bodies,
--   and TxIx: indexes of one of the bodies outputs.
txinUniv :: Era era => Term era (Set TxIn)
txinUniv :: forall era. Era era => Term era (Set TxIn)
txinUniv = V era (Set TxIn) -> Term era (Set TxIn)
forall era t. V era t -> Term era t
Var (V era (Set TxIn) -> Term era (Set TxIn))
-> V era (Set TxIn) -> Term era (Set TxIn)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set TxIn)
-> Access era Any (Set TxIn)
-> V era (Set TxIn)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"txinUniv" (Rep era TxIn -> Rep era (Set TxIn)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era TxIn
forall era. Era era => Rep era TxIn
TxInR) Access era Any (Set TxIn)
forall era s t. Access era s t
No

-- | The universe of GovActionId. Pairs of TxId: hashes of previously run transaction bodies,
--   and GovActionIx: indexes of one of the bodies Proposals .
govActionIdUniv :: Era era => Term era (Set GovActionId)
govActionIdUniv :: forall era. Era era => Term era (Set GovActionId)
govActionIdUniv = V era (Set GovActionId) -> Term era (Set GovActionId)
forall era t. V era t -> Term era t
Var (V era (Set GovActionId) -> Term era (Set GovActionId))
-> V era (Set GovActionId) -> Term era (Set GovActionId)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set GovActionId)
-> Access era Any (Set GovActionId)
-> V era (Set GovActionId)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"govActionIdUniv" (Rep era GovActionId -> Rep era (Set GovActionId)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era GovActionId
forall era. Era era => Rep era GovActionId
GovActionIdR) Access era Any (Set GovActionId)
forall era s t. Access era s t
No

-- | The universe of TxOuts.
--   It contains 'colTxoutUniv' as a sublist and 'feeOutput' as an element
--   See also 'feeOutput' which is defined by the universes, and is related.
txoutUniv :: Era era => Proof era -> Term era (Set (TxOutF era))
txoutUniv :: forall era. Era era => Proof era -> Term era (Set (TxOutF era))
txoutUniv Proof era
p = V era (Set (TxOutF era)) -> Term era (Set (TxOutF era))
forall era t. V era t -> Term era t
Var (Proof era
-> String
-> Rep era (Set (TxOutF era))
-> Access era Any (Set (TxOutF era))
-> V era (Set (TxOutF era))
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV Proof era
p String
"txoutUniv" (Rep era (TxOutF era) -> Rep era (Set (TxOutF era))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR (Proof era -> Rep era (TxOutF era)
forall era. Era era => Proof era -> Rep era (TxOutF era)
TxOutR Proof era
p)) Access era Any (Set (TxOutF era))
forall era s t. Access era s t
No)

-- | The universe of TxOuts useable for collateral
--   The collateral TxOuts consists only of VKey addresses
--   and The collateral TxOuts do not contain any non-ADA part
colTxoutUniv :: Era era => Proof era -> Term era (Set (TxOutF era))
colTxoutUniv :: forall era. Era era => Proof era -> Term era (Set (TxOutF era))
colTxoutUniv Proof era
p = V era (Set (TxOutF era)) -> Term era (Set (TxOutF era))
forall era t. V era t -> Term era t
Var (Proof era
-> String
-> Rep era (Set (TxOutF era))
-> Access era Any (Set (TxOutF era))
-> V era (Set (TxOutF era))
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV Proof era
p String
"colTxoutUniv" (Rep era (TxOutF era) -> Rep era (Set (TxOutF era))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR (Proof era -> Rep era (TxOutF era)
forall era. Era era => Proof era -> Rep era (TxOutF era)
TxOutR Proof era
p)) Access era Any (Set (TxOutF era))
forall era s t. Access era s t
No)

-- | A TxOut, guaranteed to have
--   1) no scripts in its Addr, and
--   2) It's Addr is in the addrUniv
--   3) 'bigCoin' is stored in the Addr Value, and
--   4) the Addr Value has empty MutiAssets
--   5) be a member of the txoutUniv
feeTxOut :: Reflect era => Term era (TxOutF era)
feeTxOut :: forall era. Reflect era => Term era (TxOutF era)
feeTxOut = V era (TxOutF era) -> Term era (TxOutF era)
forall era t. V era t -> Term era t
Var (String
-> Rep era (TxOutF era)
-> Access era Any (TxOutF era)
-> V era (TxOutF era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"feeTxOut" (Proof era -> Rep era (TxOutF era)
forall era. Era era => Proof era -> Rep era (TxOutF era)
TxOutR Proof era
forall era. Reflect era => Proof era
reify) Access era Any (TxOutF era)
forall era s t. Access era s t
No)

-- | A TxIn, guaranteed to have
--  1) be a member of the txinUniv
feeTxIn :: Era era => Term era TxIn
feeTxIn :: forall era. Era era => Term era TxIn
feeTxIn = V era TxIn -> Term era TxIn
forall era t. V era t -> Term era t
Var (String -> Rep era TxIn -> Access era Any TxIn -> V era TxIn
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"feeTxIn" Rep era TxIn
forall era. Era era => Rep era TxIn
TxInR Access era Any TxIn
forall era s t. Access era s t
No)

-- | A Coin large enough to pay almost any fee.
--   See also 'feeOutput' which is related.
bigCoin :: Era era => Term era Coin
bigCoin :: forall era. Era era => Term era Coin
bigCoin = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"bigCoin" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No)

datumsUniv :: Era era => Term era [Datum era]
datumsUniv :: forall era. Era era => Term era [Datum era]
datumsUniv = V era [Datum era] -> Term era [Datum era]
forall era t. V era t -> Term era t
Var (String
-> Rep era [Datum era]
-> Access era Any [Datum era]
-> V era [Datum era]
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"datumsUniv" (Rep era (Datum era) -> Rep era [Datum era]
forall era a. Rep era a -> Rep era [a]
ListR Rep era (Datum era)
forall era. Era era => Rep era (Datum era)
DatumR) Access era Any [Datum era]
forall era s t. Access era s t
No)

multiAssetUniv :: Era era => Term era [MultiAsset]
multiAssetUniv :: forall era. Era era => Term era [MultiAsset]
multiAssetUniv = V era [MultiAsset] -> Term era [MultiAsset]
forall era t. V era t -> Term era t
Var (String
-> Rep era [MultiAsset]
-> Access era Any [MultiAsset]
-> V era [MultiAsset]
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"multiAssetUniv" (Rep era MultiAsset -> Rep era [MultiAsset]
forall era a. Rep era a -> Rep era [a]
ListR Rep era MultiAsset
forall era. Era era => Rep era MultiAsset
MultiAssetR) Access era Any [MultiAsset]
forall era s t. Access era s t
No)

-- | The universe of key hashes, and the signing and validating key pairs they represent.
keymapUniv ::
  Era era => Term era (Map (KeyHash 'Witness) (KeyPair 'Witness))
keymapUniv :: forall era.
Era era =>
Term era (Map (KeyHash 'Witness) (KeyPair 'Witness))
keymapUniv = V era (Map (KeyHash 'Witness) (KeyPair 'Witness))
-> Term era (Map (KeyHash 'Witness) (KeyPair 'Witness))
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (KeyHash 'Witness) (KeyPair 'Witness))
-> Access era Any (Map (KeyHash 'Witness) (KeyPair 'Witness))
-> V era (Map (KeyHash 'Witness) (KeyPair 'Witness))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"keymapUniv" (Rep era (KeyHash 'Witness)
-> Rep era (KeyPair 'Witness)
-> Rep era (Map (KeyHash 'Witness) (KeyPair 'Witness))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'Witness)
forall era. Era era => Rep era (KeyHash 'Witness)
WitHashR Rep era (KeyPair 'Witness)
forall era. Era era => Rep era (KeyPair 'Witness)
KeyPairR) Access era Any (Map (KeyHash 'Witness) (KeyPair 'Witness))
forall era s t. Access era s t
No)

currentSlot :: Era era => Term era SlotNo
currentSlot :: forall era. Era era => Term era SlotNo
currentSlot = V era SlotNo -> Term era SlotNo
forall era t. V era t -> Term era t
Var (String -> Rep era SlotNo -> Access era Any SlotNo -> V era SlotNo
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"currentSlot" Rep era SlotNo
forall era. Rep era SlotNo
SlotNoR Access era Any SlotNo
forall era s t. Access era s t
No)

endSlotDelta :: Era era => Term era SlotNo
endSlotDelta :: forall era. Era era => Term era SlotNo
endSlotDelta = V era SlotNo -> Term era SlotNo
forall era t. V era t -> Term era t
Var (String -> Rep era SlotNo -> Access era Any SlotNo -> V era SlotNo
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"endSlotDelta" Rep era SlotNo
forall era. Rep era SlotNo
SlotNoR Access era Any SlotNo
forall era s t. Access era s t
No)

beginSlotDelta :: Era era => Term era SlotNo
beginSlotDelta :: forall era. Era era => Term era SlotNo
beginSlotDelta = V era SlotNo -> Term era SlotNo
forall era t. V era t -> Term era t
Var (String -> Rep era SlotNo -> Access era Any SlotNo -> V era SlotNo
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"beginSlotDelta" Rep era SlotNo
forall era. Rep era SlotNo
SlotNoR Access era Any SlotNo
forall era s t. Access era s t
No)

-- See also currentEpoch in NewEpochState fields

-- | From Globals
network :: Era era => Term era Network
network :: forall era. Era era => Term era Network
network = V era Network -> Term era Network
forall era t. V era t -> Term era t
Var (String
-> Rep era Network -> Access era Any Network -> V era Network
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"network" Rep era Network
forall era. Rep era Network
NetworkR Access era Any Network
forall era s t. Access era s t
No)

-- | This not really a variable, But a constant that is set by the 'testGlobals'
--   we reflect this into a Term, so we can refer to it in the Preds.
quorumConstant :: Word64
quorumConstant :: Word64
quorumConstant = Globals -> Word64
Base.quorum Globals
Utils.testGlobals

-- | From Globals. Reflected here at type Int, This is set to 'quorumConstant' in CertState.
--   because is is used to compare the Size of things, which are computed as Int
quorum :: Era era => Term era Int
quorum :: forall era. Era era => Term era Int
quorum = V era Int -> Term era Int
forall era t. V era t -> Term era t
Var (String -> Rep era Int -> Access era Any Int -> V era Int
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"quorum" Rep era Int
forall era. Rep era Int
IntR Access era Any Int
forall era s t. Access era s t
No)

addrUniv :: Era era => Term era (Set Addr)
addrUniv :: forall era. Era era => Term era (Set Addr)
addrUniv = V era (Set Addr) -> Term era (Set Addr)
forall era t. V era t -> Term era t
Var (V era (Set Addr) -> Term era (Set Addr))
-> V era (Set Addr) -> Term era (Set Addr)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set Addr)
-> Access era Any (Set Addr)
-> V era (Set Addr)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"addrUniv" (Rep era Addr -> Rep era (Set Addr)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era Addr
forall era. Era era => Rep era Addr
AddrR) Access era Any (Set Addr)
forall era s t. Access era s t
No

ptrUniv :: Era era => Term era (Set Ptr)
ptrUniv :: forall era. Era era => Term era (Set Ptr)
ptrUniv = V era (Set Ptr) -> Term era (Set Ptr)
forall era t. V era t -> Term era t
Var (V era (Set Ptr) -> Term era (Set Ptr))
-> V era (Set Ptr) -> Term era (Set Ptr)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set Ptr) -> Access era Any (Set Ptr) -> V era (Set Ptr)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"ptrUniv" (Rep era Ptr -> Rep era (Set Ptr)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era Ptr
forall era. Rep era Ptr
PtrR) Access era Any (Set Ptr)
forall era s t. Access era s t
No

plutusUniv :: Reflect era => Term era (Map ScriptHash (IsValid, ScriptF era))
plutusUniv :: forall era.
Reflect era =>
Term era (Map ScriptHash (IsValid, ScriptF era))
plutusUniv = V era (Map ScriptHash (IsValid, ScriptF era))
-> Term era (Map ScriptHash (IsValid, ScriptF era))
forall era t. V era t -> Term era t
Var (V era (Map ScriptHash (IsValid, ScriptF era))
 -> Term era (Map ScriptHash (IsValid, ScriptF era)))
-> V era (Map ScriptHash (IsValid, ScriptF era))
-> Term era (Map ScriptHash (IsValid, ScriptF era))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map ScriptHash (IsValid, ScriptF era))
-> Access era Any (Map ScriptHash (IsValid, ScriptF era))
-> V era (Map ScriptHash (IsValid, ScriptF era))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"plutusUniv" (Rep era ScriptHash
-> Rep era (IsValid, ScriptF era)
-> Rep era (Map ScriptHash (IsValid, ScriptF era))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era ScriptHash
forall era. Era era => Rep era ScriptHash
ScriptHashR (Rep era IsValid
-> Rep era (ScriptF era) -> Rep era (IsValid, ScriptF era)
forall era a b. Rep era a -> Rep era b -> Rep era (a, b)
PairR Rep era IsValid
forall era. Rep era IsValid
IsValidR (Proof era -> Rep era (ScriptF era)
forall era. Era era => Proof era -> Rep era (ScriptF era)
ScriptR Proof era
forall era. Reflect era => Proof era
reify))) Access era Any (Map ScriptHash (IsValid, ScriptF era))
forall era s t. Access era s t
No

spendPlutusUniv :: Reflect era => Term era (Map ScriptHash (IsValid, ScriptF era))
spendPlutusUniv :: forall era.
Reflect era =>
Term era (Map ScriptHash (IsValid, ScriptF era))
spendPlutusUniv = V era (Map ScriptHash (IsValid, ScriptF era))
-> Term era (Map ScriptHash (IsValid, ScriptF era))
forall era t. V era t -> Term era t
Var (V era (Map ScriptHash (IsValid, ScriptF era))
 -> Term era (Map ScriptHash (IsValid, ScriptF era)))
-> V era (Map ScriptHash (IsValid, ScriptF era))
-> Term era (Map ScriptHash (IsValid, ScriptF era))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map ScriptHash (IsValid, ScriptF era))
-> Access era Any (Map ScriptHash (IsValid, ScriptF era))
-> V era (Map ScriptHash (IsValid, ScriptF era))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"spendPlutusUniv" (Rep era ScriptHash
-> Rep era (IsValid, ScriptF era)
-> Rep era (Map ScriptHash (IsValid, ScriptF era))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era ScriptHash
forall era. Era era => Rep era ScriptHash
ScriptHashR (Rep era IsValid
-> Rep era (ScriptF era) -> Rep era (IsValid, ScriptF era)
forall era a b. Rep era a -> Rep era b -> Rep era (a, b)
PairR Rep era IsValid
forall era. Rep era IsValid
IsValidR (Proof era -> Rep era (ScriptF era)
forall era. Era era => Proof era -> Rep era (ScriptF era)
ScriptR Proof era
forall era. Reflect era => Proof era
reify))) Access era Any (Map ScriptHash (IsValid, ScriptF era))
forall era s t. Access era s t
No

-- | The universe of all Byron addresses. In Eras, Babbage, Conway we avoid these Adresses,
--   as they do not play well with Plutus Scripts.
byronAddrUniv ::
  Era era => Term era (Map (KeyHash 'Payment) (Addr, SigningKey))
byronAddrUniv :: forall era.
Era era =>
Term era (Map (KeyHash 'Payment) (Addr, SigningKey))
byronAddrUniv = V era (Map (KeyHash 'Payment) (Addr, SigningKey))
-> Term era (Map (KeyHash 'Payment) (Addr, SigningKey))
forall era t. V era t -> Term era t
Var (V era (Map (KeyHash 'Payment) (Addr, SigningKey))
 -> Term era (Map (KeyHash 'Payment) (Addr, SigningKey)))
-> V era (Map (KeyHash 'Payment) (Addr, SigningKey))
-> Term era (Map (KeyHash 'Payment) (Addr, SigningKey))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (KeyHash 'Payment) (Addr, SigningKey))
-> Access era Any (Map (KeyHash 'Payment) (Addr, SigningKey))
-> V era (Map (KeyHash 'Payment) (Addr, SigningKey))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"byronAddrUniv" (Rep era (KeyHash 'Payment)
-> Rep era (Addr, SigningKey)
-> Rep era (Map (KeyHash 'Payment) (Addr, SigningKey))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'Payment)
forall era. Era era => Rep era (KeyHash 'Payment)
PayHashR (Rep era Addr -> Rep era SigningKey -> Rep era (Addr, SigningKey)
forall era a b. Rep era a -> Rep era b -> Rep era (a, b)
PairR Rep era Addr
forall era. Era era => Rep era Addr
AddrR Rep era SigningKey
forall era. Rep era SigningKey
SigningKeyR)) Access era Any (Map (KeyHash 'Payment) (Addr, SigningKey))
forall era s t. Access era s t
No

-- ====================================================================
-- Targets for sub types of NewEpochState
-- A Target assembles variables into data stuctures. The main concern
-- is transforming the types used in the variable model into the real types
-- stored in the data structures. 4 examples of such transformation
-- 1) Wrapping and unwraping newtypes like StakeDistr
-- 2) Transforming Coin into (CompactForm Coin) a Word64
-- 3) Transforming Data.Map into Data.VMap
-- 4) Transforming the Models view of Data Families (TxOut, Value, PParams, PParamsUpdate) into
--    the data structures view.
--
-- The strategy we use is to define a "constructor function" which accepts the model types,
-- and which converts the model types into the data structure types. We then wrap this
-- "constructor function" in the "Constr" of Target. See 'newEpochStateConstr',
-- 'utxofun' and 'dstate' for examples of how this is done.

-- | Abstract constuctor function for NewEpochState
newEpochStateConstr ::
  Proof era ->
  EpochNo ->
  Map (KeyHash 'StakePool) Natural ->
  Map (KeyHash 'StakePool) Natural ->
  EpochState era ->
  Map (KeyHash 'StakePool) IndividualPoolStake ->
  NewEpochState era
newEpochStateConstr :: forall era.
Proof era
-> EpochNo
-> Map (KeyHash 'StakePool) Natural
-> Map (KeyHash 'StakePool) Natural
-> EpochState era
-> Map (KeyHash 'StakePool) IndividualPoolStake
-> NewEpochState era
newEpochStateConstr
  Proof era
proof
  EpochNo
nesEL'
  Map (KeyHash 'StakePool) Natural
nesBprev'
  Map (KeyHash 'StakePool) Natural
nesBcur'
  EpochState era
nesEs'
  Map (KeyHash 'StakePool) IndividualPoolStake
nesPd' =
    EpochNo
-> BlocksMade
-> BlocksMade
-> EpochState era
-> StrictMaybe PulsingRewUpdate
-> PoolDistr
-> StashedAVVMAddresses era
-> NewEpochState era
forall era.
EpochNo
-> BlocksMade
-> BlocksMade
-> EpochState era
-> StrictMaybe PulsingRewUpdate
-> PoolDistr
-> StashedAVVMAddresses era
-> NewEpochState era
NewEpochState
      EpochNo
nesEL'
      (Map (KeyHash 'StakePool) Natural -> BlocksMade
BlocksMade Map (KeyHash 'StakePool) Natural
nesBprev')
      (Map (KeyHash 'StakePool) Natural -> BlocksMade
BlocksMade Map (KeyHash 'StakePool) Natural
nesBcur')
      EpochState era
nesEs'
      StrictMaybe PulsingRewUpdate
forall a. StrictMaybe a
SNothing
      (Map (KeyHash 'StakePool) IndividualPoolStake
-> CompactForm Coin -> PoolDistr
PoolDistr Map (KeyHash 'StakePool) IndividualPoolStake
nesPd' (CompactForm Coin -> PoolDistr) -> CompactForm Coin -> PoolDistr
forall a b. (a -> b) -> a -> b
$ Word64 -> CompactForm Coin
CompactCoin Word64
1)
      ( case Proof era
proof of
          Proof era
Shelley -> Map TxIn (TxOut ShelleyEra) -> UTxO ShelleyEra
forall era. Map TxIn (TxOut era) -> UTxO era
UTxO Map TxIn (TxOut ShelleyEra)
Map TxIn (ShelleyTxOut ShelleyEra)
forall k a. Map k a
Map.empty
          Proof era
Allegra -> ()
          Proof era
Mary -> ()
          Proof era
Alonzo -> ()
          Proof era
Babbage -> ()
          Proof era
Conway -> ()
      )

-- | Target for NewEpochState
newEpochStateT ::
  forall era. Reflect era => Proof era -> RootTarget era (NewEpochState era) (NewEpochState era)
newEpochStateT :: forall era.
Reflect era =>
Proof era -> RootTarget era (NewEpochState era) (NewEpochState era)
newEpochStateT Proof era
proof =
  String
-> TypeRep (NewEpochState era)
-> (EpochNo
    -> Map (KeyHash 'StakePool) Natural
    -> Map (KeyHash 'StakePool) Natural
    -> EpochState era
    -> Map (KeyHash 'StakePool) IndividualPoolStake
    -> NewEpochState era)
-> RootTarget
     era
     (NewEpochState era)
     (EpochNo
      -> Map (KeyHash 'StakePool) Natural
      -> Map (KeyHash 'StakePool) Natural
      -> EpochState era
      -> Map (KeyHash 'StakePool) IndividualPoolStake
      -> NewEpochState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"NewEpochState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(NewEpochState era)) (Proof era
-> EpochNo
-> Map (KeyHash 'StakePool) Natural
-> Map (KeyHash 'StakePool) Natural
-> EpochState era
-> Map (KeyHash 'StakePool) IndividualPoolStake
-> NewEpochState era
forall era.
Proof era
-> EpochNo
-> Map (KeyHash 'StakePool) Natural
-> Map (KeyHash 'StakePool) Natural
-> EpochState era
-> Map (KeyHash 'StakePool) IndividualPoolStake
-> NewEpochState era
newEpochStateConstr Proof era
proof)
    RootTarget
  era
  (NewEpochState era)
  (EpochNo
   -> Map (KeyHash 'StakePool) Natural
   -> Map (KeyHash 'StakePool) Natural
   -> EpochState era
   -> Map (KeyHash 'StakePool) IndividualPoolStake
   -> NewEpochState era)
-> RootTarget era (NewEpochState era) EpochNo
-> RootTarget
     era
     (NewEpochState era)
     (Map (KeyHash 'StakePool) Natural
      -> Map (KeyHash 'StakePool) Natural
      -> EpochState era
      -> Map (KeyHash 'StakePool) IndividualPoolStake
      -> NewEpochState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era EpochNo
-> SimpleGetter (NewEpochState era) EpochNo
-> RootTarget era (NewEpochState era) EpochNo
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era EpochNo
forall era. Era era => Term era EpochNo
currentEpoch (EpochNo -> Const r EpochNo)
-> NewEpochState era -> Const r (NewEpochState era)
SimpleGetter (NewEpochState era) EpochNo
forall era (f :: * -> *).
Functor f =>
(EpochNo -> f EpochNo)
-> NewEpochState era -> f (NewEpochState era)
nesELL
    RootTarget
  era
  (NewEpochState era)
  (Map (KeyHash 'StakePool) Natural
   -> Map (KeyHash 'StakePool) Natural
   -> EpochState era
   -> Map (KeyHash 'StakePool) IndividualPoolStake
   -> NewEpochState era)
-> RootTarget
     era (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
-> RootTarget
     era
     (NewEpochState era)
     (Map (KeyHash 'StakePool) Natural
      -> EpochState era
      -> Map (KeyHash 'StakePool) IndividualPoolStake
      -> NewEpochState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) Natural)
-> SimpleGetter
     (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
-> RootTarget
     era (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (KeyHash 'StakePool) Natural)
forall era. Era era => Term era (Map (KeyHash 'StakePool) Natural)
prevBlocksMade (Map (KeyHash 'StakePool) Natural
 -> Const r (Map (KeyHash 'StakePool) Natural))
-> NewEpochState era -> Const r (NewEpochState era)
SimpleGetter (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) Natural
 -> f (Map (KeyHash 'StakePool) Natural))
-> NewEpochState era -> f (NewEpochState era)
nesBprevL
    RootTarget
  era
  (NewEpochState era)
  (Map (KeyHash 'StakePool) Natural
   -> EpochState era
   -> Map (KeyHash 'StakePool) IndividualPoolStake
   -> NewEpochState era)
-> RootTarget
     era (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
-> RootTarget
     era
     (NewEpochState era)
     (EpochState era
      -> Map (KeyHash 'StakePool) IndividualPoolStake
      -> NewEpochState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) Natural)
-> SimpleGetter
     (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
-> RootTarget
     era (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (KeyHash 'StakePool) Natural)
forall era. Era era => Term era (Map (KeyHash 'StakePool) Natural)
currBlocksMade (Map (KeyHash 'StakePool) Natural
 -> Const r (Map (KeyHash 'StakePool) Natural))
-> NewEpochState era -> Const r (NewEpochState era)
SimpleGetter (NewEpochState era) (Map (KeyHash 'StakePool) Natural)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) Natural
 -> f (Map (KeyHash 'StakePool) Natural))
-> NewEpochState era -> f (NewEpochState era)
nesBcurL
    RootTarget
  era
  (NewEpochState era)
  (EpochState era
   -> Map (KeyHash 'StakePool) IndividualPoolStake
   -> NewEpochState era)
-> RootTarget era (NewEpochState era) (EpochState era)
-> RootTarget
     era
     (NewEpochState era)
     (Map (KeyHash 'StakePool) IndividualPoolStake -> NewEpochState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (EpochState era) (EpochState era)
-> Lens' (NewEpochState era) (EpochState era)
-> RootTarget era (NewEpochState era) (EpochState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift (Proof era -> RootTarget era (EpochState era) (EpochState era)
forall era.
Reflect era =>
Proof era -> RootTarget era (EpochState era) (EpochState era)
epochStateT Proof era
proof) (EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
Lens' (NewEpochState era) (EpochState era)
nesEsL
    RootTarget
  era
  (NewEpochState era)
  (Map (KeyHash 'StakePool) IndividualPoolStake -> NewEpochState era)
-> RootTarget
     era
     (NewEpochState era)
     (Map (KeyHash 'StakePool) IndividualPoolStake)
-> RootTarget era (NewEpochState era) (NewEpochState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
-> SimpleGetter
     (NewEpochState era) (Map (KeyHash 'StakePool) IndividualPoolStake)
-> RootTarget
     era
     (NewEpochState era)
     (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
poolDistr ((PoolDistr -> Const r PoolDistr)
-> NewEpochState era -> Const r (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(PoolDistr -> f PoolDistr)
-> NewEpochState era -> f (NewEpochState era)
nesPdL ((PoolDistr -> Const r PoolDistr)
 -> NewEpochState era -> Const r (NewEpochState era))
-> ((Map (KeyHash 'StakePool) IndividualPoolStake
     -> Const r (Map (KeyHash 'StakePool) IndividualPoolStake))
    -> PoolDistr -> Const r PoolDistr)
-> (Map (KeyHash 'StakePool) IndividualPoolStake
    -> Const r (Map (KeyHash 'StakePool) IndividualPoolStake))
-> NewEpochState era
-> Const r (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) IndividualPoolStake
 -> Const r (Map (KeyHash 'StakePool) IndividualPoolStake))
-> PoolDistr -> Const r PoolDistr
Lens' PoolDistr (Map (KeyHash 'StakePool) IndividualPoolStake)
poolDistrDistrL)

-- | Target for EpochState
epochStateT ::
  forall era. Reflect era => Proof era -> RootTarget era (EpochState era) (EpochState era)
epochStateT :: forall era.
Reflect era =>
Proof era -> RootTarget era (EpochState era) (EpochState era)
epochStateT Proof era
proof =
  String
-> TypeRep (EpochState era)
-> (ChainAccountState
    -> LedgerState era -> SnapShots -> EpochState era)
-> RootTarget
     era
     (EpochState era)
     (ChainAccountState
      -> LedgerState era -> SnapShots -> EpochState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"EpochState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(EpochState era)) ChainAccountState -> LedgerState era -> SnapShots -> EpochState era
forall {era}.
ChainAccountState -> LedgerState era -> SnapShots -> EpochState era
epochStateFun
    RootTarget
  era
  (EpochState era)
  (ChainAccountState
   -> LedgerState era -> SnapShots -> EpochState era)
-> RootTarget era (EpochState era) ChainAccountState
-> RootTarget
     era
     (EpochState era)
     (LedgerState era -> SnapShots -> EpochState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era ChainAccountState ChainAccountState
-> Lens' (EpochState era) ChainAccountState
-> RootTarget era (EpochState era) ChainAccountState
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era ChainAccountState ChainAccountState
forall era.
Era era =>
RootTarget era ChainAccountState ChainAccountState
accountStateT (ChainAccountState -> f ChainAccountState)
-> EpochState era -> f (EpochState era)
forall era. Lens' (EpochState era) ChainAccountState
Lens' (EpochState era) ChainAccountState
forall (t :: * -> *) era.
CanSetChainAccountState t =>
Lens' (t era) ChainAccountState
chainAccountStateL
    RootTarget
  era
  (EpochState era)
  (LedgerState era -> SnapShots -> EpochState era)
-> RootTarget era (EpochState era) (LedgerState era)
-> RootTarget era (EpochState era) (SnapShots -> EpochState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (LedgerState era) (LedgerState era)
-> Lens' (EpochState era) (LedgerState era)
-> RootTarget era (EpochState era) (LedgerState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift (Proof era -> RootTarget era (LedgerState era) (LedgerState era)
forall era.
Reflect era =>
Proof era -> RootTarget era (LedgerState era) (LedgerState era)
ledgerStateT Proof era
proof) (LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
Lens' (EpochState era) (LedgerState era)
esLStateL
    RootTarget era (EpochState era) (SnapShots -> EpochState era)
-> RootTarget era (EpochState era) SnapShots
-> RootTarget era (EpochState era) (EpochState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era SnapShots SnapShots
-> Lens' (EpochState era) SnapShots
-> RootTarget era (EpochState era) SnapShots
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era SnapShots SnapShots
forall era. Era era => RootTarget era SnapShots SnapShots
snapShotsT (SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
forall era (f :: * -> *).
Functor f =>
(SnapShots -> f SnapShots) -> EpochState era -> f (EpochState era)
Lens' (EpochState era) SnapShots
esSnapshotsL
  where
    epochStateFun :: ChainAccountState -> LedgerState era -> SnapShots -> EpochState era
epochStateFun ChainAccountState
a LedgerState era
s SnapShots
l = ChainAccountState
-> LedgerState era -> SnapShots -> NonMyopic -> EpochState era
forall era.
ChainAccountState
-> LedgerState era -> SnapShots -> NonMyopic -> EpochState era
EpochState ChainAccountState
a LedgerState era
s SnapShots
l (Map (KeyHash 'StakePool) Likelihood -> Coin -> NonMyopic
NonMyopic Map (KeyHash 'StakePool) Likelihood
forall k a. Map k a
Map.empty (Integer -> Coin
Coin Integer
0))

-- | Target for ChainAccountState
accountStateT :: Era era => RootTarget era ChainAccountState ChainAccountState
accountStateT :: forall era.
Era era =>
RootTarget era ChainAccountState ChainAccountState
accountStateT =
  String
-> TypeRep ChainAccountState
-> (Coin -> Coin -> ChainAccountState)
-> RootTarget
     era ChainAccountState (Coin -> Coin -> ChainAccountState)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"ChainAccountState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @ChainAccountState) Coin -> Coin -> ChainAccountState
ChainAccountState
    RootTarget
  era ChainAccountState (Coin -> Coin -> ChainAccountState)
-> RootTarget era ChainAccountState Coin
-> RootTarget era ChainAccountState (Coin -> ChainAccountState)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era Coin
-> SimpleGetter ChainAccountState Coin
-> RootTarget era ChainAccountState Coin
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era Coin
forall era. Era era => Term era Coin
treasury (Coin -> Const r Coin)
-> ChainAccountState -> Const r ChainAccountState
SimpleGetter ChainAccountState Coin
Lens' ChainAccountState Coin
casTreasuryL
    RootTarget era ChainAccountState (Coin -> ChainAccountState)
-> RootTarget era ChainAccountState Coin
-> RootTarget era ChainAccountState ChainAccountState
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era Coin
-> SimpleGetter ChainAccountState Coin
-> RootTarget era ChainAccountState Coin
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era Coin
forall era. Era era => Term era Coin
reserves (Coin -> Const r Coin)
-> ChainAccountState -> Const r ChainAccountState
SimpleGetter ChainAccountState Coin
Lens' ChainAccountState Coin
casReservesL

-- | Target for LedgerState
ledgerStateT ::
  forall era. Reflect era => Proof era -> RootTarget era (LedgerState era) (LedgerState era)
ledgerStateT :: forall era.
Reflect era =>
Proof era -> RootTarget era (LedgerState era) (LedgerState era)
ledgerStateT Proof era
proof =
  String
-> TypeRep (LedgerState era)
-> (UTxOState era -> CertStateF era -> LedgerState era)
-> RootTarget
     era
     (LedgerState era)
     (UTxOState era -> CertStateF era -> LedgerState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"LedgerState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(LedgerState era)) UTxOState era -> CertStateF era -> LedgerState era
ledgerStateFun
    RootTarget
  era
  (LedgerState era)
  (UTxOState era -> CertStateF era -> LedgerState era)
-> RootTarget era (LedgerState era) (UTxOState era)
-> RootTarget
     era (LedgerState era) (CertStateF era -> LedgerState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (UTxOState era) (UTxOState era)
-> Lens' (LedgerState era) (UTxOState era)
-> RootTarget era (LedgerState era) (UTxOState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift (Proof era -> RootTarget era (UTxOState era) (UTxOState era)
forall era.
EraGov era =>
Proof era -> RootTarget era (UTxOState era) (UTxOState era)
utxoStateT Proof era
proof) (UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
Lens' (LedgerState era) (UTxOState era)
lsUTxOStateL
    RootTarget
  era (LedgerState era) (CertStateF era -> LedgerState era)
-> RootTarget era (LedgerState era) (CertStateF era)
-> RootTarget era (LedgerState era) (LedgerState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (CertStateF era) (CertStateF era)
-> Lens' (LedgerState era) (CertStateF era)
-> RootTarget era (LedgerState era) (CertStateF era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (CertStateF era) (CertStateF era)
forall era.
Reflect era =>
RootTarget era (CertStateF era) (CertStateF era)
certStateT ((CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL ((CertState era -> f (CertState era))
 -> LedgerState era -> f (LedgerState era))
-> ((CertStateF era -> f (CertStateF era))
    -> CertState era -> f (CertState era))
-> (CertStateF era -> f (CertStateF era))
-> LedgerState era
-> f (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertStateF era -> f (CertStateF era))
-> CertState era -> f (CertState era)
forall era. Reflect era => Lens' (CertState era) (CertStateF era)
Lens' (CertState era) (CertStateF era)
unCertStateFL)
  where
    ledgerStateFun ::
      UTxOState era ->
      CertStateF era ->
      LedgerState era
    ledgerStateFun :: UTxOState era -> CertStateF era -> LedgerState era
ledgerStateFun UTxOState era
utxoState (CertStateF Proof era
_ CertState era
x) = UTxOState era -> CertState era -> LedgerState era
forall era. UTxOState era -> CertState era -> LedgerState era
LedgerState UTxOState era
utxoState CertState era
x

ledgerState :: Reflect era => Term era (LedgerState era)
ledgerState :: forall era. Reflect era => Term era (LedgerState era)
ledgerState = V era (LedgerState era) -> Term era (LedgerState era)
forall era t. V era t -> Term era t
Var (V era (LedgerState era) -> Term era (LedgerState era))
-> V era (LedgerState era) -> Term era (LedgerState era)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (LedgerState era)
-> Access era Any (LedgerState era)
-> V era (LedgerState era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"ledgerState" (Proof era -> Rep era (LedgerState era)
forall era. Era era => Proof era -> Rep era (LedgerState era)
LedgerStateR Proof era
forall era. Reflect era => Proof era
reify) Access era Any (LedgerState era)
forall era s t. Access era s t
No

-- | Target for UTxOState
utxoStateT ::
  forall era. Gov.EraGov era => Proof era -> RootTarget era (UTxOState era) (UTxOState era)
utxoStateT :: forall era.
EraGov era =>
Proof era -> RootTarget era (UTxOState era) (UTxOState era)
utxoStateT Proof era
p =
  String
-> TypeRep (UTxOState era)
-> (Map TxIn (TxOutF era)
    -> Coin -> Coin -> GovState era -> Coin -> UTxOState era)
-> RootTarget
     era
     (UTxOState era)
     (Map TxIn (TxOutF era)
      -> Coin -> Coin -> GovState era -> Coin -> UTxOState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"UTxOState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(UTxOState era)) ((Reflect era =>
 Proof era
 -> Map TxIn (TxOutF era)
 -> Coin
 -> Coin
 -> GovState era
 -> Coin
 -> UTxOState era)
-> Proof era
-> Map TxIn (TxOutF era)
-> Coin
-> Coin
-> GovState era
-> Coin
-> UTxOState era
forall era a. (Reflect era => Proof era -> a) -> Proof era -> a
unReflect Reflect era =>
Proof era
-> Map TxIn (TxOutF era)
-> Coin
-> Coin
-> GovState era
-> Coin
-> UTxOState era
Proof era
-> Map TxIn (TxOutF era)
-> Coin
-> Coin
-> GovState era
-> Coin
-> UTxOState era
utxofun Proof era
p)
    RootTarget
  era
  (UTxOState era)
  (Map TxIn (TxOutF era)
   -> Coin -> Coin -> GovState era -> Coin -> UTxOState era)
-> RootTarget era (UTxOState era) (Map TxIn (TxOutF era))
-> RootTarget
     era
     (UTxOState era)
     (Coin -> Coin -> GovState era -> Coin -> UTxOState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map TxIn (TxOutF era))
-> SimpleGetter (UTxOState era) (Map TxIn (TxOutF era))
-> RootTarget era (UTxOState era) (Map TxIn (TxOutF era))
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Proof era -> Term era (Map TxIn (TxOutF era))
forall era.
Era era =>
Proof era -> Term era (Map TxIn (TxOutF era))
utxo Proof era
p) ((UTxO era -> Const r (UTxO era))
-> UTxOState era -> Const r (UTxOState era)
forall era. Lens' (UTxOState era) (UTxO era)
forall (t :: * -> *) era. CanSetUTxO t => Lens' (t era) (UTxO era)
utxoL ((UTxO era -> Const r (UTxO era))
 -> UTxOState era -> Const r (UTxOState era))
-> ((Map TxIn (TxOutF era) -> Const r (Map TxIn (TxOutF era)))
    -> UTxO era -> Const r (UTxO era))
-> (Map TxIn (TxOutF era) -> Const r (Map TxIn (TxOutF era)))
-> UTxOState era
-> Const r (UTxOState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proof era -> Lens' (UTxO era) (Map TxIn (TxOutF era))
forall era. Proof era -> Lens' (UTxO era) (Map TxIn (TxOutF era))
unUtxoL Proof era
p)
    RootTarget
  era
  (UTxOState era)
  (Coin -> Coin -> GovState era -> Coin -> UTxOState era)
-> RootTarget era (UTxOState era) Coin
-> RootTarget
     era (UTxOState era) (Coin -> GovState era -> Coin -> UTxOState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era Coin
-> SimpleGetter (UTxOState era) Coin
-> RootTarget era (UTxOState era) Coin
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era Coin
forall era. Era era => Term era Coin
deposits (Coin -> Const r Coin) -> UTxOState era -> Const r (UTxOState era)
SimpleGetter (UTxOState era) Coin
forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin) -> UTxOState era -> f (UTxOState era)
utxosDepositedL
    RootTarget
  era (UTxOState era) (Coin -> GovState era -> Coin -> UTxOState era)
-> RootTarget era (UTxOState era) Coin
-> RootTarget
     era (UTxOState era) (GovState era -> Coin -> UTxOState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era Coin
-> SimpleGetter (UTxOState era) Coin
-> RootTarget era (UTxOState era) Coin
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era Coin
forall era. Era era => Term era Coin
fees (Coin -> Const r Coin) -> UTxOState era -> Const r (UTxOState era)
SimpleGetter (UTxOState era) Coin
forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin) -> UTxOState era -> f (UTxOState era)
utxosFeesL
    RootTarget
  era (UTxOState era) (GovState era -> Coin -> UTxOState era)
-> RootTarget era (UTxOState era) (GovState era)
-> RootTarget era (UTxOState era) (Coin -> UTxOState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (GovState era) (GovState era)
-> Lens' (UTxOState era) (GovState era)
-> RootTarget era (UTxOState era) (GovState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift (Proof era -> RootTarget era (GovState era) (GovState era)
forall era.
Era era =>
Proof era -> RootTarget era (GovState era) (GovState era)
govStateT Proof era
p) ((GovState era -> f (GovState era))
-> UTxOState era -> f (UTxOState era)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> UTxOState era -> f (UTxOState era)
utxosGovStateL ((GovState era -> f (GovState era))
 -> UTxOState era -> f (UTxOState era))
-> ((GovState era -> f (GovState era))
    -> GovState era -> f (GovState era))
-> (GovState era -> f (GovState era))
-> UTxOState era
-> f (UTxOState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proof era -> Lens' (GovState era) (GovState era)
forall era. Proof era -> Lens' (GovState era) (GovState era)
unGovL Proof era
p)
    RootTarget era (UTxOState era) (Coin -> UTxOState era)
-> RootTarget era (UTxOState era) Coin
-> RootTarget era (UTxOState era) (UTxOState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era Coin
-> SimpleGetter (UTxOState era) Coin
-> RootTarget era (UTxOState era) Coin
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era Coin
forall era. Era era => Term era Coin
donation (Coin -> Const r Coin) -> UTxOState era -> Const r (UTxOState era)
SimpleGetter (UTxOState era) Coin
forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin) -> UTxOState era -> f (UTxOState era)
utxosDonationL
  where
    utxofun ::
      Reflect era =>
      Proof era ->
      Map TxIn (TxOutF era) ->
      Coin ->
      Coin ->
      GovState era ->
      Coin ->
      UTxOState era
    utxofun :: Reflect era =>
Proof era
-> Map TxIn (TxOutF era)
-> Coin
-> Coin
-> GovState era
-> Coin
-> UTxOState era
utxofun Proof era
proof Map TxIn (TxOutF era)
u Coin
c1 Coin
c2 (GovState Proof era
_ GovState era
x) = PParams era
-> UTxO era
-> Coin
-> Coin
-> GovState era
-> Coin
-> UTxOState era
forall era.
EraStake era =>
PParams era
-> UTxO era
-> Coin
-> Coin
-> GovState era
-> Coin
-> UTxOState era
smartUTxOState (Proof era -> PParams era
forall era. Reflect era => Proof era -> PParams era
justProtocolVersion Proof era
proof) (Map TxIn (TxOutF era) -> UTxO era
forall era. Map TxIn (TxOutF era) -> UTxO era
liftUTxO Map TxIn (TxOutF era)
u) Coin
c1 Coin
c2 GovState era
x

unGovL :: Proof era -> Lens' (Gov.GovState era) (GovState era)
unGovL :: forall era. Proof era -> Lens' (GovState era) (GovState era)
unGovL Proof era
p = (GovState era -> GovState era)
-> (GovState era -> GovState era -> GovState era)
-> Lens (GovState era) (GovState era) (GovState era) (GovState era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (\GovState era
x -> Proof era -> GovState era -> GovState era
forall era. Proof era -> GovState era -> GovState era
GovState Proof era
p GovState era
x) (\GovState era
_ (GovState Proof era
_ GovState era
y) -> GovState era
y)

justProtocolVersion :: forall era. Reflect era => Proof era -> PParams era
justProtocolVersion :: forall era. Reflect era => Proof era -> PParams era
justProtocolVersion Proof era
proof = Proof era -> [PParamsField era] -> PParams era
forall era.
EraPParams era =>
Proof era -> [PParamsField era] -> PParams era
newPParams Proof era
proof [ProtVer -> PParamsField era
forall era. ProtVer -> PParamsField era
Fields.ProtocolVersion (ProtVer -> PParamsField era) -> ProtVer -> PParamsField era
forall a b. (a -> b) -> a -> b
$ Proof era -> ProtVer
forall era. Proof era -> ProtVer
protocolVersion Proof era
proof]

unCertStateFL :: Reflect era => Lens' (CertState era) (CertStateF era)
unCertStateFL :: forall era. Reflect era => Lens' (CertState era) (CertStateF era)
unCertStateFL = (CertState era -> CertStateF era)
-> (CertState era -> CertStateF era -> CertState era)
-> Lens
     (CertState era) (CertState era) (CertStateF era) (CertStateF era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Proof era -> CertState era -> CertStateF era
forall era. Proof era -> CertState era -> CertStateF era
CertStateF Proof era
forall era. Reflect era => Proof era
reify) (\CertState era
_ (CertStateF Proof era
_ CertState era
x) -> CertState era
x)

certStateFL :: Lens' (CertStateF era) (CertState era)
certStateFL :: forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> CertStateF era -> f (CertStateF era)
certStateFL = (CertStateF era -> CertState era)
-> (CertStateF era -> CertState era -> CertStateF era)
-> Lens
     (CertStateF era) (CertStateF era) (CertState era) (CertState era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens CertStateF era -> CertState era
forall era. CertStateF era -> CertState era
unCertStateF (\(CertStateF Proof era
p CertState era
_) CertState era
y -> Proof era -> CertState era -> CertStateF era
forall era. Proof era -> CertState era -> CertStateF era
CertStateF Proof era
p CertState era
y)

-- | Target for CertState
certStateT :: forall era. Reflect era => RootTarget era (CertStateF era) (CertStateF era)
certStateT :: forall era.
Reflect era =>
RootTarget era (CertStateF era) (CertStateF era)
certStateT = case forall era. Reflect era => Proof era
reify @era of
  Proof era
Shelley ->
    String
-> TypeRep (CertStateF era)
-> (ShelleyCertState era -> CertStateF era)
-> RootTarget
     era (CertStateF era) (ShelleyCertState era -> CertStateF era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"CertState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(CertStateF era)) (Proof era -> CertState era -> CertStateF era
forall era. Proof era -> CertState era -> CertStateF era
CertStateF Proof era
forall era. Reflect era => Proof era
reify)
      RootTarget
  era (CertStateF era) (ShelleyCertState era -> CertStateF era)
-> RootTarget era (CertStateF era) (ShelleyCertState era)
-> RootTarget era (CertStateF era) (CertStateF era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (ShelleyCertState era) (ShelleyCertState era)
-> Lens' (CertStateF era) (ShelleyCertState era)
-> RootTarget era (CertStateF era) (ShelleyCertState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (ShelleyCertState era) (ShelleyCertState era)
shelleyCertStateT (CertState era -> f (CertState era))
-> CertStateF era -> f (CertStateF era)
(ShelleyCertState era -> f (ShelleyCertState era))
-> CertStateF era -> f (CertStateF era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> CertStateF era -> f (CertStateF era)
Lens' (CertStateF era) (ShelleyCertState era)
certStateFL
  Proof era
Allegra ->
    String
-> TypeRep (CertStateF era)
-> (ShelleyCertState era -> CertStateF era)
-> RootTarget
     era (CertStateF era) (ShelleyCertState era -> CertStateF era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"CertState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(CertStateF era)) (Proof era -> CertState era -> CertStateF era
forall era. Proof era -> CertState era -> CertStateF era
CertStateF Proof era
forall era. Reflect era => Proof era
reify)
      RootTarget
  era (CertStateF era) (ShelleyCertState era -> CertStateF era)
-> RootTarget era (CertStateF era) (ShelleyCertState era)
-> RootTarget era (CertStateF era) (CertStateF era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (ShelleyCertState era) (ShelleyCertState era)
-> Lens' (CertStateF era) (ShelleyCertState era)
-> RootTarget era (CertStateF era) (ShelleyCertState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (ShelleyCertState era) (ShelleyCertState era)
shelleyCertStateT (CertState era -> f (CertState era))
-> CertStateF era -> f (CertStateF era)
(ShelleyCertState era -> f (ShelleyCertState era))
-> CertStateF era -> f (CertStateF era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> CertStateF era -> f (CertStateF era)
Lens' (CertStateF era) (ShelleyCertState era)
certStateFL
  Proof era
Mary ->
    String
-> TypeRep (CertStateF era)
-> (ShelleyCertState era -> CertStateF era)
-> RootTarget
     era (CertStateF era) (ShelleyCertState era -> CertStateF era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"CertState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(CertStateF era)) (Proof era -> CertState era -> CertStateF era
forall era. Proof era -> CertState era -> CertStateF era
CertStateF Proof era
forall era. Reflect era => Proof era
reify)
      RootTarget
  era (CertStateF era) (ShelleyCertState era -> CertStateF era)
-> RootTarget era (CertStateF era) (ShelleyCertState era)
-> RootTarget era (CertStateF era) (CertStateF era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (ShelleyCertState era) (ShelleyCertState era)
-> Lens' (CertStateF era) (ShelleyCertState era)
-> RootTarget era (CertStateF era) (ShelleyCertState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (ShelleyCertState era) (ShelleyCertState era)
shelleyCertStateT (CertState era -> f (CertState era))
-> CertStateF era -> f (CertStateF era)
(ShelleyCertState era -> f (ShelleyCertState era))
-> CertStateF era -> f (CertStateF era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> CertStateF era -> f (CertStateF era)
Lens' (CertStateF era) (ShelleyCertState era)
certStateFL
  Proof era
Alonzo ->
    String
-> TypeRep (CertStateF era)
-> (ShelleyCertState era -> CertStateF era)
-> RootTarget
     era (CertStateF era) (ShelleyCertState era -> CertStateF era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"CertState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(CertStateF era)) (Proof era -> CertState era -> CertStateF era
forall era. Proof era -> CertState era -> CertStateF era
CertStateF Proof era
forall era. Reflect era => Proof era
reify)
      RootTarget
  era (CertStateF era) (ShelleyCertState era -> CertStateF era)
-> RootTarget era (CertStateF era) (ShelleyCertState era)
-> RootTarget era (CertStateF era) (CertStateF era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (ShelleyCertState era) (ShelleyCertState era)
-> Lens' (CertStateF era) (ShelleyCertState era)
-> RootTarget era (CertStateF era) (ShelleyCertState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (ShelleyCertState era) (ShelleyCertState era)
shelleyCertStateT (CertState era -> f (CertState era))
-> CertStateF era -> f (CertStateF era)
(ShelleyCertState era -> f (ShelleyCertState era))
-> CertStateF era -> f (CertStateF era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> CertStateF era -> f (CertStateF era)
Lens' (CertStateF era) (ShelleyCertState era)
certStateFL
  Proof era
Babbage ->
    String
-> TypeRep (CertStateF era)
-> (ShelleyCertState era -> CertStateF era)
-> RootTarget
     era (CertStateF era) (ShelleyCertState era -> CertStateF era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"CertState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(CertStateF era)) (Proof era -> CertState era -> CertStateF era
forall era. Proof era -> CertState era -> CertStateF era
CertStateF Proof era
forall era. Reflect era => Proof era
reify)
      RootTarget
  era (CertStateF era) (ShelleyCertState era -> CertStateF era)
-> RootTarget era (CertStateF era) (ShelleyCertState era)
-> RootTarget era (CertStateF era) (CertStateF era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (ShelleyCertState era) (ShelleyCertState era)
-> Lens' (CertStateF era) (ShelleyCertState era)
-> RootTarget era (CertStateF era) (ShelleyCertState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (ShelleyCertState era) (ShelleyCertState era)
shelleyCertStateT (CertState era -> f (CertState era))
-> CertStateF era -> f (CertStateF era)
(ShelleyCertState era -> f (ShelleyCertState era))
-> CertStateF era -> f (CertStateF era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> CertStateF era -> f (CertStateF era)
Lens' (CertStateF era) (ShelleyCertState era)
certStateFL
  Proof era
Conway ->
    String
-> TypeRep (CertStateF era)
-> (ConwayCertState era -> CertStateF era)
-> RootTarget
     era (CertStateF era) (ConwayCertState era -> CertStateF era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"CertState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(CertStateF era)) (Proof era -> CertState era -> CertStateF era
forall era. Proof era -> CertState era -> CertStateF era
CertStateF Proof era
forall era. Reflect era => Proof era
reify)
      RootTarget
  era (CertStateF era) (ConwayCertState era -> CertStateF era)
-> RootTarget era (CertStateF era) (ConwayCertState era)
-> RootTarget era (CertStateF era) (CertStateF era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (ConwayCertState era) (ConwayCertState era)
-> Lens' (CertStateF era) (ConwayCertState era)
-> RootTarget era (CertStateF era) (ConwayCertState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (ConwayCertState era) (ConwayCertState era)
ConwayEraCertState era =>
RootTarget era (ConwayCertState era) (ConwayCertState era)
conwayCertStateT (CertState era -> f (CertState era))
-> CertStateF era -> f (CertStateF era)
(ConwayCertState era -> f (ConwayCertState era))
-> CertStateF era -> f (CertStateF era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> CertStateF era -> f (CertStateF era)
Lens' (CertStateF era) (ConwayCertState era)
certStateFL
  where
    shelleyCertStateT :: RootTarget era (ShelleyCertState era) (ShelleyCertState era)
    shelleyCertStateT :: RootTarget era (ShelleyCertState era) (ShelleyCertState era)
shelleyCertStateT =
      String
-> TypeRep (ShelleyCertState era)
-> (PState era -> DState era -> ShelleyCertState era)
-> RootTarget
     era
     (ShelleyCertState era)
     (PState era -> DState era -> ShelleyCertState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"ShelleyCertState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(ShelleyCertState era)) PState era -> DState era -> ShelleyCertState era
forall era. PState era -> DState era -> ShelleyCertState era
ShelleyCertState
        RootTarget
  era
  (ShelleyCertState era)
  (PState era -> DState era -> ShelleyCertState era)
-> RootTarget era (ShelleyCertState era) (PState era)
-> RootTarget
     era (ShelleyCertState era) (DState era -> ShelleyCertState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ (RootTarget era (PState era) (PState era)
-> Lens' (ShelleyCertState era) (PState era)
-> RootTarget era (ShelleyCertState era) (PState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (PState era) (PState era)
forall era.
EraCertState era =>
RootTarget era (PState era) (PState era)
pstateT (PState era -> f (PState era))
-> ShelleyCertState era -> f (ShelleyCertState era)
forall era (f :: * -> *).
Functor f =>
(PState era -> f (PState era))
-> ShelleyCertState era -> f (ShelleyCertState era)
Lens' (ShelleyCertState era) (PState era)
shelleyCertPStateL)
        RootTarget
  era (ShelleyCertState era) (DState era -> ShelleyCertState era)
-> RootTarget era (ShelleyCertState era) (DState era)
-> RootTarget era (ShelleyCertState era) (ShelleyCertState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ (RootTarget era (DState era) (DState era)
-> Lens' (ShelleyCertState era) (DState era)
-> RootTarget era (ShelleyCertState era) (DState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (DState era) (DState era)
forall era.
EraCertState era =>
RootTarget era (DState era) (DState era)
dstateT (DState era -> f (DState era))
-> ShelleyCertState era -> f (ShelleyCertState era)
forall era (f :: * -> *).
Functor f =>
(DState era -> f (DState era))
-> ShelleyCertState era -> f (ShelleyCertState era)
Lens' (ShelleyCertState era) (DState era)
shelleyCertDStateL)
    conwayCertStateT ::
      ConwayEraCertState era => RootTarget era (ConwayCertState era) (ConwayCertState era)
    conwayCertStateT :: ConwayEraCertState era =>
RootTarget era (ConwayCertState era) (ConwayCertState era)
conwayCertStateT =
      String
-> TypeRep (ConwayCertState era)
-> (VState era -> PState era -> DState era -> ConwayCertState era)
-> RootTarget
     era
     (ConwayCertState era)
     (VState era -> PState era -> DState era -> ConwayCertState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"ConwayCertState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(ConwayCertState era)) VState era -> PState era -> DState era -> ConwayCertState era
forall era.
VState era -> PState era -> DState era -> ConwayCertState era
ConwayCertState
        RootTarget
  era
  (ConwayCertState era)
  (VState era -> PState era -> DState era -> ConwayCertState era)
-> RootTarget era (ConwayCertState era) (VState era)
-> RootTarget
     era
     (ConwayCertState era)
     (PState era -> DState era -> ConwayCertState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ (RootTarget era (VState era) (VState era)
-> Lens' (ConwayCertState era) (VState era)
-> RootTarget era (ConwayCertState era) (VState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (VState era) (VState era)
forall era.
ConwayEraCertState era =>
RootTarget era (VState era) (VState era)
vstateT (VState era -> f (VState era))
-> ConwayCertState era -> f (ConwayCertState era)
forall era (f :: * -> *).
Functor f =>
(VState era -> f (VState era))
-> ConwayCertState era -> f (ConwayCertState era)
Lens' (ConwayCertState era) (VState era)
conwayCertVStateL)
        RootTarget
  era
  (ConwayCertState era)
  (PState era -> DState era -> ConwayCertState era)
-> RootTarget era (ConwayCertState era) (PState era)
-> RootTarget
     era (ConwayCertState era) (DState era -> ConwayCertState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ (RootTarget era (PState era) (PState era)
-> Lens' (ConwayCertState era) (PState era)
-> RootTarget era (ConwayCertState era) (PState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (PState era) (PState era)
forall era.
EraCertState era =>
RootTarget era (PState era) (PState era)
pstateT (PState era -> f (PState era))
-> ConwayCertState era -> f (ConwayCertState era)
forall era (f :: * -> *).
Functor f =>
(PState era -> f (PState era))
-> ConwayCertState era -> f (ConwayCertState era)
Lens' (ConwayCertState era) (PState era)
conwayCertPStateL)
        RootTarget
  era (ConwayCertState era) (DState era -> ConwayCertState era)
-> RootTarget era (ConwayCertState era) (DState era)
-> RootTarget era (ConwayCertState era) (ConwayCertState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ (RootTarget era (DState era) (DState era)
-> Lens' (ConwayCertState era) (DState era)
-> RootTarget era (ConwayCertState era) (DState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (DState era) (DState era)
forall era.
EraCertState era =>
RootTarget era (DState era) (DState era)
dstateT (DState era -> f (DState era))
-> ConwayCertState era -> f (ConwayCertState era)
forall era (f :: * -> *).
Functor f =>
(DState era -> f (DState era))
-> ConwayCertState era -> f (ConwayCertState era)
Lens' (ConwayCertState era) (DState era)
conwayCertDStateL)

-- | Target for VState
vstateT :: forall era. ConwayEraCertState era => RootTarget era (VState era) (VState era)
vstateT :: forall era.
ConwayEraCertState era =>
RootTarget era (VState era) (VState era)
vstateT =
  String
-> TypeRep (VState era)
-> (Map (Credential 'DRepRole) DRepState
    -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
    -> EpochNo
    -> VState era)
-> RootTarget
     era
     (VState era)
     (Map (Credential 'DRepRole) DRepState
      -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
      -> EpochNo
      -> VState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"VState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(VState era)) (\Map (Credential 'DRepRole) DRepState
x Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
y EpochNo
z -> Map (Credential 'DRepRole) DRepState
-> CommitteeState era -> EpochNo -> VState era
forall era.
Map (Credential 'DRepRole) DRepState
-> CommitteeState era -> EpochNo -> VState era
VState Map (Credential 'DRepRole) DRepState
x (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
-> CommitteeState era
forall era.
Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
-> CommitteeState era
CommitteeState Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
y) EpochNo
z)
    RootTarget
  era
  (VState era)
  (Map (Credential 'DRepRole) DRepState
   -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
   -> EpochNo
   -> VState era)
-> RootTarget
     era (VState era) (Map (Credential 'DRepRole) DRepState)
-> RootTarget
     era
     (VState era)
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
      -> EpochNo -> VState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'DRepRole) DRepState)
-> SimpleGetter (VState era) (Map (Credential 'DRepRole) DRepState)
-> RootTarget
     era (VState era) (Map (Credential 'DRepRole) DRepState)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'DRepRole) DRepState)
forall era.
ConwayEraCertState era =>
Term era (Map (Credential 'DRepRole) DRepState)
currentDRepState (Map (Credential 'DRepRole) DRepState
 -> Const r (Map (Credential 'DRepRole) DRepState))
-> VState era -> Const r (VState era)
SimpleGetter (VState era) (Map (Credential 'DRepRole) DRepState)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'DRepRole) DRepState
 -> f (Map (Credential 'DRepRole) DRepState))
-> VState era -> f (VState era)
vsDRepsL
    RootTarget
  era
  (VState era)
  (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
   -> EpochNo -> VState era)
-> RootTarget
     era
     (VState era)
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> RootTarget era (VState era) (EpochNo -> VState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> SimpleGetter
     (VState era)
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> RootTarget
     era
     (VState era)
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall era.
ConwayEraCertState era =>
Term
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
committeeState ((CommitteeState era -> Const r (CommitteeState era))
-> VState era -> Const r (VState era)
forall era (f :: * -> *).
Functor f =>
(CommitteeState era -> f (CommitteeState era))
-> VState era -> f (VState era)
vsCommitteeStateL ((CommitteeState era -> Const r (CommitteeState era))
 -> VState era -> Const r (VState era))
-> ((Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
     -> Const
          r (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
    -> CommitteeState era -> Const r (CommitteeState era))
-> (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
    -> Const
         r (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> VState era
-> Const r (VState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
 -> Const
      r (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> CommitteeState era -> Const r (CommitteeState era)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
 -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> CommitteeState era -> f (CommitteeState era)
csCommitteeCredsL)
    RootTarget era (VState era) (EpochNo -> VState era)
-> RootTarget era (VState era) EpochNo
-> RootTarget era (VState era) (VState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era EpochNo
-> SimpleGetter (VState era) EpochNo
-> RootTarget era (VState era) EpochNo
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era EpochNo
forall era. ConwayEraCertState era => Term era EpochNo
numDormantEpochs (EpochNo -> Const r EpochNo) -> VState era -> Const r (VState era)
SimpleGetter (VState era) EpochNo
forall era (f :: * -> *).
Functor f =>
(EpochNo -> f EpochNo) -> VState era -> f (VState era)
vsNumDormantEpochsL

committeeL ::
  Lens' (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization) (CommitteeState era)
committeeL :: forall era (f :: * -> *).
Functor f =>
(CommitteeState era -> f (CommitteeState era))
-> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
-> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
committeeL = (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
 -> CommitteeState era)
-> (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
    -> CommitteeState era
    -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> Lens
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
     (CommitteeState era)
     (CommitteeState era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
-> CommitteeState era
forall era.
Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
-> CommitteeState era
CommitteeState (\Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
_ (CommitteeState Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
x) -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
x)

-- | Target for PState
pstateT :: forall era. EraCertState era => RootTarget era (PState era) (PState era)
pstateT :: forall era.
EraCertState era =>
RootTarget era (PState era) (PState era)
pstateT =
  String
-> TypeRep (PState era)
-> (Map (KeyHash 'StakePool) PoolParams
    -> Map (KeyHash 'StakePool) PoolParams
    -> Map (KeyHash 'StakePool) EpochNo
    -> Map (KeyHash 'StakePool) Coin
    -> PState era)
-> RootTarget
     era
     (PState era)
     (Map (KeyHash 'StakePool) PoolParams
      -> Map (KeyHash 'StakePool) PoolParams
      -> Map (KeyHash 'StakePool) EpochNo
      -> Map (KeyHash 'StakePool) Coin
      -> PState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"PState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(PState era)) Map (KeyHash 'StakePool) PoolParams
-> Map (KeyHash 'StakePool) PoolParams
-> Map (KeyHash 'StakePool) EpochNo
-> Map (KeyHash 'StakePool) Coin
-> PState era
forall era.
Map (KeyHash 'StakePool) PoolParams
-> Map (KeyHash 'StakePool) PoolParams
-> Map (KeyHash 'StakePool) EpochNo
-> Map (KeyHash 'StakePool) Coin
-> PState era
PState
    RootTarget
  era
  (PState era)
  (Map (KeyHash 'StakePool) PoolParams
   -> Map (KeyHash 'StakePool) PoolParams
   -> Map (KeyHash 'StakePool) EpochNo
   -> Map (KeyHash 'StakePool) Coin
   -> PState era)
-> RootTarget
     era (PState era) (Map (KeyHash 'StakePool) PoolParams)
-> RootTarget
     era
     (PState era)
     (Map (KeyHash 'StakePool) PoolParams
      -> Map (KeyHash 'StakePool) EpochNo
      -> Map (KeyHash 'StakePool) Coin
      -> PState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) PoolParams)
-> SimpleGetter (PState era) (Map (KeyHash 'StakePool) PoolParams)
-> RootTarget
     era (PState era) (Map (KeyHash 'StakePool) PoolParams)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (KeyHash 'StakePool) PoolParams)
forall era.
EraCertState era =>
Term era (Map (KeyHash 'StakePool) PoolParams)
regPools (Map (KeyHash 'StakePool) PoolParams
 -> Const r (Map (KeyHash 'StakePool) PoolParams))
-> PState era -> Const r (PState era)
SimpleGetter (PState era) (Map (KeyHash 'StakePool) PoolParams)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> PState era -> f (PState era)
psStakePoolParamsL
    RootTarget
  era
  (PState era)
  (Map (KeyHash 'StakePool) PoolParams
   -> Map (KeyHash 'StakePool) EpochNo
   -> Map (KeyHash 'StakePool) Coin
   -> PState era)
-> RootTarget
     era (PState era) (Map (KeyHash 'StakePool) PoolParams)
-> RootTarget
     era
     (PState era)
     (Map (KeyHash 'StakePool) EpochNo
      -> Map (KeyHash 'StakePool) Coin -> PState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) PoolParams)
-> SimpleGetter (PState era) (Map (KeyHash 'StakePool) PoolParams)
-> RootTarget
     era (PState era) (Map (KeyHash 'StakePool) PoolParams)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (KeyHash 'StakePool) PoolParams)
forall era.
EraCertState era =>
Term era (Map (KeyHash 'StakePool) PoolParams)
futureRegPools (Map (KeyHash 'StakePool) PoolParams
 -> Const r (Map (KeyHash 'StakePool) PoolParams))
-> PState era -> Const r (PState era)
SimpleGetter (PState era) (Map (KeyHash 'StakePool) PoolParams)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> PState era -> f (PState era)
psFutureStakePoolParamsL
    RootTarget
  era
  (PState era)
  (Map (KeyHash 'StakePool) EpochNo
   -> Map (KeyHash 'StakePool) Coin -> PState era)
-> RootTarget era (PState era) (Map (KeyHash 'StakePool) EpochNo)
-> RootTarget
     era (PState era) (Map (KeyHash 'StakePool) Coin -> PState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) EpochNo)
-> SimpleGetter (PState era) (Map (KeyHash 'StakePool) EpochNo)
-> RootTarget era (PState era) (Map (KeyHash 'StakePool) EpochNo)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (KeyHash 'StakePool) EpochNo)
forall era.
EraCertState era =>
Term era (Map (KeyHash 'StakePool) EpochNo)
retiring (Map (KeyHash 'StakePool) EpochNo
 -> Const r (Map (KeyHash 'StakePool) EpochNo))
-> PState era -> Const r (PState era)
SimpleGetter (PState era) (Map (KeyHash 'StakePool) EpochNo)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) EpochNo
 -> f (Map (KeyHash 'StakePool) EpochNo))
-> PState era -> f (PState era)
psRetiringL
    RootTarget
  era (PState era) (Map (KeyHash 'StakePool) Coin -> PState era)
-> RootTarget era (PState era) (Map (KeyHash 'StakePool) Coin)
-> RootTarget era (PState era) (PState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) Coin)
-> SimpleGetter (PState era) (Map (KeyHash 'StakePool) Coin)
-> RootTarget era (PState era) (Map (KeyHash 'StakePool) Coin)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (KeyHash 'StakePool) Coin)
forall era.
EraCertState era =>
Term era (Map (KeyHash 'StakePool) Coin)
poolDeposits (Map (KeyHash 'StakePool) Coin
 -> Const r (Map (KeyHash 'StakePool) Coin))
-> PState era -> Const r (PState era)
SimpleGetter (PState era) (Map (KeyHash 'StakePool) Coin)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) Coin
 -> f (Map (KeyHash 'StakePool) Coin))
-> PState era -> f (PState era)
psDepositsL

-- | Target for DState
dstateT :: forall era. EraCertState era => RootTarget era (DState era) (DState era)
dstateT :: forall era.
EraCertState era =>
RootTarget era (DState era) (DState era)
dstateT =
  String
-> TypeRep (DState era)
-> (Map (Credential 'Staking) Coin
    -> Map (Credential 'Staking) Coin
    -> Map (Credential 'Staking) (KeyHash 'StakePool)
    -> Map (Credential 'Staking) DRep
    -> Map Ptr (Credential 'Staking)
    -> Map FutureGenDeleg GenDelegPair
    -> Map (KeyHash 'Genesis) GenDelegPair
    -> InstantaneousRewards
    -> DState era)
-> RootTarget
     era
     (DState era)
     (Map (Credential 'Staking) Coin
      -> Map (Credential 'Staking) Coin
      -> Map (Credential 'Staking) (KeyHash 'StakePool)
      -> Map (Credential 'Staking) DRep
      -> Map Ptr (Credential 'Staking)
      -> Map FutureGenDeleg GenDelegPair
      -> Map (KeyHash 'Genesis) GenDelegPair
      -> InstantaneousRewards
      -> DState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"DState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(DState era)) Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) DRep
-> Map Ptr (Credential 'Staking)
-> Map FutureGenDeleg GenDelegPair
-> Map (KeyHash 'Genesis) GenDelegPair
-> InstantaneousRewards
-> DState era
forall era.
Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) DRep
-> Map Ptr (Credential 'Staking)
-> Map FutureGenDeleg GenDelegPair
-> Map (KeyHash 'Genesis) GenDelegPair
-> InstantaneousRewards
-> DState era
dstate
    RootTarget
  era
  (DState era)
  (Map (Credential 'Staking) Coin
   -> Map (Credential 'Staking) Coin
   -> Map (Credential 'Staking) (KeyHash 'StakePool)
   -> Map (Credential 'Staking) DRep
   -> Map Ptr (Credential 'Staking)
   -> Map FutureGenDeleg GenDelegPair
   -> Map (KeyHash 'Genesis) GenDelegPair
   -> InstantaneousRewards
   -> DState era)
-> RootTarget era (DState era) (Map (Credential 'Staking) Coin)
-> RootTarget
     era
     (DState era)
     (Map (Credential 'Staking) Coin
      -> Map (Credential 'Staking) (KeyHash 'StakePool)
      -> Map (Credential 'Staking) DRep
      -> Map Ptr (Credential 'Staking)
      -> Map FutureGenDeleg GenDelegPair
      -> Map (KeyHash 'Genesis) GenDelegPair
      -> InstantaneousRewards
      -> DState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) Coin)
-> SimpleGetter (DState era) (Map (Credential 'Staking) Coin)
-> RootTarget era (DState era) (Map (Credential 'Staking) Coin)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'Staking) Coin)
forall era.
EraCertState era =>
Term era (Map (Credential 'Staking) Coin)
rewards ((UMap -> Const r UMap) -> DState era -> Const r (DState era)
forall era (f :: * -> *).
Functor f =>
(UMap -> f UMap) -> DState era -> f (DState era)
dsUnifiedL ((UMap -> Const r UMap) -> DState era -> Const r (DState era))
-> ((Map (Credential 'Staking) Coin
     -> Const r (Map (Credential 'Staking) Coin))
    -> UMap -> Const r UMap)
-> (Map (Credential 'Staking) Coin
    -> Const r (Map (Credential 'Staking) Coin))
-> DState era
-> Const r (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) Coin
 -> Const r (Map (Credential 'Staking) Coin))
-> UMap -> Const r UMap
Lens' UMap (Map (Credential 'Staking) Coin)
rewardsUMapL)
    RootTarget
  era
  (DState era)
  (Map (Credential 'Staking) Coin
   -> Map (Credential 'Staking) (KeyHash 'StakePool)
   -> Map (Credential 'Staking) DRep
   -> Map Ptr (Credential 'Staking)
   -> Map FutureGenDeleg GenDelegPair
   -> Map (KeyHash 'Genesis) GenDelegPair
   -> InstantaneousRewards
   -> DState era)
-> RootTarget era (DState era) (Map (Credential 'Staking) Coin)
-> RootTarget
     era
     (DState era)
     (Map (Credential 'Staking) (KeyHash 'StakePool)
      -> Map (Credential 'Staking) DRep
      -> Map Ptr (Credential 'Staking)
      -> Map FutureGenDeleg GenDelegPair
      -> Map (KeyHash 'Genesis) GenDelegPair
      -> InstantaneousRewards
      -> DState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) Coin)
-> SimpleGetter (DState era) (Map (Credential 'Staking) Coin)
-> RootTarget era (DState era) (Map (Credential 'Staking) Coin)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'Staking) Coin)
forall era.
EraCertState era =>
Term era (Map (Credential 'Staking) Coin)
stakeDeposits ((UMap -> Const r UMap) -> DState era -> Const r (DState era)
forall era (f :: * -> *).
Functor f =>
(UMap -> f UMap) -> DState era -> f (DState era)
dsUnifiedL ((UMap -> Const r UMap) -> DState era -> Const r (DState era))
-> ((Map (Credential 'Staking) Coin
     -> Const r (Map (Credential 'Staking) Coin))
    -> UMap -> Const r UMap)
-> (Map (Credential 'Staking) Coin
    -> Const r (Map (Credential 'Staking) Coin))
-> DState era
-> Const r (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) Coin
 -> Const r (Map (Credential 'Staking) Coin))
-> UMap -> Const r UMap
Lens' UMap (Map (Credential 'Staking) Coin)
stakeDepositsUMapL)
    RootTarget
  era
  (DState era)
  (Map (Credential 'Staking) (KeyHash 'StakePool)
   -> Map (Credential 'Staking) DRep
   -> Map Ptr (Credential 'Staking)
   -> Map FutureGenDeleg GenDelegPair
   -> Map (KeyHash 'Genesis) GenDelegPair
   -> InstantaneousRewards
   -> DState era)
-> RootTarget
     era (DState era) (Map (Credential 'Staking) (KeyHash 'StakePool))
-> RootTarget
     era
     (DState era)
     (Map (Credential 'Staking) DRep
      -> Map Ptr (Credential 'Staking)
      -> Map FutureGenDeleg GenDelegPair
      -> Map (KeyHash 'Genesis) GenDelegPair
      -> InstantaneousRewards
      -> DState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
-> SimpleGetter
     (DState era) (Map (Credential 'Staking) (KeyHash 'StakePool))
-> RootTarget
     era (DState era) (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
forall era.
EraCertState era =>
Term era (Map (Credential 'Staking) (KeyHash 'StakePool))
delegations ((UMap -> Const r UMap) -> DState era -> Const r (DState era)
forall era (f :: * -> *).
Functor f =>
(UMap -> f UMap) -> DState era -> f (DState era)
dsUnifiedL ((UMap -> Const r UMap) -> DState era -> Const r (DState era))
-> ((Map (Credential 'Staking) (KeyHash 'StakePool)
     -> Const r (Map (Credential 'Staking) (KeyHash 'StakePool)))
    -> UMap -> Const r UMap)
-> (Map (Credential 'Staking) (KeyHash 'StakePool)
    -> Const r (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> DState era
-> Const r (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) (KeyHash 'StakePool)
 -> Const r (Map (Credential 'Staking) (KeyHash 'StakePool)))
-> UMap -> Const r UMap
Lens' UMap (Map (Credential 'Staking) (KeyHash 'StakePool))
delegationsUMapL)
    RootTarget
  era
  (DState era)
  (Map (Credential 'Staking) DRep
   -> Map Ptr (Credential 'Staking)
   -> Map FutureGenDeleg GenDelegPair
   -> Map (KeyHash 'Genesis) GenDelegPair
   -> InstantaneousRewards
   -> DState era)
-> RootTarget era (DState era) (Map (Credential 'Staking) DRep)
-> RootTarget
     era
     (DState era)
     (Map Ptr (Credential 'Staking)
      -> Map FutureGenDeleg GenDelegPair
      -> Map (KeyHash 'Genesis) GenDelegPair
      -> InstantaneousRewards
      -> DState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) DRep)
-> SimpleGetter (DState era) (Map (Credential 'Staking) DRep)
-> RootTarget era (DState era) (Map (Credential 'Staking) DRep)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'Staking) DRep)
forall era.
EraCertState era =>
Term era (Map (Credential 'Staking) DRep)
drepDelegation ((UMap -> Const r UMap) -> DState era -> Const r (DState era)
forall era (f :: * -> *).
Functor f =>
(UMap -> f UMap) -> DState era -> f (DState era)
dsUnifiedL ((UMap -> Const r UMap) -> DState era -> Const r (DState era))
-> ((Map (Credential 'Staking) DRep
     -> Const r (Map (Credential 'Staking) DRep))
    -> UMap -> Const r UMap)
-> (Map (Credential 'Staking) DRep
    -> Const r (Map (Credential 'Staking) DRep))
-> DState era
-> Const r (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) DRep
 -> Const r (Map (Credential 'Staking) DRep))
-> UMap -> Const r UMap
Lens' UMap (Map (Credential 'Staking) DRep)
drepUMapL)
    RootTarget
  era
  (DState era)
  (Map Ptr (Credential 'Staking)
   -> Map FutureGenDeleg GenDelegPair
   -> Map (KeyHash 'Genesis) GenDelegPair
   -> InstantaneousRewards
   -> DState era)
-> RootTarget era (DState era) (Map Ptr (Credential 'Staking))
-> RootTarget
     era
     (DState era)
     (Map FutureGenDeleg GenDelegPair
      -> Map (KeyHash 'Genesis) GenDelegPair
      -> InstantaneousRewards
      -> DState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map Ptr (Credential 'Staking))
-> SimpleGetter (DState era) (Map Ptr (Credential 'Staking))
-> RootTarget era (DState era) (Map Ptr (Credential 'Staking))
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map Ptr (Credential 'Staking))
forall era.
EraCertState era =>
Term era (Map Ptr (Credential 'Staking))
ptrs ((UMap -> Const r UMap) -> DState era -> Const r (DState era)
forall era (f :: * -> *).
Functor f =>
(UMap -> f UMap) -> DState era -> f (DState era)
dsUnifiedL ((UMap -> Const r UMap) -> DState era -> Const r (DState era))
-> ((Map Ptr (Credential 'Staking)
     -> Const r (Map Ptr (Credential 'Staking)))
    -> UMap -> Const r UMap)
-> (Map Ptr (Credential 'Staking)
    -> Const r (Map Ptr (Credential 'Staking)))
-> DState era
-> Const r (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map Ptr (Credential 'Staking)
 -> Const r (Map Ptr (Credential 'Staking)))
-> UMap -> Const r UMap
Lens' UMap (Map Ptr (Credential 'Staking))
ptrsUMapL)
    RootTarget
  era
  (DState era)
  (Map FutureGenDeleg GenDelegPair
   -> Map (KeyHash 'Genesis) GenDelegPair
   -> InstantaneousRewards
   -> DState era)
-> RootTarget era (DState era) (Map FutureGenDeleg GenDelegPair)
-> RootTarget
     era
     (DState era)
     (Map (KeyHash 'Genesis) GenDelegPair
      -> InstantaneousRewards -> DState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map FutureGenDeleg GenDelegPair)
-> SimpleGetter (DState era) (Map FutureGenDeleg GenDelegPair)
-> RootTarget era (DState era) (Map FutureGenDeleg GenDelegPair)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map FutureGenDeleg GenDelegPair)
forall era.
EraCertState era =>
Term era (Map FutureGenDeleg GenDelegPair)
futureGenDelegs (Map FutureGenDeleg GenDelegPair
 -> Const r (Map FutureGenDeleg GenDelegPair))
-> DState era -> Const r (DState era)
SimpleGetter (DState era) (Map FutureGenDeleg GenDelegPair)
forall era (f :: * -> *).
Functor f =>
(Map FutureGenDeleg GenDelegPair
 -> f (Map FutureGenDeleg GenDelegPair))
-> DState era -> f (DState era)
dsFutureGenDelegsL
    RootTarget
  era
  (DState era)
  (Map (KeyHash 'Genesis) GenDelegPair
   -> InstantaneousRewards -> DState era)
-> RootTarget
     era (DState era) (Map (KeyHash 'Genesis) GenDelegPair)
-> RootTarget era (DState era) (InstantaneousRewards -> DState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'Genesis) GenDelegPair)
-> SimpleGetter (DState era) (Map (KeyHash 'Genesis) GenDelegPair)
-> RootTarget
     era (DState era) (Map (KeyHash 'Genesis) GenDelegPair)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (KeyHash 'Genesis) GenDelegPair)
forall era.
EraCertState era =>
Term era (Map (KeyHash 'Genesis) GenDelegPair)
genDelegs ((GenDelegs -> Const r GenDelegs)
-> DState era -> Const r (DState era)
forall era (f :: * -> *).
Functor f =>
(GenDelegs -> f GenDelegs) -> DState era -> f (DState era)
dsGenDelegsL ((GenDelegs -> Const r GenDelegs)
 -> DState era -> Const r (DState era))
-> ((Map (KeyHash 'Genesis) GenDelegPair
     -> Const r (Map (KeyHash 'Genesis) GenDelegPair))
    -> GenDelegs -> Const r GenDelegs)
-> (Map (KeyHash 'Genesis) GenDelegPair
    -> Const r (Map (KeyHash 'Genesis) GenDelegPair))
-> DState era
-> Const r (DState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'Genesis) GenDelegPair
 -> Const r (Map (KeyHash 'Genesis) GenDelegPair))
-> GenDelegs -> Const r GenDelegs
Lens' GenDelegs (Map (KeyHash 'Genesis) GenDelegPair)
unGenDelegsL)
    RootTarget era (DState era) (InstantaneousRewards -> DState era)
-> RootTarget era (DState era) InstantaneousRewards
-> RootTarget era (DState era) (DState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era InstantaneousRewards InstantaneousRewards
-> Lens' (DState era) InstantaneousRewards
-> RootTarget era (DState era) InstantaneousRewards
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era InstantaneousRewards InstantaneousRewards
forall era.
EraCertState era =>
RootTarget era InstantaneousRewards InstantaneousRewards
instantaneousRewardsT (InstantaneousRewards -> f InstantaneousRewards)
-> DState era -> f (DState era)
forall era (f :: * -> *).
Functor f =>
(InstantaneousRewards -> f InstantaneousRewards)
-> DState era -> f (DState era)
Lens' (DState era) InstantaneousRewards
dsIRewardsL

-- | Abstract construcor function for DState
dstate ::
  Map (Credential 'Staking) Coin ->
  Map (Credential 'Staking) Coin ->
  Map (Credential 'Staking) (KeyHash 'StakePool) ->
  Map (Credential 'Staking) DRep ->
  Map Ptr (Credential 'Staking) ->
  Map FutureGenDeleg GenDelegPair ->
  Map (KeyHash 'Genesis) GenDelegPair ->
  InstantaneousRewards ->
  DState era
dstate :: forall era.
Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) DRep
-> Map Ptr (Credential 'Staking)
-> Map FutureGenDeleg GenDelegPair
-> Map (KeyHash 'Genesis) GenDelegPair
-> InstantaneousRewards
-> DState era
dstate Map (Credential 'Staking) Coin
rew Map (Credential 'Staking) Coin
dep Map (Credential 'Staking) (KeyHash 'StakePool)
deleg Map (Credential 'Staking) DRep
drepdeleg Map Ptr (Credential 'Staking)
ptr Map FutureGenDeleg GenDelegPair
fgen Map (KeyHash 'Genesis) GenDelegPair
gen =
  UMap
-> Map FutureGenDeleg GenDelegPair
-> GenDelegs
-> InstantaneousRewards
-> DState era
forall era.
UMap
-> Map FutureGenDeleg GenDelegPair
-> GenDelegs
-> InstantaneousRewards
-> DState era
DState
    (Split -> UMap
unSplitUMap (Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) DRep
-> Map (Credential 'Staking) (Set Ptr)
-> Map Ptr (Credential 'Staking)
-> Split
Split Map (Credential 'Staking) Coin
rew Map (Credential 'Staking) Coin
dep Map (Credential 'Staking) (KeyHash 'StakePool)
deleg Map (Credential 'Staking) DRep
drepdeleg (String -> Map (Credential 'Staking) (Set Ptr)
forall a. HasCallStack => String -> a
error String
"Not implemented") Map Ptr (Credential 'Staking)
ptr))
    Map FutureGenDeleg GenDelegPair
fgen
    (Map (KeyHash 'Genesis) GenDelegPair -> GenDelegs
GenDelegs Map (KeyHash 'Genesis) GenDelegPair
gen)

instantaneousRewardsT ::
  forall era.
  EraCertState era =>
  RootTarget era InstantaneousRewards InstantaneousRewards
instantaneousRewardsT :: forall era.
EraCertState era =>
RootTarget era InstantaneousRewards InstantaneousRewards
instantaneousRewardsT =
  String
-> TypeRep InstantaneousRewards
-> (Map (Credential 'Staking) Coin
    -> Map (Credential 'Staking) Coin
    -> DeltaCoin
    -> DeltaCoin
    -> InstantaneousRewards)
-> RootTarget
     era
     InstantaneousRewards
     (Map (Credential 'Staking) Coin
      -> Map (Credential 'Staking) Coin
      -> DeltaCoin
      -> DeltaCoin
      -> InstantaneousRewards)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"InstanRew" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @InstantaneousRewards) Map (Credential 'Staking) Coin
-> Map (Credential 'Staking) Coin
-> DeltaCoin
-> DeltaCoin
-> InstantaneousRewards
InstantaneousRewards
    RootTarget
  era
  InstantaneousRewards
  (Map (Credential 'Staking) Coin
   -> Map (Credential 'Staking) Coin
   -> DeltaCoin
   -> DeltaCoin
   -> InstantaneousRewards)
-> RootTarget
     era InstantaneousRewards (Map (Credential 'Staking) Coin)
-> RootTarget
     era
     InstantaneousRewards
     (Map (Credential 'Staking) Coin
      -> DeltaCoin -> DeltaCoin -> InstantaneousRewards)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) Coin)
-> SimpleGetter
     InstantaneousRewards (Map (Credential 'Staking) Coin)
-> RootTarget
     era InstantaneousRewards (Map (Credential 'Staking) Coin)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'Staking) Coin)
forall era.
EraCertState era =>
Term era (Map (Credential 'Staking) Coin)
instanReserves (Map (Credential 'Staking) Coin
 -> Const r (Map (Credential 'Staking) Coin))
-> InstantaneousRewards -> Const r InstantaneousRewards
SimpleGetter InstantaneousRewards (Map (Credential 'Staking) Coin)
Lens' InstantaneousRewards (Map (Credential 'Staking) Coin)
iRReservesL
    RootTarget
  era
  InstantaneousRewards
  (Map (Credential 'Staking) Coin
   -> DeltaCoin -> DeltaCoin -> InstantaneousRewards)
-> RootTarget
     era InstantaneousRewards (Map (Credential 'Staking) Coin)
-> RootTarget
     era
     InstantaneousRewards
     (DeltaCoin -> DeltaCoin -> InstantaneousRewards)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) Coin)
-> SimpleGetter
     InstantaneousRewards (Map (Credential 'Staking) Coin)
-> RootTarget
     era InstantaneousRewards (Map (Credential 'Staking) Coin)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'Staking) Coin)
forall era.
EraCertState era =>
Term era (Map (Credential 'Staking) Coin)
instanTreasury (Map (Credential 'Staking) Coin
 -> Const r (Map (Credential 'Staking) Coin))
-> InstantaneousRewards -> Const r InstantaneousRewards
SimpleGetter InstantaneousRewards (Map (Credential 'Staking) Coin)
Lens' InstantaneousRewards (Map (Credential 'Staking) Coin)
iRTreasuryL
    RootTarget
  era
  InstantaneousRewards
  (DeltaCoin -> DeltaCoin -> InstantaneousRewards)
-> RootTarget era InstantaneousRewards DeltaCoin
-> RootTarget
     era InstantaneousRewards (DeltaCoin -> InstantaneousRewards)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era DeltaCoin
-> SimpleGetter InstantaneousRewards DeltaCoin
-> RootTarget era InstantaneousRewards DeltaCoin
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era DeltaCoin
forall era. EraCertState era => Term era DeltaCoin
deltaReserves (DeltaCoin -> Const r DeltaCoin)
-> InstantaneousRewards -> Const r InstantaneousRewards
SimpleGetter InstantaneousRewards DeltaCoin
Lens' InstantaneousRewards DeltaCoin
deltaReservesL
    RootTarget
  era InstantaneousRewards (DeltaCoin -> InstantaneousRewards)
-> RootTarget era InstantaneousRewards DeltaCoin
-> RootTarget era InstantaneousRewards InstantaneousRewards
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era DeltaCoin
-> SimpleGetter InstantaneousRewards DeltaCoin
-> RootTarget era InstantaneousRewards DeltaCoin
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era DeltaCoin
forall era. EraCertState era => Term era DeltaCoin
deltaTreasury (DeltaCoin -> Const r DeltaCoin)
-> InstantaneousRewards -> Const r InstantaneousRewards
SimpleGetter InstantaneousRewards DeltaCoin
Lens' InstantaneousRewards DeltaCoin
deltaTreasuryL

-- | A String that pretty prints the complete set of variables of the NewEpochState
allvars :: String
allvars :: String
allvars = PDoc -> String
forall a. Show a => a -> String
show (RootTarget
  ConwayEra (NewEpochState ConwayEra) (NewEpochState ConwayEra)
-> PDoc
forall era r t. RootTarget era r t -> PDoc
ppTarget (Proof ConwayEra
-> RootTarget
     ConwayEra (NewEpochState ConwayEra) (NewEpochState ConwayEra)
forall era.
Reflect era =>
Proof era -> RootTarget era (NewEpochState era) (NewEpochState era)
newEpochStateT Proof ConwayEra
Conway))

printTarget :: RootTarget era root t -> IO ()
printTarget :: forall era root t. RootTarget era root t -> IO ()
printTarget RootTarget era root t
t = String -> IO ()
putStrLn (PDoc -> String
forall a. Show a => a -> String
show (RootTarget era root t -> PDoc
forall era r t. RootTarget era r t -> PDoc
ppTarget RootTarget era root t
t))

-- =====================================================================
-- PParams fields

-- | ProtVer in pparams
protVer :: Era era => Proof era -> Term era ProtVer
protVer :: forall era. Era era => Proof era -> Term era ProtVer
protVer Proof era
proof =
  V era ProtVer -> Term era ProtVer
forall era t. V era t -> Term era t
Var
    ( Proof era
-> String
-> Rep era ProtVer
-> Access era (PParamsF era) ProtVer
-> V era ProtVer
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV
        Proof era
proof
        String
"protVer"
        (Proof era -> Rep era ProtVer
forall era. Era era => Proof era -> Rep era ProtVer
ProtVerR Proof era
proof)
        (Rep era (PParamsF era)
-> (forall {f :: * -> *}.
    Functor f =>
    (ProtVer -> f ProtVer) -> PParamsF era -> f (PParamsF era))
-> Access era (PParamsF era) ProtVer
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
proof) ((forall {f :: * -> *}.
  Functor f =>
  (ProtVer -> f ProtVer) -> PParamsF era -> f (PParamsF era))
 -> Access era (PParamsF era) ProtVer)
-> (forall {f :: * -> *}.
    Functor f =>
    (ProtVer -> f ProtVer) -> PParamsF era -> f (PParamsF era))
-> Access era (PParamsF era) ProtVer
forall a b. (a -> b) -> a -> b
$ Proof era
-> (EraPParams era =>
    (ProtVer -> f ProtVer) -> PParamsF era -> f (PParamsF era))
-> (ProtVer -> f ProtVer)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
proof ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((ProtVer -> f ProtVer) -> PParams era -> f (PParams era))
-> (ProtVer -> f ProtVer)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ProtVer -> f ProtVer) -> PParams era -> f (PParams era)
forall era. EraPParams era => Lens' (PParams era) ProtVer
Lens' (PParams era) ProtVer
ppProtocolVersionL))
    )

-- | ProtVer in prevPParams
prevProtVer :: Era era => Proof era -> Term era ProtVer
prevProtVer :: forall era. Era era => Proof era -> Term era ProtVer
prevProtVer Proof era
proof =
  V era ProtVer -> Term era ProtVer
forall era t. V era t -> Term era t
Var
    ( Proof era
-> String
-> Rep era ProtVer
-> Access era (PParamsF era) ProtVer
-> V era ProtVer
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV
        Proof era
proof
        String
"prevProtVer"
        (Proof era -> Rep era ProtVer
forall era. Era era => Proof era -> Rep era ProtVer
ProtVerR Proof era
proof)
        (Rep era (PParamsF era)
-> (forall {f :: * -> *}.
    Functor f =>
    (ProtVer -> f ProtVer) -> PParamsF era -> f (PParamsF era))
-> Access era (PParamsF era) ProtVer
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
proof) ((forall {f :: * -> *}.
  Functor f =>
  (ProtVer -> f ProtVer) -> PParamsF era -> f (PParamsF era))
 -> Access era (PParamsF era) ProtVer)
-> (forall {f :: * -> *}.
    Functor f =>
    (ProtVer -> f ProtVer) -> PParamsF era -> f (PParamsF era))
-> Access era (PParamsF era) ProtVer
forall a b. (a -> b) -> a -> b
$ Proof era
-> (EraPParams era =>
    (ProtVer -> f ProtVer) -> PParamsF era -> f (PParamsF era))
-> (ProtVer -> f ProtVer)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
proof ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((ProtVer -> f ProtVer) -> PParams era -> f (PParams era))
-> (ProtVer -> f ProtVer)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ProtVer -> f ProtVer) -> PParams era -> f (PParams era)
forall era. EraPParams era => Lens' (PParams era) ProtVer
Lens' (PParams era) ProtVer
ppProtocolVersionL))
    )

minFeeA :: Era era => Proof era -> Term era Coin
minFeeA :: forall era. Era era => Proof era -> Term era Coin
minFeeA Proof era
proof =
  V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var
    ( Proof era
-> String
-> Rep era Coin
-> Access era (PParamsF era) Coin
-> V era Coin
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV
        Proof era
proof
        String
"minFeeA"
        Rep era Coin
forall era. Rep era Coin
CoinR
        (Rep era (PParamsF era)
-> (forall {f :: * -> *}.
    Functor f =>
    (Coin -> f Coin) -> PParamsF era -> f (PParamsF era))
-> Access era (PParamsF era) Coin
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
proof) ((forall {f :: * -> *}.
  Functor f =>
  (Coin -> f Coin) -> PParamsF era -> f (PParamsF era))
 -> Access era (PParamsF era) Coin)
-> (forall {f :: * -> *}.
    Functor f =>
    (Coin -> f Coin) -> PParamsF era -> f (PParamsF era))
-> Access era (PParamsF era) Coin
forall a b. (a -> b) -> a -> b
$ Proof era
-> (EraPParams era =>
    (Coin -> f Coin) -> PParamsF era -> f (PParamsF era))
-> (Coin -> f Coin)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
proof ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((Coin -> f Coin) -> PParams era -> f (PParams era))
-> (Coin -> f Coin)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Coin -> f Coin) -> PParams era -> f (PParams era)
forall era. EraPParams era => Lens' (PParams era) Coin
Lens' (PParams era) Coin
ppMinFeeAL))
    )

minFeeB :: Era era => Proof era -> Term era Coin
minFeeB :: forall era. Era era => Proof era -> Term era Coin
minFeeB Proof era
proof =
  V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var
    ( Proof era
-> String
-> Rep era Coin
-> Access era (PParamsF era) Coin
-> V era Coin
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV
        Proof era
proof
        String
"minFeeB"
        Rep era Coin
forall era. Rep era Coin
CoinR
        (Rep era (PParamsF era)
-> (forall {f :: * -> *}.
    Functor f =>
    (Coin -> f Coin) -> PParamsF era -> f (PParamsF era))
-> Access era (PParamsF era) Coin
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
proof) ((forall {f :: * -> *}.
  Functor f =>
  (Coin -> f Coin) -> PParamsF era -> f (PParamsF era))
 -> Access era (PParamsF era) Coin)
-> (forall {f :: * -> *}.
    Functor f =>
    (Coin -> f Coin) -> PParamsF era -> f (PParamsF era))
-> Access era (PParamsF era) Coin
forall a b. (a -> b) -> a -> b
$ Proof era
-> (EraPParams era =>
    (Coin -> f Coin) -> PParamsF era -> f (PParamsF era))
-> (Coin -> f Coin)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
proof ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((Coin -> f Coin) -> PParams era -> f (PParams era))
-> (Coin -> f Coin)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Coin -> f Coin) -> PParams era -> f (PParams era)
forall era. EraPParams era => Lens' (PParams era) Coin
Lens' (PParams era) Coin
ppMinFeeBL))
    )

-- | Max Block Body Size
maxBBSize :: Era era => Proof era -> Term era Natural
maxBBSize :: forall era. Era era => Proof era -> Term era Natural
maxBBSize Proof era
p =
  V era Natural -> Term era Natural
forall era t. V era t -> Term era t
Var
    ( Proof era
-> String
-> Rep era Natural
-> Access era (PParamsF era) Natural
-> V era Natural
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV
        Proof era
p
        String
"maxBBSize"
        Rep era Natural
forall era. Rep era Natural
NaturalR
        (Rep era (PParamsF era)
-> Lens' (PParamsF era) Natural
-> Access era (PParamsF era) Natural
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
p) (Proof era
-> (EraPParams era =>
    (Natural -> f Natural) -> PParamsF era -> f (PParamsF era))
-> (Natural -> f Natural)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
p ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((Natural -> f Natural) -> PParams era -> f (PParams era))
-> (Natural -> f Natural)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word32 -> f Word32) -> PParams era -> f (PParams era)
forall era. EraPParams era => Lens' (PParams era) Word32
Lens' (PParams era) Word32
ppMaxBBSizeL ((Word32 -> f Word32) -> PParams era -> f (PParams era))
-> ((Natural -> f Natural) -> Word32 -> f Word32)
-> (Natural -> f Natural)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Natural -> f Natural) -> Word32 -> f Word32
Lens' Word32 Natural
word32NaturalL)))
    )

-- | Max Tx Size
maxTxSize :: Era era => Proof era -> Term era Natural
maxTxSize :: forall era. Era era => Proof era -> Term era Natural
maxTxSize Proof era
p =
  V era Natural -> Term era Natural
forall era t. V era t -> Term era t
Var
    ( Proof era
-> String
-> Rep era Natural
-> Access era (PParamsF era) Natural
-> V era Natural
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV
        Proof era
p
        String
"maxTxSize"
        Rep era Natural
forall era. Rep era Natural
NaturalR
        (Rep era (PParamsF era)
-> Lens' (PParamsF era) Natural
-> Access era (PParamsF era) Natural
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
p) (Proof era
-> (EraPParams era =>
    (Natural -> f Natural) -> PParamsF era -> f (PParamsF era))
-> (Natural -> f Natural)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
p ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((Natural -> f Natural) -> PParams era -> f (PParams era))
-> (Natural -> f Natural)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word32 -> f Word32) -> PParams era -> f (PParams era)
forall era. EraPParams era => Lens' (PParams era) Word32
Lens' (PParams era) Word32
ppMaxTxSizeL ((Word32 -> f Word32) -> PParams era -> f (PParams era))
-> ((Natural -> f Natural) -> Word32 -> f Word32)
-> (Natural -> f Natural)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Natural -> f Natural) -> Word32 -> f Word32
Lens' Word32 Natural
word32NaturalL)))
    )

fromIntegralBounded ::
  forall a b.
  (HasCallStack, Integral a, Show a, Integral b, Bounded b, Show b) =>
  String ->
  a ->
  b
fromIntegralBounded :: forall a b.
(HasCallStack, Integral a, Show a, Integral b, Bounded b,
 Show b) =>
String -> a -> b
fromIntegralBounded String
name a
x
  | b -> Integer
forall a. Integral a => a -> Integer
toInteger (b
forall a. Bounded a => a
minBound :: b) Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
xi Bool -> Bool -> Bool
&& Integer
xi Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= b -> Integer
forall a. Integral a => a -> Integer
toInteger (b
forall a. Bounded a => a
maxBound :: b) = a -> b
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
x
  | Bool
otherwise =
      String -> b
forall a. HasCallStack => String -> a
error (String -> b) -> String -> b
forall a b. (a -> b) -> a -> b
$
        String
"While converting "
          String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
name
          String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
", "
          String -> String -> String
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show a
x String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
" is out of bounds: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> (b, b) -> String
forall a. Show a => a -> String
show (b
forall a. Bounded a => a
minBound :: b, b
forall a. Bounded a => a
maxBound :: b)
  where
    xi :: Integer
xi = a -> Integer
forall a. Integral a => a -> Integer
toInteger a
x

word32NaturalL :: Lens' Word32 Natural
word32NaturalL :: Lens' Word32 Natural
word32NaturalL = (Word32 -> Natural)
-> (Word32 -> Natural -> Word32) -> Lens' Word32 Natural
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Word32 -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral (\Word32
_ Natural
y -> String -> Integer -> Word32
forall a b.
(HasCallStack, Integral a, Show a, Integral b, Bounded b,
 Show b) =>
String -> a -> b
fromIntegralBounded String
"word32NaturaL" (Natural -> Integer
forall a. Integral a => a -> Integer
toInteger Natural
y))

word16NaturalL :: Lens' Word16 Natural
word16NaturalL :: Lens' Word16 Natural
word16NaturalL = (Word16 -> Natural)
-> (Word16 -> Natural -> Word16) -> Lens' Word16 Natural
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Word16 -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral (\Word16
_ Natural
y -> String -> Integer -> Word16
forall a b.
(HasCallStack, Integral a, Show a, Integral b, Bounded b,
 Show b) =>
String -> a -> b
fromIntegralBounded String
"word16NaturalL" (Natural -> Integer
forall a. Integral a => a -> Integer
toInteger Natural
y))

-- | Max Block Header Size
maxBHSize :: Era era => Proof era -> Term era Natural
maxBHSize :: forall era. Era era => Proof era -> Term era Natural
maxBHSize Proof era
p =
  V era Natural -> Term era Natural
forall era t. V era t -> Term era t
Var
    ( Proof era
-> String
-> Rep era Natural
-> Access era (PParamsF era) Natural
-> V era Natural
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV
        Proof era
p
        String
"maxBHSize"
        Rep era Natural
forall era. Rep era Natural
NaturalR
        (Rep era (PParamsF era)
-> Lens' (PParamsF era) Natural
-> Access era (PParamsF era) Natural
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
p) (Proof era
-> (EraPParams era =>
    (Natural -> f Natural) -> PParamsF era -> f (PParamsF era))
-> (Natural -> f Natural)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
p ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((Natural -> f Natural) -> PParams era -> f (PParams era))
-> (Natural -> f Natural)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word16 -> f Word16) -> PParams era -> f (PParams era)
forall era. EraPParams era => Lens' (PParams era) Word16
Lens' (PParams era) Word16
ppMaxBHSizeL ((Word16 -> f Word16) -> PParams era -> f (PParams era))
-> ((Natural -> f Natural) -> Word16 -> f Word16)
-> (Natural -> f Natural)
-> PParams era
-> f (PParams era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Natural -> f Natural) -> Word16 -> f Word16
Lens' Word16 Natural
word16NaturalL)))
    )

poolDepAmt :: Era era => Proof era -> Term era Coin
poolDepAmt :: forall era. Era era => Proof era -> Term era Coin
poolDepAmt Proof era
p =
  V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$
    Proof era
-> String
-> Rep era Coin
-> Access era (PParamsF era) Coin
-> V era Coin
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV
      Proof era
p
      String
"poolDepAmt"
      Rep era Coin
forall era. Rep era Coin
CoinR
      (Rep era (PParamsF era)
-> Lens' (PParamsF era) Coin -> Access era (PParamsF era) Coin
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
p) (Proof era
-> (EraPParams era =>
    (Coin -> f Coin) -> PParamsF era -> f (PParamsF era))
-> (Coin -> f Coin)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
p ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((Coin -> f Coin) -> PParams era -> f (PParams era))
-> (Coin -> f Coin)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Coin -> f Coin) -> PParams era -> f (PParams era)
forall era. EraPParams era => Lens' (PParams era) Coin
Lens' (PParams era) Coin
ppPoolDepositL)))

keyDepAmt :: Era era => Proof era -> Term era Coin
keyDepAmt :: forall era. Era era => Proof era -> Term era Coin
keyDepAmt Proof era
p =
  V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$
    Proof era
-> String
-> Rep era Coin
-> Access era (PParamsF era) Coin
-> V era Coin
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV
      Proof era
p
      String
"keyDepAmt"
      Rep era Coin
forall era. Rep era Coin
CoinR
      (Rep era (PParamsF era)
-> Lens' (PParamsF era) Coin -> Access era (PParamsF era) Coin
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
p) (Proof era
-> (EraPParams era =>
    (Coin -> f Coin) -> PParamsF era -> f (PParamsF era))
-> (Coin -> f Coin)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
p ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((Coin -> f Coin) -> PParams era -> f (PParams era))
-> (Coin -> f Coin)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Coin -> f Coin) -> PParams era -> f (PParams era)
forall era. EraPParams era => Lens' (PParams era) Coin
Lens' (PParams era) Coin
ppKeyDepositL)))

proposalDeposit :: ConwayEraPParams era => Proof era -> Term era Coin
proposalDeposit :: forall era. ConwayEraPParams era => Proof era -> Term era Coin
proposalDeposit Proof era
p =
  V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$
    Proof era
-> String
-> Rep era Coin
-> Access era (PParamsF era) Coin
-> V era Coin
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV
      Proof era
p
      String
"proposalDeposit"
      Rep era Coin
forall era. Rep era Coin
CoinR
      (Rep era (PParamsF era)
-> Lens' (PParamsF era) Coin -> Access era (PParamsF era) Coin
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
p) (Proof era
-> (EraPParams era =>
    (Coin -> f Coin) -> PParamsF era -> f (PParamsF era))
-> (Coin -> f Coin)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
p ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((Coin -> f Coin) -> PParams era -> f (PParams era))
-> (Coin -> f Coin)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Coin -> f Coin) -> PParams era -> f (PParams era)
forall era. ConwayEraPParams era => Lens' (PParams era) Coin
Lens' (PParams era) Coin
ppGovActionDepositL)))

maxTxExUnits :: AlonzoEraPParams era => Proof era -> Term era ExUnits
maxTxExUnits :: forall era. AlonzoEraPParams era => Proof era -> Term era ExUnits
maxTxExUnits Proof era
p =
  V era ExUnits -> Term era ExUnits
forall era t. V era t -> Term era t
Var (V era ExUnits -> Term era ExUnits)
-> V era ExUnits -> Term era ExUnits
forall a b. (a -> b) -> a -> b
$
    Proof era
-> String
-> Rep era ExUnits
-> Access era (PParamsF era) ExUnits
-> V era ExUnits
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV
      Proof era
p
      String
"maxTxExUnits"
      Rep era ExUnits
forall era. Rep era ExUnits
ExUnitsR
      (Rep era (PParamsF era)
-> Lens' (PParamsF era) ExUnits
-> Access era (PParamsF era) ExUnits
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
p) (Proof era
-> (EraPParams era =>
    (ExUnits -> f ExUnits) -> PParamsF era -> f (PParamsF era))
-> (ExUnits -> f ExUnits)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
p ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((ExUnits -> f ExUnits) -> PParams era -> f (PParams era))
-> (ExUnits -> f ExUnits)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ExUnits -> f ExUnits) -> PParams era -> f (PParams era)
forall era. AlonzoEraPParams era => Lens' (PParams era) ExUnits
Lens' (PParams era) ExUnits
ppMaxTxExUnitsL)))

collateralPercentage :: AlonzoEraPParams era => Proof era -> Term era Natural
collateralPercentage :: forall era. AlonzoEraPParams era => Proof era -> Term era Natural
collateralPercentage Proof era
p =
  V era Natural -> Term era Natural
forall era t. V era t -> Term era t
Var (V era Natural -> Term era Natural)
-> V era Natural -> Term era Natural
forall a b. (a -> b) -> a -> b
$
    Proof era
-> String
-> Rep era Natural
-> Access era (PParamsF era) Natural
-> V era Natural
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV
      Proof era
p
      String
"collateralPercentage"
      Rep era Natural
forall era. Rep era Natural
NaturalR
      (Rep era (PParamsF era)
-> Lens' (PParamsF era) Natural
-> Access era (PParamsF era) Natural
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
p) (Proof era
-> (EraPParams era =>
    (Natural -> f Natural) -> PParamsF era -> f (PParamsF era))
-> (Natural -> f Natural)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
p ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((Natural -> f Natural) -> PParams era -> f (PParams era))
-> (Natural -> f Natural)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Natural -> f Natural) -> PParams era -> f (PParams era)
forall era. AlonzoEraPParams era => Lens' (PParams era) Natural
Lens' (PParams era) Natural
ppCollateralPercentageL)))

drepDeposit :: ConwayEraPParams era => Proof era -> Term era Coin
drepDeposit :: forall era. ConwayEraPParams era => Proof era -> Term era Coin
drepDeposit Proof era
p =
  V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$
    Proof era
-> String
-> Rep era Coin
-> Access era (PParamsF era) Coin
-> V era Coin
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV Proof era
p String
"drepDeposit" Rep era Coin
forall era. Rep era Coin
CoinR (Rep era (PParamsF era)
-> Lens' (PParamsF era) Coin -> Access era (PParamsF era) Coin
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
p) (Proof era
-> (EraPParams era =>
    (Coin -> f Coin) -> PParamsF era -> f (PParamsF era))
-> (Coin -> f Coin)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
p ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((Coin -> f Coin) -> PParams era -> f (PParams era))
-> (Coin -> f Coin)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Coin -> f Coin) -> PParams era -> f (PParams era)
forall era. ConwayEraPParams era => Lens' (PParams era) Coin
Lens' (PParams era) Coin
ppDRepDepositL)))

drepActivity :: ConwayEraPParams era => Proof era -> Term era Base.EpochInterval
drepActivity :: forall era.
ConwayEraPParams era =>
Proof era -> Term era EpochInterval
drepActivity Proof era
p =
  V era EpochInterval -> Term era EpochInterval
forall era t. V era t -> Term era t
Var (V era EpochInterval -> Term era EpochInterval)
-> V era EpochInterval -> Term era EpochInterval
forall a b. (a -> b) -> a -> b
$
    Proof era
-> String
-> Rep era EpochInterval
-> Access era (PParamsF era) EpochInterval
-> V era EpochInterval
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV
      Proof era
p
      String
"drepActivty"
      Rep era EpochInterval
forall era. Rep era EpochInterval
EpochIntervalR
      (Rep era (PParamsF era)
-> Lens' (PParamsF era) EpochInterval
-> Access era (PParamsF era) EpochInterval
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
p) (Proof era
-> (EraPParams era =>
    (EpochInterval -> f EpochInterval)
    -> PParamsF era -> f (PParamsF era))
-> (EpochInterval -> f EpochInterval)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
p ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((EpochInterval -> f EpochInterval)
    -> PParams era -> f (PParams era))
-> (EpochInterval -> f EpochInterval)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (EpochInterval -> f EpochInterval)
-> PParams era -> f (PParams era)
forall era.
ConwayEraPParams era =>
Lens' (PParams era) EpochInterval
Lens' (PParams era) EpochInterval
ppDRepActivityL)))

maxEpoch :: Era era => Proof era -> Term era Base.EpochInterval
maxEpoch :: forall era. Era era => Proof era -> Term era EpochInterval
maxEpoch Proof era
p =
  V era EpochInterval -> Term era EpochInterval
forall era t. V era t -> Term era t
Var (V era EpochInterval -> Term era EpochInterval)
-> V era EpochInterval -> Term era EpochInterval
forall a b. (a -> b) -> a -> b
$
    Proof era
-> String
-> Rep era EpochInterval
-> Access era (PParamsF era) EpochInterval
-> V era EpochInterval
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV
      Proof era
p
      String
"maxEpoch"
      Rep era EpochInterval
forall era. Rep era EpochInterval
EpochIntervalR
      (Rep era (PParamsF era)
-> Lens' (PParamsF era) EpochInterval
-> Access era (PParamsF era) EpochInterval
forall era s t. Rep era s -> Lens' s t -> Access era s t
Yes (Proof era -> Rep era (PParamsF era)
forall era. Era era => Proof era -> Rep era (PParamsF era)
PParamsR Proof era
p) (Proof era
-> (EraPParams era =>
    (EpochInterval -> f EpochInterval)
    -> PParamsF era -> f (PParamsF era))
-> (EpochInterval -> f EpochInterval)
-> PParamsF era
-> f (PParamsF era)
forall era a. Proof era -> (EraPParams era => a) -> a
withEraPParams Proof era
p ((PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> PParamsF era -> f (PParamsF era)
pparamsWrapperL ((PParams era -> f (PParams era))
 -> PParamsF era -> f (PParamsF era))
-> ((EpochInterval -> f EpochInterval)
    -> PParams era -> f (PParams era))
-> (EpochInterval -> f EpochInterval)
-> PParamsF era
-> f (PParamsF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (EpochInterval -> f EpochInterval)
-> PParams era -> f (PParams era)
forall era. EraPParams era => Lens' (PParams era) EpochInterval
Lens' (PParams era) EpochInterval
ppEMaxL)))

-- =================================================================
-- TxBody vars

txbodyterm :: Reflect era => Term era (TxBodyF era)
txbodyterm :: forall era. Reflect era => Term era (TxBodyF era)
txbodyterm = V era (TxBodyF era) -> Term era (TxBodyF era)
forall era t. V era t -> Term era t
Var (V era (TxBodyF era) -> Term era (TxBodyF era))
-> V era (TxBodyF era) -> Term era (TxBodyF era)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (TxBodyF era)
-> Access era Any (TxBodyF era)
-> V era (TxBodyF era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"txbodyterm" (Proof era -> Rep era (TxBodyF era)
forall era. Era era => Proof era -> Rep era (TxBodyF era)
TxBodyR Proof era
forall era. Reflect era => Proof era
reify) Access era Any (TxBodyF era)
forall era s t. Access era s t
No

inputs :: Era era => Term era (Set TxIn)
inputs :: forall era. Era era => Term era (Set TxIn)
inputs = V era (Set TxIn) -> Term era (Set TxIn)
forall era t. V era t -> Term era t
Var (V era (Set TxIn) -> Term era (Set TxIn))
-> V era (Set TxIn) -> Term era (Set TxIn)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set TxIn)
-> Access era Any (Set TxIn)
-> V era (Set TxIn)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"inputs" (Rep era TxIn -> Rep era (Set TxIn)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era TxIn
forall era. Era era => Rep era TxIn
TxInR) Access era Any (Set TxIn)
forall era s t. Access era s t
No

collateral :: Era era => Term era (Set TxIn)
collateral :: forall era. Era era => Term era (Set TxIn)
collateral = V era (Set TxIn) -> Term era (Set TxIn)
forall era t. V era t -> Term era t
Var (V era (Set TxIn) -> Term era (Set TxIn))
-> V era (Set TxIn) -> Term era (Set TxIn)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set TxIn)
-> Access era Any (Set TxIn)
-> V era (Set TxIn)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"collateral" (Rep era TxIn -> Rep era (Set TxIn)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era TxIn
forall era. Era era => Rep era TxIn
TxInR) Access era Any (Set TxIn)
forall era s t. Access era s t
No

refInputs :: Era era => Term era (Set TxIn)
refInputs :: forall era. Era era => Term era (Set TxIn)
refInputs = V era (Set TxIn) -> Term era (Set TxIn)
forall era t. V era t -> Term era t
Var (V era (Set TxIn) -> Term era (Set TxIn))
-> V era (Set TxIn) -> Term era (Set TxIn)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set TxIn)
-> Access era Any (Set TxIn)
-> V era (Set TxIn)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"refInputs" (Rep era TxIn -> Rep era (Set TxIn)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era TxIn
forall era. Era era => Rep era TxIn
TxInR) Access era Any (Set TxIn)
forall era s t. Access era s t
No

outputs :: Era era => Proof era -> Term era [TxOutF era]
outputs :: forall era. Era era => Proof era -> Term era [TxOutF era]
outputs Proof era
p = V era [TxOutF era] -> Term era [TxOutF era]
forall era t. V era t -> Term era t
Var (V era [TxOutF era] -> Term era [TxOutF era])
-> V era [TxOutF era] -> Term era [TxOutF era]
forall a b. (a -> b) -> a -> b
$ Proof era
-> String
-> Rep era [TxOutF era]
-> Access era Any [TxOutF era]
-> V era [TxOutF era]
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV Proof era
p String
"outputs" (Rep era (TxOutF era) -> Rep era [TxOutF era]
forall era a. Rep era a -> Rep era [a]
ListR (Proof era -> Rep era (TxOutF era)
forall era. Era era => Proof era -> Rep era (TxOutF era)
TxOutR Proof era
p)) Access era Any [TxOutF era]
forall era s t. Access era s t
No

collateralReturn :: Era era => Proof era -> Term era (TxOutF era)
collateralReturn :: forall era. Era era => Proof era -> Term era (TxOutF era)
collateralReturn Proof era
p = V era (TxOutF era) -> Term era (TxOutF era)
forall era t. V era t -> Term era t
Var (V era (TxOutF era) -> Term era (TxOutF era))
-> V era (TxOutF era) -> Term era (TxOutF era)
forall a b. (a -> b) -> a -> b
$ Proof era
-> String
-> Rep era (TxOutF era)
-> Access era Any (TxOutF era)
-> V era (TxOutF era)
forall era t s.
Proof era -> String -> Rep era t -> Access era s t -> V era t
pV Proof era
p String
"collateralReturn" (Proof era -> Rep era (TxOutF era)
forall era. Era era => Proof era -> Rep era (TxOutF era)
TxOutR Proof era
p) Access era Any (TxOutF era)
forall era s t. Access era s t
No

-- | The sum of all the 'collateral' inputs. The Tx is constucted
--   by SNothing or wrapping 'SJust' around this value.
totalCol :: Era era => Term era Coin
totalCol :: forall era. Era era => Term era Coin
totalCol = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"totalCol" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No

certs :: Reflect era => Term era [TxCertF era]
certs :: forall era. Reflect era => Term era [TxCertF era]
certs = V era [TxCertF era] -> Term era [TxCertF era]
forall era t. V era t -> Term era t
Var (V era [TxCertF era] -> Term era [TxCertF era])
-> V era [TxCertF era] -> Term era [TxCertF era]
forall a b. (a -> b) -> a -> b
$ String
-> Rep era [TxCertF era]
-> Access era Any [TxCertF era]
-> V era [TxCertF era]
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"certs" (Rep era (TxCertF era) -> Rep era [TxCertF era]
forall era a. Rep era a -> Rep era [a]
ListR (Proof era -> Rep era (TxCertF era)
forall era. Era era => Proof era -> Rep era (TxCertF era)
TxCertR Proof era
forall era. Reflect era => Proof era
reify)) Access era Any [TxCertF era]
forall era s t. Access era s t
No

withdrawals :: forall era. Era era => Term era (Map RewardAccount Coin)
withdrawals :: forall era. Era era => Term era (Map RewardAccount Coin)
withdrawals = V era (Map RewardAccount Coin) -> Term era (Map RewardAccount Coin)
forall era t. V era t -> Term era t
Var (V era (Map RewardAccount Coin)
 -> Term era (Map RewardAccount Coin))
-> V era (Map RewardAccount Coin)
-> Term era (Map RewardAccount Coin)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map RewardAccount Coin)
-> Access era Any (Map RewardAccount Coin)
-> V era (Map RewardAccount Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"withdrawals" (Rep era RewardAccount
-> Rep era Coin -> Rep era (Map RewardAccount Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR (forall era. Era era => Rep era RewardAccount
RewardAccountR @era) Rep era Coin
forall era. Rep era Coin
CoinR) Access era Any (Map RewardAccount Coin)
forall era s t. Access era s t
No

txfee :: Era era => Term era Coin
txfee :: forall era. Era era => Term era Coin
txfee = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"txfee" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No

ttl :: Era era => Term era SlotNo
ttl :: forall era. Era era => Term era SlotNo
ttl = V era SlotNo -> Term era SlotNo
forall era t. V era t -> Term era t
Var (V era SlotNo -> Term era SlotNo)
-> V era SlotNo -> Term era SlotNo
forall a b. (a -> b) -> a -> b
$ String -> Rep era SlotNo -> Access era Any SlotNo -> V era SlotNo
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"ttl" Rep era SlotNo
forall era. Rep era SlotNo
SlotNoR Access era Any SlotNo
forall era s t. Access era s t
No

validityInterval :: Era era => Term era ValidityInterval
validityInterval :: forall era. Era era => Term era ValidityInterval
validityInterval = V era ValidityInterval -> Term era ValidityInterval
forall era t. V era t -> Term era t
Var (V era ValidityInterval -> Term era ValidityInterval)
-> V era ValidityInterval -> Term era ValidityInterval
forall a b. (a -> b) -> a -> b
$ String
-> Rep era ValidityInterval
-> Access era Any ValidityInterval
-> V era ValidityInterval
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"validityInterval" Rep era ValidityInterval
forall era. Era era => Rep era ValidityInterval
ValidityIntervalR Access era Any ValidityInterval
forall era s t. Access era s t
No

mint :: Era era => Term era (Map ScriptHash (Map AssetName Integer))
mint :: forall era.
Era era =>
Term era (Map ScriptHash (Map AssetName Integer))
mint = V era (Map ScriptHash (Map AssetName Integer))
-> Term era (Map ScriptHash (Map AssetName Integer))
forall era t. V era t -> Term era t
Var (V era (Map ScriptHash (Map AssetName Integer))
 -> Term era (Map ScriptHash (Map AssetName Integer)))
-> V era (Map ScriptHash (Map AssetName Integer))
-> Term era (Map ScriptHash (Map AssetName Integer))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map ScriptHash (Map AssetName Integer))
-> Access era Any (Map ScriptHash (Map AssetName Integer))
-> V era (Map ScriptHash (Map AssetName Integer))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"mint" (Rep era ScriptHash
-> Rep era (Map AssetName Integer)
-> Rep era (Map ScriptHash (Map AssetName Integer))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era ScriptHash
forall era. Era era => Rep era ScriptHash
ScriptHashR (Rep era AssetName
-> Rep era Integer -> Rep era (Map AssetName Integer)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era AssetName
forall era. Rep era AssetName
AssetNameR Rep era Integer
forall era. Rep era Integer
IntegerR)) Access era Any (Map ScriptHash (Map AssetName Integer))
forall era s t. Access era s t
No

reqSignerHashes :: Era era => Term era (Set (KeyHash 'Witness))
reqSignerHashes :: forall era. Era era => Term era (Set (KeyHash 'Witness))
reqSignerHashes = V era (Set (KeyHash 'Witness)) -> Term era (Set (KeyHash 'Witness))
forall era t. V era t -> Term era t
Var (V era (Set (KeyHash 'Witness))
 -> Term era (Set (KeyHash 'Witness)))
-> V era (Set (KeyHash 'Witness))
-> Term era (Set (KeyHash 'Witness))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set (KeyHash 'Witness))
-> Access era Any (Set (KeyHash 'Witness))
-> V era (Set (KeyHash 'Witness))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"reqSignerHashes" (Rep era (KeyHash 'Witness) -> Rep era (Set (KeyHash 'Witness))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era (KeyHash 'Witness)
forall era. Era era => Rep era (KeyHash 'Witness)
WitHashR) Access era Any (Set (KeyHash 'Witness))
forall era s t. Access era s t
No

networkID :: Era era => Term era (Maybe Network)
networkID :: forall era. Era era => Term era (Maybe Network)
networkID = V era (Maybe Network) -> Term era (Maybe Network)
forall era t. V era t -> Term era t
Var (V era (Maybe Network) -> Term era (Maybe Network))
-> V era (Maybe Network) -> Term era (Maybe Network)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Maybe Network)
-> Access era Any (Maybe Network)
-> V era (Maybe Network)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"networkID" (Rep era Network -> Rep era (Maybe Network)
forall era t1. Rep era t1 -> Rep era (Maybe t1)
MaybeR Rep era Network
forall era. Rep era Network
NetworkR) Access era Any (Maybe Network)
forall era s t. Access era s t
No

adHash :: Era era => Term era (Maybe TxAuxDataHash)
adHash :: forall era. Era era => Term era (Maybe TxAuxDataHash)
adHash = V era (Maybe TxAuxDataHash) -> Term era (Maybe TxAuxDataHash)
forall era t. V era t -> Term era t
Var (V era (Maybe TxAuxDataHash) -> Term era (Maybe TxAuxDataHash))
-> V era (Maybe TxAuxDataHash) -> Term era (Maybe TxAuxDataHash)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Maybe TxAuxDataHash)
-> Access era Any (Maybe TxAuxDataHash)
-> V era (Maybe TxAuxDataHash)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"adHash" (Rep era TxAuxDataHash -> Rep era (Maybe TxAuxDataHash)
forall era t1. Rep era t1 -> Rep era (Maybe t1)
MaybeR Rep era TxAuxDataHash
forall era. Era era => Rep era TxAuxDataHash
TxAuxDataHashR) Access era Any (Maybe TxAuxDataHash)
forall era s t. Access era s t
No

wppHash :: Era era => Term era (Maybe (SafeHash EraIndependentScriptIntegrity))
wppHash :: forall era.
Era era =>
Term era (Maybe (SafeHash EraIndependentScriptIntegrity))
wppHash = V era (Maybe (SafeHash EraIndependentScriptIntegrity))
-> Term era (Maybe (SafeHash EraIndependentScriptIntegrity))
forall era t. V era t -> Term era t
Var (V era (Maybe (SafeHash EraIndependentScriptIntegrity))
 -> Term era (Maybe (SafeHash EraIndependentScriptIntegrity)))
-> V era (Maybe (SafeHash EraIndependentScriptIntegrity))
-> Term era (Maybe (SafeHash EraIndependentScriptIntegrity))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Maybe (SafeHash EraIndependentScriptIntegrity))
-> Access era Any (Maybe (SafeHash EraIndependentScriptIntegrity))
-> V era (Maybe (SafeHash EraIndependentScriptIntegrity))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"wppHash" (Rep era (SafeHash EraIndependentScriptIntegrity)
-> Rep era (Maybe (SafeHash EraIndependentScriptIntegrity))
forall era t1. Rep era t1 -> Rep era (Maybe t1)
MaybeR Rep era (SafeHash EraIndependentScriptIntegrity)
forall era.
Era era =>
Rep era (SafeHash EraIndependentScriptIntegrity)
ScriptIntegrityHashR) Access era Any (Maybe (SafeHash EraIndependentScriptIntegrity))
forall era s t. Access era s t
No

txDonation :: Era era => Term era Coin
txDonation :: forall era. Era era => Term era Coin
txDonation = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"txDonation" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No

-- | lift the model type of 'mint' into a MultiAsset
liftMultiAsset :: Map ScriptHash (Map AssetName Integer) -> MultiAsset
liftMultiAsset :: Map ScriptHash (Map AssetName Integer) -> MultiAsset
liftMultiAsset Map ScriptHash (Map AssetName Integer)
m = Map PolicyID (Map AssetName Integer) -> MultiAsset
MultiAsset ((ScriptHash -> PolicyID)
-> Map ScriptHash (Map AssetName Integer)
-> Map PolicyID (Map AssetName Integer)
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys ScriptHash -> PolicyID
PolicyID Map ScriptHash (Map AssetName Integer)
m)

scriptsNeeded :: Reflect era => Term era (ScriptsNeededF era)
scriptsNeeded :: forall era. Reflect era => Term era (ScriptsNeededF era)
scriptsNeeded = V era (ScriptsNeededF era) -> Term era (ScriptsNeededF era)
forall era t. V era t -> Term era t
Var (V era (ScriptsNeededF era) -> Term era (ScriptsNeededF era))
-> V era (ScriptsNeededF era) -> Term era (ScriptsNeededF era)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (ScriptsNeededF era)
-> Access era Any (ScriptsNeededF era)
-> V era (ScriptsNeededF era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"scriptsNeeded" (Proof era -> Rep era (ScriptsNeededF era)
forall era. Era era => Proof era -> Rep era (ScriptsNeededF era)
ScriptsNeededR Proof era
forall era. Reflect era => Proof era
reify) Access era Any (ScriptsNeededF era)
forall era s t. Access era s t
No

smNeededL ::
  ScriptsNeeded era ~ ShelleyScriptsNeeded era =>
  Lens' (ScriptsNeededF era) (Set ScriptHash)
smNeededL :: forall era.
(ScriptsNeeded era ~ ShelleyScriptsNeeded era) =>
Lens' (ScriptsNeededF era) (Set ScriptHash)
smNeededL =
  (ScriptsNeededF era -> Set ScriptHash)
-> (ScriptsNeededF era -> Set ScriptHash -> ScriptsNeededF era)
-> Lens
     (ScriptsNeededF era)
     (ScriptsNeededF era)
     (Set ScriptHash)
     (Set ScriptHash)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    (\(ScriptsNeededF Proof era
_ (ShelleyScriptsNeeded Set ScriptHash
s)) -> Set ScriptHash
s)
    (\(ScriptsNeededF Proof era
p ScriptsNeeded era
_) Set ScriptHash
s -> Proof era -> ScriptsNeeded era -> ScriptsNeededF era
forall era. Proof era -> ScriptsNeeded era -> ScriptsNeededF era
ScriptsNeededF Proof era
p (Set ScriptHash -> ShelleyScriptsNeeded era
forall era. Set ScriptHash -> ShelleyScriptsNeeded era
ShelleyScriptsNeeded Set ScriptHash
s))

acNeededL ::
  ScriptsNeeded era ~ AlonzoScriptsNeeded era =>
  Lens' (ScriptsNeededF era) [(PlutusPurposeF era, ScriptHash)]
acNeededL :: forall era.
(ScriptsNeeded era ~ AlonzoScriptsNeeded era) =>
Lens' (ScriptsNeededF era) [(PlutusPurposeF era, ScriptHash)]
acNeededL =
  (ScriptsNeededF era -> [(PlutusPurposeF era, ScriptHash)])
-> (ScriptsNeededF era
    -> [(PlutusPurposeF era, ScriptHash)] -> ScriptsNeededF era)
-> Lens
     (ScriptsNeededF era)
     (ScriptsNeededF era)
     [(PlutusPurposeF era, ScriptHash)]
     [(PlutusPurposeF era, ScriptHash)]
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    (\(ScriptsNeededF Proof era
p (AlonzoScriptsNeeded [(PlutusPurpose AsIxItem era, ScriptHash)]
s)) -> ((PlutusPurpose AsIxItem era, ScriptHash)
 -> (PlutusPurposeF era, ScriptHash))
-> [(PlutusPurpose AsIxItem era, ScriptHash)]
-> [(PlutusPurposeF era, ScriptHash)]
forall a b. (a -> b) -> [a] -> [b]
map ((PlutusPurpose AsIxItem era -> PlutusPurposeF era)
-> (PlutusPurpose AsIxItem era, ScriptHash)
-> (PlutusPurposeF era, ScriptHash)
forall b c d. (b -> c) -> (b, d) -> (c, d)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first (Proof era -> PlutusPurpose AsIxItem era -> PlutusPurposeF era
forall era.
Proof era -> PlutusPurpose AsIxItem era -> PlutusPurposeF era
PlutusPurposeF Proof era
p)) [(PlutusPurpose AsIxItem era, ScriptHash)]
s)
    ( \(ScriptsNeededF Proof era
p ScriptsNeeded era
_) [(PlutusPurposeF era, ScriptHash)]
s ->
        Proof era -> ScriptsNeeded era -> ScriptsNeededF era
forall era. Proof era -> ScriptsNeeded era -> ScriptsNeededF era
ScriptsNeededF Proof era
p ([(PlutusPurpose AsIxItem era, ScriptHash)]
-> AlonzoScriptsNeeded era
forall era.
[(PlutusPurpose AsIxItem era, ScriptHash)]
-> AlonzoScriptsNeeded era
AlonzoScriptsNeeded (((PlutusPurposeF era, ScriptHash)
 -> (PlutusPurpose AsIxItem era, ScriptHash))
-> [(PlutusPurposeF era, ScriptHash)]
-> [(PlutusPurpose AsIxItem era, ScriptHash)]
forall a b. (a -> b) -> [a] -> [b]
map ((PlutusPurposeF era -> PlutusPurpose AsIxItem era)
-> (PlutusPurposeF era, ScriptHash)
-> (PlutusPurpose AsIxItem era, ScriptHash)
forall b c d. (b -> c) -> (b, d) -> (c, d)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first PlutusPurposeF era -> PlutusPurpose AsIxItem era
forall era. PlutusPurposeF era -> PlutusPurpose AsIxItem era
unPlutusPurposeF) [(PlutusPurposeF era, ScriptHash)]
s))
    )

-- ===============
-- Auxliary Vars to compute collateral

-- | A Coin that needs to be added to the range of the colInputs in the UtxO
--   that will make sure the collateral is large enough to pay the fees if needed
extraCol :: Era era => Term era Coin
extraCol :: forall era. Era era => Term era Coin
extraCol = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"extraCol" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No

-- | The sum of all the 'collateral' inputs, total colateral of the Tx is computed by adding (SJust _) to this value.
sumCol :: Era era => Term era Coin
sumCol :: forall era. Era era => Term era Coin
sumCol = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"sumCol" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No

colRetAddr :: Era era => Term era Addr
colRetAddr :: forall era. Era era => Term era Addr
colRetAddr = V era Addr -> Term era Addr
forall era t. V era t -> Term era t
Var (V era Addr -> Term era Addr) -> V era Addr -> Term era Addr
forall a b. (a -> b) -> a -> b
$ String -> Rep era Addr -> Access era Any Addr -> V era Addr
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"colRetAddr" Rep era Addr
forall era. Era era => Rep era Addr
AddrR Access era Any Addr
forall era s t. Access era s t
No

-- | The Coin in the 'collateralReturn' TxOut
colRetCoin :: Era era => Term era Coin
colRetCoin :: forall era. Era era => Term era Coin
colRetCoin = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"colRetCoin" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No

-- | The amount that the collateral must cover if there is a two phase error.
--   This is roughly the 'collateralPercentage' * 'txfee' . The calculation deals with rounding,
--   but you don't need those details to understand what is going on.
owed :: Era era => Term era Coin
owed :: forall era. Era era => Term era Coin
owed = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"owed" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No

-- ==============================================================
-- Tx Vars

txbody :: Reflect era => Term era (TxBodyF era)
txbody :: forall era. Reflect era => Term era (TxBodyF era)
txbody = V era (TxBodyF era) -> Term era (TxBodyF era)
forall era t. V era t -> Term era t
Var (V era (TxBodyF era) -> Term era (TxBodyF era))
-> V era (TxBodyF era) -> Term era (TxBodyF era)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (TxBodyF era)
-> Access era Any (TxBodyF era)
-> V era (TxBodyF era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"txbody" (Proof era -> Rep era (TxBodyF era)
forall era. Era era => Proof era -> Rep era (TxBodyF era)
TxBodyR Proof era
forall era. Reflect era => Proof era
reify) Access era Any (TxBodyF era)
forall era s t. Access era s t
No

txwits :: Reflect era => Term era (TxWitsF era)
txwits :: forall era. Reflect era => Term era (TxWitsF era)
txwits = V era (TxWitsF era) -> Term era (TxWitsF era)
forall era t. V era t -> Term era t
Var (V era (TxWitsF era) -> Term era (TxWitsF era))
-> V era (TxWitsF era) -> Term era (TxWitsF era)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (TxWitsF era)
-> Access era Any (TxWitsF era)
-> V era (TxWitsF era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"txwits" (Proof era -> Rep era (TxWitsF era)
forall era. Era era => Proof era -> Rep era (TxWitsF era)
TxWitsR Proof era
forall era. Reflect era => Proof era
reify) Access era Any (TxWitsF era)
forall era s t. Access era s t
No

txauxdata :: Reflect era => Term era (Maybe (TxAuxDataF era))
txauxdata :: forall era. Reflect era => Term era (Maybe (TxAuxDataF era))
txauxdata = V era (Maybe (TxAuxDataF era)) -> Term era (Maybe (TxAuxDataF era))
forall era t. V era t -> Term era t
Var (V era (Maybe (TxAuxDataF era))
 -> Term era (Maybe (TxAuxDataF era)))
-> V era (Maybe (TxAuxDataF era))
-> Term era (Maybe (TxAuxDataF era))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Maybe (TxAuxDataF era))
-> Access era Any (Maybe (TxAuxDataF era))
-> V era (Maybe (TxAuxDataF era))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"txauxdata" (Rep era (TxAuxDataF era) -> Rep era (Maybe (TxAuxDataF era))
forall era t1. Rep era t1 -> Rep era (Maybe t1)
MaybeR (Proof era -> Rep era (TxAuxDataF era)
forall era. Era era => Proof era -> Rep era (TxAuxDataF era)
TxAuxDataR Proof era
forall era. Reflect era => Proof era
reify)) Access era Any (Maybe (TxAuxDataF era))
forall era s t. Access era s t
No

txisvalid :: Era era => Term era IsValid
txisvalid :: forall era. Era era => Term era IsValid
txisvalid = V era IsValid -> Term era IsValid
forall era t. V era t -> Term era t
Var (V era IsValid -> Term era IsValid)
-> V era IsValid -> Term era IsValid
forall a b. (a -> b) -> a -> b
$ String
-> Rep era IsValid -> Access era Any IsValid -> V era IsValid
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"txisvalid" Rep era IsValid
forall era. Rep era IsValid
IsValidR Access era Any IsValid
forall era s t. Access era s t
No

valids :: Era era => Term era [IsValid]
valids :: forall era. Era era => Term era [IsValid]
valids = V era [IsValid] -> Term era [IsValid]
forall era t. V era t -> Term era t
Var (V era [IsValid] -> Term era [IsValid])
-> V era [IsValid] -> Term era [IsValid]
forall a b. (a -> b) -> a -> b
$ String
-> Rep era [IsValid] -> Access era Any [IsValid] -> V era [IsValid]
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"valids" (Rep era IsValid -> Rep era [IsValid]
forall era a. Rep era a -> Rep era [a]
ListR Rep era IsValid
forall era. Rep era IsValid
IsValidR) Access era Any [IsValid]
forall era s t. Access era s t
No

txterm :: Reflect era => Term era (TxF era)
txterm :: forall era. Reflect era => Term era (TxF era)
txterm = V era (TxF era) -> Term era (TxF era)
forall era t. V era t -> Term era t
Var (V era (TxF era) -> Term era (TxF era))
-> V era (TxF era) -> Term era (TxF era)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (TxF era) -> Access era Any (TxF era) -> V era (TxF era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"txterm" (Proof era -> Rep era (TxF era)
forall era. Era era => Proof era -> Rep era (TxF era)
TxR Proof era
forall era. Reflect era => Proof era
reify) Access era Any (TxF era)
forall era s t. Access era s t
No

-- ==============================================================
-- Terms and Fields for use in TxOut and TxBody

-- Lenses for use in TxBody

getRwdCredL :: Lens' RewardAccount (Credential 'Staking)
getRwdCredL :: Lens' RewardAccount (Credential 'Staking)
getRwdCredL = (RewardAccount -> Credential 'Staking)
-> (RewardAccount -> Credential 'Staking -> RewardAccount)
-> Lens' RewardAccount (Credential 'Staking)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens RewardAccount -> Credential 'Staking
raCredential (\RewardAccount
r Credential 'Staking
c -> RewardAccount
r {raCredential = c})

txOutFL :: Lens' (TxOutF era) (TxOut era)
txOutFL :: forall era (f :: * -> *).
Functor f =>
(TxOut era -> f (TxOut era)) -> TxOutF era -> f (TxOutF era)
txOutFL = (TxOutF era -> TxOut era)
-> (TxOutF era -> TxOut era -> TxOutF era)
-> Lens (TxOutF era) (TxOutF era) (TxOut era) (TxOut era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TxOutF era -> TxOut era
forall era. TxOutF era -> TxOut era
unTxOut (\(TxOutF Proof era
p TxOut era
_) TxOut era
y -> Proof era -> TxOut era -> TxOutF era
forall era. Proof era -> TxOut era -> TxOutF era
TxOutF Proof era
p TxOut era
y)

valueFL :: Reflect era => Lens' (Value era) (ValueF era)
valueFL :: forall era. Reflect era => Lens' (Value era) (ValueF era)
valueFL = (Value era -> ValueF era)
-> (Value era -> ValueF era -> Value era)
-> Lens (Value era) (Value era) (ValueF era) (ValueF era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Proof era -> Value era -> ValueF era
forall era. Proof era -> Value era -> ValueF era
ValueF Proof era
forall era. Reflect era => Proof era
reify) (\Value era
_ (ValueF Proof era
_ Value era
u) -> Value era
u)

lensVC :: Val t => Lens' t Coin
lensVC :: forall t. Val t => Lens' t Coin
lensVC = (t -> Coin)
-> (t -> Coin -> t)
-> forall {f :: * -> *}. Functor f => (Coin -> f Coin) -> t -> f t
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens t -> Coin
forall t. Val t => t -> Coin
coin ((t -> Coin -> t)
 -> forall {f :: * -> *}. Functor f => (Coin -> f Coin) -> t -> f t)
-> (t -> Coin -> t)
-> forall {f :: * -> *}. Functor f => (Coin -> f Coin) -> t -> f t
forall a b. (a -> b) -> a -> b
$ \t
t Coin
c -> (Coin -> Coin) -> t -> t
forall t. Val t => (Coin -> Coin) -> t -> t
modifyCoin (Coin -> Coin -> Coin
forall a b. a -> b -> a
const Coin
c) t
t

valueFCoinL :: (HasCallStack, Reflect era) => Lens' (ValueF era) Coin
valueFCoinL :: forall era. (HasCallStack, Reflect era) => Lens' (ValueF era) Coin
valueFCoinL =
  (ValueF era -> Coin)
-> (ValueF era -> Coin -> ValueF era)
-> Lens (ValueF era) (ValueF era) Coin Coin
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    (Value era -> Coin
forall t. Val t => t -> Coin
coin (Value era -> Coin)
-> (ValueF era -> Value era) -> ValueF era -> Coin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ValueF era -> Value era
forall era. ValueF era -> Value era
unValue)
    ( \(ValueF Proof era
p Value era
v) c :: Coin
c@(Coin Integer
i) ->
        if Integer
i Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0
          then String -> ValueF era
forall a. HasCallStack => String -> a
error (String
"Coin is less than 0 " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Integer -> String
forall a. Show a => a -> String
show Integer
i String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" in valueFCoinL")
          else (Proof era -> Value era -> ValueF era
forall era. Proof era -> Value era -> ValueF era
ValueF Proof era
p ((Coin -> Coin) -> Value era -> Value era
forall t. Val t => (Coin -> Coin) -> t -> t
modifyCoin (Coin -> Coin -> Coin
forall a b. a -> b -> a
const Coin
c) Value era
v))
    )

outputCoinL :: (HasCallStack, Reflect era) => Lens' (TxOutF era) Coin
outputCoinL :: forall era. (HasCallStack, Reflect era) => Lens' (TxOutF era) Coin
outputCoinL =
  (TxOutF era -> Coin)
-> (TxOutF era -> Coin -> TxOutF era)
-> Lens (TxOutF era) (TxOutF era) Coin Coin
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    (\(TxOutF Proof era
_ TxOut era
out) -> TxOut era
out TxOut era -> Getting Coin (TxOut era) Coin -> Coin
forall s a. s -> Getting a s a -> a
^. Getting Coin (TxOut era) Coin
forall era. (HasCallStack, EraTxOut era) => Lens' (TxOut era) Coin
Lens' (TxOut era) Coin
coinTxOutL)
    (\(TxOutF Proof era
p TxOut era
out) Coin
c -> Proof era -> TxOut era -> TxOutF era
forall era. Proof era -> TxOut era -> TxOutF era
TxOutF Proof era
p (TxOut era
out TxOut era -> (TxOut era -> TxOut era) -> TxOut era
forall a b. a -> (a -> b) -> b
& (Coin -> Identity Coin) -> TxOut era -> Identity (TxOut era)
forall era. (HasCallStack, EraTxOut era) => Lens' (TxOut era) Coin
Lens' (TxOut era) Coin
coinTxOutL ((Coin -> Identity Coin) -> TxOut era -> Identity (TxOut era))
-> Coin -> TxOut era -> TxOut era
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Coin
c))

-- | a Field from (ValueF era) to Coin
valCoinF :: (HasCallStack, Reflect era) => Field era (ValueF era) Coin
valCoinF :: forall era.
(HasCallStack, Reflect era) =>
Field era (ValueF era) Coin
valCoinF = String
-> Rep era Coin
-> Rep era (ValueF era)
-> Lens' (ValueF era) Coin
-> Field era (ValueF era) Coin
forall era t s.
Era era =>
String -> Rep era t -> Rep era s -> Lens' s t -> Field era s t
Field String
"valCoin" Rep era Coin
forall era. Rep era Coin
CoinR (Proof era -> Rep era (ValueF era)
forall era. Era era => Proof era -> Rep era (ValueF era)
ValueR Proof era
forall era. Reflect era => Proof era
reify) (Coin -> f Coin) -> ValueF era -> f (ValueF era)
forall era. (HasCallStack, Reflect era) => Lens' (ValueF era) Coin
Lens' (ValueF era) Coin
valueFCoinL

valCoin :: (HasCallStack, Reflect era) => Term era Coin
valCoin :: forall era. (HasCallStack, Reflect era) => Term era Coin
valCoin = Field era (ValueF era) Coin -> Term era Coin
forall era rec field. Field era rec field -> Term era field
fieldToTerm Field era (ValueF era) Coin
forall era.
(HasCallStack, Reflect era) =>
Field era (ValueF era) Coin
valCoinF

maryValueMultiAssetL :: Lens' MaryValue MultiAsset
maryValueMultiAssetL :: Lens' MaryValue MultiAsset
maryValueMultiAssetL =
  (MaryValue -> MultiAsset)
-> (MaryValue -> MultiAsset -> MaryValue)
-> Lens' MaryValue MultiAsset
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    (\(MaryValue Coin
_ MultiAsset
ma) -> MultiAsset
ma)
    (\(MaryValue Coin
c MultiAsset
_) MultiAsset
ma -> Coin -> MultiAsset -> MaryValue
MaryValue Coin
c MultiAsset
ma)

valueFMultiAssetL :: Lens' (ValueF era) MultiAsset
valueFMultiAssetL :: forall era (f :: * -> *).
Functor f =>
(MultiAsset -> f MultiAsset) -> ValueF era -> f (ValueF era)
valueFMultiAssetL = (ValueF era -> MultiAsset)
-> (ValueF era -> MultiAsset -> ValueF era)
-> Lens (ValueF era) (ValueF era) MultiAsset MultiAsset
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ValueF era -> MultiAsset
forall era. ValueF era -> MultiAsset
get ValueF era -> MultiAsset -> ValueF era
forall era. ValueF era -> MultiAsset -> ValueF era
put
  where
    get :: ValueF era -> MultiAsset
    get :: forall era. ValueF era -> MultiAsset
get (ValueF Proof era
p Value era
x) = case Proof era -> ValueWit era
forall era. Proof era -> ValueWit era
whichValue Proof era
p of
      ValueWit era
ValueShelleyToAllegra -> Map PolicyID (Map AssetName Integer) -> MultiAsset
MultiAsset Map PolicyID (Map AssetName Integer)
forall k a. Map k a
Map.empty
      ValueWit era
ValueMaryToConway -> Value era
MaryValue
x MaryValue -> Getting MultiAsset MaryValue MultiAsset -> MultiAsset
forall s a. s -> Getting a s a -> a
^. Getting MultiAsset MaryValue MultiAsset
Lens' MaryValue MultiAsset
maryValueMultiAssetL

    put :: ValueF era -> MultiAsset -> ValueF era
    put :: forall era. ValueF era -> MultiAsset -> ValueF era
put (ValueF Proof era
p Value era
x) MultiAsset
new = case Proof era -> ValueWit era
forall era. Proof era -> ValueWit era
whichValue Proof era
p of
      ValueWit era
ValueShelleyToAllegra -> Proof era -> Value era -> ValueF era
forall era. Proof era -> Value era -> ValueF era
ValueF Proof era
p Value era
x
      ValueWit era
ValueMaryToConway -> Proof era -> Value era -> ValueF era
forall era. Proof era -> Value era -> ValueF era
ValueF Proof era
p (Value era
MaryValue
x MaryValue -> (MaryValue -> MaryValue) -> MaryValue
forall a b. a -> (a -> b) -> b
& (MultiAsset -> Identity MultiAsset)
-> MaryValue -> Identity MaryValue
Lens' MaryValue MultiAsset
maryValueMultiAssetL ((MultiAsset -> Identity MultiAsset)
 -> MaryValue -> Identity MaryValue)
-> MultiAsset -> MaryValue -> MaryValue
forall s t a b. ASetter s t a b -> b -> s -> t
.~ MultiAsset
new)

-- | a Field from (ValueF era) to MultiAsset
valueFMultiAssetF :: Reflect era => Field era (ValueF era) MultiAsset
valueFMultiAssetF :: forall era. Reflect era => Field era (ValueF era) MultiAsset
valueFMultiAssetF = String
-> Rep era MultiAsset
-> Rep era (ValueF era)
-> Lens' (ValueF era) MultiAsset
-> Field era (ValueF era) MultiAsset
forall era t s.
Era era =>
String -> Rep era t -> Rep era s -> Lens' s t -> Field era s t
Field String
"valueFMultiAsset" Rep era MultiAsset
forall era. Era era => Rep era MultiAsset
MultiAssetR (Proof era -> Rep era (ValueF era)
forall era. Era era => Proof era -> Rep era (ValueF era)
ValueR Proof era
forall era. Reflect era => Proof era
reify) (MultiAsset -> f MultiAsset) -> ValueF era -> f (ValueF era)
forall era (f :: * -> *).
Functor f =>
(MultiAsset -> f MultiAsset) -> ValueF era -> f (ValueF era)
Lens' (ValueF era) MultiAsset
valueFMultiAssetL

valueFMultiAsset :: Reflect era => Term era MultiAsset
valueFMultiAsset :: forall era. Reflect era => Term era MultiAsset
valueFMultiAsset = Field era (ValueF era) MultiAsset -> Term era MultiAsset
forall era rec field. Field era rec field -> Term era field
fieldToTerm Field era (ValueF era) MultiAsset
forall era. Reflect era => Field era (ValueF era) MultiAsset
valueFMultiAssetF

-- | a Field from (TxOut era) to (Addr era)
txoutAddressF :: Reflect era => Field era (TxOutF era) Addr
txoutAddressF :: forall era. Reflect era => Field era (TxOutF era) Addr
txoutAddressF = String
-> Rep era Addr
-> Rep era (TxOutF era)
-> Lens' (TxOutF era) Addr
-> Field era (TxOutF era) Addr
forall era t s.
Era era =>
String -> Rep era t -> Rep era s -> Lens' s t -> Field era s t
Field String
"txoutAddress" Rep era Addr
forall era. Era era => Rep era Addr
AddrR (Proof era -> Rep era (TxOutF era)
forall era. Era era => Proof era -> Rep era (TxOutF era)
TxOutR Proof era
forall era. Reflect era => Proof era
reify) ((TxOut era -> f (TxOut era)) -> TxOutF era -> f (TxOutF era)
forall era (f :: * -> *).
Functor f =>
(TxOut era -> f (TxOut era)) -> TxOutF era -> f (TxOutF era)
txOutFL ((TxOut era -> f (TxOut era)) -> TxOutF era -> f (TxOutF era))
-> ((Addr -> f Addr) -> TxOut era -> f (TxOut era))
-> (Addr -> f Addr)
-> TxOutF era
-> f (TxOutF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Addr -> f Addr) -> TxOut era -> f (TxOut era)
forall era. EraTxOut era => Lens' (TxOut era) Addr
Lens' (TxOut era) Addr
addrTxOutL)

txoutAddress :: Reflect era => Term era Addr
txoutAddress :: forall era. Reflect era => Term era Addr
txoutAddress = Field era (TxOutF era) Addr -> Term era Addr
forall era rec field. Field era rec field -> Term era field
fieldToTerm Field era (TxOutF era) Addr
forall era. Reflect era => Field era (TxOutF era) Addr
txoutAddressF

-- | a Field from (TxOutF era) to Coin
txoutCoinF :: (HasCallStack, Reflect era) => Field era (TxOutF era) Coin
txoutCoinF :: forall era.
(HasCallStack, Reflect era) =>
Field era (TxOutF era) Coin
txoutCoinF = String
-> Rep era Coin
-> Rep era (TxOutF era)
-> Lens' (TxOutF era) Coin
-> Field era (TxOutF era) Coin
forall era t s.
Era era =>
String -> Rep era t -> Rep era s -> Lens' s t -> Field era s t
Field String
"txoutCoin" Rep era Coin
forall era. Rep era Coin
CoinR (Proof era -> Rep era (TxOutF era)
forall era. Era era => Proof era -> Rep era (TxOutF era)
TxOutR Proof era
forall era. Reflect era => Proof era
reify) (Coin -> f Coin) -> TxOutF era -> f (TxOutF era)
forall era. (HasCallStack, Reflect era) => Lens' (TxOutF era) Coin
Lens' (TxOutF era) Coin
outputCoinL

txoutCoin :: (HasCallStack, Reflect era) => Term era Coin
txoutCoin :: forall era. (HasCallStack, Reflect era) => Term era Coin
txoutCoin = Field era (TxOutF era) Coin -> Term era Coin
forall era rec field. Field era rec field -> Term era field
fieldToTerm Field era (TxOutF era) Coin
forall era.
(HasCallStack, Reflect era) =>
Field era (TxOutF era) Coin
txoutCoinF

-- | a Field from (TxOutF era) to (ValueF era)
txoutAmountF :: Reflect era => Field era (TxOutF era) (ValueF era)
txoutAmountF :: forall era. Reflect era => Field era (TxOutF era) (ValueF era)
txoutAmountF = String
-> Rep era (ValueF era)
-> Rep era (TxOutF era)
-> Lens' (TxOutF era) (ValueF era)
-> Field era (TxOutF era) (ValueF era)
forall era t s.
Era era =>
String -> Rep era t -> Rep era s -> Lens' s t -> Field era s t
Field String
"txoutAmount" (Proof era -> Rep era (ValueF era)
forall era. Era era => Proof era -> Rep era (ValueF era)
ValueR Proof era
forall era. Reflect era => Proof era
reify) (Proof era -> Rep era (TxOutF era)
forall era. Era era => Proof era -> Rep era (TxOutF era)
TxOutR Proof era
forall era. Reflect era => Proof era
reify) ((TxOut era -> f (TxOut era)) -> TxOutF era -> f (TxOutF era)
forall era (f :: * -> *).
Functor f =>
(TxOut era -> f (TxOut era)) -> TxOutF era -> f (TxOutF era)
txOutFL ((TxOut era -> f (TxOut era)) -> TxOutF era -> f (TxOutF era))
-> ((ValueF era -> f (ValueF era)) -> TxOut era -> f (TxOut era))
-> (ValueF era -> f (ValueF era))
-> TxOutF era
-> f (TxOutF era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value era -> f (Value era)) -> TxOut era -> f (TxOut era)
forall era. EraTxOut era => Lens' (TxOut era) (Value era)
Lens' (TxOut era) (Value era)
valueTxOutL ((Value era -> f (Value era)) -> TxOut era -> f (TxOut era))
-> ((ValueF era -> f (ValueF era)) -> Value era -> f (Value era))
-> (ValueF era -> f (ValueF era))
-> TxOut era
-> f (TxOut era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ValueF era -> f (ValueF era)) -> Value era -> f (Value era)
forall era. Reflect era => Lens' (Value era) (ValueF era)
Lens' (Value era) (ValueF era)
valueFL)

txoutAmount :: Reflect era => Term era (ValueF era)
txoutAmount :: forall era. Reflect era => Term era (ValueF era)
txoutAmount = Field era (TxOutF era) (ValueF era) -> Term era (ValueF era)
forall era rec field. Field era rec field -> Term era field
fieldToTerm Field era (TxOutF era) (ValueF era)
forall era. Reflect era => Field era (TxOutF era) (ValueF era)
txoutAmountF

-- =================================
-- Witnesses

scriptWits :: Reflect era => Term era (Map ScriptHash (ScriptF era))
scriptWits :: forall era. Reflect era => Term era (Map ScriptHash (ScriptF era))
scriptWits = V era (Map ScriptHash (ScriptF era))
-> Term era (Map ScriptHash (ScriptF era))
forall era t. V era t -> Term era t
Var (V era (Map ScriptHash (ScriptF era))
 -> Term era (Map ScriptHash (ScriptF era)))
-> V era (Map ScriptHash (ScriptF era))
-> Term era (Map ScriptHash (ScriptF era))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map ScriptHash (ScriptF era))
-> Access era Any (Map ScriptHash (ScriptF era))
-> V era (Map ScriptHash (ScriptF era))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"scriptWits" (Rep era ScriptHash
-> Rep era (ScriptF era) -> Rep era (Map ScriptHash (ScriptF era))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era ScriptHash
forall era. Era era => Rep era ScriptHash
ScriptHashR (Proof era -> Rep era (ScriptF era)
forall era. Era era => Proof era -> Rep era (ScriptF era)
ScriptR Proof era
forall era. Reflect era => Proof era
reify)) Access era Any (Map ScriptHash (ScriptF era))
forall era s t. Access era s t
No

redeemers :: Reflect era => Term era (Map (PlutusPointerF era) (Data era, ExUnits))
redeemers :: forall era.
Reflect era =>
Term era (Map (PlutusPointerF era) (Data era, ExUnits))
redeemers = V era (Map (PlutusPointerF era) (Data era, ExUnits))
-> Term era (Map (PlutusPointerF era) (Data era, ExUnits))
forall era t. V era t -> Term era t
Var (V era (Map (PlutusPointerF era) (Data era, ExUnits))
 -> Term era (Map (PlutusPointerF era) (Data era, ExUnits)))
-> V era (Map (PlutusPointerF era) (Data era, ExUnits))
-> Term era (Map (PlutusPointerF era) (Data era, ExUnits))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (PlutusPointerF era) (Data era, ExUnits))
-> Access era Any (Map (PlutusPointerF era) (Data era, ExUnits))
-> V era (Map (PlutusPointerF era) (Data era, ExUnits))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"redeemers" (Rep era (PlutusPointerF era)
-> Rep era (Data era, ExUnits)
-> Rep era (Map (PlutusPointerF era) (Data era, ExUnits))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR (Proof era -> Rep era (PlutusPointerF era)
forall era. Era era => Proof era -> Rep era (PlutusPointerF era)
RdmrPtrR Proof era
forall era. Reflect era => Proof era
reify) (Rep era (Data era)
-> Rep era ExUnits -> Rep era (Data era, ExUnits)
forall era a b. Rep era a -> Rep era b -> Rep era (a, b)
PairR Rep era (Data era)
forall era. Era era => Rep era (Data era)
DataR Rep era ExUnits
forall era. Rep era ExUnits
ExUnitsR)) Access era Any (Map (PlutusPointerF era) (Data era, ExUnits))
forall era s t. Access era s t
No

bootWits :: forall era. Reflect era => Term era (Set BootstrapWitness)
bootWits :: forall era. Reflect era => Term era (Set BootstrapWitness)
bootWits = V era (Set BootstrapWitness) -> Term era (Set BootstrapWitness)
forall era t. V era t -> Term era t
Var (V era (Set BootstrapWitness) -> Term era (Set BootstrapWitness))
-> V era (Set BootstrapWitness) -> Term era (Set BootstrapWitness)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set BootstrapWitness)
-> Access era Any (Set BootstrapWitness)
-> V era (Set BootstrapWitness)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"bootWits" (Rep era BootstrapWitness -> Rep era (Set BootstrapWitness)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR (forall era. Era era => Rep era BootstrapWitness
BootstrapWitnessR @era)) Access era Any (Set BootstrapWitness)
forall era s t. Access era s t
No

dataWits :: Reflect era => Term era (Map DataHash (Data era))
dataWits :: forall era. Reflect era => Term era (Map DataHash (Data era))
dataWits = V era (Map DataHash (Data era))
-> Term era (Map DataHash (Data era))
forall era t. V era t -> Term era t
Var (V era (Map DataHash (Data era))
 -> Term era (Map DataHash (Data era)))
-> V era (Map DataHash (Data era))
-> Term era (Map DataHash (Data era))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map DataHash (Data era))
-> Access era Any (Map DataHash (Data era))
-> V era (Map DataHash (Data era))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"dataWits" (Rep era DataHash
-> Rep era (Data era) -> Rep era (Map DataHash (Data era))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era DataHash
forall era. Era era => Rep era DataHash
DataHashR Rep era (Data era)
forall era. Era era => Rep era (Data era)
DataR) Access era Any (Map DataHash (Data era))
forall era s t. Access era s t
No

keyWits :: Reflect era => Term era (Set (WitVKey 'Witness))
keyWits :: forall era. Reflect era => Term era (Set (WitVKey 'Witness))
keyWits = V era (Set (WitVKey 'Witness)) -> Term era (Set (WitVKey 'Witness))
forall era t. V era t -> Term era t
Var (V era (Set (WitVKey 'Witness))
 -> Term era (Set (WitVKey 'Witness)))
-> V era (Set (WitVKey 'Witness))
-> Term era (Set (WitVKey 'Witness))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set (WitVKey 'Witness))
-> Access era Any (Set (WitVKey 'Witness))
-> V era (Set (WitVKey 'Witness))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"keyWits" (Rep era (WitVKey 'Witness) -> Rep era (Set (WitVKey 'Witness))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR (Proof era -> Rep era (WitVKey 'Witness)
forall era. Era era => Proof era -> Rep era (WitVKey 'Witness)
WitVKeyR Proof era
forall era. Reflect era => Proof era
reify)) Access era Any (Set (WitVKey 'Witness))
forall era s t. Access era s t
No

-- =======================================================================================
-- Targets for building Transactions and their components. Since we compute these in two
-- passes, the targets are parameterized by the things that change between the first and
-- second passes. Here is an accounting of the things that change
-- 1) witsTarget: The witnesses that depend on the hash of the TxBody 'bootWits' and 'keyWits'
-- 2) txbodyTarget: 'txfee' , 'totaland 'wppHash'
-- 3) txTarget:  'txbodyterm', 'bootWits', and 'keyWits', since a Tx has both a body and witnesses

witsTarget ::
  Reflect era =>
  Term era (Set BootstrapWitness) ->
  Term era (Set (WitVKey 'Witness)) ->
  Target era (TxWits era)
witsTarget :: forall era.
Reflect era =>
Term era (Set BootstrapWitness)
-> Term era (Set (WitVKey 'Witness)) -> Target era (TxWits era)
witsTarget Term era (Set BootstrapWitness)
bootWitsParam Term era (Set (WitVKey 'Witness))
keyWitsParam =
  String
-> (Map ScriptHash (ScriptF era)
    -> Map (PlutusPointerF era) (Data era, ExUnits)
    -> Set BootstrapWitness
    -> Map DataHash (Data era)
    -> Set (WitVKey 'Witness)
    -> TxWits era)
-> RootTarget
     era
     Void
     (Map ScriptHash (ScriptF era)
      -> Map (PlutusPointerF era) (Data era, ExUnits)
      -> Set BootstrapWitness
      -> Map DataHash (Data era)
      -> Set (WitVKey 'Witness)
      -> TxWits era)
forall a b era. String -> (a -> b) -> RootTarget era Void (a -> b)
Constr String
"TxWits" Map ScriptHash (ScriptF era)
-> Map (PlutusPointerF era) (Data era, ExUnits)
-> Set BootstrapWitness
-> Map DataHash (Data era)
-> Set (WitVKey 'Witness)
-> TxWits era
witsf RootTarget
  era
  Void
  (Map ScriptHash (ScriptF era)
   -> Map (PlutusPointerF era) (Data era, ExUnits)
   -> Set BootstrapWitness
   -> Map DataHash (Data era)
   -> Set (WitVKey 'Witness)
   -> TxWits era)
-> Term era (Map ScriptHash (ScriptF era))
-> Target
     era
     (Map (PlutusPointerF era) (Data era, ExUnits)
      -> Set BootstrapWitness
      -> Map DataHash (Data era)
      -> Set (WitVKey 'Witness)
      -> TxWits era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Map ScriptHash (ScriptF era))
forall era. Reflect era => Term era (Map ScriptHash (ScriptF era))
scriptWits Target
  era
  (Map (PlutusPointerF era) (Data era, ExUnits)
   -> Set BootstrapWitness
   -> Map DataHash (Data era)
   -> Set (WitVKey 'Witness)
   -> TxWits era)
-> Term era (Map (PlutusPointerF era) (Data era, ExUnits))
-> Target
     era
     (Set BootstrapWitness
      -> Map DataHash (Data era) -> Set (WitVKey 'Witness) -> TxWits era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Map (PlutusPointerF era) (Data era, ExUnits))
forall era.
Reflect era =>
Term era (Map (PlutusPointerF era) (Data era, ExUnits))
redeemers Target
  era
  (Set BootstrapWitness
   -> Map DataHash (Data era) -> Set (WitVKey 'Witness) -> TxWits era)
-> Term era (Set BootstrapWitness)
-> Target
     era
     (Map DataHash (Data era) -> Set (WitVKey 'Witness) -> TxWits era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Set BootstrapWitness)
bootWitsParam Target
  era
  (Map DataHash (Data era) -> Set (WitVKey 'Witness) -> TxWits era)
-> Term era (Map DataHash (Data era))
-> Target era (Set (WitVKey 'Witness) -> TxWits era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Map DataHash (Data era))
forall era. Reflect era => Term era (Map DataHash (Data era))
dataWits Target era (Set (WitVKey 'Witness) -> TxWits era)
-> Term era (Set (WitVKey 'Witness))
-> RootTarget era Void (TxWits era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Set (WitVKey 'Witness))
keyWitsParam
  where
    proof :: Proof era
proof = Proof era
forall era. Reflect era => Proof era
reify
    witsf :: Map ScriptHash (ScriptF era)
-> Map (PlutusPointerF era) (Data era, ExUnits)
-> Set BootstrapWitness
-> Map DataHash (Data era)
-> Set (WitVKey 'Witness)
-> TxWits era
witsf Map ScriptHash (ScriptF era)
script Map (PlutusPointerF era) (Data era, ExUnits)
redeem Set BootstrapWitness
boot Map DataHash (Data era)
dataw Set (WitVKey 'Witness)
key =
      Policy -> Proof era -> [WitnessesField era] -> TxWits era
forall era.
Policy -> Proof era -> [WitnessesField era] -> TxWits era
newWitnesses
        t -> t -> t
Policy
merge
        Proof era
proof
        [ Set (WitVKey 'Witness) -> WitnessesField era
forall era. Set (WitVKey 'Witness) -> WitnessesField era
AddrWits Set (WitVKey 'Witness)
key
        , Set BootstrapWitness -> WitnessesField era
forall era. Set BootstrapWitness -> WitnessesField era
BootWits Set BootstrapWitness
boot
        , Map ScriptHash (Script era) -> WitnessesField era
forall era. Map ScriptHash (Script era) -> WitnessesField era
ScriptWits ((ScriptF era -> Script era)
-> Map ScriptHash (ScriptF era) -> Map ScriptHash (Script era)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map ScriptF era -> Script era
forall era. ScriptF era -> Script era
unScriptF Map ScriptHash (ScriptF era)
script)
        , TxDats era -> WitnessesField era
forall era. TxDats era -> WitnessesField era
DataWits (Map DataHash (Data era) -> TxDats era
forall era. Era era => Map DataHash (Data era) -> TxDats era
TxDats Map DataHash (Data era)
dataw)
        , Redeemers era -> WitnessesField era
forall era. Redeemers era -> WitnessesField era
RdmrWits (Proof era
-> [(PlutusPurpose AsIx era, (Data era, ExUnits))] -> Redeemers era
forall era.
Proof era
-> [(PlutusPurpose AsIx era, (Data era, ExUnits))] -> Redeemers era
mkRedeemers Proof era
proof ([(PlutusPurpose AsIx era, (Data era, ExUnits))] -> Redeemers era)
-> [(PlutusPurpose AsIx era, (Data era, ExUnits))] -> Redeemers era
forall a b. (a -> b) -> a -> b
$ ((PlutusPointerF era, (Data era, ExUnits))
 -> (PlutusPurpose AsIx era, (Data era, ExUnits)))
-> [(PlutusPointerF era, (Data era, ExUnits))]
-> [(PlutusPurpose AsIx era, (Data era, ExUnits))]
forall a b. (a -> b) -> [a] -> [b]
map ((PlutusPointerF era -> PlutusPurpose AsIx era)
-> (PlutusPointerF era, (Data era, ExUnits))
-> (PlutusPurpose AsIx era, (Data era, ExUnits))
forall b c d. (b -> c) -> (b, d) -> (c, d)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first PlutusPointerF era -> PlutusPurpose AsIx era
forall era. PlutusPointerF era -> PlutusPurpose AsIx era
unPlutusPointerF) ([(PlutusPointerF era, (Data era, ExUnits))]
 -> [(PlutusPurpose AsIx era, (Data era, ExUnits))])
-> [(PlutusPointerF era, (Data era, ExUnits))]
-> [(PlutusPurpose AsIx era, (Data era, ExUnits))]
forall a b. (a -> b) -> a -> b
$ Map (PlutusPointerF era) (Data era, ExUnits)
-> [(PlutusPointerF era, (Data era, ExUnits))]
forall k a. Map k a -> [(k, a)]
Map.toList (Map (PlutusPointerF era) (Data era, ExUnits)
 -> [(PlutusPointerF era, (Data era, ExUnits))])
-> Map (PlutusPointerF era) (Data era, ExUnits)
-> [(PlutusPointerF era, (Data era, ExUnits))]
forall a b. (a -> b) -> a -> b
$ Map (PlutusPointerF era) (Data era, ExUnits)
redeem)
        ]

txTarget ::
  Reflect era =>
  Term era (TxBodyF era) ->
  Term era (Set BootstrapWitness) ->
  Term era (Set (WitVKey 'Witness)) ->
  Target era (TxF era)
txTarget :: forall era.
Reflect era =>
Term era (TxBodyF era)
-> Term era (Set BootstrapWitness)
-> Term era (Set (WitVKey 'Witness))
-> Target era (TxF era)
txTarget Term era (TxBodyF era)
bodyparam Term era (Set BootstrapWitness)
bootWitsParam Term era (Set (WitVKey 'Witness))
keyWitsParam =
  String
-> (TxBodyF era
    -> TxWits era -> Maybe (TxAuxDataF era) -> IsValid -> TxF era)
-> RootTarget
     era
     Void
     (TxBodyF era
      -> TxWits era -> Maybe (TxAuxDataF era) -> IsValid -> TxF era)
forall a b era. String -> (a -> b) -> RootTarget era Void (a -> b)
Constr String
"tx" TxBodyF era
-> TxWits era -> Maybe (TxAuxDataF era) -> IsValid -> TxF era
forall {era}.
TxBodyF era
-> TxWits era -> Maybe (TxAuxDataF era) -> IsValid -> TxF era
txf RootTarget
  era
  Void
  (TxBodyF era
   -> TxWits era -> Maybe (TxAuxDataF era) -> IsValid -> TxF era)
-> Term era (TxBodyF era)
-> Target
     era (TxWits era -> Maybe (TxAuxDataF era) -> IsValid -> TxF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (TxBodyF era)
bodyparam Target
  era (TxWits era -> Maybe (TxAuxDataF era) -> IsValid -> TxF era)
-> RootTarget era Void (TxWits era)
-> RootTarget
     era Void (Maybe (TxAuxDataF era) -> IsValid -> TxF era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era Void (TxWits era)
wits RootTarget era Void (Maybe (TxAuxDataF era) -> IsValid -> TxF era)
-> Term era (Maybe (TxAuxDataF era))
-> Target era (IsValid -> TxF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Maybe (TxAuxDataF era))
forall era. Reflect era => Term era (Maybe (TxAuxDataF era))
txauxdata Target era (IsValid -> TxF era)
-> Term era IsValid -> Target era (TxF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era IsValid
forall era. Era era => Term era IsValid
txisvalid
  where
    wits :: RootTarget era Void (TxWits era)
wits = Term era (Set BootstrapWitness)
-> Term era (Set (WitVKey 'Witness))
-> RootTarget era Void (TxWits era)
forall era.
Reflect era =>
Term era (Set BootstrapWitness)
-> Term era (Set (WitVKey 'Witness)) -> Target era (TxWits era)
witsTarget Term era (Set BootstrapWitness)
bootWitsParam Term era (Set (WitVKey 'Witness))
keyWitsParam
    txf :: TxBodyF era
-> TxWits era -> Maybe (TxAuxDataF era) -> IsValid -> TxF era
txf (TxBodyF Proof era
proof TxBody era
txb) TxWits era
w Maybe (TxAuxDataF era)
auxs IsValid
isvalid =
      Proof era -> Tx era -> TxF era
forall era. Proof era -> Tx era -> TxF era
TxF Proof era
proof (Proof era -> [TxField era] -> Tx era
forall era. Proof era -> [TxField era] -> Tx era
newTx Proof era
proof [TxBody era -> TxField era
forall era. TxBody era -> TxField era
Body TxBody era
txb, TxWits era -> TxField era
forall era. TxWits era -> TxField era
TxWits TxWits era
w, [TxAuxData era] -> TxField era
forall era. [TxAuxData era] -> TxField era
AuxData' (Maybe (TxAuxDataF era) -> [TxAuxData era]
forall {era}. Maybe (TxAuxDataF era) -> [TxAuxData era]
fixM Maybe (TxAuxDataF era)
auxs), IsValid -> TxField era
forall era. IsValid -> TxField era
Valid IsValid
isvalid])
    fixM :: Maybe (TxAuxDataF era) -> [TxAuxData era]
fixM Maybe (TxAuxDataF era)
Nothing = []
    fixM (Just (TxAuxDataF Proof era
_ TxAuxData era
x)) = [TxAuxData era
x]

-- | Need to build the TxBody with different terms that control the fee and wppHash so we
--   parameterise this target over those two terms
txbodyTarget ::
  Reflect era =>
  Term era Coin ->
  Term era (Maybe ScriptIntegrityHash) ->
  Term era Coin ->
  Target era (TxBodyF era)
txbodyTarget :: forall era.
Reflect era =>
Term era Coin
-> Term era (Maybe (SafeHash EraIndependentScriptIntegrity))
-> Term era Coin
-> Target era (TxBodyF era)
txbodyTarget Term era Coin
feeparam Term era (Maybe (SafeHash EraIndependentScriptIntegrity))
wpphashparam Term era Coin
totalColParam =
  String
-> (Set TxIn
    -> Set TxIn
    -> Set TxIn
    -> [TxOutF era]
    -> TxOutF era
    -> Coin
    -> [TxCertF era]
    -> Map RewardAccount Coin
    -> SlotNo
    -> ValidityInterval
    -> Map ScriptHash (Map AssetName Integer)
    -> Set (KeyHash 'Witness)
    -> Maybe Network
    -> Maybe TxAuxDataHash
    -> Maybe (SafeHash EraIndependentScriptIntegrity)
    -> Coin
    -> Coin
    -> TxBodyF era)
-> RootTarget
     era
     Void
     (Set TxIn
      -> Set TxIn
      -> Set TxIn
      -> [TxOutF era]
      -> TxOutF era
      -> Coin
      -> [TxCertF era]
      -> Map RewardAccount Coin
      -> SlotNo
      -> ValidityInterval
      -> Map ScriptHash (Map AssetName Integer)
      -> Set (KeyHash 'Witness)
      -> Maybe Network
      -> Maybe TxAuxDataHash
      -> Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin
      -> Coin
      -> TxBodyF era)
forall a b era. String -> (a -> b) -> RootTarget era Void (a -> b)
Constr String
"txbody" Set TxIn
-> Set TxIn
-> Set TxIn
-> [TxOutF era]
-> TxOutF era
-> Coin
-> [TxCertF era]
-> Map RewardAccount Coin
-> SlotNo
-> ValidityInterval
-> Map ScriptHash (Map AssetName Integer)
-> Set (KeyHash 'Witness)
-> Maybe Network
-> Maybe TxAuxDataHash
-> Maybe (SafeHash EraIndependentScriptIntegrity)
-> Coin
-> Coin
-> TxBodyF era
txbodyf
    RootTarget
  era
  Void
  (Set TxIn
   -> Set TxIn
   -> Set TxIn
   -> [TxOutF era]
   -> TxOutF era
   -> Coin
   -> [TxCertF era]
   -> Map RewardAccount Coin
   -> SlotNo
   -> ValidityInterval
   -> Map ScriptHash (Map AssetName Integer)
   -> Set (KeyHash 'Witness)
   -> Maybe Network
   -> Maybe TxAuxDataHash
   -> Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin
   -> Coin
   -> TxBodyF era)
-> Term era (Set TxIn)
-> Target
     era
     (Set TxIn
      -> Set TxIn
      -> [TxOutF era]
      -> TxOutF era
      -> Coin
      -> [TxCertF era]
      -> Map RewardAccount Coin
      -> SlotNo
      -> ValidityInterval
      -> Map ScriptHash (Map AssetName Integer)
      -> Set (KeyHash 'Witness)
      -> Maybe Network
      -> Maybe TxAuxDataHash
      -> Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin
      -> Coin
      -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Set TxIn)
forall era. Era era => Term era (Set TxIn)
inputs
    Target
  era
  (Set TxIn
   -> Set TxIn
   -> [TxOutF era]
   -> TxOutF era
   -> Coin
   -> [TxCertF era]
   -> Map RewardAccount Coin
   -> SlotNo
   -> ValidityInterval
   -> Map ScriptHash (Map AssetName Integer)
   -> Set (KeyHash 'Witness)
   -> Maybe Network
   -> Maybe TxAuxDataHash
   -> Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin
   -> Coin
   -> TxBodyF era)
-> Term era (Set TxIn)
-> Target
     era
     (Set TxIn
      -> [TxOutF era]
      -> TxOutF era
      -> Coin
      -> [TxCertF era]
      -> Map RewardAccount Coin
      -> SlotNo
      -> ValidityInterval
      -> Map ScriptHash (Map AssetName Integer)
      -> Set (KeyHash 'Witness)
      -> Maybe Network
      -> Maybe TxAuxDataHash
      -> Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin
      -> Coin
      -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Set TxIn)
forall era. Era era => Term era (Set TxIn)
collateral
    Target
  era
  (Set TxIn
   -> [TxOutF era]
   -> TxOutF era
   -> Coin
   -> [TxCertF era]
   -> Map RewardAccount Coin
   -> SlotNo
   -> ValidityInterval
   -> Map ScriptHash (Map AssetName Integer)
   -> Set (KeyHash 'Witness)
   -> Maybe Network
   -> Maybe TxAuxDataHash
   -> Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin
   -> Coin
   -> TxBodyF era)
-> Term era (Set TxIn)
-> Target
     era
     ([TxOutF era]
      -> TxOutF era
      -> Coin
      -> [TxCertF era]
      -> Map RewardAccount Coin
      -> SlotNo
      -> ValidityInterval
      -> Map ScriptHash (Map AssetName Integer)
      -> Set (KeyHash 'Witness)
      -> Maybe Network
      -> Maybe TxAuxDataHash
      -> Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin
      -> Coin
      -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Set TxIn)
forall era. Era era => Term era (Set TxIn)
refInputs
    Target
  era
  ([TxOutF era]
   -> TxOutF era
   -> Coin
   -> [TxCertF era]
   -> Map RewardAccount Coin
   -> SlotNo
   -> ValidityInterval
   -> Map ScriptHash (Map AssetName Integer)
   -> Set (KeyHash 'Witness)
   -> Maybe Network
   -> Maybe TxAuxDataHash
   -> Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin
   -> Coin
   -> TxBodyF era)
-> Term era [TxOutF era]
-> Target
     era
     (TxOutF era
      -> Coin
      -> [TxCertF era]
      -> Map RewardAccount Coin
      -> SlotNo
      -> ValidityInterval
      -> Map ScriptHash (Map AssetName Integer)
      -> Set (KeyHash 'Witness)
      -> Maybe Network
      -> Maybe TxAuxDataHash
      -> Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin
      -> Coin
      -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ (Proof era -> Term era [TxOutF era]
forall era. Era era => Proof era -> Term era [TxOutF era]
outputs Proof era
proof)
    Target
  era
  (TxOutF era
   -> Coin
   -> [TxCertF era]
   -> Map RewardAccount Coin
   -> SlotNo
   -> ValidityInterval
   -> Map ScriptHash (Map AssetName Integer)
   -> Set (KeyHash 'Witness)
   -> Maybe Network
   -> Maybe TxAuxDataHash
   -> Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin
   -> Coin
   -> TxBodyF era)
-> Term era (TxOutF era)
-> Target
     era
     (Coin
      -> [TxCertF era]
      -> Map RewardAccount Coin
      -> SlotNo
      -> ValidityInterval
      -> Map ScriptHash (Map AssetName Integer)
      -> Set (KeyHash 'Witness)
      -> Maybe Network
      -> Maybe TxAuxDataHash
      -> Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin
      -> Coin
      -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ (Proof era -> Term era (TxOutF era)
forall era. Era era => Proof era -> Term era (TxOutF era)
collateralReturn Proof era
proof)
    -- \^$ updates
    Target
  era
  (Coin
   -> [TxCertF era]
   -> Map RewardAccount Coin
   -> SlotNo
   -> ValidityInterval
   -> Map ScriptHash (Map AssetName Integer)
   -> Set (KeyHash 'Witness)
   -> Maybe Network
   -> Maybe TxAuxDataHash
   -> Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin
   -> Coin
   -> TxBodyF era)
-> Term era Coin
-> Target
     era
     ([TxCertF era]
      -> Map RewardAccount Coin
      -> SlotNo
      -> ValidityInterval
      -> Map ScriptHash (Map AssetName Integer)
      -> Set (KeyHash 'Witness)
      -> Maybe Network
      -> Maybe TxAuxDataHash
      -> Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin
      -> Coin
      -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era Coin
totalColParam
    Target
  era
  ([TxCertF era]
   -> Map RewardAccount Coin
   -> SlotNo
   -> ValidityInterval
   -> Map ScriptHash (Map AssetName Integer)
   -> Set (KeyHash 'Witness)
   -> Maybe Network
   -> Maybe TxAuxDataHash
   -> Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin
   -> Coin
   -> TxBodyF era)
-> Term era [TxCertF era]
-> Target
     era
     (Map RewardAccount Coin
      -> SlotNo
      -> ValidityInterval
      -> Map ScriptHash (Map AssetName Integer)
      -> Set (KeyHash 'Witness)
      -> Maybe Network
      -> Maybe TxAuxDataHash
      -> Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin
      -> Coin
      -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era [TxCertF era]
forall era. Reflect era => Term era [TxCertF era]
certs
    Target
  era
  (Map RewardAccount Coin
   -> SlotNo
   -> ValidityInterval
   -> Map ScriptHash (Map AssetName Integer)
   -> Set (KeyHash 'Witness)
   -> Maybe Network
   -> Maybe TxAuxDataHash
   -> Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin
   -> Coin
   -> TxBodyF era)
-> Term era (Map RewardAccount Coin)
-> Target
     era
     (SlotNo
      -> ValidityInterval
      -> Map ScriptHash (Map AssetName Integer)
      -> Set (KeyHash 'Witness)
      -> Maybe Network
      -> Maybe TxAuxDataHash
      -> Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin
      -> Coin
      -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Map RewardAccount Coin)
forall era. Era era => Term era (Map RewardAccount Coin)
withdrawals
    Target
  era
  (SlotNo
   -> ValidityInterval
   -> Map ScriptHash (Map AssetName Integer)
   -> Set (KeyHash 'Witness)
   -> Maybe Network
   -> Maybe TxAuxDataHash
   -> Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin
   -> Coin
   -> TxBodyF era)
-> Term era SlotNo
-> Target
     era
     (ValidityInterval
      -> Map ScriptHash (Map AssetName Integer)
      -> Set (KeyHash 'Witness)
      -> Maybe Network
      -> Maybe TxAuxDataHash
      -> Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin
      -> Coin
      -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era SlotNo
forall era. Era era => Term era SlotNo
ttl
    Target
  era
  (ValidityInterval
   -> Map ScriptHash (Map AssetName Integer)
   -> Set (KeyHash 'Witness)
   -> Maybe Network
   -> Maybe TxAuxDataHash
   -> Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin
   -> Coin
   -> TxBodyF era)
-> Term era ValidityInterval
-> Target
     era
     (Map ScriptHash (Map AssetName Integer)
      -> Set (KeyHash 'Witness)
      -> Maybe Network
      -> Maybe TxAuxDataHash
      -> Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin
      -> Coin
      -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era ValidityInterval
forall era. Era era => Term era ValidityInterval
validityInterval
    Target
  era
  (Map ScriptHash (Map AssetName Integer)
   -> Set (KeyHash 'Witness)
   -> Maybe Network
   -> Maybe TxAuxDataHash
   -> Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin
   -> Coin
   -> TxBodyF era)
-> Term era (Map ScriptHash (Map AssetName Integer))
-> Target
     era
     (Set (KeyHash 'Witness)
      -> Maybe Network
      -> Maybe TxAuxDataHash
      -> Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin
      -> Coin
      -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Map ScriptHash (Map AssetName Integer))
forall era.
Era era =>
Term era (Map ScriptHash (Map AssetName Integer))
mint
    Target
  era
  (Set (KeyHash 'Witness)
   -> Maybe Network
   -> Maybe TxAuxDataHash
   -> Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin
   -> Coin
   -> TxBodyF era)
-> Term era (Set (KeyHash 'Witness))
-> Target
     era
     (Maybe Network
      -> Maybe TxAuxDataHash
      -> Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin
      -> Coin
      -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Set (KeyHash 'Witness))
forall era. Era era => Term era (Set (KeyHash 'Witness))
reqSignerHashes
    Target
  era
  (Maybe Network
   -> Maybe TxAuxDataHash
   -> Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin
   -> Coin
   -> TxBodyF era)
-> Term era (Maybe Network)
-> Target
     era
     (Maybe TxAuxDataHash
      -> Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin
      -> Coin
      -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Maybe Network)
forall era. Era era => Term era (Maybe Network)
networkID
    Target
  era
  (Maybe TxAuxDataHash
   -> Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin
   -> Coin
   -> TxBodyF era)
-> Term era (Maybe TxAuxDataHash)
-> Target
     era
     (Maybe (SafeHash EraIndependentScriptIntegrity)
      -> Coin -> Coin -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Maybe TxAuxDataHash)
forall era. Era era => Term era (Maybe TxAuxDataHash)
adHash
    Target
  era
  (Maybe (SafeHash EraIndependentScriptIntegrity)
   -> Coin -> Coin -> TxBodyF era)
-> Term era (Maybe (SafeHash EraIndependentScriptIntegrity))
-> Target era (Coin -> Coin -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era (Maybe (SafeHash EraIndependentScriptIntegrity))
wpphashparam
    Target era (Coin -> Coin -> TxBodyF era)
-> Term era Coin -> Target era (Coin -> TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era Coin
feeparam
    Target era (Coin -> TxBodyF era)
-> Term era Coin -> Target era (TxBodyF era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Term era Coin
forall era. Era era => Term era Coin
txDonation
  where
    proof :: Proof era
proof = Proof era
forall era. Reflect era => Proof era
reify
    txbodyf :: Set TxIn
-> Set TxIn
-> Set TxIn
-> [TxOutF era]
-> TxOutF era
-> Coin
-> [TxCertF era]
-> Map RewardAccount Coin
-> SlotNo
-> ValidityInterval
-> Map ScriptHash (Map AssetName Integer)
-> Set (KeyHash 'Witness)
-> Maybe Network
-> Maybe TxAuxDataHash
-> Maybe (SafeHash EraIndependentScriptIntegrity)
-> Coin
-> Coin
-> TxBodyF era
txbodyf
      Set TxIn
ins
      Set TxIn
col
      Set TxIn
refs
      [TxOutF era]
out
      (TxOutF Proof era
_ TxOut era
colret)
      Coin
totcol
      --    updates
      [TxCertF era]
cs
      Map RewardAccount Coin
ws
      SlotNo
tt
      ValidityInterval
vi
      Map ScriptHash (Map AssetName Integer)
mnt
      Set (KeyHash 'Witness)
req
      Maybe Network
net
      Maybe TxAuxDataHash
adh
      Maybe (SafeHash EraIndependentScriptIntegrity)
wpp
      Coin
fee
      Coin
donate =
        Proof era -> TxBody era -> TxBodyF era
forall era. Proof era -> TxBody era -> TxBodyF era
TxBodyF
          Proof era
proof
          ( Proof era -> [TxBodyField era] -> TxBody era
forall era.
EraTxBody era =>
Proof era -> [TxBodyField era] -> TxBody era
newTxBody
              Proof era
proof
              [ Set TxIn -> TxBodyField era
forall era. Set TxIn -> TxBodyField era
Inputs Set TxIn
ins
              , Set TxIn -> TxBodyField era
forall era. Set TxIn -> TxBodyField era
Collateral Set TxIn
col
              , Set TxIn -> TxBodyField era
forall era. Set TxIn -> TxBodyField era
RefInputs Set TxIn
refs
              , [TxOut era] -> TxBodyField era
forall era. [TxOut era] -> TxBodyField era
Outputs' ((TxOutF era -> TxOut era) -> [TxOutF era] -> [TxOut era]
forall a b. (a -> b) -> [a] -> [b]
map TxOutF era -> TxOut era
forall era. TxOutF era -> TxOut era
unTxOut [TxOutF era]
out)
              , StrictMaybe (TxOut era) -> TxBodyField era
forall era. StrictMaybe (TxOut era) -> TxBodyField era
CollateralReturn (TxOut era -> StrictMaybe (TxOut era)
forall a. a -> StrictMaybe a
SJust TxOut era
colret)
              , -- , Update upd
                StrictMaybe Coin -> TxBodyField era
forall era. StrictMaybe Coin -> TxBodyField era
TotalCol (Coin -> StrictMaybe Coin
forall a. a -> StrictMaybe a
SJust Coin
totcol)
              , [TxCert era] -> TxBodyField era
forall era. [TxCert era] -> TxBodyField era
Certs' ((TxCertF era -> TxCert era) -> [TxCertF era] -> [TxCert era]
forall a b. (a -> b) -> [a] -> [b]
map TxCertF era -> TxCert era
forall era. TxCertF era -> TxCert era
unTxCertF [TxCertF era]
cs)
              , Withdrawals -> TxBodyField era
forall era. Withdrawals -> TxBodyField era
Withdrawals' (Map RewardAccount Coin -> Withdrawals
Withdrawals Map RewardAccount Coin
ws)
              , Coin -> TxBodyField era
forall era. Coin -> TxBodyField era
Txfee Coin
fee
              , SlotNo -> TxBodyField era
forall era. SlotNo -> TxBodyField era
TTL SlotNo
tt
              , ValidityInterval -> TxBodyField era
forall era. ValidityInterval -> TxBodyField era
Vldt ValidityInterval
vi
              , MultiAsset -> TxBodyField era
forall era. MultiAsset -> TxBodyField era
Fields.Mint (Map ScriptHash (Map AssetName Integer) -> MultiAsset
liftMultiAsset Map ScriptHash (Map AssetName Integer)
mnt)
              , Set (KeyHash 'Witness) -> TxBodyField era
forall era. Set (KeyHash 'Witness) -> TxBodyField era
ReqSignerHashes Set (KeyHash 'Witness)
req
              , StrictMaybe Network -> TxBodyField era
forall era. StrictMaybe Network -> TxBodyField era
Txnetworkid (Maybe Network -> StrictMaybe Network
forall a. Maybe a -> StrictMaybe a
maybeToStrictMaybe Maybe Network
net)
              , StrictMaybe TxAuxDataHash -> TxBodyField era
forall era. StrictMaybe TxAuxDataHash -> TxBodyField era
AdHash (Maybe TxAuxDataHash -> StrictMaybe TxAuxDataHash
forall a. Maybe a -> StrictMaybe a
maybeToStrictMaybe Maybe TxAuxDataHash
adh)
              , StrictMaybe (SafeHash EraIndependentScriptIntegrity)
-> TxBodyField era
forall era.
StrictMaybe (SafeHash EraIndependentScriptIntegrity)
-> TxBodyField era
WppHash (Maybe (SafeHash EraIndependentScriptIntegrity)
-> StrictMaybe (SafeHash EraIndependentScriptIntegrity)
forall a. Maybe a -> StrictMaybe a
maybeToStrictMaybe Maybe (SafeHash EraIndependentScriptIntegrity)
wpp)
              , Coin -> TxBodyField era
forall era. Coin -> TxBodyField era
TreasuryDonation Coin
donate
              ]
          )

-- ==================================================
-- Hardforks

allowMIRTransfer :: Proof era -> Term era Bool
allowMIRTransfer :: forall era. Proof era -> Term era Bool
allowMIRTransfer Proof era
p = Rep era Bool -> Bool -> Term era Bool
forall era t. Rep era t -> t -> Term era t
Lit Rep era Bool
forall era. Rep era Bool
BoolR (ProtVer -> Bool
HardForks.allowMIRTransfer (Proof era -> ProtVer
forall era. Proof era -> ProtVer
protocolVersion Proof era
p))

-- ====================================
-- ConwayGovState variables

constitution :: Era era => Term era (Constitution era)
constitution :: forall era. Era era => Term era (Constitution era)
constitution = V era (Constitution era) -> Term era (Constitution era)
forall era t. V era t -> Term era t
Var (V era (Constitution era) -> Term era (Constitution era))
-> V era (Constitution era) -> Term era (Constitution era)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Constitution era)
-> Access era Any (Constitution era)
-> V era (Constitution era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"constitution" Rep era (Constitution era)
forall era. Era era => Rep era (Constitution era)
ConstitutionR Access era Any (Constitution era)
forall era s t. Access era s t
No

enactTreasury :: Era era => Term era Coin
enactTreasury :: forall era. Era era => Term era Coin
enactTreasury = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"enactTreasury" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No

enactWithdrawals :: forall era. Era era => Term era (Map (Credential 'Staking) Coin)
enactWithdrawals :: forall era. Era era => Term era (Map (Credential 'Staking) Coin)
enactWithdrawals = V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'Staking) Coin)
 -> Term era (Map (Credential 'Staking) Coin))
-> V era (Map (Credential 'Staking) Coin)
-> Term era (Map (Credential 'Staking) Coin)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (Credential 'Staking) Coin)
-> Access era Any (Map (Credential 'Staking) Coin)
-> V era (Map (Credential 'Staking) Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"enactWithdrawals" (Rep era (Credential 'Staking)
-> Rep era Coin -> Rep era (Map (Credential 'Staking) Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era Coin
forall era. Rep era Coin
CoinR) Access era Any (Map (Credential 'Staking) Coin)
forall era s t. Access era s t
No

currentGovActionStates ::
  Era era => Term era (Map GovActionId (GovActionState era))
currentGovActionStates :: forall era.
Era era =>
Term era (Map GovActionId (GovActionState era))
currentGovActionStates = V era (Map GovActionId (GovActionState era))
-> Term era (Map GovActionId (GovActionState era))
forall era t. V era t -> Term era t
Var (V era (Map GovActionId (GovActionState era))
 -> Term era (Map GovActionId (GovActionState era)))
-> V era (Map GovActionId (GovActionState era))
-> Term era (Map GovActionId (GovActionState era))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map GovActionId (GovActionState era))
-> Access era Any (Map GovActionId (GovActionState era))
-> V era (Map GovActionId (GovActionState era))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"currentGovActionStates" (Rep era GovActionId
-> Rep era (GovActionState era)
-> Rep era (Map GovActionId (GovActionState era))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era GovActionId
forall era. Era era => Rep era GovActionId
GovActionIdR Rep era (GovActionState era)
forall era. Era era => Rep era (GovActionState era)
GovActionStateR) Access era Any (Map GovActionId (GovActionState era))
forall era s t. Access era s t
No

currentProposalOrder :: Era era => Term era [GovActionId]
currentProposalOrder :: forall era. Era era => Term era [GovActionId]
currentProposalOrder = V era [GovActionId] -> Term era [GovActionId]
forall era t. V era t -> Term era t
Var (V era [GovActionId] -> Term era [GovActionId])
-> V era [GovActionId] -> Term era [GovActionId]
forall a b. (a -> b) -> a -> b
$ String
-> Rep era [GovActionId]
-> Access era Any [GovActionId]
-> V era [GovActionId]
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"currentProposalOrder" (Rep era GovActionId -> Rep era [GovActionId]
forall era a. Rep era a -> Rep era [a]
ListR Rep era GovActionId
forall era. Era era => Rep era GovActionId
GovActionIdR) Access era Any [GovActionId]
forall era s t. Access era s t
No

prevGovActionStates :: Era era => Term era (Map GovActionId (GovActionState era))
prevGovActionStates :: forall era.
Era era =>
Term era (Map GovActionId (GovActionState era))
prevGovActionStates = V era (Map GovActionId (GovActionState era))
-> Term era (Map GovActionId (GovActionState era))
forall era t. V era t -> Term era t
Var (V era (Map GovActionId (GovActionState era))
 -> Term era (Map GovActionId (GovActionState era)))
-> V era (Map GovActionId (GovActionState era))
-> Term era (Map GovActionId (GovActionState era))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map GovActionId (GovActionState era))
-> Access era Any (Map GovActionId (GovActionState era))
-> V era (Map GovActionId (GovActionState era))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"prevGovActionStates" (Rep era GovActionId
-> Rep era (GovActionState era)
-> Rep era (Map GovActionId (GovActionState era))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era GovActionId
forall era. Era era => Rep era GovActionId
GovActionIdR Rep era (GovActionState era)
forall era. Era era => Rep era (GovActionState era)
GovActionStateR) Access era Any (Map GovActionId (GovActionState era))
forall era s t. Access era s t
No

prevProposalOrder :: Era era => Term era [GovActionId]
prevProposalOrder :: forall era. Era era => Term era [GovActionId]
prevProposalOrder = V era [GovActionId] -> Term era [GovActionId]
forall era t. V era t -> Term era t
Var (V era [GovActionId] -> Term era [GovActionId])
-> V era [GovActionId] -> Term era [GovActionId]
forall a b. (a -> b) -> a -> b
$ String
-> Rep era [GovActionId]
-> Access era Any [GovActionId]
-> V era [GovActionId]
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"prevProposalOrder" (Rep era GovActionId -> Rep era [GovActionId]
forall era a. Rep era a -> Rep era [a]
ListR Rep era GovActionId
forall era. Era era => Rep era GovActionId
GovActionIdR) Access era Any [GovActionId]
forall era s t. Access era s t
No

previousCommitteeState ::
  Era era =>
  Term
    era
    ( Map
        (Credential 'ColdCommitteeRole)
        (Maybe (Credential 'HotCommitteeRole))
    )
previousCommitteeState :: forall era.
Era era =>
Term
  era
  (Map
     (Credential 'ColdCommitteeRole)
     (Maybe (Credential 'HotCommitteeRole)))
previousCommitteeState = V era
  (Map
     (Credential 'ColdCommitteeRole)
     (Maybe (Credential 'HotCommitteeRole)))
-> Term
     era
     (Map
        (Credential 'ColdCommitteeRole)
        (Maybe (Credential 'HotCommitteeRole)))
forall era t. V era t -> Term era t
Var (V era
   (Map
      (Credential 'ColdCommitteeRole)
      (Maybe (Credential 'HotCommitteeRole)))
 -> Term
      era
      (Map
         (Credential 'ColdCommitteeRole)
         (Maybe (Credential 'HotCommitteeRole))))
-> V era
     (Map
        (Credential 'ColdCommitteeRole)
        (Maybe (Credential 'HotCommitteeRole)))
-> Term
     era
     (Map
        (Credential 'ColdCommitteeRole)
        (Maybe (Credential 'HotCommitteeRole)))
forall a b. (a -> b) -> a -> b
$ String
-> Rep
     era
     (Map
        (Credential 'ColdCommitteeRole)
        (Maybe (Credential 'HotCommitteeRole)))
-> Access
     era
     Any
     (Map
        (Credential 'ColdCommitteeRole)
        (Maybe (Credential 'HotCommitteeRole)))
-> V era
     (Map
        (Credential 'ColdCommitteeRole)
        (Maybe (Credential 'HotCommitteeRole)))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"previousCommitteeState" (Rep era (Credential 'ColdCommitteeRole)
-> Rep era (Maybe (Credential 'HotCommitteeRole))
-> Rep
     era
     (Map
        (Credential 'ColdCommitteeRole)
        (Maybe (Credential 'HotCommitteeRole)))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'ColdCommitteeRole)
forall era. Era era => Rep era (Credential 'ColdCommitteeRole)
CommColdCredR (Rep era (Credential 'HotCommitteeRole)
-> Rep era (Maybe (Credential 'HotCommitteeRole))
forall era t1. Rep era t1 -> Rep era (Maybe t1)
MaybeR Rep era (Credential 'HotCommitteeRole)
forall era. Era era => Rep era (Credential 'HotCommitteeRole)
CommHotCredR)) Access
  era
  Any
  (Map
     (Credential 'ColdCommitteeRole)
     (Maybe (Credential 'HotCommitteeRole)))
forall era s t. Access era s t
No

commMembers :: Era era => Term era (Map (Credential 'ColdCommitteeRole) EpochNo)
commMembers :: forall era.
Era era =>
Term era (Map (Credential 'ColdCommitteeRole) EpochNo)
commMembers = V era (Map (Credential 'ColdCommitteeRole) EpochNo)
-> Term era (Map (Credential 'ColdCommitteeRole) EpochNo)
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'ColdCommitteeRole) EpochNo)
 -> Term era (Map (Credential 'ColdCommitteeRole) EpochNo))
-> V era (Map (Credential 'ColdCommitteeRole) EpochNo)
-> Term era (Map (Credential 'ColdCommitteeRole) EpochNo)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (Credential 'ColdCommitteeRole) EpochNo)
-> Access era Any (Map (Credential 'ColdCommitteeRole) EpochNo)
-> V era (Map (Credential 'ColdCommitteeRole) EpochNo)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"commMembers" (Rep era (Credential 'ColdCommitteeRole)
-> Rep era EpochNo
-> Rep era (Map (Credential 'ColdCommitteeRole) EpochNo)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'ColdCommitteeRole)
forall era. Era era => Rep era (Credential 'ColdCommitteeRole)
CommColdCredR Rep era EpochNo
forall era. Rep era EpochNo
EpochR) Access era Any (Map (Credential 'ColdCommitteeRole) EpochNo)
forall era s t. Access era s t
No

commQuorum :: Era era => Term era UnitInterval
commQuorum :: forall era. Era era => Term era UnitInterval
commQuorum = V era UnitInterval -> Term era UnitInterval
forall era t. V era t -> Term era t
Var (V era UnitInterval -> Term era UnitInterval)
-> V era UnitInterval -> Term era UnitInterval
forall a b. (a -> b) -> a -> b
$ String
-> Rep era UnitInterval
-> Access era Any UnitInterval
-> V era UnitInterval
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"commQuorum" Rep era UnitInterval
forall era. Rep era UnitInterval
UnitIntervalR Access era Any UnitInterval
forall era s t. Access era s t
No

committeeVar :: Era era => Term era (Maybe (Committee era))
committeeVar :: forall era. Era era => Term era (Maybe (Committee era))
committeeVar = V era (Maybe (Committee era)) -> Term era (Maybe (Committee era))
forall era t. V era t -> Term era t
Var (V era (Maybe (Committee era)) -> Term era (Maybe (Committee era)))
-> V era (Maybe (Committee era))
-> Term era (Maybe (Committee era))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Maybe (Committee era))
-> Access era Any (Maybe (Committee era))
-> V era (Maybe (Committee era))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"committeeVar" (Rep era (Committee era) -> Rep era (Maybe (Committee era))
forall era t1. Rep era t1 -> Rep era (Maybe t1)
MaybeR Rep era (Committee era)
forall era. Era era => Rep era (Committee era)
CommitteeR) Access era Any (Maybe (Committee era))
forall era s t. Access era s t
No

-- ====================================
-- ConwayGovState Targets

-- ================
-- The DRepPulsingState has two forms
-- 1. DRPulsing
-- 2. DRComplete
-- They both act as Snapshots, storing information from previous epochs
-- DRPulsing stores each 'prevXXX' as a field, and
-- DRComplete stores them in a dedicated datatype PulsingSnapshot

-- | There are 2 forms of DRepPulsingState. This is part of the first one where the pulsing is
--   not complete, and the snapshots are stored as fields in the datatype 'DRepPulser'.
--   Note that the function part of 'Invert' : 'initPulser' makes many transformations from the
--   types used in the Model, and the types stored in the implementation types.
--   In order to construct a valid DRepPulser we need the UTxO (to compute the IncrementalStake)
--   But we cannot find a Lens that can recover the UTxO from a DRepPulser. So we introduce this
--   type ' UtxoPulse' that pairs the two (which makes the recovery possible). W
type UtxoPulse era =
  (Map TxIn (TxOutF era), DRepPulser era Identity (RatifyState era))

-- | We also introduce an intermediate variable 'utxoPulse' which can constrain this value
--   by using the predicate [ utxoPulse p :<-: pulsingPair p ]
utxoPulse :: (RunConwayRatify era, Reflect era) => Proof era -> Term era (UtxoPulse era)
utxoPulse :: forall era.
(RunConwayRatify era, Reflect era) =>
Proof era -> Term era (UtxoPulse era)
utxoPulse Proof era
p = V era (UtxoPulse era) -> Term era (UtxoPulse era)
forall era t. V era t -> Term era t
Var (V era (UtxoPulse era) -> Term era (UtxoPulse era))
-> V era (UtxoPulse era) -> Term era (UtxoPulse era)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (UtxoPulse era)
-> Access era Any (UtxoPulse era)
-> V era (UtxoPulse era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"utxoPulse" (Rep era (Map TxIn (TxOutF era))
-> Rep era (DRepPulser era Identity (RatifyState era))
-> Rep era (UtxoPulse era)
forall era a b. Rep era a -> Rep era b -> Rep era (a, b)
PairR (Rep era TxIn
-> Rep era (TxOutF era) -> Rep era (Map TxIn (TxOutF era))
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era TxIn
forall era. Era era => Rep era TxIn
TxInR (Proof era -> Rep era (TxOutF era)
forall era. Era era => Proof era -> Rep era (TxOutF era)
TxOutR Proof era
p)) Rep era (DRepPulser era Identity (RatifyState era))
forall era.
(RunConwayRatify era, Reflect era) =>
Rep era (DRepPulser era Identity (RatifyState era))
DRepPulserR) Access era Any (UtxoPulse era)
forall era s t. Access era s t
No

-- | an invertable RootTarget to compute a (UtxoPulse era)
pulsingPairT ::
  forall era.
  (RunConwayRatify era, Reflect era, ConwayEraCertState era) =>
  Proof era ->
  RootTarget era (UtxoPulse era) (UtxoPulse era)
pulsingPairT :: forall era.
(RunConwayRatify era, Reflect era, ConwayEraCertState era) =>
Proof era -> RootTarget era (UtxoPulse era) (UtxoPulse era)
pulsingPairT Proof era
proof =
  String
-> TypeRep (UtxoPulse era)
-> (Map TxIn (TxOutF era)
    -> Map (Credential 'Staking) DRep
    -> Map (KeyHash 'StakePool) IndividualPoolStake
    -> Map (Credential 'DRepRole) DRepState
    -> EpochNo
    -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
    -> EnactState era
    -> [GovActionState era]
    -> Map (KeyHash 'StakePool) PoolParams
    -> UtxoPulse era)
-> RootTarget
     era
     (UtxoPulse era)
     (Map TxIn (TxOutF era)
      -> Map (Credential 'Staking) DRep
      -> Map (KeyHash 'StakePool) IndividualPoolStake
      -> Map (Credential 'DRepRole) DRepState
      -> EpochNo
      -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
      -> EnactState era
      -> [GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams
      -> UtxoPulse era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert
    String
"DRepPulser"
    (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(UtxoPulse era))
    (\Map TxIn (TxOutF era)
utx Map (Credential 'Staking) DRep
a Map (KeyHash 'StakePool) IndividualPoolStake
b Map (Credential 'DRepRole) DRepState
c EpochNo
d Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
e EnactState era
f [GovActionState era]
g Map (KeyHash 'StakePool) PoolParams
h -> (Map TxIn (TxOutF era)
utx, Proof era
-> Map TxIn (TxOutF era)
-> Map (Credential 'Staking) DRep
-> Map (KeyHash 'StakePool) IndividualPoolStake
-> Map (Credential 'DRepRole) DRepState
-> EpochNo
-> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
-> EnactState era
-> [GovActionState era]
-> Map (KeyHash 'StakePool) PoolParams
-> DRepPulser era Identity (RatifyState era)
forall era.
(Reflect era, RunConwayRatify era) =>
Proof era
-> Map TxIn (TxOutF era)
-> Map (Credential 'Staking) DRep
-> Map (KeyHash 'StakePool) IndividualPoolStake
-> Map (Credential 'DRepRole) DRepState
-> EpochNo
-> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
-> EnactState era
-> [GovActionState era]
-> Map (KeyHash 'StakePool) PoolParams
-> DRepPulser era Identity (RatifyState era)
initPulser Proof era
proof Map TxIn (TxOutF era)
utx Map (Credential 'Staking) DRep
a Map (KeyHash 'StakePool) IndividualPoolStake
b Map (Credential 'DRepRole) DRepState
c EpochNo
d Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
e EnactState era
f [GovActionState era]
g Map (KeyHash 'StakePool) PoolParams
h))
    RootTarget
  era
  (UtxoPulse era)
  (Map TxIn (TxOutF era)
   -> Map (Credential 'Staking) DRep
   -> Map (KeyHash 'StakePool) IndividualPoolStake
   -> Map (Credential 'DRepRole) DRepState
   -> EpochNo
   -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
   -> EnactState era
   -> [GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams
   -> UtxoPulse era)
-> RootTarget era (UtxoPulse era) (Map TxIn (TxOutF era))
-> RootTarget
     era
     (UtxoPulse era)
     (Map (Credential 'Staking) DRep
      -> Map (KeyHash 'StakePool) IndividualPoolStake
      -> Map (Credential 'DRepRole) DRepState
      -> EpochNo
      -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
      -> EnactState era
      -> [GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams
      -> UtxoPulse era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map TxIn (TxOutF era))
-> SimpleGetter (UtxoPulse era) (Map TxIn (TxOutF era))
-> RootTarget era (UtxoPulse era) (Map TxIn (TxOutF era))
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Proof era -> Term era (Map TxIn (TxOutF era))
forall era.
Era era =>
Proof era -> Term era (Map TxIn (TxOutF era))
utxo Proof era
proof) (Map TxIn (TxOutF era) -> Const r (Map TxIn (TxOutF era)))
-> UtxoPulse era -> Const r (UtxoPulse era)
SimpleGetter (UtxoPulse era) (Map TxIn (TxOutF era))
forall s t a b. Field1 s t a b => Lens s t a b
Lens
  (UtxoPulse era)
  (UtxoPulse era)
  (Map TxIn (TxOutF era))
  (Map TxIn (TxOutF era))
_1
    RootTarget
  era
  (UtxoPulse era)
  (Map (Credential 'Staking) DRep
   -> Map (KeyHash 'StakePool) IndividualPoolStake
   -> Map (Credential 'DRepRole) DRepState
   -> EpochNo
   -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
   -> EnactState era
   -> [GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams
   -> UtxoPulse era)
-> RootTarget era (UtxoPulse era) (Map (Credential 'Staking) DRep)
-> RootTarget
     era
     (UtxoPulse era)
     (Map (KeyHash 'StakePool) IndividualPoolStake
      -> Map (Credential 'DRepRole) DRepState
      -> EpochNo
      -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
      -> EnactState era
      -> [GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams
      -> UtxoPulse era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) DRep)
-> PDoc
-> Lens' (UtxoPulse era) (Map (Credential 'Staking) DRep)
-> RootTarget era (UtxoPulse era) (Map (Credential 'Staking) DRep)
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term era (Map (Credential 'Staking) DRep)
forall era.
EraCertState era =>
Term era (Map (Credential 'Staking) DRep)
drepDelegation (String -> PDoc
forall a. String -> Doc a
ppString String
"prevDRepDelegations") ((DRepPulser era Identity (RatifyState era)
 -> f (DRepPulser era Identity (RatifyState era)))
-> UtxoPulse era -> f (UtxoPulse era)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (UtxoPulse era)
  (UtxoPulse era)
  (DRepPulser era Identity (RatifyState era))
  (DRepPulser era Identity (RatifyState era))
_2 ((DRepPulser era Identity (RatifyState era)
  -> f (DRepPulser era Identity (RatifyState era)))
 -> UtxoPulse era -> f (UtxoPulse era))
-> ((Map (Credential 'Staking) DRep
     -> f (Map (Credential 'Staking) DRep))
    -> DRepPulser era Identity (RatifyState era)
    -> f (DRepPulser era Identity (RatifyState era)))
-> (Map (Credential 'Staking) DRep
    -> f (Map (Credential 'Staking) DRep))
-> UtxoPulse era
-> f (UtxoPulse era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'Staking) DRep
 -> f (Map (Credential 'Staking) DRep))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) DRep
 -> f (Map (Credential 'Staking) DRep))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
prevDRepDelegationsL)
    RootTarget
  era
  (UtxoPulse era)
  (Map (KeyHash 'StakePool) IndividualPoolStake
   -> Map (Credential 'DRepRole) DRepState
   -> EpochNo
   -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
   -> EnactState era
   -> [GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams
   -> UtxoPulse era)
-> RootTarget
     era (UtxoPulse era) (Map (KeyHash 'StakePool) IndividualPoolStake)
-> RootTarget
     era
     (UtxoPulse era)
     (Map (Credential 'DRepRole) DRepState
      -> EpochNo
      -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
      -> EnactState era
      -> [GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams
      -> UtxoPulse era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
-> PDoc
-> Lens'
     (UtxoPulse era) (Map (KeyHash 'StakePool) IndividualPoolStake)
-> RootTarget
     era (UtxoPulse era) (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
poolDistr (String -> PDoc
forall a. String -> Doc a
ppString String
"prevPoolDistr") ((DRepPulser era Identity (RatifyState era)
 -> f (DRepPulser era Identity (RatifyState era)))
-> UtxoPulse era -> f (UtxoPulse era)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (UtxoPulse era)
  (UtxoPulse era)
  (DRepPulser era Identity (RatifyState era))
  (DRepPulser era Identity (RatifyState era))
_2 ((DRepPulser era Identity (RatifyState era)
  -> f (DRepPulser era Identity (RatifyState era)))
 -> UtxoPulse era -> f (UtxoPulse era))
-> ((Map (KeyHash 'StakePool) IndividualPoolStake
     -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
    -> DRepPulser era Identity (RatifyState era)
    -> f (DRepPulser era Identity (RatifyState era)))
-> (Map (KeyHash 'StakePool) IndividualPoolStake
    -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> UtxoPulse era
-> f (UtxoPulse era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) IndividualPoolStake
 -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) IndividualPoolStake
 -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
prevPoolDistrL)
    RootTarget
  era
  (UtxoPulse era)
  (Map (Credential 'DRepRole) DRepState
   -> EpochNo
   -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
   -> EnactState era
   -> [GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams
   -> UtxoPulse era)
-> RootTarget
     era (UtxoPulse era) (Map (Credential 'DRepRole) DRepState)
-> RootTarget
     era
     (UtxoPulse era)
     (EpochNo
      -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
      -> EnactState era
      -> [GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams
      -> UtxoPulse era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'DRepRole) DRepState)
-> PDoc
-> Lens' (UtxoPulse era) (Map (Credential 'DRepRole) DRepState)
-> RootTarget
     era (UtxoPulse era) (Map (Credential 'DRepRole) DRepState)
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term era (Map (Credential 'DRepRole) DRepState)
forall era.
ConwayEraCertState era =>
Term era (Map (Credential 'DRepRole) DRepState)
currentDRepState (String -> PDoc
forall a. String -> Doc a
ppString String
"prevDRepState") ((DRepPulser era Identity (RatifyState era)
 -> f (DRepPulser era Identity (RatifyState era)))
-> UtxoPulse era -> f (UtxoPulse era)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (UtxoPulse era)
  (UtxoPulse era)
  (DRepPulser era Identity (RatifyState era))
  (DRepPulser era Identity (RatifyState era))
_2 ((DRepPulser era Identity (RatifyState era)
  -> f (DRepPulser era Identity (RatifyState era)))
 -> UtxoPulse era -> f (UtxoPulse era))
-> ((Map (Credential 'DRepRole) DRepState
     -> f (Map (Credential 'DRepRole) DRepState))
    -> DRepPulser era Identity (RatifyState era)
    -> f (DRepPulser era Identity (RatifyState era)))
-> (Map (Credential 'DRepRole) DRepState
    -> f (Map (Credential 'DRepRole) DRepState))
-> UtxoPulse era
-> f (UtxoPulse era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'DRepRole) DRepState
 -> f (Map (Credential 'DRepRole) DRepState))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'DRepRole) DRepState
 -> f (Map (Credential 'DRepRole) DRepState))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
prevDRepStateL)
    RootTarget
  era
  (UtxoPulse era)
  (EpochNo
   -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
   -> EnactState era
   -> [GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams
   -> UtxoPulse era)
-> RootTarget era (UtxoPulse era) EpochNo
-> RootTarget
     era
     (UtxoPulse era)
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
      -> EnactState era
      -> [GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams
      -> UtxoPulse era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era EpochNo
-> PDoc
-> Lens' (UtxoPulse era) EpochNo
-> RootTarget era (UtxoPulse era) EpochNo
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term era EpochNo
forall era. Era era => Term era EpochNo
currentEpoch (String -> PDoc
forall a. String -> Doc a
ppString String
"prevEpoch") ((DRepPulser era Identity (RatifyState era)
 -> f (DRepPulser era Identity (RatifyState era)))
-> UtxoPulse era -> f (UtxoPulse era)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (UtxoPulse era)
  (UtxoPulse era)
  (DRepPulser era Identity (RatifyState era))
  (DRepPulser era Identity (RatifyState era))
_2 ((DRepPulser era Identity (RatifyState era)
  -> f (DRepPulser era Identity (RatifyState era)))
 -> UtxoPulse era -> f (UtxoPulse era))
-> ((EpochNo -> f EpochNo)
    -> DRepPulser era Identity (RatifyState era)
    -> f (DRepPulser era Identity (RatifyState era)))
-> (EpochNo -> f EpochNo)
-> UtxoPulse era
-> f (UtxoPulse era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (EpochNo -> f EpochNo)
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(EpochNo -> f EpochNo)
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
prevEpochL)
    RootTarget
  era
  (UtxoPulse era)
  (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
   -> EnactState era
   -> [GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams
   -> UtxoPulse era)
-> RootTarget
     era
     (UtxoPulse era)
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> RootTarget
     era
     (UtxoPulse era)
     (EnactState era
      -> [GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams
      -> UtxoPulse era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> PDoc
-> Lens'
     (UtxoPulse era)
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> RootTarget
     era
     (UtxoPulse era)
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall era.
ConwayEraCertState era =>
Term
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
committeeState (String -> PDoc
forall a. String -> Doc a
ppString String
"prevCommitteeState") ((DRepPulser era Identity (RatifyState era)
 -> f (DRepPulser era Identity (RatifyState era)))
-> UtxoPulse era -> f (UtxoPulse era)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (UtxoPulse era)
  (UtxoPulse era)
  (DRepPulser era Identity (RatifyState era))
  (DRepPulser era Identity (RatifyState era))
_2 ((DRepPulser era Identity (RatifyState era)
  -> f (DRepPulser era Identity (RatifyState era)))
 -> UtxoPulse era -> f (UtxoPulse era))
-> ((Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
     -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
    -> DRepPulser era Identity (RatifyState era)
    -> f (DRepPulser era Identity (RatifyState era)))
-> (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
    -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> UtxoPulse era
-> f (UtxoPulse era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
 -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
 -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
prevCommitteeStateL)
    RootTarget
  era
  (UtxoPulse era)
  (EnactState era
   -> [GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams
   -> UtxoPulse era)
-> RootTarget era (UtxoPulse era) (EnactState era)
-> RootTarget
     era
     (UtxoPulse era)
     ([GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams -> UtxoPulse era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (EnactState era) (EnactState era)
-> Lens' (UtxoPulse era) (EnactState era)
-> RootTarget era (UtxoPulse era) (EnactState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (EnactState era) (EnactState era)
forall era.
Reflect era =>
RootTarget era (EnactState era) (EnactState era)
enactStateT ((DRepPulser era Identity (RatifyState era)
 -> f (DRepPulser era Identity (RatifyState era)))
-> UtxoPulse era -> f (UtxoPulse era)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (UtxoPulse era)
  (UtxoPulse era)
  (DRepPulser era Identity (RatifyState era))
  (DRepPulser era Identity (RatifyState era))
_2 ((DRepPulser era Identity (RatifyState era)
  -> f (DRepPulser era Identity (RatifyState era)))
 -> UtxoPulse era -> f (UtxoPulse era))
-> ((EnactState era -> f (EnactState era))
    -> DRepPulser era Identity (RatifyState era)
    -> f (DRepPulser era Identity (RatifyState era)))
-> (EnactState era -> f (EnactState era))
-> UtxoPulse era
-> f (UtxoPulse era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (EnactState era -> f (EnactState era))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(EnactState era -> f (EnactState era))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
prevEnactStateL)
    RootTarget
  era
  (UtxoPulse era)
  ([GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams -> UtxoPulse era)
-> RootTarget era (UtxoPulse era) [GovActionState era]
-> RootTarget
     era
     (UtxoPulse era)
     (Map (KeyHash 'StakePool) PoolParams -> UtxoPulse era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era [GovActionState era]
-> PDoc
-> Lens' (UtxoPulse era) [GovActionState era]
-> RootTarget era (UtxoPulse era) [GovActionState era]
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term era [GovActionState era]
forall era. Era era => Term era [GovActionState era]
currGovStates (String -> PDoc
forall a. String -> Doc a
ppString String
"prevProposals") ((DRepPulser era Identity (RatifyState era)
 -> f (DRepPulser era Identity (RatifyState era)))
-> UtxoPulse era -> f (UtxoPulse era)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (UtxoPulse era)
  (UtxoPulse era)
  (DRepPulser era Identity (RatifyState era))
  (DRepPulser era Identity (RatifyState era))
_2 ((DRepPulser era Identity (RatifyState era)
  -> f (DRepPulser era Identity (RatifyState era)))
 -> UtxoPulse era -> f (UtxoPulse era))
-> (([GovActionState era] -> f [GovActionState era])
    -> DRepPulser era Identity (RatifyState era)
    -> f (DRepPulser era Identity (RatifyState era)))
-> ([GovActionState era] -> f [GovActionState era])
-> UtxoPulse era
-> f (UtxoPulse era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([GovActionState era] -> f [GovActionState era])
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
([GovActionState era] -> f [GovActionState era])
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
ratifyGovActionStatesL)
    RootTarget
  era
  (UtxoPulse era)
  (Map (KeyHash 'StakePool) PoolParams -> UtxoPulse era)
-> RootTarget
     era (UtxoPulse era) (Map (KeyHash 'StakePool) PoolParams)
-> RootTarget era (UtxoPulse era) (UtxoPulse era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) PoolParams)
-> PDoc
-> Lens' (UtxoPulse era) (Map (KeyHash 'StakePool) PoolParams)
-> RootTarget
     era (UtxoPulse era) (Map (KeyHash 'StakePool) PoolParams)
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term era (Map (KeyHash 'StakePool) PoolParams)
forall era.
EraCertState era =>
Term era (Map (KeyHash 'StakePool) PoolParams)
regPools (String -> PDoc
forall a. String -> Doc a
ppString String
"prevPoolParams") ((DRepPulser era Identity (RatifyState era)
 -> f (DRepPulser era Identity (RatifyState era)))
-> UtxoPulse era -> f (UtxoPulse era)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (UtxoPulse era)
  (UtxoPulse era)
  (DRepPulser era Identity (RatifyState era))
  (DRepPulser era Identity (RatifyState era))
_2 ((DRepPulser era Identity (RatifyState era)
  -> f (DRepPulser era Identity (RatifyState era)))
 -> UtxoPulse era -> f (UtxoPulse era))
-> ((Map (KeyHash 'StakePool) PoolParams
     -> f (Map (KeyHash 'StakePool) PoolParams))
    -> DRepPulser era Identity (RatifyState era)
    -> f (DRepPulser era Identity (RatifyState era)))
-> (Map (KeyHash 'StakePool) PoolParams
    -> f (Map (KeyHash 'StakePool) PoolParams))
-> UtxoPulse era
-> f (UtxoPulse era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
prevRegPoolsL)

-- TODO access prevTreasury from the EnactState
--  :$ Virtual treasury (ppString "prevTreasury") (_2 . prevTreasuryL)

justPulser ::
  forall era.
  (Reflect era, RunConwayRatify era, ConwayEraCertState era) =>
  Proof era ->
  RootTarget
    era
    (DRepPulser era Identity (RatifyState era))
    (DRepPulser era Identity (RatifyState era))
justPulser :: forall era.
(Reflect era, RunConwayRatify era, ConwayEraCertState era) =>
Proof era
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (DRepPulser era Identity (RatifyState era))
justPulser Proof era
p =
  String
-> TypeRep (DRepPulser era Identity (RatifyState era))
-> (Map (Credential 'Staking) DRep
    -> Map (KeyHash 'StakePool) IndividualPoolStake
    -> Map (Credential 'DRepRole) DRepState
    -> EpochNo
    -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
    -> EnactState era
    -> [GovActionState era]
    -> Map (KeyHash 'StakePool) PoolParams
    -> DRepPulser era Identity (RatifyState era))
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'Staking) DRep
      -> Map (KeyHash 'StakePool) IndividualPoolStake
      -> Map (Credential 'DRepRole) DRepState
      -> EpochNo
      -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
      -> EnactState era
      -> [GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams
      -> DRepPulser era Identity (RatifyState era))
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"DRepPulser" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(DRepPulser era Identity (RatifyState era))) (Proof era
-> Map TxIn (TxOutF era)
-> Map (Credential 'Staking) DRep
-> Map (KeyHash 'StakePool) IndividualPoolStake
-> Map (Credential 'DRepRole) DRepState
-> EpochNo
-> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
-> EnactState era
-> [GovActionState era]
-> Map (KeyHash 'StakePool) PoolParams
-> DRepPulser era Identity (RatifyState era)
forall era.
(Reflect era, RunConwayRatify era) =>
Proof era
-> Map TxIn (TxOutF era)
-> Map (Credential 'Staking) DRep
-> Map (KeyHash 'StakePool) IndividualPoolStake
-> Map (Credential 'DRepRole) DRepState
-> EpochNo
-> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
-> EnactState era
-> [GovActionState era]
-> Map (KeyHash 'StakePool) PoolParams
-> DRepPulser era Identity (RatifyState era)
initPulser Proof era
p Map TxIn (TxOutF era)
forall k a. Map k a
Map.empty)
    RootTarget
  era
  (DRepPulser era Identity (RatifyState era))
  (Map (Credential 'Staking) DRep
   -> Map (KeyHash 'StakePool) IndividualPoolStake
   -> Map (Credential 'DRepRole) DRepState
   -> EpochNo
   -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
   -> EnactState era
   -> [GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams
   -> DRepPulser era Identity (RatifyState era))
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'Staking) DRep)
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (KeyHash 'StakePool) IndividualPoolStake
      -> Map (Credential 'DRepRole) DRepState
      -> EpochNo
      -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
      -> EnactState era
      -> [GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams
      -> DRepPulser era Identity (RatifyState era))
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) DRep)
-> PDoc
-> Lens'
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'Staking) DRep)
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'Staking) DRep)
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term era (Map (Credential 'Staking) DRep)
forall era.
EraCertState era =>
Term era (Map (Credential 'Staking) DRep)
drepDelegation (String -> PDoc
forall a. String -> Doc a
ppString String
"prevDRepDelegations") (Map (Credential 'Staking) DRep
 -> f (Map (Credential 'Staking) DRep))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) DRep
 -> f (Map (Credential 'Staking) DRep))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens'
  (DRepPulser era Identity (RatifyState era))
  (Map (Credential 'Staking) DRep)
prevDRepDelegationsL
    RootTarget
  era
  (DRepPulser era Identity (RatifyState era))
  (Map (KeyHash 'StakePool) IndividualPoolStake
   -> Map (Credential 'DRepRole) DRepState
   -> EpochNo
   -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
   -> EnactState era
   -> [GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams
   -> DRepPulser era Identity (RatifyState era))
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (KeyHash 'StakePool) IndividualPoolStake)
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'DRepRole) DRepState
      -> EpochNo
      -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
      -> EnactState era
      -> [GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams
      -> DRepPulser era Identity (RatifyState era))
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
-> PDoc
-> Lens'
     (DRepPulser era Identity (RatifyState era))
     (Map (KeyHash 'StakePool) IndividualPoolStake)
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
poolDistr (String -> PDoc
forall a. String -> Doc a
ppString String
"prevPoolDistr") (Map (KeyHash 'StakePool) IndividualPoolStake
 -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) IndividualPoolStake
 -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens'
  (DRepPulser era Identity (RatifyState era))
  (Map (KeyHash 'StakePool) IndividualPoolStake)
prevPoolDistrL
    RootTarget
  era
  (DRepPulser era Identity (RatifyState era))
  (Map (Credential 'DRepRole) DRepState
   -> EpochNo
   -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
   -> EnactState era
   -> [GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams
   -> DRepPulser era Identity (RatifyState era))
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'DRepRole) DRepState)
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (EpochNo
      -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
      -> EnactState era
      -> [GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams
      -> DRepPulser era Identity (RatifyState era))
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'DRepRole) DRepState)
-> PDoc
-> Lens'
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'DRepRole) DRepState)
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'DRepRole) DRepState)
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term era (Map (Credential 'DRepRole) DRepState)
forall era.
ConwayEraCertState era =>
Term era (Map (Credential 'DRepRole) DRepState)
currentDRepState (String -> PDoc
forall a. String -> Doc a
ppString String
"prevDRepState") (Map (Credential 'DRepRole) DRepState
 -> f (Map (Credential 'DRepRole) DRepState))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'DRepRole) DRepState
 -> f (Map (Credential 'DRepRole) DRepState))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens'
  (DRepPulser era Identity (RatifyState era))
  (Map (Credential 'DRepRole) DRepState)
prevDRepStateL
    RootTarget
  era
  (DRepPulser era Identity (RatifyState era))
  (EpochNo
   -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
   -> EnactState era
   -> [GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams
   -> DRepPulser era Identity (RatifyState era))
-> RootTarget
     era (DRepPulser era Identity (RatifyState era)) EpochNo
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
      -> EnactState era
      -> [GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams
      -> DRepPulser era Identity (RatifyState era))
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era EpochNo
-> PDoc
-> Lens' (DRepPulser era Identity (RatifyState era)) EpochNo
-> RootTarget
     era (DRepPulser era Identity (RatifyState era)) EpochNo
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term era EpochNo
forall era. Era era => Term era EpochNo
currentEpoch (String -> PDoc
forall a. String -> Doc a
ppString String
"prevEpoch") (EpochNo -> f EpochNo)
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(EpochNo -> f EpochNo)
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens' (DRepPulser era Identity (RatifyState era)) EpochNo
prevEpochL
    RootTarget
  era
  (DRepPulser era Identity (RatifyState era))
  (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
   -> EnactState era
   -> [GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams
   -> DRepPulser era Identity (RatifyState era))
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (EnactState era
      -> [GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams
      -> DRepPulser era Identity (RatifyState era))
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> PDoc
-> Lens'
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall era.
ConwayEraCertState era =>
Term
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
committeeState (String -> PDoc
forall a. String -> Doc a
ppString String
"prevCommitteeState") (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
 -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
 -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens'
  (DRepPulser era Identity (RatifyState era))
  (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
prevCommitteeStateL
    RootTarget
  era
  (DRepPulser era Identity (RatifyState era))
  (EnactState era
   -> [GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams
   -> DRepPulser era Identity (RatifyState era))
-> RootTarget
     era (DRepPulser era Identity (RatifyState era)) (EnactState era)
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     ([GovActionState era]
      -> Map (KeyHash 'StakePool) PoolParams
      -> DRepPulser era Identity (RatifyState era))
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (EnactState era) (EnactState era)
-> Lens'
     (DRepPulser era Identity (RatifyState era)) (EnactState era)
-> RootTarget
     era (DRepPulser era Identity (RatifyState era)) (EnactState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (EnactState era) (EnactState era)
forall era.
Reflect era =>
RootTarget era (EnactState era) (EnactState era)
enactStateT (EnactState era -> f (EnactState era))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(EnactState era -> f (EnactState era))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens' (DRepPulser era Identity (RatifyState era)) (EnactState era)
prevEnactStateL
    RootTarget
  era
  (DRepPulser era Identity (RatifyState era))
  ([GovActionState era]
   -> Map (KeyHash 'StakePool) PoolParams
   -> DRepPulser era Identity (RatifyState era))
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     [GovActionState era]
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (KeyHash 'StakePool) PoolParams
      -> DRepPulser era Identity (RatifyState era))
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era [GovActionState era]
-> PDoc
-> Lens'
     (DRepPulser era Identity (RatifyState era)) [GovActionState era]
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     [GovActionState era]
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term era [GovActionState era]
forall era. Era era => Term era [GovActionState era]
currGovStates (String -> PDoc
forall a. String -> Doc a
ppString String
"prevProposals") ([GovActionState era] -> f [GovActionState era])
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
([GovActionState era] -> f [GovActionState era])
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens'
  (DRepPulser era Identity (RatifyState era)) [GovActionState era]
ratifyGovActionStatesL
    RootTarget
  era
  (DRepPulser era Identity (RatifyState era))
  (Map (KeyHash 'StakePool) PoolParams
   -> DRepPulser era Identity (RatifyState era))
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (KeyHash 'StakePool) PoolParams)
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (DRepPulser era Identity (RatifyState era))
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) PoolParams)
-> PDoc
-> Lens'
     (DRepPulser era Identity (RatifyState era))
     (Map (KeyHash 'StakePool) PoolParams)
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (Map (KeyHash 'StakePool) PoolParams)
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term era (Map (KeyHash 'StakePool) PoolParams)
forall era.
EraCertState era =>
Term era (Map (KeyHash 'StakePool) PoolParams)
regPools (String -> PDoc
forall a. String -> Doc a
ppString String
"prevPoolParams") (Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens'
  (DRepPulser era Identity (RatifyState era))
  (Map (KeyHash 'StakePool) PoolParams)
prevRegPoolsL

-- TODO access prevTreasury from the EnactState
-- :$ Virtual treasury (ppString "prevTreasury") (prevTreasuryL)

-- | Variable used to constrain the DRepPulser
drepPulser ::
  (RunConwayRatify era, Reflect era) => Term era (DRepPulser era Identity (RatifyState era))
drepPulser :: forall era.
(RunConwayRatify era, Reflect era) =>
Term era (DRepPulser era Identity (RatifyState era))
drepPulser = V era (DRepPulser era Identity (RatifyState era))
-> Term era (DRepPulser era Identity (RatifyState era))
forall era t. V era t -> Term era t
Var (V era (DRepPulser era Identity (RatifyState era))
 -> Term era (DRepPulser era Identity (RatifyState era)))
-> V era (DRepPulser era Identity (RatifyState era))
-> Term era (DRepPulser era Identity (RatifyState era))
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (DRepPulser era Identity (RatifyState era))
-> Access era Any (DRepPulser era Identity (RatifyState era))
-> V era (DRepPulser era Identity (RatifyState era))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"drepPulser" Rep era (DRepPulser era Identity (RatifyState era))
forall era.
(RunConwayRatify era, Reflect era) =>
Rep era (DRepPulser era Identity (RatifyState era))
DRepPulserR Access era Any (DRepPulser era Identity (RatifyState era))
forall era s t. Access era s t
No

-- | Predicates that constrain the DRepPuser and all its 'prevXXX' snapshots
--   These ensure we generate state just passing the epoch boundary
prevPulsingPreds ::
  (RunConwayRatify era, Reflect era, ConwayEraCertState era) => Proof era -> [Pred era]
prevPulsingPreds :: forall era.
(RunConwayRatify era, Reflect era, ConwayEraCertState era) =>
Proof era -> [Pred era]
prevPulsingPreds Proof era
p =
  [ Term era Size -> Term era (Set (Credential 'Staking)) -> Pred era
forall t era. Sizeable t => Term era Size -> Term era t -> Pred era
Sized (Int -> Term era Size
forall era. Era era => Int -> Term era Size
ExactSize Int
0) (Term era (Map (Credential 'Staking) Coin)
-> Term era (Set (Credential 'Staking))
forall a era b. Ord a => Term era (Map a b) -> Term era (Set a)
Dom Term era (Map (Credential 'Staking) Coin)
forall era. Era era => Term era (Map (Credential 'Staking) Coin)
enactWithdrawals)
  , Rep era Coin -> Coin -> Term era Coin
forall era t. Rep era t -> t -> Term era t
Lit Rep era Coin
forall era. Rep era Coin
CoinR (Integer -> Coin
Coin Integer
0) Term era Coin -> Term era Coin -> Pred era
forall a era. Eq a => Term era a -> Term era a -> Pred era
:=: Term era Coin
forall era. Era era => Term era Coin
enactTreasury
  , Proof era -> Term era (UtxoPulse era)
forall era.
(RunConwayRatify era, Reflect era) =>
Proof era -> Term era (UtxoPulse era)
utxoPulse Proof era
p Term era (UtxoPulse era)
-> RootTarget era (UtxoPulse era) (UtxoPulse era) -> Pred era
forall era t r. Term era t -> RootTarget era r t -> Pred era
:<-: Proof era -> RootTarget era (UtxoPulse era) (UtxoPulse era)
forall era.
(RunConwayRatify era, Reflect era, ConwayEraCertState era) =>
Proof era -> RootTarget era (UtxoPulse era) (UtxoPulse era)
pulsingPairT Proof era
p
  , Term era (GovRelation StrictMaybe era)
forall era. Reflect era => Term era (GovRelation StrictMaybe era)
prevGovActionIds
      Term era (GovRelation StrictMaybe era)
-> RootTarget era Void (GovRelation StrictMaybe era) -> Pred era
forall era t r. Term era t -> RootTarget era r t -> Pred era
:<-: ( String
-> (Proposals era -> GovRelation StrictMaybe era)
-> RootTarget
     era Void (Proposals era -> GovRelation StrictMaybe era)
forall a b era. String -> (a -> b) -> RootTarget era Void (a -> b)
Constr String
"PrevGovActionIdsFromProposals" (\Proposals era
cp -> GovRelation PRoot era -> GovRelation StrictMaybe era
forall era. GovRelation PRoot era -> GovRelation StrictMaybe era
toPrevGovActionIds (Proposals era
cp Proposals era
-> Getting
     (GovRelation PRoot era) (Proposals era) (GovRelation PRoot era)
-> GovRelation PRoot era
forall s a. s -> Getting a s a -> a
^. Getting
  (GovRelation PRoot era) (Proposals era) (GovRelation PRoot era)
forall era (f :: * -> *).
Functor f =>
(GovRelation PRoot era -> f (GovRelation PRoot era))
-> Proposals era -> f (Proposals era)
pRootsL))
               RootTarget era Void (Proposals era -> GovRelation StrictMaybe era)
-> Term era (Proposals era)
-> RootTarget era Void (GovRelation StrictMaybe era)
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ (Proof era -> Term era (Proposals era)
forall era. Era era => Proof era -> Term era (Proposals era)
currProposals Proof era
p)
           )
  , Term era [GovActionState era]
forall era. Era era => Term era [GovActionState era]
currGovStates Term era [GovActionState era]
-> RootTarget era Void [GovActionState era] -> Pred era
forall era t r. Term era t -> RootTarget era r t -> Pred era
:<-: (String
-> (Proposals era -> [GovActionState era])
-> RootTarget era Void (Proposals era -> [GovActionState era])
forall a b era. String -> (a -> b) -> RootTarget era Void (a -> b)
Constr String
"proposalsActions" (StrictSeq (GovActionState era) -> [GovActionState era]
forall a. StrictSeq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (StrictSeq (GovActionState era) -> [GovActionState era])
-> (Proposals era -> StrictSeq (GovActionState era))
-> Proposals era
-> [GovActionState era]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proposals era -> StrictSeq (GovActionState era)
forall era. Proposals era -> StrictSeq (GovActionState era)
proposalsActions) RootTarget era Void (Proposals era -> [GovActionState era])
-> Term era (Proposals era)
-> RootTarget era Void [GovActionState era]
forall era a t. Target era (a -> t) -> Term era a -> Target era t
^$ Proof era -> Term era (Proposals era)
forall era. Era era => Proof era -> Term era (Proposals era)
currProposals Proof era
p)
  , Term era (DRepPulser era Identity (RatifyState era))
-> Term era (UtxoPulse era)
-> Lens'
     (UtxoPulse era) (DRepPulser era Identity (RatifyState era))
-> Pred era
forall t era big.
(Eq t, Era era) =>
Term era t -> Term era big -> Lens' big t -> Pred era
select Term era (DRepPulser era Identity (RatifyState era))
forall era.
(RunConwayRatify era, Reflect era) =>
Term era (DRepPulser era Identity (RatifyState era))
drepPulser (Proof era -> Term era (UtxoPulse era)
forall era.
(RunConwayRatify era, Reflect era) =>
Proof era -> Term era (UtxoPulse era)
utxoPulse Proof era
p) (DRepPulser era Identity (RatifyState era)
 -> f (DRepPulser era Identity (RatifyState era)))
-> UtxoPulse era -> f (UtxoPulse era)
forall s t a b. Field2 s t a b => Lens s t a b
Lens' (UtxoPulse era) (DRepPulser era Identity (RatifyState era))
_2
  , Term era (Map DRep Coin)
-> Term era (DRepPulser era Identity (RatifyState era))
-> Lens'
     (DRepPulser era Identity (RatifyState era)) (Map DRep Coin)
-> Pred era
forall t era big.
(Eq t, Era era) =>
Term era t -> Term era big -> Lens' big t -> Pred era
select Term era (Map DRep Coin)
forall era. Era era => Term era (Map DRep Coin)
partialDRepDistr Term era (DRepPulser era Identity (RatifyState era))
forall era.
(RunConwayRatify era, Reflect era) =>
Term era (DRepPulser era Identity (RatifyState era))
drepPulser (Map DRep Coin -> f (Map DRep Coin))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map DRep Coin -> f (Map DRep Coin))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens' (DRepPulser era Identity (RatifyState era)) (Map DRep Coin)
partialDRepDistrL
  , Term era (Map (Credential 'Staking) DRep)
-> Term era (DRepPulser era Identity (RatifyState era))
-> Lens'
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'Staking) DRep)
-> Pred era
forall t era big.
(Eq t, Era era) =>
Term era t -> Term era big -> Lens' big t -> Pred era
select Term era (Map (Credential 'Staking) DRep)
forall era. Era era => Term era (Map (Credential 'Staking) DRep)
prevDRepDelegations Term era (DRepPulser era Identity (RatifyState era))
forall era.
(RunConwayRatify era, Reflect era) =>
Term era (DRepPulser era Identity (RatifyState era))
drepPulser (Map (Credential 'Staking) DRep
 -> f (Map (Credential 'Staking) DRep))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) DRep
 -> f (Map (Credential 'Staking) DRep))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens'
  (DRepPulser era Identity (RatifyState era))
  (Map (Credential 'Staking) DRep)
prevDRepDelegationsL
  , Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
-> Term era (DRepPulser era Identity (RatifyState era))
-> Lens'
     (DRepPulser era Identity (RatifyState era))
     (Map (KeyHash 'StakePool) IndividualPoolStake)
-> Pred era
forall t era big.
(Eq t, Era era) =>
Term era t -> Term era big -> Lens' big t -> Pred era
select Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
prevPoolDistr Term era (DRepPulser era Identity (RatifyState era))
forall era.
(RunConwayRatify era, Reflect era) =>
Term era (DRepPulser era Identity (RatifyState era))
drepPulser (Map (KeyHash 'StakePool) IndividualPoolStake
 -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) IndividualPoolStake
 -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens'
  (DRepPulser era Identity (RatifyState era))
  (Map (KeyHash 'StakePool) IndividualPoolStake)
prevPoolDistrL
  , Term era (Map (Credential 'DRepRole) DRepState)
-> Term era (DRepPulser era Identity (RatifyState era))
-> Lens'
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'DRepRole) DRepState)
-> Pred era
forall t era big.
(Eq t, Era era) =>
Term era t -> Term era big -> Lens' big t -> Pred era
select Term era (Map (Credential 'DRepRole) DRepState)
forall era.
Era era =>
Term era (Map (Credential 'DRepRole) DRepState)
prevDRepState Term era (DRepPulser era Identity (RatifyState era))
forall era.
(RunConwayRatify era, Reflect era) =>
Term era (DRepPulser era Identity (RatifyState era))
drepPulser (Map (Credential 'DRepRole) DRepState
 -> f (Map (Credential 'DRepRole) DRepState))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'DRepRole) DRepState
 -> f (Map (Credential 'DRepRole) DRepState))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens'
  (DRepPulser era Identity (RatifyState era))
  (Map (Credential 'DRepRole) DRepState)
prevDRepStateL
  , Term era EpochNo
-> Term era (DRepPulser era Identity (RatifyState era))
-> Lens' (DRepPulser era Identity (RatifyState era)) EpochNo
-> Pred era
forall t era big.
(Eq t, Era era) =>
Term era t -> Term era big -> Lens' big t -> Pred era
select Term era EpochNo
forall era. Era era => Term era EpochNo
prevEpoch Term era (DRepPulser era Identity (RatifyState era))
forall era.
(RunConwayRatify era, Reflect era) =>
Term era (DRepPulser era Identity (RatifyState era))
drepPulser (EpochNo -> f EpochNo)
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(EpochNo -> f EpochNo)
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens' (DRepPulser era Identity (RatifyState era)) EpochNo
prevEpochL
  , Term
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> Term era (DRepPulser era Identity (RatifyState era))
-> Lens'
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> Pred era
forall t era big.
(Eq t, Era era) =>
Term era t -> Term era big -> Lens' big t -> Pred era
select Term
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall era.
Era era =>
Term
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
prevCommitteeState Term era (DRepPulser era Identity (RatifyState era))
forall era.
(RunConwayRatify era, Reflect era) =>
Term era (DRepPulser era Identity (RatifyState era))
drepPulser (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
 -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
 -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens'
  (DRepPulser era Identity (RatifyState era))
  (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
prevCommitteeStateL
  , Term era (EnactState era)
-> Term era (DRepPulser era Identity (RatifyState era))
-> Lens'
     (DRepPulser era Identity (RatifyState era)) (EnactState era)
-> Pred era
forall t era big.
(Eq t, Era era) =>
Term era t -> Term era big -> Lens' big t -> Pred era
select Term era (EnactState era)
forall era. Reflect era => Term era (EnactState era)
prevEnactState Term era (DRepPulser era Identity (RatifyState era))
forall era.
(RunConwayRatify era, Reflect era) =>
Term era (DRepPulser era Identity (RatifyState era))
drepPulser (EnactState era -> f (EnactState era))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
forall era (f :: * -> *).
Functor f =>
(EnactState era -> f (EnactState era))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
Lens' (DRepPulser era Identity (RatifyState era)) (EnactState era)
prevEnactStateL
  , Proof era -> Term era (Proposals era)
forall era. Era era => Proof era -> Term era (Proposals era)
currProposals Proof era
p Term era (Proposals era) -> Term era (Proposals era) -> Pred era
forall a era. Eq a => Term era a -> Term era a -> Pred era
:=: Proof era -> Term era (Proposals era)
forall era. Era era => Proof era -> Term era (Proposals era)
prevProposals Proof era
p
  -- TODO access prevTreasury from the EnactState
  -- , select prevTreasury drepPulser prevTreasuryL
  ]

-- | Target for assembling 'DRPulsing' form of (DRepPulsingState era)
--   from 'drepPulser' :: forall era. Term era (DRepPulser era Identity (RatifyState era))
pulsingPulsingStateT ::
  forall era.
  (RunConwayRatify era, Reflect era, ConwayEraCertState era) =>
  RootTarget era (DRepPulsingState era) (DRepPulsingState era)
pulsingPulsingStateT :: forall era.
(RunConwayRatify era, Reflect era, ConwayEraCertState era) =>
RootTarget era (DRepPulsingState era) (DRepPulsingState era)
pulsingPulsingStateT =
  String
-> TypeRep (DRepPulsingState era)
-> (DRepPulser era Identity (RatifyState era)
    -> DRepPulsingState era)
-> RootTarget
     era
     (DRepPulsingState era)
     (DRepPulser era Identity (RatifyState era) -> DRepPulsingState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"DRPulsing" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(DRepPulsingState era)) DRepPulser era Identity (RatifyState era) -> DRepPulsingState era
forall era.
DRepPulser era Identity (RatifyState era) -> DRepPulsingState era
DRPulsing
    RootTarget
  era
  (DRepPulsingState era)
  (DRepPulser era Identity (RatifyState era) -> DRepPulsingState era)
-> RootTarget
     era
     (DRepPulsingState era)
     (DRepPulser era Identity (RatifyState era))
-> RootTarget era (DRepPulsingState era) (DRepPulsingState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (DRepPulser era Identity (RatifyState era))
-> PDoc
-> Lens'
     (DRepPulsingState era) (DRepPulser era Identity (RatifyState era))
-> RootTarget
     era
     (DRepPulsingState era)
     (DRepPulser era Identity (RatifyState era))
forall era t root.
Term era t -> PDoc -> Lens' root t -> RootTarget era root t
Virtual Term era (DRepPulser era Identity (RatifyState era))
forall era.
(RunConwayRatify era, Reflect era) =>
Term era (DRepPulser era Identity (RatifyState era))
drepPulser (RootTarget
  era
  (DRepPulser era Identity (RatifyState era))
  (DRepPulser era Identity (RatifyState era))
-> PDoc
forall era r t. RootTarget era r t -> PDoc
ppTarget (forall era.
(Reflect era, RunConwayRatify era, ConwayEraCertState era) =>
Proof era
-> RootTarget
     era
     (DRepPulser era Identity (RatifyState era))
     (DRepPulser era Identity (RatifyState era))
justPulser @era Proof era
forall era. Reflect era => Proof era
reify)) (DRepPulser era Identity (RatifyState era)
 -> f (DRepPulser era Identity (RatifyState era)))
-> DRepPulsingState era -> f (DRepPulsingState era)
forall era (f :: * -> *).
Functor f =>
(DRepPulser era Identity (RatifyState era)
 -> f (DRepPulser era Identity (RatifyState era)))
-> DRepPulsingState era -> f (DRepPulsingState era)
Lens'
  (DRepPulsingState era) (DRepPulser era Identity (RatifyState era))
pulsingStatePulserL

-- | The Lens' used in pulsingPulsingStateT
pulsingStatePulserL :: Lens' (DRepPulsingState era) (DRepPulser era Identity (RatifyState era))
pulsingStatePulserL :: forall era (f :: * -> *).
Functor f =>
(DRepPulser era Identity (RatifyState era)
 -> f (DRepPulser era Identity (RatifyState era)))
-> DRepPulsingState era -> f (DRepPulsingState era)
pulsingStatePulserL = (DRepPulsingState era -> DRepPulser era Identity (RatifyState era))
-> (DRepPulsingState era
    -> DRepPulser era Identity (RatifyState era)
    -> DRepPulsingState era)
-> Lens
     (DRepPulsingState era)
     (DRepPulsingState era)
     (DRepPulser era Identity (RatifyState era))
     (DRepPulser era Identity (RatifyState era))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DRepPulsingState era -> DRepPulser era Identity (RatifyState era)
forall {era}.
DRepPulsingState era -> DRepPulser era Identity (RatifyState era)
getter DRepPulsingState era
-> DRepPulser era Identity (RatifyState era)
-> DRepPulsingState era
forall {era} {era}.
DRepPulsingState era
-> DRepPulser era Identity (RatifyState era)
-> DRepPulsingState era
setter
  where
    getter :: DRepPulsingState era -> DRepPulser era Identity (RatifyState era)
getter (DRPulsing DRepPulser era Identity (RatifyState era)
x) = DRepPulser era Identity (RatifyState era)
x
    getter (DRComplete PulsingSnapshot era
_ RatifyState era
_) =
      String -> DRepPulser era Identity (RatifyState era)
forall a. HasCallStack => String -> a
error (String
"Can't turn a DRCompete into a DRPulsing in pulsingStatePulserL lens.")
    {- There is a way we could do this, by partitioning the prev parts of 'DRPulsing' into
       3 parts RatifyState, RatifySignal, and RatifyEnv, and then making Store those 3
       instead of storing a single PulsingSnapshot. Then we could reassemble a DRPulsing
       that was ready for completion.
    -}
    setter :: DRepPulsingState era
-> DRepPulser era Identity (RatifyState era)
-> DRepPulsingState era
setter (DRPulsing DRepPulser era Identity (RatifyState era)
_) DRepPulser era Identity (RatifyState era)
x = DRepPulser era Identity (RatifyState era) -> DRepPulsingState era
forall era.
DRepPulser era Identity (RatifyState era) -> DRepPulsingState era
DRPulsing DRepPulser era Identity (RatifyState era)
x
    setter (DRComplete PulsingSnapshot era
_ RatifyState era
_) DRepPulser era Identity (RatifyState era)
x = DRepPulser era Identity (RatifyState era) -> DRepPulsingState era
forall era.
DRepPulser era Identity (RatifyState era) -> DRepPulsingState era
DRPulsing DRepPulser era Identity (RatifyState era)
x

-- | The abstract form of DRepPulser that transforms from the Model types
--   used in the inputs, and the concrete types actually stored in 'DRepPulser'
initPulser ::
  forall era.
  (Reflect era, RunConwayRatify era) =>
  Proof era ->
  Map TxIn (TxOutF era) ->
  Map (Credential 'Staking) DRep ->
  Map (KeyHash 'StakePool) IndividualPoolStake ->
  Map (Credential 'DRepRole) DRepState ->
  EpochNo ->
  Map (Credential 'ColdCommitteeRole) CommitteeAuthorization ->
  EnactState era ->
  [GovActionState era] ->
  -- Coin ->
  Map (KeyHash 'StakePool) PoolParams ->
  DRepPulser era Identity (RatifyState era)
initPulser :: forall era.
(Reflect era, RunConwayRatify era) =>
Proof era
-> Map TxIn (TxOutF era)
-> Map (Credential 'Staking) DRep
-> Map (KeyHash 'StakePool) IndividualPoolStake
-> Map (Credential 'DRepRole) DRepState
-> EpochNo
-> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
-> EnactState era
-> [GovActionState era]
-> Map (KeyHash 'StakePool) PoolParams
-> DRepPulser era Identity (RatifyState era)
initPulser Proof era
proof Map TxIn (TxOutF era)
utx Map (Credential 'Staking) DRep
credDRepMap Map (KeyHash 'StakePool) IndividualPoolStake
poold Map (Credential 'DRepRole) DRepState
credDRepStateMap EpochNo
epoch Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
commstate EnactState era
enactstate [GovActionState era]
govstates {- treas -} Map (KeyHash 'StakePool) PoolParams
poolParams =
  let umap :: UMap
umap = Map (Credential 'Staking) RDPair
-> Map Ptr (Credential 'Staking)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) DRep
-> UMap
unify Map (Credential 'Staking) RDPair
forall k a. Map k a
Map.empty Map Ptr (Credential 'Staking)
forall k a. Map k a
Map.empty Map (Credential 'Staking) (KeyHash 'StakePool)
forall k a. Map k a
Map.empty Map (Credential 'Staking) DRep
credDRepMap
      umapSize :: Int
umapSize = Map (Credential 'Staking) DRep -> Int
forall k a. Map k a -> Int
Map.size Map (Credential 'Staking) DRep
credDRepMap
      k :: NonZero Word64
k = Globals -> NonZero Word64
securityParameter Globals
testGlobals
      instantStake :: InstantStake era
instantStake = UTxO era -> InstantStake era -> InstantStake era
forall era.
EraStake era =>
UTxO era -> InstantStake era -> InstantStake era
addInstantStake (Map TxIn (TxOutF era)
utx Map TxIn (TxOutF era)
-> Getting (UTxO era) (Map TxIn (TxOutF era)) (UTxO era)
-> UTxO era
forall s a. s -> Getting a s a -> a
^. Proof era -> Lens' (Map TxIn (TxOutF era)) (UTxO era)
forall era. Proof era -> Lens' (Map TxIn (TxOutF era)) (UTxO era)
utxoFL Proof era
proof) InstantStake era
forall a. Monoid a => a
mempty
   in Int
-> UMap
-> Int
-> InstantStake era
-> PoolDistr
-> Map DRep (CompactForm Coin)
-> Map (Credential 'DRepRole) DRepState
-> EpochNo
-> CommitteeState era
-> EnactState era
-> StrictSeq (GovActionState era)
-> Map (Credential 'Staking) (CompactForm Coin)
-> Globals
-> Map (KeyHash 'StakePool) PoolParams
-> DRepPulser era Identity (RatifyState era)
forall era ans (m :: * -> *).
(ans ~ RatifyState era, m ~ Identity, RunConwayRatify era) =>
Int
-> UMap
-> Int
-> InstantStake era
-> PoolDistr
-> Map DRep (CompactForm Coin)
-> Map (Credential 'DRepRole) DRepState
-> EpochNo
-> CommitteeState era
-> EnactState era
-> StrictSeq (GovActionState era)
-> Map (Credential 'Staking) (CompactForm Coin)
-> Globals
-> Map (KeyHash 'StakePool) PoolParams
-> DRepPulser era m ans
DRepPulser
        (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
1 (Rational -> Int
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
ceiling (Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
umapSize Integer -> NonZero Integer -> Rational
forall a. Integral a => a -> NonZero a -> Ratio a
%. (forall (n :: Natural). (KnownNat n, 1 <= n) => NonZero Integer
knownNonZero @8 NonZero Integer -> NonZero Integer -> NonZero Integer
forall a b.
(Integral a, Integral b) =>
NonZero a -> NonZero b -> NonZero Integer
`mulNonZero` NonZero Word64 -> NonZero Integer
forall a. Integral a => NonZero a -> NonZero Integer
toIntegerNonZero NonZero Word64
k))))
        UMap
umap
        Int
0
        InstantStake era
instantStake
        (Map (KeyHash 'StakePool) IndividualPoolStake
-> CompactForm Coin -> PoolDistr
PoolDistr Map (KeyHash 'StakePool) IndividualPoolStake
poold (CompactForm Coin -> PoolDistr) -> CompactForm Coin -> PoolDistr
forall a b. (a -> b) -> a -> b
$ Word64 -> CompactForm Coin
CompactCoin Word64
1)
        Map DRep (CompactForm Coin)
forall k a. Map k a
Map.empty
        Map (Credential 'DRepRole) DRepState
credDRepStateMap
        EpochNo
epoch
        (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
-> CommitteeState era
forall era.
Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
-> CommitteeState era
CommitteeState Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
commstate)
        EnactState era
enactstate
        ([GovActionState era] -> StrictSeq (GovActionState era)
forall a. [a] -> StrictSeq a
SS.fromList [GovActionState era]
govstates)
        (Proposals era -> Map (Credential 'Staking) (CompactForm Coin)
forall era.
Proposals era -> Map (Credential 'Staking) (CompactForm Coin)
proposalsDeposits (Proposals era -> Map (Credential 'Staking) (CompactForm Coin))
-> Proposals era -> Map (Credential 'Staking) (CompactForm Coin)
forall a b. (a -> b) -> a -> b
$ Proposals era
forall a. Default a => a
def Proposals era -> (Proposals era -> Proposals era) -> Proposals era
forall a b. a -> (a -> b) -> b
& (OMap GovActionId (GovActionState era)
 -> Identity (OMap GovActionId (GovActionState era)))
-> Proposals era -> Identity (Proposals era)
forall era (f :: * -> *).
Functor f =>
(OMap GovActionId (GovActionState era)
 -> f (OMap GovActionId (GovActionState era)))
-> Proposals era -> f (Proposals era)
pPropsL ((OMap GovActionId (GovActionState era)
  -> Identity (OMap GovActionId (GovActionState era)))
 -> Proposals era -> Identity (Proposals era))
-> OMap GovActionId (GovActionState era)
-> Proposals era
-> Proposals era
forall s t a b. ASetter s t a b -> b -> s -> t
.~ [GovActionState era] -> OMap GovActionId (GovActionState era)
forall (f :: * -> *) k v.
(Foldable f, HasOKey k v) =>
f v -> OMap k v
OMap.fromFoldable [GovActionState era]
govstates)
        -- treas
        Globals
testGlobals
        Map (KeyHash 'StakePool) PoolParams
poolParams

proposalsT :: forall era. Era era => Proof era -> RootTarget era (Proposals era) (Proposals era)
proposalsT :: forall era.
Era era =>
Proof era -> RootTarget era (Proposals era) (Proposals era)
proposalsT Proof era
proof =
  String
-> TypeRep (Proposals era)
-> (Proposals era -> Proposals era)
-> RootTarget era (Proposals era) (Proposals era -> Proposals era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"Proposals" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(Proposals era)) Proposals era -> Proposals era
forall a. a -> a
id
    RootTarget era (Proposals era) (Proposals era -> Proposals era)
-> RootTarget era (Proposals era) (Proposals era)
-> RootTarget era (Proposals era) (Proposals era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Proposals era)
-> SimpleGetter (Proposals era) (Proposals era)
-> RootTarget era (Proposals era) (Proposals era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Proof era -> Term era (Proposals era)
forall era. Era era => Proof era -> Term era (Proposals era)
currProposals Proof era
proof) ((Proposals era -> Proposals era)
-> (Proposals era -> Proposals era -> Proposals era)
-> forall {f :: * -> *}.
   Functor f =>
   (Proposals era -> f (Proposals era))
   -> Proposals era -> f (Proposals era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Proposals era -> Proposals era
forall a. a -> a
id ((Proposals era -> Proposals era -> Proposals era)
 -> forall {f :: * -> *}.
    Functor f =>
    (Proposals era -> f (Proposals era))
    -> Proposals era -> f (Proposals era))
-> (Proposals era -> Proposals era -> Proposals era)
-> forall {f :: * -> *}.
   Functor f =>
   (Proposals era -> f (Proposals era))
   -> Proposals era -> f (Proposals era)
forall a b. (a -> b) -> a -> b
$ (Proposals era -> Proposals era)
-> Proposals era -> Proposals era -> Proposals era
forall a b. a -> b -> a
const Proposals era -> Proposals era
forall a. a -> a
id)

-- ==================================================
-- Second form of DRepPulsingState 'DRComplete'
-- ==================================================

-- | The snapshot dedicated datatype (PulsingSnapshot era) stored inside 'DRComplete'
--   Note this is used in 'dRepPulsingStateT', the second  DRepPulsingState form.
pulsingSnapshotT ::
  forall era. Era era => RootTarget era (PulsingSnapshot era) (PulsingSnapshot era)
pulsingSnapshotT :: forall era.
Era era =>
RootTarget era (PulsingSnapshot era) (PulsingSnapshot era)
pulsingSnapshotT =
  String
-> TypeRep (PulsingSnapshot era)
-> ([GovActionState era]
    -> Map DRep Coin
    -> Map (Credential 'DRepRole) DRepState
    -> Map (KeyHash 'StakePool) Coin
    -> PulsingSnapshot era)
-> RootTarget
     era
     (PulsingSnapshot era)
     ([GovActionState era]
      -> Map DRep Coin
      -> Map (Credential 'DRepRole) DRepState
      -> Map (KeyHash 'StakePool) Coin
      -> PulsingSnapshot era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert
    String
"PulsingSnapshot"
    (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(PulsingSnapshot era))
    ( \[GovActionState era]
a Map DRep Coin
b Map (Credential 'DRepRole) DRepState
c Map (KeyHash 'StakePool) Coin
d -> StrictSeq (GovActionState era)
-> Map DRep (CompactForm Coin)
-> Map (Credential 'DRepRole) DRepState
-> Map (KeyHash 'StakePool) (CompactForm Coin)
-> PulsingSnapshot era
forall era.
StrictSeq (GovActionState era)
-> Map DRep (CompactForm Coin)
-> Map (Credential 'DRepRole) DRepState
-> Map (KeyHash 'StakePool) (CompactForm Coin)
-> PulsingSnapshot era
PulsingSnapshot ([GovActionState era] -> StrictSeq (GovActionState era)
forall a. [a] -> StrictSeq a
SS.fromList [GovActionState era]
a) ((Coin -> CompactForm Coin)
-> Map DRep Coin -> Map DRep (CompactForm Coin)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map HasCallStack => Coin -> CompactForm Coin
Coin -> CompactForm Coin
compactCoinOrError Map DRep Coin
b) Map (Credential 'DRepRole) DRepState
c ((Coin -> CompactForm Coin)
-> Map (KeyHash 'StakePool) Coin
-> Map (KeyHash 'StakePool) (CompactForm Coin)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map HasCallStack => Coin -> CompactForm Coin
Coin -> CompactForm Coin
compactCoinOrError Map (KeyHash 'StakePool) Coin
d)
    )
    RootTarget
  era
  (PulsingSnapshot era)
  ([GovActionState era]
   -> Map DRep Coin
   -> Map (Credential 'DRepRole) DRepState
   -> Map (KeyHash 'StakePool) Coin
   -> PulsingSnapshot era)
-> RootTarget era (PulsingSnapshot era) [GovActionState era]
-> RootTarget
     era
     (PulsingSnapshot era)
     (Map DRep Coin
      -> Map (Credential 'DRepRole) DRepState
      -> Map (KeyHash 'StakePool) Coin
      -> PulsingSnapshot era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era [GovActionState era]
-> SimpleGetter (PulsingSnapshot era) [GovActionState era]
-> RootTarget era (PulsingSnapshot era) [GovActionState era]
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era [GovActionState era]
forall era. Era era => Term era [GovActionState era]
currGovStates ((StrictSeq (GovActionState era)
 -> Const r (StrictSeq (GovActionState era)))
-> PulsingSnapshot era -> Const r (PulsingSnapshot era)
forall era (f :: * -> *).
Functor f =>
(StrictSeq (GovActionState era)
 -> f (StrictSeq (GovActionState era)))
-> PulsingSnapshot era -> f (PulsingSnapshot era)
psProposalsL ((StrictSeq (GovActionState era)
  -> Const r (StrictSeq (GovActionState era)))
 -> PulsingSnapshot era -> Const r (PulsingSnapshot era))
-> (([GovActionState era] -> Const r [GovActionState era])
    -> StrictSeq (GovActionState era)
    -> Const r (StrictSeq (GovActionState era)))
-> ([GovActionState era] -> Const r [GovActionState era])
-> PulsingSnapshot era
-> Const r (PulsingSnapshot era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([GovActionState era] -> Const r [GovActionState era])
-> StrictSeq (GovActionState era)
-> Const r (StrictSeq (GovActionState era))
forall a (f :: * -> *).
Functor f =>
([a] -> f [a]) -> StrictSeq a -> f (StrictSeq a)
strictSeqListL)
    RootTarget
  era
  (PulsingSnapshot era)
  (Map DRep Coin
   -> Map (Credential 'DRepRole) DRepState
   -> Map (KeyHash 'StakePool) Coin
   -> PulsingSnapshot era)
-> RootTarget era (PulsingSnapshot era) (Map DRep Coin)
-> RootTarget
     era
     (PulsingSnapshot era)
     (Map (Credential 'DRepRole) DRepState
      -> Map (KeyHash 'StakePool) Coin -> PulsingSnapshot era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map DRep Coin)
-> SimpleGetter (PulsingSnapshot era) (Map DRep Coin)
-> RootTarget era (PulsingSnapshot era) (Map DRep Coin)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map DRep Coin)
forall era. Era era => Term era (Map DRep Coin)
partialDRepDistr ((Map DRep (CompactForm Coin)
 -> Const r (Map DRep (CompactForm Coin)))
-> PulsingSnapshot era -> Const r (PulsingSnapshot era)
forall era (f :: * -> *).
Functor f =>
(Map DRep (CompactForm Coin) -> f (Map DRep (CompactForm Coin)))
-> PulsingSnapshot era -> f (PulsingSnapshot era)
psDRepDistrL ((Map DRep (CompactForm Coin)
  -> Const r (Map DRep (CompactForm Coin)))
 -> PulsingSnapshot era -> Const r (PulsingSnapshot era))
-> ((Map DRep Coin -> Const r (Map DRep Coin))
    -> Map DRep (CompactForm Coin)
    -> Const r (Map DRep (CompactForm Coin)))
-> (Map DRep Coin -> Const r (Map DRep Coin))
-> PulsingSnapshot era
-> Const r (PulsingSnapshot era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map DRep Coin -> Const r (Map DRep Coin))
-> Map DRep (CompactForm Coin)
-> Const r (Map DRep (CompactForm Coin))
forall a (f :: * -> *).
Functor f =>
(Map a Coin -> f (Map a Coin))
-> Map a (CompactForm Coin) -> f (Map a (CompactForm Coin))
mapCompactFormCoinL)
    RootTarget
  era
  (PulsingSnapshot era)
  (Map (Credential 'DRepRole) DRepState
   -> Map (KeyHash 'StakePool) Coin -> PulsingSnapshot era)
-> RootTarget
     era (PulsingSnapshot era) (Map (Credential 'DRepRole) DRepState)
-> RootTarget
     era
     (PulsingSnapshot era)
     (Map (KeyHash 'StakePool) Coin -> PulsingSnapshot era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'DRepRole) DRepState)
-> SimpleGetter
     (PulsingSnapshot era) (Map (Credential 'DRepRole) DRepState)
-> RootTarget
     era (PulsingSnapshot era) (Map (Credential 'DRepRole) DRepState)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'DRepRole) DRepState)
forall era.
Era era =>
Term era (Map (Credential 'DRepRole) DRepState)
prevDRepState (Map (Credential 'DRepRole) DRepState
 -> Const r (Map (Credential 'DRepRole) DRepState))
-> PulsingSnapshot era -> Const r (PulsingSnapshot era)
SimpleGetter
  (PulsingSnapshot era) (Map (Credential 'DRepRole) DRepState)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'DRepRole) DRepState
 -> f (Map (Credential 'DRepRole) DRepState))
-> PulsingSnapshot era -> f (PulsingSnapshot era)
psDRepStateL
    RootTarget
  era
  (PulsingSnapshot era)
  (Map (KeyHash 'StakePool) Coin -> PulsingSnapshot era)
-> RootTarget
     era (PulsingSnapshot era) (Map (KeyHash 'StakePool) Coin)
-> RootTarget era (PulsingSnapshot era) (PulsingSnapshot era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) Coin)
-> SimpleGetter
     (PulsingSnapshot era) (Map (KeyHash 'StakePool) Coin)
-> RootTarget
     era (PulsingSnapshot era) (Map (KeyHash 'StakePool) Coin)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (KeyHash 'StakePool) Coin)
forall era. Era era => Term era (Map (KeyHash 'StakePool) Coin)
partialIndividualPoolStake ((Map (KeyHash 'StakePool) (CompactForm Coin)
 -> Const r (Map (KeyHash 'StakePool) (CompactForm Coin)))
-> PulsingSnapshot era -> Const r (PulsingSnapshot era)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) (CompactForm Coin)
 -> f (Map (KeyHash 'StakePool) (CompactForm Coin)))
-> PulsingSnapshot era -> f (PulsingSnapshot era)
psPoolDistrL ((Map (KeyHash 'StakePool) (CompactForm Coin)
  -> Const r (Map (KeyHash 'StakePool) (CompactForm Coin)))
 -> PulsingSnapshot era -> Const r (PulsingSnapshot era))
-> ((Map (KeyHash 'StakePool) Coin
     -> Const r (Map (KeyHash 'StakePool) Coin))
    -> Map (KeyHash 'StakePool) (CompactForm Coin)
    -> Const r (Map (KeyHash 'StakePool) (CompactForm Coin)))
-> (Map (KeyHash 'StakePool) Coin
    -> Const r (Map (KeyHash 'StakePool) Coin))
-> PulsingSnapshot era
-> Const r (PulsingSnapshot era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash 'StakePool) Coin
 -> Const r (Map (KeyHash 'StakePool) Coin))
-> Map (KeyHash 'StakePool) (CompactForm Coin)
-> Const r (Map (KeyHash 'StakePool) (CompactForm Coin))
forall a (f :: * -> *).
Functor f =>
(Map a Coin -> f (Map a Coin))
-> Map a (CompactForm Coin) -> f (Map a (CompactForm Coin))
mapCompactFormCoinL)

pulsingSnapshotL :: EraStake era => Lens' (DRepPulsingState era) (PulsingSnapshot era)
pulsingSnapshotL :: forall era.
EraStake era =>
Lens' (DRepPulsingState era) (PulsingSnapshot era)
pulsingSnapshotL = (DRepPulsingState era -> PulsingSnapshot era)
-> (DRepPulsingState era
    -> PulsingSnapshot era -> DRepPulsingState era)
-> Lens
     (DRepPulsingState era)
     (DRepPulsingState era)
     (PulsingSnapshot era)
     (PulsingSnapshot era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DRepPulsingState era -> PulsingSnapshot era
forall {era}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 EraStake era) =>
DRepPulsingState era -> PulsingSnapshot era
getter DRepPulsingState era -> PulsingSnapshot era -> DRepPulsingState era
forall {era}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 EraStake era) =>
DRepPulsingState era -> PulsingSnapshot era -> DRepPulsingState era
setter
  where
    getter :: DRepPulsingState era -> PulsingSnapshot era
getter (DRComplete PulsingSnapshot era
x RatifyState era
_) = PulsingSnapshot era
x
    getter DRepPulsingState era
other = (PulsingSnapshot era, RatifyState era) -> PulsingSnapshot era
forall a b. (a, b) -> a
fst (DRepPulsingState era -> (PulsingSnapshot era, RatifyState era)
forall era.
EraStake era =>
DRepPulsingState era -> (PulsingSnapshot era, RatifyState era)
finishDRepPulser DRepPulsingState era
other)
    setter :: DRepPulsingState era -> PulsingSnapshot era -> DRepPulsingState era
setter (DRComplete PulsingSnapshot era
_ RatifyState era
y) PulsingSnapshot era
x = PulsingSnapshot era -> RatifyState era -> DRepPulsingState era
forall era.
PulsingSnapshot era -> RatifyState era -> DRepPulsingState era
DRComplete PulsingSnapshot era
x RatifyState era
y
    setter DRepPulsingState era
other PulsingSnapshot era
x = PulsingSnapshot era -> RatifyState era -> DRepPulsingState era
forall era.
PulsingSnapshot era -> RatifyState era -> DRepPulsingState era
DRComplete PulsingSnapshot era
x RatifyState era
y
      where
        (PulsingSnapshot era
_, RatifyState era
y) = DRepPulsingState era -> (PulsingSnapshot era, RatifyState era)
forall era.
EraStake era =>
DRepPulsingState era -> (PulsingSnapshot era, RatifyState era)
finishDRepPulser DRepPulsingState era
other

-- | There are 2 forms of DRepPulsingState. This is the second one
--   where the pulsing is complete
completePulsingStateT ::
  forall era.
  Reflect era =>
  Proof era ->
  RootTarget era (DRepPulsingState era) (DRepPulsingState era)
completePulsingStateT :: forall era.
Reflect era =>
Proof era
-> RootTarget era (DRepPulsingState era) (DRepPulsingState era)
completePulsingStateT Proof era
_p =
  String
-> TypeRep (DRepPulsingState era)
-> (PulsingSnapshot era -> RatifyState era -> DRepPulsingState era)
-> RootTarget
     era
     (DRepPulsingState era)
     (PulsingSnapshot era -> RatifyState era -> DRepPulsingState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"DRComplete" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(DRepPulsingState era)) PulsingSnapshot era -> RatifyState era -> DRepPulsingState era
forall era.
PulsingSnapshot era -> RatifyState era -> DRepPulsingState era
DRComplete
    RootTarget
  era
  (DRepPulsingState era)
  (PulsingSnapshot era -> RatifyState era -> DRepPulsingState era)
-> RootTarget era (DRepPulsingState era) (PulsingSnapshot era)
-> RootTarget
     era
     (DRepPulsingState era)
     (RatifyState era -> DRepPulsingState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (PulsingSnapshot era) (PulsingSnapshot era)
-> Lens' (DRepPulsingState era) (PulsingSnapshot era)
-> RootTarget era (DRepPulsingState era) (PulsingSnapshot era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (PulsingSnapshot era) (PulsingSnapshot era)
forall era.
Era era =>
RootTarget era (PulsingSnapshot era) (PulsingSnapshot era)
pulsingSnapshotT (PulsingSnapshot era -> f (PulsingSnapshot era))
-> DRepPulsingState era -> f (DRepPulsingState era)
forall era.
EraStake era =>
Lens' (DRepPulsingState era) (PulsingSnapshot era)
Lens' (DRepPulsingState era) (PulsingSnapshot era)
pulsingSnapshotL
    RootTarget
  era
  (DRepPulsingState era)
  (RatifyState era -> DRepPulsingState era)
-> RootTarget era (DRepPulsingState era) (RatifyState era)
-> RootTarget era (DRepPulsingState era) (DRepPulsingState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (RatifyState era)
-> SimpleGetter (DRepPulsingState era) (RatifyState era)
-> RootTarget era (DRepPulsingState era) (RatifyState era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (RatifyState era)
forall era. Reflect era => Term era (RatifyState era)
ratifyState (RatifyState era -> Const r (RatifyState era))
-> DRepPulsingState era -> Const r (DRepPulsingState era)
forall era.
Reflect era =>
Lens' (DRepPulsingState era) (RatifyState era)
SimpleGetter (DRepPulsingState era) (RatifyState era)
Lens' (DRepPulsingState era) (RatifyState era)
ratifyStateL

ratifyState :: Reflect era => Term era (RatifyState era)
ratifyState :: forall era. Reflect era => Term era (RatifyState era)
ratifyState = V era (RatifyState era) -> Term era (RatifyState era)
forall era t. V era t -> Term era t
Var (V era (RatifyState era) -> Term era (RatifyState era))
-> V era (RatifyState era) -> Term era (RatifyState era)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (RatifyState era)
-> Access era Any (RatifyState era)
-> V era (RatifyState era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"ratifyState" Rep era (RatifyState era)
forall era. Reflect era => Rep era (RatifyState era)
RatifyStateR Access era Any (RatifyState era)
forall era s t. Access era s t
No

ratifyStateL :: Reflect era => Lens' (DRepPulsingState era) (RatifyState era)
ratifyStateL :: forall era.
Reflect era =>
Lens' (DRepPulsingState era) (RatifyState era)
ratifyStateL = (DRepPulsingState era -> RatifyState era)
-> (DRepPulsingState era
    -> RatifyState era -> DRepPulsingState era)
-> Lens
     (DRepPulsingState era)
     (DRepPulsingState era)
     (RatifyState era)
     (RatifyState era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DRepPulsingState era -> RatifyState era
forall {era}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 EraStake era) =>
DRepPulsingState era -> RatifyState era
getter DRepPulsingState era -> RatifyState era -> DRepPulsingState era
forall {era}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 EraStake era) =>
DRepPulsingState era -> RatifyState era -> DRepPulsingState era
setter
  where
    getter :: DRepPulsingState era -> RatifyState era
getter (DRComplete PulsingSnapshot era
_ RatifyState era
y) = RatifyState era
y
    getter x :: DRepPulsingState era
x@(DRPulsing {}) = (PulsingSnapshot era, RatifyState era) -> RatifyState era
forall a b. (a, b) -> b
snd (DRepPulsingState era -> (PulsingSnapshot era, RatifyState era)
forall era.
EraStake era =>
DRepPulsingState era -> (PulsingSnapshot era, RatifyState era)
finishDRepPulser DRepPulsingState era
x)
    setter :: DRepPulsingState era -> RatifyState era -> DRepPulsingState era
setter (DRComplete PulsingSnapshot era
x RatifyState era
_) RatifyState era
y = PulsingSnapshot era -> RatifyState era -> DRepPulsingState era
forall era.
PulsingSnapshot era -> RatifyState era -> DRepPulsingState era
DRComplete PulsingSnapshot era
x RatifyState era
y
    setter z :: DRepPulsingState era
z@(DRPulsing {}) RatifyState era
y = case DRepPulsingState era -> (PulsingSnapshot era, RatifyState era)
forall era.
EraStake era =>
DRepPulsingState era -> (PulsingSnapshot era, RatifyState era)
finishDRepPulser DRepPulsingState era
z of
      (PulsingSnapshot era
x, RatifyState era
_) -> PulsingSnapshot era -> RatifyState era -> DRepPulsingState era
forall era.
PulsingSnapshot era -> RatifyState era -> DRepPulsingState era
DRComplete PulsingSnapshot era
x RatifyState era
y

prevProposals :: Era era => Proof era -> Term era (Proposals era)
prevProposals :: forall era. Era era => Proof era -> Term era (Proposals era)
prevProposals Proof era
p = V era (Proposals era) -> Term era (Proposals era)
forall era t. V era t -> Term era t
Var (V era (Proposals era) -> Term era (Proposals era))
-> V era (Proposals era) -> Term era (Proposals era)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Proposals era)
-> Access era Any (Proposals era)
-> V era (Proposals era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"prevProposals" (Proof era -> Rep era (Proposals era)
forall era. Era era => Proof era -> Rep era (Proposals era)
ProposalsR Proof era
p) Access era Any (Proposals era)
forall era s t. Access era s t
No

ratifyGovActionStatesL :: Lens' (DRepPulser era Identity (RatifyState era)) [GovActionState era]
ratifyGovActionStatesL :: forall era (f :: * -> *).
Functor f =>
([GovActionState era] -> f [GovActionState era])
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
ratifyGovActionStatesL =
  (DRepPulser era Identity (RatifyState era) -> [GovActionState era])
-> (DRepPulser era Identity (RatifyState era)
    -> [GovActionState era]
    -> DRepPulser era Identity (RatifyState era))
-> Lens
     (DRepPulser era Identity (RatifyState era))
     (DRepPulser era Identity (RatifyState era))
     [GovActionState era]
     [GovActionState era]
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    (StrictSeq (GovActionState era) -> [GovActionState era]
forall a. StrictSeq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList (StrictSeq (GovActionState era) -> [GovActionState era])
-> (DRepPulser era Identity (RatifyState era)
    -> StrictSeq (GovActionState era))
-> DRepPulser era Identity (RatifyState era)
-> [GovActionState era]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DRepPulser era Identity (RatifyState era)
-> StrictSeq (GovActionState era)
forall era ans (m :: * -> *).
DRepPulser era m ans -> StrictSeq (GovActionState era)
dpProposals)
    (\DRepPulser era Identity (RatifyState era)
x [GovActionState era]
y -> DRepPulser era Identity (RatifyState era)
x {dpProposals = SS.fromList y})

-- | Partially computed DRepDistr inside the pulser
partialDRepDistr :: Era era => Term era (Map DRep Coin)
partialDRepDistr :: forall era. Era era => Term era (Map DRep Coin)
partialDRepDistr = V era (Map DRep Coin) -> Term era (Map DRep Coin)
forall era t. V era t -> Term era t
Var (V era (Map DRep Coin) -> Term era (Map DRep Coin))
-> V era (Map DRep Coin) -> Term era (Map DRep Coin)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map DRep Coin)
-> Access era Any (Map DRep Coin)
-> V era (Map DRep Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"partialDRepDistr" (Rep era DRep -> Rep era Coin -> Rep era (Map DRep Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era DRep
forall era. Era era => Rep era DRep
DRepR Rep era Coin
forall era. Rep era Coin
CoinR) Access era Any (Map DRep Coin)
forall era s t. Access era s t
No

partialDRepDistrL ::
  Lens' (DRepPulser era Identity (RatifyState era)) (Map DRep Coin)
partialDRepDistrL :: forall era (f :: * -> *).
Functor f =>
(Map DRep Coin -> f (Map DRep Coin))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
partialDRepDistrL =
  (DRepPulser era Identity (RatifyState era) -> Map DRep Coin)
-> (DRepPulser era Identity (RatifyState era)
    -> Map DRep Coin -> DRepPulser era Identity (RatifyState era))
-> Lens
     (DRepPulser era Identity (RatifyState era))
     (DRepPulser era Identity (RatifyState era))
     (Map DRep Coin)
     (Map DRep Coin)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    ((CompactForm Coin -> Coin)
-> Map DRep (CompactForm Coin) -> Map DRep Coin
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map CompactForm Coin -> Coin
forall a. Compactible a => CompactForm a -> a
fromCompact (Map DRep (CompactForm Coin) -> Map DRep Coin)
-> (DRepPulser era Identity (RatifyState era)
    -> Map DRep (CompactForm Coin))
-> DRepPulser era Identity (RatifyState era)
-> Map DRep Coin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DRepPulser era Identity (RatifyState era)
-> Map DRep (CompactForm Coin)
forall era ans (m :: * -> *).
DRepPulser era m ans -> Map DRep (CompactForm Coin)
dpDRepDistr)
    (\DRepPulser era Identity (RatifyState era)
x Map DRep Coin
y -> DRepPulser era Identity (RatifyState era)
x {dpDRepDistr = Map.map compactCoinOrError y})

-- | Snapshot of 'dreps' from the start of the current epoch
prevDRepState ::
  Era era => Term era (Map (Credential 'DRepRole) DRepState)
prevDRepState :: forall era.
Era era =>
Term era (Map (Credential 'DRepRole) DRepState)
prevDRepState = V era (Map (Credential 'DRepRole) DRepState)
-> Term era (Map (Credential 'DRepRole) DRepState)
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'DRepRole) DRepState)
 -> Term era (Map (Credential 'DRepRole) DRepState))
-> V era (Map (Credential 'DRepRole) DRepState)
-> Term era (Map (Credential 'DRepRole) DRepState)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (Credential 'DRepRole) DRepState)
-> Access era Any (Map (Credential 'DRepRole) DRepState)
-> V era (Map (Credential 'DRepRole) DRepState)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"prevDRepState" (Rep era (Credential 'DRepRole)
-> Rep era DRepState
-> Rep era (Map (Credential 'DRepRole) DRepState)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'DRepRole)
forall era. Era era => Rep era (Credential 'DRepRole)
VCredR Rep era DRepState
forall era. Era era => Rep era DRepState
DRepStateR) Access era Any (Map (Credential 'DRepRole) DRepState)
forall era s t. Access era s t
No

prevDRepStateL ::
  Lens'
    (DRepPulser era Identity (RatifyState era))
    (Map (Credential 'DRepRole) DRepState)
prevDRepStateL :: forall era (f :: * -> *).
Functor f =>
(Map (Credential 'DRepRole) DRepState
 -> f (Map (Credential 'DRepRole) DRepState))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
prevDRepStateL = (DRepPulser era Identity (RatifyState era)
 -> Map (Credential 'DRepRole) DRepState)
-> (DRepPulser era Identity (RatifyState era)
    -> Map (Credential 'DRepRole) DRepState
    -> DRepPulser era Identity (RatifyState era))
-> Lens
     (DRepPulser era Identity (RatifyState era))
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'DRepRole) DRepState)
     (Map (Credential 'DRepRole) DRepState)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DRepPulser era Identity (RatifyState era)
-> Map (Credential 'DRepRole) DRepState
forall era ans (m :: * -> *).
DRepPulser era m ans -> Map (Credential 'DRepRole) DRepState
dpDRepState (\DRepPulser era Identity (RatifyState era)
x Map (Credential 'DRepRole) DRepState
y -> DRepPulser era Identity (RatifyState era)
x {dpDRepState = y})

-- | snapshot of 'poolDistr' from the start of the current epoch
prevPoolDistr ::
  Era era => Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
prevPoolDistr :: forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
prevPoolDistr = V era (Map (KeyHash 'StakePool) IndividualPoolStake)
-> Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era t. V era t -> Term era t
Var (V era (Map (KeyHash 'StakePool) IndividualPoolStake)
 -> Term era (Map (KeyHash 'StakePool) IndividualPoolStake))
-> V era (Map (KeyHash 'StakePool) IndividualPoolStake)
-> Term era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (KeyHash 'StakePool) IndividualPoolStake)
-> Access era Any (Map (KeyHash 'StakePool) IndividualPoolStake)
-> V era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"prevPoolDistr" (Rep era (KeyHash 'StakePool)
-> Rep era IndividualPoolStake
-> Rep era (Map (KeyHash 'StakePool) IndividualPoolStake)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era IndividualPoolStake
forall era. Era era => Rep era IndividualPoolStake
IPoolStakeR) Access era Any (Map (KeyHash 'StakePool) IndividualPoolStake)
forall era s t. Access era s t
No

prevPoolDistrL ::
  Lens'
    (DRepPulser era Identity (RatifyState era))
    (Map (KeyHash 'StakePool) IndividualPoolStake)
prevPoolDistrL :: forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) IndividualPoolStake
 -> f (Map (KeyHash 'StakePool) IndividualPoolStake))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
prevPoolDistrL =
  (DRepPulser era Identity (RatifyState era)
 -> Map (KeyHash 'StakePool) IndividualPoolStake)
-> (DRepPulser era Identity (RatifyState era)
    -> Map (KeyHash 'StakePool) IndividualPoolStake
    -> DRepPulser era Identity (RatifyState era))
-> Lens
     (DRepPulser era Identity (RatifyState era))
     (DRepPulser era Identity (RatifyState era))
     (Map (KeyHash 'StakePool) IndividualPoolStake)
     (Map (KeyHash 'StakePool) IndividualPoolStake)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    (\DRepPulser era Identity (RatifyState era)
x -> PoolDistr -> Map (KeyHash 'StakePool) IndividualPoolStake
unPoolDistr (DRepPulser era Identity (RatifyState era) -> PoolDistr
forall era ans (m :: * -> *). DRepPulser era m ans -> PoolDistr
dpStakePoolDistr DRepPulser era Identity (RatifyState era)
x))
    (\DRepPulser era Identity (RatifyState era)
x Map (KeyHash 'StakePool) IndividualPoolStake
y -> DRepPulser era Identity (RatifyState era)
x {dpStakePoolDistr = PoolDistr y $ CompactCoin 1})

-- | Snapshot of the 'drepDelegation' from he start of the current epoch.
prevDRepDelegations ::
  Era era => Term era (Map (Credential 'Staking) DRep)
prevDRepDelegations :: forall era. Era era => Term era (Map (Credential 'Staking) DRep)
prevDRepDelegations = V era (Map (Credential 'Staking) DRep)
-> Term era (Map (Credential 'Staking) DRep)
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'Staking) DRep)
 -> Term era (Map (Credential 'Staking) DRep))
-> V era (Map (Credential 'Staking) DRep)
-> Term era (Map (Credential 'Staking) DRep)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (Credential 'Staking) DRep)
-> Access era Any (Map (Credential 'Staking) DRep)
-> V era (Map (Credential 'Staking) DRep)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"prevDRepDelegations" (Rep era (Credential 'Staking)
-> Rep era DRep -> Rep era (Map (Credential 'Staking) DRep)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'Staking)
forall era. Era era => Rep era (Credential 'Staking)
CredR Rep era DRep
forall era. Era era => Rep era DRep
DRepR) Access era Any (Map (Credential 'Staking) DRep)
forall era s t. Access era s t
No

-- | Snapshot of 'drepDelegation' from the start of the current epoch
prevDRepDelegationsL ::
  Lens'
    (DRepPulser era Identity (RatifyState era))
    (Map (Credential 'Staking) DRep)
prevDRepDelegationsL :: forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) DRep
 -> f (Map (Credential 'Staking) DRep))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
prevDRepDelegationsL =
  (DRepPulser era Identity (RatifyState era)
 -> Map (Credential 'Staking) DRep)
-> (DRepPulser era Identity (RatifyState era)
    -> Map (Credential 'Staking) DRep
    -> DRepPulser era Identity (RatifyState era))
-> Lens
     (DRepPulser era Identity (RatifyState era))
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'Staking) DRep)
     (Map (Credential 'Staking) DRep)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    (\DRepPulser era Identity (RatifyState era)
x -> DRepPulser era Identity (RatifyState era) -> UMap
forall era ans (m :: * -> *). DRepPulser era m ans -> UMap
dpUMap DRepPulser era Identity (RatifyState era)
x UMap
-> Getting
     (Map (Credential 'Staking) DRep)
     UMap
     (Map (Credential 'Staking) DRep)
-> Map (Credential 'Staking) DRep
forall s a. s -> Getting a s a -> a
^. Getting
  (Map (Credential 'Staking) DRep)
  UMap
  (Map (Credential 'Staking) DRep)
Lens' UMap (Map (Credential 'Staking) DRep)
drepUMapL)
    ( \DRepPulser era Identity (RatifyState era)
x Map (Credential 'Staking) DRep
y ->
        DRepPulser era Identity (RatifyState era)
x
          { dpUMap =
              unify
                (rdPairMap (dpUMap x))
                (ptrMap (dpUMap x))
                (sPoolMap (dpUMap x))
                y
          }
    )

-- | Snapshot of 'committeeState' from the start of the current epoch
prevCommitteeState ::
  Era era =>
  Term
    era
    (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
prevCommitteeState :: forall era.
Era era =>
Term
  era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
prevCommitteeState = V era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> Term
     era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall era t. V era t -> Term era t
Var (V era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
 -> Term
      era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> V era
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> Term
     era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall a b. (a -> b) -> a -> b
$ String
-> Rep
     era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> Access
     era
     Any
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> V era
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"prevCommitteeState" (Rep era (Credential 'ColdCommitteeRole)
-> Rep era CommitteeAuthorization
-> Rep
     era (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'ColdCommitteeRole)
forall era. Era era => Rep era (Credential 'ColdCommitteeRole)
CommColdCredR Rep era CommitteeAuthorization
forall era. Era era => Rep era CommitteeAuthorization
CommitteeAuthorizationR) Access
  era
  Any
  (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall era s t. Access era s t
No

prevCommitteeStateL ::
  Lens'
    (DRepPulser era Identity (RatifyState era))
    (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
prevCommitteeStateL :: forall era (f :: * -> *).
Functor f =>
(Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
 -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
prevCommitteeStateL =
  (DRepPulser era Identity (RatifyState era)
 -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> (DRepPulser era Identity (RatifyState era)
    -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
    -> DRepPulser era Identity (RatifyState era))
-> Lens
     (DRepPulser era Identity (RatifyState era))
     (DRepPulser era Identity (RatifyState era))
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
     (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    (CommitteeState era
-> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
forall era.
CommitteeState era
-> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
csCommitteeCreds (CommitteeState era
 -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> (DRepPulser era Identity (RatifyState era)
    -> CommitteeState era)
-> DRepPulser era Identity (RatifyState era)
-> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DRepPulser era Identity (RatifyState era) -> CommitteeState era
forall era ans (m :: * -> *).
DRepPulser era m ans -> CommitteeState era
dpCommitteeState)
    (\DRepPulser era Identity (RatifyState era)
x Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
y -> DRepPulser era Identity (RatifyState era)
x {dpCommitteeState = CommitteeState y})

-- | Snapshot of the enactState built by 'enactStateT' assembled from data at the start the current epoch
prevEnactState :: Reflect era => Term era (EnactState era)
prevEnactState :: forall era. Reflect era => Term era (EnactState era)
prevEnactState = V era (EnactState era) -> Term era (EnactState era)
forall era t. V era t -> Term era t
Var (V era (EnactState era) -> Term era (EnactState era))
-> V era (EnactState era) -> Term era (EnactState era)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (EnactState era)
-> Access era Any (EnactState era)
-> V era (EnactState era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"prevEnactState" Rep era (EnactState era)
forall era. Reflect era => Rep era (EnactState era)
EnactStateR Access era Any (EnactState era)
forall era s t. Access era s t
No

prevEnactStateL :: Lens' (DRepPulser era Identity (RatifyState era)) (EnactState era)
prevEnactStateL :: forall era (f :: * -> *).
Functor f =>
(EnactState era -> f (EnactState era))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
prevEnactStateL = (DRepPulser era Identity (RatifyState era) -> EnactState era)
-> (DRepPulser era Identity (RatifyState era)
    -> EnactState era -> DRepPulser era Identity (RatifyState era))
-> Lens
     (DRepPulser era Identity (RatifyState era))
     (DRepPulser era Identity (RatifyState era))
     (EnactState era)
     (EnactState era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DRepPulser era Identity (RatifyState era) -> EnactState era
forall era ans (m :: * -> *).
DRepPulser era m ans -> EnactState era
dpEnactState (\DRepPulser era Identity (RatifyState era)
x EnactState era
y -> DRepPulser era Identity (RatifyState era)
x {dpEnactState = y})

-- | Snapshot of 'currentEpoch' just before the start of the current epoch. (currenEpoch - 1)
prevEpoch :: Era era => Term era EpochNo
prevEpoch :: forall era. Era era => Term era EpochNo
prevEpoch = V era EpochNo -> Term era EpochNo
forall era t. V era t -> Term era t
Var (V era EpochNo -> Term era EpochNo)
-> V era EpochNo -> Term era EpochNo
forall a b. (a -> b) -> a -> b
$ String
-> Rep era EpochNo -> Access era Any EpochNo -> V era EpochNo
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"prevEpoch" Rep era EpochNo
forall era. Rep era EpochNo
EpochR Access era Any EpochNo
forall era s t. Access era s t
No

prevEpochL :: Lens' (DRepPulser era Identity (RatifyState era)) EpochNo
prevEpochL :: forall era (f :: * -> *).
Functor f =>
(EpochNo -> f EpochNo)
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
prevEpochL = (DRepPulser era Identity (RatifyState era) -> EpochNo)
-> (DRepPulser era Identity (RatifyState era)
    -> EpochNo -> DRepPulser era Identity (RatifyState era))
-> Lens
     (DRepPulser era Identity (RatifyState era))
     (DRepPulser era Identity (RatifyState era))
     EpochNo
     EpochNo
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DRepPulser era Identity (RatifyState era) -> EpochNo
forall era ans (m :: * -> *). DRepPulser era m ans -> EpochNo
dpCurrentEpoch (\DRepPulser era Identity (RatifyState era)
x EpochNo
y -> DRepPulser era Identity (RatifyState era)
x {dpCurrentEpoch = y})

prevTreasury :: Era era => Term era Coin
prevTreasury :: forall era. Era era => Term era Coin
prevTreasury = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (V era Coin -> Term era Coin) -> V era Coin -> Term era Coin
forall a b. (a -> b) -> a -> b
$ String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"prevTreasury" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No

{-
-- TODO access prevTreasury from the EnactState
prevTreasuryL :: Lens' (DRepPulser era Identity (RatifyState era)) Coin
prevTreasuryL = lens dpTreasury (\x y -> x {dpTreasury = y})
-}

partialIndividualPoolStake :: Era era => Term era (Map (KeyHash 'StakePool) Coin)
partialIndividualPoolStake :: forall era. Era era => Term era (Map (KeyHash 'StakePool) Coin)
partialIndividualPoolStake = V era (Map (KeyHash 'StakePool) Coin)
-> Term era (Map (KeyHash 'StakePool) Coin)
forall era t. V era t -> Term era t
Var (V era (Map (KeyHash 'StakePool) Coin)
 -> Term era (Map (KeyHash 'StakePool) Coin))
-> V era (Map (KeyHash 'StakePool) Coin)
-> Term era (Map (KeyHash 'StakePool) Coin)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (KeyHash 'StakePool) Coin)
-> Access era Any (Map (KeyHash 'StakePool) Coin)
-> V era (Map (KeyHash 'StakePool) Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"partialIndividualPoolStake" (Rep era (KeyHash 'StakePool)
-> Rep era Coin -> Rep era (Map (KeyHash 'StakePool) Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era Coin
forall era. Rep era Coin
CoinR) Access era Any (Map (KeyHash 'StakePool) Coin)
forall era s t. Access era s t
No

prevRegPools ::
  Era era => Term era (Map (KeyHash 'StakePool) PoolParams)
prevRegPools :: forall era.
Era era =>
Term era (Map (KeyHash 'StakePool) PoolParams)
prevRegPools = V era (Map (KeyHash 'StakePool) PoolParams)
-> Term era (Map (KeyHash 'StakePool) PoolParams)
forall era t. V era t -> Term era t
Var (V era (Map (KeyHash 'StakePool) PoolParams)
 -> Term era (Map (KeyHash 'StakePool) PoolParams))
-> V era (Map (KeyHash 'StakePool) PoolParams)
-> Term era (Map (KeyHash 'StakePool) PoolParams)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Map (KeyHash 'StakePool) PoolParams)
-> Access era Any (Map (KeyHash 'StakePool) PoolParams)
-> V era (Map (KeyHash 'StakePool) PoolParams)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"prevRegPools" (Rep era (KeyHash 'StakePool)
-> Rep era PoolParams
-> Rep era (Map (KeyHash 'StakePool) PoolParams)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era PoolParams
forall era. Era era => Rep era PoolParams
PoolParamsR) Access era Any (Map (KeyHash 'StakePool) PoolParams)
forall era s t. Access era s t
No

prevRegPoolsL ::
  Lens'
    (DRepPulser era Identity (RatifyState era))
    (Map (KeyHash 'StakePool) PoolParams)
prevRegPoolsL :: forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) PoolParams
 -> f (Map (KeyHash 'StakePool) PoolParams))
-> DRepPulser era Identity (RatifyState era)
-> f (DRepPulser era Identity (RatifyState era))
prevRegPoolsL =
  (DRepPulser era Identity (RatifyState era)
 -> Map (KeyHash 'StakePool) PoolParams)
-> (DRepPulser era Identity (RatifyState era)
    -> Map (KeyHash 'StakePool) PoolParams
    -> DRepPulser era Identity (RatifyState era))
-> Lens
     (DRepPulser era Identity (RatifyState era))
     (DRepPulser era Identity (RatifyState era))
     (Map (KeyHash 'StakePool) PoolParams)
     (Map (KeyHash 'StakePool) PoolParams)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    DRepPulser era Identity (RatifyState era)
-> Map (KeyHash 'StakePool) PoolParams
forall era ans (m :: * -> *).
DRepPulser era m ans -> Map (KeyHash 'StakePool) PoolParams
dpPoolParams
    (\DRepPulser era Identity (RatifyState era)
x Map (KeyHash 'StakePool) PoolParams
y -> DRepPulser era Identity (RatifyState era)
x {dpPoolParams = y})

-- ======================================
-- ConwayGovState

conwayGovStateT ::
  forall era.
  (RunConwayRatify era, Reflect era, ConwayEraCertState era) =>
  Proof era ->
  RootTarget era (ConwayGovState era) (ConwayGovState era)
conwayGovStateT :: forall era.
(RunConwayRatify era, Reflect era, ConwayEraCertState era) =>
Proof era
-> RootTarget era (ConwayGovState era) (ConwayGovState era)
conwayGovStateT Proof era
p =
  String
-> TypeRep (ConwayGovState era)
-> (Proposals era
    -> Maybe (Committee era)
    -> Constitution era
    -> PParamsF era
    -> PParamsF era
    -> FuturePParams era
    -> DRepPulsingState era
    -> ConwayGovState era)
-> RootTarget
     era
     (ConwayGovState era)
     (Proposals era
      -> Maybe (Committee era)
      -> Constitution era
      -> PParamsF era
      -> PParamsF era
      -> FuturePParams era
      -> DRepPulsingState era
      -> ConwayGovState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert
    String
"ConwayGovState"
    (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(ConwayGovState era))
    ( \Proposals era
pr Maybe (Committee era)
com Constitution era
con (PParamsF Proof era
_ PParams era
cpp) (PParamsF Proof era
_ PParams era
ppp) FuturePParams era
pu -> Proposals era
-> StrictMaybe (Committee era)
-> Constitution era
-> PParams era
-> PParams era
-> FuturePParams era
-> DRepPulsingState era
-> ConwayGovState era
forall era.
Proposals era
-> StrictMaybe (Committee era)
-> Constitution era
-> PParams era
-> PParams era
-> FuturePParams era
-> DRepPulsingState era
-> ConwayGovState era
ConwayGovState Proposals era
pr (Maybe (Committee era) -> StrictMaybe (Committee era)
forall a. Maybe a -> StrictMaybe a
maybeToStrictMaybe Maybe (Committee era)
com) Constitution era
con PParams era
cpp PParams era
ppp FuturePParams era
pu
    )
    RootTarget
  era
  (ConwayGovState era)
  (Proposals era
   -> Maybe (Committee era)
   -> Constitution era
   -> PParamsF era
   -> PParamsF era
   -> FuturePParams era
   -> DRepPulsingState era
   -> ConwayGovState era)
-> RootTarget era (ConwayGovState era) (Proposals era)
-> RootTarget
     era
     (ConwayGovState era)
     (Maybe (Committee era)
      -> Constitution era
      -> PParamsF era
      -> PParamsF era
      -> FuturePParams era
      -> DRepPulsingState era
      -> ConwayGovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Proposals era)
-> SimpleGetter (ConwayGovState era) (Proposals era)
-> RootTarget era (ConwayGovState era) (Proposals era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Proof era -> Term era (Proposals era)
forall era. Era era => Proof era -> Term era (Proposals era)
currProposals Proof era
p) (Proposals era -> Const r (Proposals era))
-> ConwayGovState era -> Const r (ConwayGovState era)
SimpleGetter (ConwayGovState era) (Proposals era)
forall era (f :: * -> *).
Functor f =>
(Proposals era -> f (Proposals era))
-> ConwayGovState era -> f (ConwayGovState era)
cgsProposalsL
    RootTarget
  era
  (ConwayGovState era)
  (Maybe (Committee era)
   -> Constitution era
   -> PParamsF era
   -> PParamsF era
   -> FuturePParams era
   -> DRepPulsingState era
   -> ConwayGovState era)
-> RootTarget era (ConwayGovState era) (Maybe (Committee era))
-> RootTarget
     era
     (ConwayGovState era)
     (Constitution era
      -> PParamsF era
      -> PParamsF era
      -> FuturePParams era
      -> DRepPulsingState era
      -> ConwayGovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Maybe (Committee era))
-> SimpleGetter (ConwayGovState era) (Maybe (Committee era))
-> RootTarget era (ConwayGovState era) (Maybe (Committee era))
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Maybe (Committee era))
forall era. Era era => Term era (Maybe (Committee era))
committeeVar ((StrictMaybe (Committee era)
 -> Const r (StrictMaybe (Committee era)))
-> ConwayGovState era -> Const r (ConwayGovState era)
forall era (f :: * -> *).
Functor f =>
(StrictMaybe (Committee era) -> f (StrictMaybe (Committee era)))
-> ConwayGovState era -> f (ConwayGovState era)
cgsCommitteeL ((StrictMaybe (Committee era)
  -> Const r (StrictMaybe (Committee era)))
 -> ConwayGovState era -> Const r (ConwayGovState era))
-> ((Maybe (Committee era) -> Const r (Maybe (Committee era)))
    -> StrictMaybe (Committee era)
    -> Const r (StrictMaybe (Committee era)))
-> (Maybe (Committee era) -> Const r (Maybe (Committee era)))
-> ConwayGovState era
-> Const r (ConwayGovState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe (Committee era) -> Const r (Maybe (Committee era)))
-> StrictMaybe (Committee era)
-> Const r (StrictMaybe (Committee era))
forall x (f :: * -> *).
Functor f =>
(Maybe x -> f (Maybe x)) -> StrictMaybe x -> f (StrictMaybe x)
strictMaybeToMaybeL) -- see 'committeeT' to construct a binding for committeeVar
    RootTarget
  era
  (ConwayGovState era)
  (Constitution era
   -> PParamsF era
   -> PParamsF era
   -> FuturePParams era
   -> DRepPulsingState era
   -> ConwayGovState era)
-> RootTarget era (ConwayGovState era) (Constitution era)
-> RootTarget
     era
     (ConwayGovState era)
     (PParamsF era
      -> PParamsF era
      -> FuturePParams era
      -> DRepPulsingState era
      -> ConwayGovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Constitution era)
-> SimpleGetter (ConwayGovState era) (Constitution era)
-> RootTarget era (ConwayGovState era) (Constitution era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Constitution era)
forall era. Era era => Term era (Constitution era)
constitution (Constitution era -> Const r (Constitution era))
-> ConwayGovState era -> Const r (ConwayGovState era)
SimpleGetter (ConwayGovState era) (Constitution era)
forall era (f :: * -> *).
Functor f =>
(Constitution era -> f (Constitution era))
-> ConwayGovState era -> f (ConwayGovState era)
cgsConstitutionL
    RootTarget
  era
  (ConwayGovState era)
  (PParamsF era
   -> PParamsF era
   -> FuturePParams era
   -> DRepPulsingState era
   -> ConwayGovState era)
-> RootTarget era (ConwayGovState era) (PParamsF era)
-> RootTarget
     era
     (ConwayGovState era)
     (PParamsF era
      -> FuturePParams era -> DRepPulsingState era -> ConwayGovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (PParamsF era)
-> SimpleGetter (ConwayGovState era) (PParamsF era)
-> RootTarget era (ConwayGovState era) (PParamsF era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Proof era -> Term era (PParamsF era)
forall era. Era era => Proof era -> Term era (PParamsF era)
currPParams Proof era
forall era. Reflect era => Proof era
reify) ((PParams era -> Const r (PParams era))
-> ConwayGovState era -> Const r (ConwayGovState era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> ConwayGovState era -> f (ConwayGovState era)
cgsCurPParamsL ((PParams era -> Const r (PParams era))
 -> ConwayGovState era -> Const r (ConwayGovState era))
-> ((PParamsF era -> Const r (PParamsF era))
    -> PParams era -> Const r (PParams era))
-> (PParamsF era -> Const r (PParamsF era))
-> ConwayGovState era
-> Const r (ConwayGovState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proof era -> Lens' (PParams era) (PParamsF era)
forall era. Proof era -> Lens' (PParams era) (PParamsF era)
pparamsFL Proof era
forall era. Reflect era => Proof era
reify)
    RootTarget
  era
  (ConwayGovState era)
  (PParamsF era
   -> FuturePParams era -> DRepPulsingState era -> ConwayGovState era)
-> RootTarget era (ConwayGovState era) (PParamsF era)
-> RootTarget
     era
     (ConwayGovState era)
     (FuturePParams era -> DRepPulsingState era -> ConwayGovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (PParamsF era)
-> SimpleGetter (ConwayGovState era) (PParamsF era)
-> RootTarget era (ConwayGovState era) (PParamsF era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Proof era -> Term era (PParamsF era)
forall era. EraGov era => Proof era -> Term era (PParamsF era)
prevPParams Proof era
forall era. Reflect era => Proof era
reify) ((PParams era -> Const r (PParams era))
-> ConwayGovState era -> Const r (ConwayGovState era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> ConwayGovState era -> f (ConwayGovState era)
cgsPrevPParamsL ((PParams era -> Const r (PParams era))
 -> ConwayGovState era -> Const r (ConwayGovState era))
-> ((PParamsF era -> Const r (PParamsF era))
    -> PParams era -> Const r (PParams era))
-> (PParamsF era -> Const r (PParamsF era))
-> ConwayGovState era
-> Const r (ConwayGovState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proof era -> Lens' (PParams era) (PParamsF era)
forall era. Proof era -> Lens' (PParams era) (PParamsF era)
pparamsFL Proof era
forall era. Reflect era => Proof era
reify)
    RootTarget
  era
  (ConwayGovState era)
  (FuturePParams era -> DRepPulsingState era -> ConwayGovState era)
-> RootTarget era (ConwayGovState era) (FuturePParams era)
-> RootTarget
     era
     (ConwayGovState era)
     (DRepPulsingState era -> ConwayGovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (FuturePParams era)
-> SimpleGetter (ConwayGovState era) (FuturePParams era)
-> RootTarget era (ConwayGovState era) (FuturePParams era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Proof era -> Term era (FuturePParams era)
forall era. Era era => Proof era -> Term era (FuturePParams era)
futurePParams Proof era
forall era. Reflect era => Proof era
reify) (FuturePParams era -> Const r (FuturePParams era))
-> ConwayGovState era -> Const r (ConwayGovState era)
SimpleGetter (ConwayGovState era) (FuturePParams era)
forall era (f :: * -> *).
Functor f =>
(FuturePParams era -> f (FuturePParams era))
-> ConwayGovState era -> f (ConwayGovState era)
cgsFuturePParamsL
    RootTarget
  era
  (ConwayGovState era)
  (DRepPulsingState era -> ConwayGovState era)
-> RootTarget era (ConwayGovState era) (DRepPulsingState era)
-> RootTarget era (ConwayGovState era) (ConwayGovState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (DRepPulsingState era) (DRepPulsingState era)
-> Lens' (ConwayGovState era) (DRepPulsingState era)
-> RootTarget era (ConwayGovState era) (DRepPulsingState era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift RootTarget era (DRepPulsingState era) (DRepPulsingState era)
forall era.
(RunConwayRatify era, Reflect era, ConwayEraCertState era) =>
RootTarget era (DRepPulsingState era) (DRepPulsingState era)
pulsingPulsingStateT (DRepPulsingState era -> f (DRepPulsingState era))
-> ConwayGovState era -> f (ConwayGovState era)
forall era (f :: * -> *).
Functor f =>
(DRepPulsingState era -> f (DRepPulsingState era))
-> ConwayGovState era -> f (ConwayGovState era)
Lens' (ConwayGovState era) (DRepPulsingState era)
cgsDRepPulsingStateL

-- | The sum of all the 'gasDeposit' fields of 'currProposals'
proposalDeposits :: Era era => Term era Coin
proposalDeposits :: forall era. Era era => Term era Coin
proposalDeposits = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"proposalDeposits" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No)

-- | A view of 'currentDRepState' (sum of the drepDeposit field of in the range of 'currentDRepState')
drepDepositsView :: Era era => Term era (Map (Credential 'DRepRole) Coin)
drepDepositsView :: forall era. Era era => Term era (Map (Credential 'DRepRole) Coin)
drepDepositsView = V era (Map (Credential 'DRepRole) Coin)
-> Term era (Map (Credential 'DRepRole) Coin)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (Credential 'DRepRole) Coin)
-> Access era Any (Map (Credential 'DRepRole) Coin)
-> V era (Map (Credential 'DRepRole) Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"drepDepositsView" (Rep era (Credential 'DRepRole)
-> Rep era Coin -> Rep era (Map (Credential 'DRepRole) Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'DRepRole)
forall era. Era era => Rep era (Credential 'DRepRole)
VCredR Rep era Coin
forall era. Rep era Coin
CoinR) Access era Any (Map (Credential 'DRepRole) Coin)
forall era s t. Access era s t
No)

-- | The current set of proposals. Proposals has a serious set of invariants.
--   We do not attempt to state these proposals (Yes I know that is cheating)
--   We get random Proposals (that meets its invariants) by using (genSizedRep n (ProposalsR p))
currProposals :: Era era => Proof era -> Term era (Proposals era)
currProposals :: forall era. Era era => Proof era -> Term era (Proposals era)
currProposals Proof era
p = V era (Proposals era) -> Term era (Proposals era)
forall era t. V era t -> Term era t
Var (V era (Proposals era) -> Term era (Proposals era))
-> V era (Proposals era) -> Term era (Proposals era)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Proposals era)
-> Access era Any (Proposals era)
-> V era (Proposals era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"currProposals" (Proof era -> Rep era (Proposals era)
forall era. Era era => Proof era -> Rep era (Proposals era)
ProposalsR Proof era
p) Access era Any (Proposals era)
forall era s t. Access era s t
No

-- | Part of the EnactState, it is computed by selecting from currProposals
prevGovActionIds :: forall era. Reflect era => Term era (GovRelation StrictMaybe era)
prevGovActionIds :: forall era. Reflect era => Term era (GovRelation StrictMaybe era)
prevGovActionIds = V era (GovRelation StrictMaybe era)
-> Term era (GovRelation StrictMaybe era)
forall era t. V era t -> Term era t
Var (V era (GovRelation StrictMaybe era)
 -> Term era (GovRelation StrictMaybe era))
-> V era (GovRelation StrictMaybe era)
-> Term era (GovRelation StrictMaybe era)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (GovRelation StrictMaybe era)
-> Access era Any (GovRelation StrictMaybe era)
-> V era (GovRelation StrictMaybe era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"prevGovActionIds" Rep era (GovRelation StrictMaybe era)
forall era. Era era => Rep era (GovRelation StrictMaybe era)
PrevGovActionIdsR Access era Any (GovRelation StrictMaybe era)
forall era s t. Access era s t
No

-- | This is a view of currProposals, so will compute it once
--   once currProposals is defined
currGovStates :: Era era => Term era [GovActionState era]
currGovStates :: forall era. Era era => Term era [GovActionState era]
currGovStates = V era [GovActionState era] -> Term era [GovActionState era]
forall era t. V era t -> Term era t
Var (String
-> Rep era [GovActionState era]
-> Access era Any [GovActionState era]
-> V era [GovActionState era]
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"currGovStates" (Rep era (GovActionState era) -> Rep era [GovActionState era]
forall era a. Rep era a -> Rep era [a]
ListR Rep era (GovActionState era)
forall era. Era era => Rep era (GovActionState era)
GovActionStateR) Access era Any [GovActionState era]
forall era s t. Access era s t
No)

enactStateT :: forall era. Reflect era => RootTarget era (EnactState era) (EnactState era)
enactStateT :: forall era.
Reflect era =>
RootTarget era (EnactState era) (EnactState era)
enactStateT =
  String
-> TypeRep (EnactState era)
-> (Maybe (Committee era)
    -> Constitution era
    -> PParamsF era
    -> PParamsF era
    -> Coin
    -> Map (Credential 'Staking) Coin
    -> GovRelation StrictMaybe era
    -> EnactState era)
-> RootTarget
     era
     (EnactState era)
     (Maybe (Committee era)
      -> Constitution era
      -> PParamsF era
      -> PParamsF era
      -> Coin
      -> Map (Credential 'Staking) Coin
      -> GovRelation StrictMaybe era
      -> EnactState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert
    String
"EnactState"
    (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(EnactState era))
    (\Maybe (Committee era)
x Constitution era
y (PParamsF Proof era
_ PParams era
z) (PParamsF Proof era
_ PParams era
w) Coin
a Map (Credential 'Staking) Coin
b GovRelation StrictMaybe era
c -> StrictMaybe (Committee era)
-> Constitution era
-> PParams era
-> PParams era
-> Coin
-> Map (Credential 'Staking) Coin
-> GovRelation StrictMaybe era
-> EnactState era
forall era.
StrictMaybe (Committee era)
-> Constitution era
-> PParams era
-> PParams era
-> Coin
-> Map (Credential 'Staking) Coin
-> GovRelation StrictMaybe era
-> EnactState era
EnactState (Maybe (Committee era) -> StrictMaybe (Committee era)
forall a. Maybe a -> StrictMaybe a
maybeToStrictMaybe Maybe (Committee era)
x) Constitution era
y PParams era
z PParams era
w Coin
a Map (Credential 'Staking) Coin
b GovRelation StrictMaybe era
c)
    RootTarget
  era
  (EnactState era)
  (Maybe (Committee era)
   -> Constitution era
   -> PParamsF era
   -> PParamsF era
   -> Coin
   -> Map (Credential 'Staking) Coin
   -> GovRelation StrictMaybe era
   -> EnactState era)
-> RootTarget era (EnactState era) (Maybe (Committee era))
-> RootTarget
     era
     (EnactState era)
     (Constitution era
      -> PParamsF era
      -> PParamsF era
      -> Coin
      -> Map (Credential 'Staking) Coin
      -> GovRelation StrictMaybe era
      -> EnactState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Maybe (Committee era))
-> SimpleGetter (EnactState era) (Maybe (Committee era))
-> RootTarget era (EnactState era) (Maybe (Committee era))
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Maybe (Committee era))
forall era. Era era => Term era (Maybe (Committee era))
committeeVar ((StrictMaybe (Committee era)
 -> Const r (StrictMaybe (Committee era)))
-> EnactState era -> Const r (EnactState era)
forall era (f :: * -> *).
Functor f =>
(StrictMaybe (Committee era) -> f (StrictMaybe (Committee era)))
-> EnactState era -> f (EnactState era)
ensCommitteeL ((StrictMaybe (Committee era)
  -> Const r (StrictMaybe (Committee era)))
 -> EnactState era -> Const r (EnactState era))
-> ((Maybe (Committee era) -> Const r (Maybe (Committee era)))
    -> StrictMaybe (Committee era)
    -> Const r (StrictMaybe (Committee era)))
-> (Maybe (Committee era) -> Const r (Maybe (Committee era)))
-> EnactState era
-> Const r (EnactState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe (Committee era) -> Const r (Maybe (Committee era)))
-> StrictMaybe (Committee era)
-> Const r (StrictMaybe (Committee era))
forall x (f :: * -> *).
Functor f =>
(Maybe x -> f (Maybe x)) -> StrictMaybe x -> f (StrictMaybe x)
strictMaybeToMaybeL) -- see 'committeeT' to construct a binding for committeeVar
    RootTarget
  era
  (EnactState era)
  (Constitution era
   -> PParamsF era
   -> PParamsF era
   -> Coin
   -> Map (Credential 'Staking) Coin
   -> GovRelation StrictMaybe era
   -> EnactState era)
-> RootTarget era (EnactState era) (Constitution era)
-> RootTarget
     era
     (EnactState era)
     (PParamsF era
      -> PParamsF era
      -> Coin
      -> Map (Credential 'Staking) Coin
      -> GovRelation StrictMaybe era
      -> EnactState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Constitution era)
-> SimpleGetter (EnactState era) (Constitution era)
-> RootTarget era (EnactState era) (Constitution era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Constitution era)
forall era. Era era => Term era (Constitution era)
constitution (Constitution era -> Const r (Constitution era))
-> EnactState era -> Const r (EnactState era)
SimpleGetter (EnactState era) (Constitution era)
forall era (f :: * -> *).
Functor f =>
(Constitution era -> f (Constitution era))
-> EnactState era -> f (EnactState era)
ensConstitutionL
    RootTarget
  era
  (EnactState era)
  (PParamsF era
   -> PParamsF era
   -> Coin
   -> Map (Credential 'Staking) Coin
   -> GovRelation StrictMaybe era
   -> EnactState era)
-> RootTarget era (EnactState era) (PParamsF era)
-> RootTarget
     era
     (EnactState era)
     (PParamsF era
      -> Coin
      -> Map (Credential 'Staking) Coin
      -> GovRelation StrictMaybe era
      -> EnactState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (PParamsF era)
-> SimpleGetter (EnactState era) (PParamsF era)
-> RootTarget era (EnactState era) (PParamsF era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Proof era -> Term era (PParamsF era)
forall era. Era era => Proof era -> Term era (PParamsF era)
currPParams Proof era
forall era. Reflect era => Proof era
reify) ((PParams era -> Const r (PParams era))
-> EnactState era -> Const r (EnactState era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> EnactState era -> f (EnactState era)
ensCurPParamsL ((PParams era -> Const r (PParams era))
 -> EnactState era -> Const r (EnactState era))
-> ((PParamsF era -> Const r (PParamsF era))
    -> PParams era -> Const r (PParams era))
-> (PParamsF era -> Const r (PParamsF era))
-> EnactState era
-> Const r (EnactState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proof era -> Lens' (PParams era) (PParamsF era)
forall era. Proof era -> Lens' (PParams era) (PParamsF era)
pparamsFL Proof era
forall era. Reflect era => Proof era
reify)
    RootTarget
  era
  (EnactState era)
  (PParamsF era
   -> Coin
   -> Map (Credential 'Staking) Coin
   -> GovRelation StrictMaybe era
   -> EnactState era)
-> RootTarget era (EnactState era) (PParamsF era)
-> RootTarget
     era
     (EnactState era)
     (Coin
      -> Map (Credential 'Staking) Coin
      -> GovRelation StrictMaybe era
      -> EnactState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (PParamsF era)
-> SimpleGetter (EnactState era) (PParamsF era)
-> RootTarget era (EnactState era) (PParamsF era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Proof era -> Term era (PParamsF era)
forall era. EraGov era => Proof era -> Term era (PParamsF era)
prevPParams Proof era
forall era. Reflect era => Proof era
reify) ((PParams era -> Const r (PParams era))
-> EnactState era -> Const r (EnactState era)
forall era (f :: * -> *).
Functor f =>
(PParams era -> f (PParams era))
-> EnactState era -> f (EnactState era)
ensPrevPParamsL ((PParams era -> Const r (PParams era))
 -> EnactState era -> Const r (EnactState era))
-> ((PParamsF era -> Const r (PParamsF era))
    -> PParams era -> Const r (PParams era))
-> (PParamsF era -> Const r (PParamsF era))
-> EnactState era
-> Const r (EnactState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proof era -> Lens' (PParams era) (PParamsF era)
forall era. Proof era -> Lens' (PParams era) (PParamsF era)
pparamsFL Proof era
forall era. Reflect era => Proof era
reify)
    RootTarget
  era
  (EnactState era)
  (Coin
   -> Map (Credential 'Staking) Coin
   -> GovRelation StrictMaybe era
   -> EnactState era)
-> RootTarget era (EnactState era) Coin
-> RootTarget
     era
     (EnactState era)
     (Map (Credential 'Staking) Coin
      -> GovRelation StrictMaybe era -> EnactState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era Coin
-> SimpleGetter (EnactState era) Coin
-> RootTarget era (EnactState era) Coin
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era Coin
forall era. Era era => Term era Coin
enactTreasury (Coin -> Const r Coin)
-> EnactState era -> Const r (EnactState era)
SimpleGetter (EnactState era) Coin
forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin) -> EnactState era -> f (EnactState era)
ensTreasuryL
    RootTarget
  era
  (EnactState era)
  (Map (Credential 'Staking) Coin
   -> GovRelation StrictMaybe era -> EnactState era)
-> RootTarget era (EnactState era) (Map (Credential 'Staking) Coin)
-> RootTarget
     era
     (EnactState era)
     (GovRelation StrictMaybe era -> EnactState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'Staking) Coin)
-> SimpleGetter (EnactState era) (Map (Credential 'Staking) Coin)
-> RootTarget era (EnactState era) (Map (Credential 'Staking) Coin)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'Staking) Coin)
forall era. Era era => Term era (Map (Credential 'Staking) Coin)
enactWithdrawals (Map (Credential 'Staking) Coin
 -> Const r (Map (Credential 'Staking) Coin))
-> EnactState era -> Const r (EnactState era)
SimpleGetter (EnactState era) (Map (Credential 'Staking) Coin)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'Staking) Coin
 -> f (Map (Credential 'Staking) Coin))
-> EnactState era -> f (EnactState era)
ensWithdrawalsL
    RootTarget
  era
  (EnactState era)
  (GovRelation StrictMaybe era -> EnactState era)
-> RootTarget era (EnactState era) (GovRelation StrictMaybe era)
-> RootTarget era (EnactState era) (EnactState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (GovRelation StrictMaybe era)
-> SimpleGetter (EnactState era) (GovRelation StrictMaybe era)
-> RootTarget era (EnactState era) (GovRelation StrictMaybe era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (GovRelation StrictMaybe era)
forall era. Reflect era => Term era (GovRelation StrictMaybe era)
prevGovActionIds (GovRelation StrictMaybe era
 -> Const r (GovRelation StrictMaybe era))
-> EnactState era -> Const r (EnactState era)
SimpleGetter (EnactState era) (GovRelation StrictMaybe era)
forall era (f :: * -> *).
Functor f =>
(GovRelation StrictMaybe era -> f (GovRelation StrictMaybe era))
-> EnactState era -> f (EnactState era)
ensPrevGovActionIdsL

-- | One can use this Target, to make a constraint for 'committeeVar' from the
--   vars 'commMembers' and 'commQuorum'
committeeT :: forall era. Era era => RootTarget era (Committee era) (Committee era)
committeeT :: forall era.
Era era =>
RootTarget era (Committee era) (Committee era)
committeeT =
  String
-> TypeRep (Committee era)
-> (Map (Credential 'ColdCommitteeRole) EpochNo
    -> UnitInterval -> Committee era)
-> RootTarget
     era
     (Committee era)
     (Map (Credential 'ColdCommitteeRole) EpochNo
      -> UnitInterval -> Committee era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"Committee" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(Committee era)) Map (Credential 'ColdCommitteeRole) EpochNo
-> UnitInterval -> Committee era
forall era.
Map (Credential 'ColdCommitteeRole) EpochNo
-> UnitInterval -> Committee era
Committee
    RootTarget
  era
  (Committee era)
  (Map (Credential 'ColdCommitteeRole) EpochNo
   -> UnitInterval -> Committee era)
-> RootTarget
     era (Committee era) (Map (Credential 'ColdCommitteeRole) EpochNo)
-> RootTarget era (Committee era) (UnitInterval -> Committee era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'ColdCommitteeRole) EpochNo)
-> SimpleGetter
     (Committee era) (Map (Credential 'ColdCommitteeRole) EpochNo)
-> RootTarget
     era (Committee era) (Map (Credential 'ColdCommitteeRole) EpochNo)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'ColdCommitteeRole) EpochNo)
forall era.
Era era =>
Term era (Map (Credential 'ColdCommitteeRole) EpochNo)
commMembers (Map (Credential 'ColdCommitteeRole) EpochNo
 -> Const r (Map (Credential 'ColdCommitteeRole) EpochNo))
-> Committee era -> Const r (Committee era)
SimpleGetter
  (Committee era) (Map (Credential 'ColdCommitteeRole) EpochNo)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'ColdCommitteeRole) EpochNo
 -> f (Map (Credential 'ColdCommitteeRole) EpochNo))
-> Committee era -> f (Committee era)
committeeMembersL
    RootTarget era (Committee era) (UnitInterval -> Committee era)
-> RootTarget era (Committee era) UnitInterval
-> RootTarget era (Committee era) (Committee era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era UnitInterval
-> SimpleGetter (Committee era) UnitInterval
-> RootTarget era (Committee era) UnitInterval
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era UnitInterval
forall era. Era era => Term era UnitInterval
commQuorum (UnitInterval -> Const r UnitInterval)
-> Committee era -> Const r (Committee era)
SimpleGetter (Committee era) UnitInterval
forall era (f :: * -> *).
Functor f =>
(UnitInterval -> f UnitInterval)
-> Committee era -> f (Committee era)
committeeThresholdL

{-
prevGovActionIdsT =
  Invert
    "prevGovActionIds"
    (typeRep @(PrevGovActionIds era))
    (\w x y z -> PrevGovActionIds $ PForest (maybeToStrictMaybe w) (maybeToStrictMaybe x) (maybeToStrictMaybe y) (maybeToStrictMaybe z))
    :$ Lensed prevPParamUpdate (prevGovActionIdsL . pfPParamUpdateL . strictMaybeToMaybeL)
    :$ Lensed prevHardFork (prevGovActionIdsL . pfHardForkL . strictMaybeToMaybeL)
    :$ Lensed prevCommittee (prevGovActionIdsL . pfCommitteeL . strictMaybeToMaybeL)
    :$ Lensed prevConstitution (prevGovActionIdsL . pfConstitutionL . strictMaybeToMaybeL)

prevPParamUpdate :: Era era => Term era (Maybe (GovPurposeId 'PParamUpdatePurpose era))
prevPParamUpdate = Var $ V "prevPParamUpdate" (MaybeR PrevPParamUpdateR) No

prevHardFork :: Era era => Term era (Maybe (GovPurposeId 'HardForkPurpose era))
prevHardFork = Var $ V "prevHardFork" (MaybeR PrevHardForkR) No

-- | Snapshot of 'committeeState' from the start of the current epoch
prevCommittee :: Era era => Term era (Maybe (GovPurposeId 'CommitteePurpose era))
prevCommittee = Var $ V "prevCommittee" (MaybeR PrevCommitteeR) No

prevConstitution :: Era era => Term era (Maybe (GovPurposeId 'ConstitutionPurpose era))
prevConstitution = Var $ V "prevConstitution" (MaybeR PrevConstitutionR) No

-}

ppUpdateChildren :: Era era => Term era (Set GovActionId)
ppUpdateChildren :: forall era. Era era => Term era (Set GovActionId)
ppUpdateChildren = V era (Set GovActionId) -> Term era (Set GovActionId)
forall era t. V era t -> Term era t
Var (V era (Set GovActionId) -> Term era (Set GovActionId))
-> V era (Set GovActionId) -> Term era (Set GovActionId)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set GovActionId)
-> Access era Any (Set GovActionId)
-> V era (Set GovActionId)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"ppUpdateChildren" (Rep era GovActionId -> Rep era (Set GovActionId)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era GovActionId
forall era. Era era => Rep era GovActionId
GovActionIdR) Access era Any (Set GovActionId)
forall era s t. Access era s t
No

hardForkChildren :: Era era => Term era (Set GovActionId)
hardForkChildren :: forall era. Era era => Term era (Set GovActionId)
hardForkChildren = V era (Set GovActionId) -> Term era (Set GovActionId)
forall era t. V era t -> Term era t
Var (V era (Set GovActionId) -> Term era (Set GovActionId))
-> V era (Set GovActionId) -> Term era (Set GovActionId)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set GovActionId)
-> Access era Any (Set GovActionId)
-> V era (Set GovActionId)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"hardForkChildren" (Rep era GovActionId -> Rep era (Set GovActionId)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era GovActionId
forall era. Era era => Rep era GovActionId
GovActionIdR) Access era Any (Set GovActionId)
forall era s t. Access era s t
No

committeeChildren :: Era era => Term era (Set GovActionId)
committeeChildren :: forall era. Era era => Term era (Set GovActionId)
committeeChildren = V era (Set GovActionId) -> Term era (Set GovActionId)
forall era t. V era t -> Term era t
Var (V era (Set GovActionId) -> Term era (Set GovActionId))
-> V era (Set GovActionId) -> Term era (Set GovActionId)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set GovActionId)
-> Access era Any (Set GovActionId)
-> V era (Set GovActionId)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"committeeChildren" (Rep era GovActionId -> Rep era (Set GovActionId)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era GovActionId
forall era. Era era => Rep era GovActionId
GovActionIdR) Access era Any (Set GovActionId)
forall era s t. Access era s t
No

constitutionChildren :: Era era => Term era (Set GovActionId)
constitutionChildren :: forall era. Era era => Term era (Set GovActionId)
constitutionChildren = V era (Set GovActionId) -> Term era (Set GovActionId)
forall era t. V era t -> Term era t
Var (V era (Set GovActionId) -> Term era (Set GovActionId))
-> V era (Set GovActionId) -> Term era (Set GovActionId)
forall a b. (a -> b) -> a -> b
$ String
-> Rep era (Set GovActionId)
-> Access era Any (Set GovActionId)
-> V era (Set GovActionId)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"constitutionChildren" (Rep era GovActionId -> Rep era (Set GovActionId)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era GovActionId
forall era. Era era => Rep era GovActionId
GovActionIdR) Access era Any (Set GovActionId)
forall era s t. Access era s t
No

-- ================
-- Lenses

pparamsFL :: Proof era -> Lens' (PParams era) (PParamsF era)
pparamsFL :: forall era. Proof era -> Lens' (PParams era) (PParamsF era)
pparamsFL Proof era
p = (PParams era -> PParamsF era)
-> (PParams era -> PParamsF era -> PParams era)
-> Lens (PParams era) (PParams era) (PParamsF era) (PParamsF era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (Proof era -> PParams era -> PParamsF era
forall era. Proof era -> PParams era -> PParamsF era
PParamsF Proof era
p) (\PParams era
_ (PParamsF Proof era
_ PParams era
x) -> PParams era
x)

pparamsMaybeFL :: Proof era -> Lens' (Maybe (PParams era)) (Maybe (PParamsF era))
pparamsMaybeFL :: forall era.
Proof era -> Lens' (Maybe (PParams era)) (Maybe (PParamsF era))
pparamsMaybeFL Proof era
p =
  (Maybe (PParams era) -> Maybe (PParamsF era))
-> (Maybe (PParams era)
    -> Maybe (PParamsF era) -> Maybe (PParams era))
-> Lens
     (Maybe (PParams era))
     (Maybe (PParams era))
     (Maybe (PParamsF era))
     (Maybe (PParamsF era))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    ((PParams era -> PParamsF era)
-> Maybe (PParams era) -> Maybe (PParamsF era)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Proof era -> PParams era -> PParamsF era
forall era. Proof era -> PParams era -> PParamsF era
PParamsF Proof era
p))
    (\Maybe (PParams era)
_ -> (PParamsF era -> PParams era)
-> Maybe (PParamsF era) -> Maybe (PParams era)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(PParamsF Proof era
_ PParams era
x) -> PParams era
x))

smCommL :: Lens' (StrictMaybe (Committee era)) (Committee era)
smCommL :: forall era (f :: * -> *).
Functor f =>
(Committee era -> f (Committee era))
-> StrictMaybe (Committee era) -> f (StrictMaybe (Committee era))
smCommL = (StrictMaybe (Committee era) -> Committee era)
-> (StrictMaybe (Committee era)
    -> Committee era -> StrictMaybe (Committee era))
-> Lens
     (StrictMaybe (Committee era))
     (StrictMaybe (Committee era))
     (Committee era)
     (Committee era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens StrictMaybe (Committee era) -> Committee era
forall {era}. StrictMaybe (Committee era) -> Committee era
getter (\StrictMaybe (Committee era)
_ Committee era
t -> Committee era -> StrictMaybe (Committee era)
forall a. a -> StrictMaybe a
SJust Committee era
t)
  where
    getter :: StrictMaybe (Committee era) -> Committee era
getter StrictMaybe (Committee era)
SNothing = Map (Credential 'ColdCommitteeRole) EpochNo
-> UnitInterval -> Committee era
forall era.
Map (Credential 'ColdCommitteeRole) EpochNo
-> UnitInterval -> Committee era
Committee Map (Credential 'ColdCommitteeRole) EpochNo
forall k a. Map k a
Map.empty UnitInterval
forall a. Bounded a => a
maxBound
    getter (SJust Committee era
x) = Committee era
x

proposedMapL ::
  Proof era ->
  Lens' (ProposedPPUpdates era) (Map (KeyHash 'Genesis) (PParamsUpdateF era))
proposedMapL :: forall era.
Proof era
-> Lens'
     (ProposedPPUpdates era)
     (Map (KeyHash 'Genesis) (PParamsUpdateF era))
proposedMapL Proof era
p =
  (ProposedPPUpdates era
 -> Map (KeyHash 'Genesis) (PParamsUpdateF era))
-> (ProposedPPUpdates era
    -> Map (KeyHash 'Genesis) (PParamsUpdateF era)
    -> ProposedPPUpdates era)
-> Lens
     (ProposedPPUpdates era)
     (ProposedPPUpdates era)
     (Map (KeyHash 'Genesis) (PParamsUpdateF era))
     (Map (KeyHash 'Genesis) (PParamsUpdateF era))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    (\(ProposedPPUpdates Map (KeyHash 'Genesis) (PParamsUpdate era)
x) -> (PParamsUpdate era -> PParamsUpdateF era)
-> Map (KeyHash 'Genesis) (PParamsUpdate era)
-> Map (KeyHash 'Genesis) (PParamsUpdateF era)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (Proof era -> PParamsUpdate era -> PParamsUpdateF era
forall era. Proof era -> PParamsUpdate era -> PParamsUpdateF era
PParamsUpdateF Proof era
p) Map (KeyHash 'Genesis) (PParamsUpdate era)
x)
    (\(ProposedPPUpdates Map (KeyHash 'Genesis) (PParamsUpdate era)
_) Map (KeyHash 'Genesis) (PParamsUpdateF era)
y -> Map (KeyHash 'Genesis) (PParamsUpdate era) -> ProposedPPUpdates era
forall era.
Map (KeyHash 'Genesis) (PParamsUpdate era) -> ProposedPPUpdates era
ProposedPPUpdates ((PParamsUpdateF era -> PParamsUpdate era)
-> Map (KeyHash 'Genesis) (PParamsUpdateF era)
-> Map (KeyHash 'Genesis) (PParamsUpdate era)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map PParamsUpdateF era -> PParamsUpdate era
forall era. PParamsUpdateF era -> PParamsUpdate era
unPParamsUpdate Map (KeyHash 'Genesis) (PParamsUpdateF era)
y))

pair1 :: Era era => Rep era a -> Term era a
pair1 :: forall era a. Era era => Rep era a -> Term era a
pair1 Rep era a
rep = V era a -> Term era a
forall era t. V era t -> Term era t
Var (String -> Rep era a -> Access era Any a -> V era a
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"pair1" Rep era a
rep Access era Any a
forall era s t. Access era s t
No)

pair2 :: Era era => Rep era b -> Term era b
pair2 :: forall era a. Era era => Rep era a -> Term era a
pair2 Rep era b
rep = V era b -> Term era b
forall era t. V era t -> Term era t
Var (String -> Rep era b -> Access era Any b -> V era b
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"pair2" Rep era b
rep Access era Any b
forall era s t. Access era s t
No)

pairT ::
  forall era a b.
  (Typeable a, Typeable b, Era era) =>
  Rep era a ->
  Rep era b ->
  RootTarget era (a, b) (a, b)
pairT :: forall era a b.
(Typeable a, Typeable b, Era era) =>
Rep era a -> Rep era b -> RootTarget era (a, b) (a, b)
pairT Rep era a
repa Rep era b
repb =
  String
-> TypeRep (a, b)
-> (a -> b -> (a, b))
-> RootTarget era (a, b) (a -> b -> (a, b))
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"(,)" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(a, b)) (,)
    RootTarget era (a, b) (a -> b -> (a, b))
-> RootTarget era (a, b) a -> RootTarget era (a, b) (b -> (a, b))
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era a -> SimpleGetter (a, b) a -> RootTarget era (a, b) a
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Rep era a -> Term era a
forall era a. Era era => Rep era a -> Term era a
pair1 Rep era a
repa) (a -> Const r a) -> (a, b) -> Const r (a, b)
SimpleGetter (a, b) a
forall a b (f :: * -> *).
Functor f =>
(a -> f a) -> (a, b) -> f (a, b)
fstL
    RootTarget era (a, b) (b -> (a, b))
-> RootTarget era (a, b) b -> RootTarget era (a, b) (a, b)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era b -> SimpleGetter (a, b) b -> RootTarget era (a, b) b
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Rep era b -> Term era b
forall era a. Era era => Rep era a -> Term era a
pair2 Rep era b
repb) (b -> Const r b) -> (a, b) -> Const r (a, b)
SimpleGetter (a, b) b
forall a b (f :: * -> *).
Functor f =>
(b -> f b) -> (a, b) -> f (a, b)
sndL

-- ==========================================
-- Targets for GovActionState
-- The variables xxV align with the field selectors gasXx

idV :: Era era => Term era GovActionId
idV :: forall era. Era era => Term era GovActionId
idV = V era GovActionId -> Term era GovActionId
forall era t. V era t -> Term era t
Var (String
-> Rep era GovActionId
-> Access era Any GovActionId
-> V era GovActionId
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"idV" Rep era GovActionId
forall era. Era era => Rep era GovActionId
GovActionIdR Access era Any GovActionId
forall era s t. Access era s t
No)

committeeVotesV :: Era era => Term era (Map (Credential 'HotCommitteeRole) Vote)
committeeVotesV :: forall era.
Era era =>
Term era (Map (Credential 'HotCommitteeRole) Vote)
committeeVotesV = V era (Map (Credential 'HotCommitteeRole) Vote)
-> Term era (Map (Credential 'HotCommitteeRole) Vote)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (Credential 'HotCommitteeRole) Vote)
-> Access era Any (Map (Credential 'HotCommitteeRole) Vote)
-> V era (Map (Credential 'HotCommitteeRole) Vote)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"committeeVotesV" (Rep era (Credential 'HotCommitteeRole)
-> Rep era Vote
-> Rep era (Map (Credential 'HotCommitteeRole) Vote)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'HotCommitteeRole)
forall era. Era era => Rep era (Credential 'HotCommitteeRole)
CommHotCredR Rep era Vote
forall era. Rep era Vote
VoteR) Access era Any (Map (Credential 'HotCommitteeRole) Vote)
forall era s t. Access era s t
No)

drepVotesV :: Era era => Term era (Map (Credential 'DRepRole) Vote)
drepVotesV :: forall era. Era era => Term era (Map (Credential 'DRepRole) Vote)
drepVotesV = V era (Map (Credential 'DRepRole) Vote)
-> Term era (Map (Credential 'DRepRole) Vote)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (Credential 'DRepRole) Vote)
-> Access era Any (Map (Credential 'DRepRole) Vote)
-> V era (Map (Credential 'DRepRole) Vote)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"drepVotesV" (Rep era (Credential 'DRepRole)
-> Rep era Vote -> Rep era (Map (Credential 'DRepRole) Vote)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'DRepRole)
forall era. Era era => Rep era (Credential 'DRepRole)
VCredR Rep era Vote
forall era. Rep era Vote
VoteR) Access era Any (Map (Credential 'DRepRole) Vote)
forall era s t. Access era s t
No)

stakePoolVotesV :: Era era => Term era (Map (KeyHash 'StakePool) Vote)
stakePoolVotesV :: forall era. Era era => Term era (Map (KeyHash 'StakePool) Vote)
stakePoolVotesV = V era (Map (KeyHash 'StakePool) Vote)
-> Term era (Map (KeyHash 'StakePool) Vote)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (KeyHash 'StakePool) Vote)
-> Access era Any (Map (KeyHash 'StakePool) Vote)
-> V era (Map (KeyHash 'StakePool) Vote)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"stakePoolVotesV" (Rep era (KeyHash 'StakePool)
-> Rep era Vote -> Rep era (Map (KeyHash 'StakePool) Vote)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (KeyHash 'StakePool)
forall era. Era era => Rep era (KeyHash 'StakePool)
PoolHashR Rep era Vote
forall era. Rep era Vote
VoteR) Access era Any (Map (KeyHash 'StakePool) Vote)
forall era s t. Access era s t
No)

depositV :: Era era => Term era Coin
depositV :: forall era. Era era => Term era Coin
depositV = V era Coin -> Term era Coin
forall era t. V era t -> Term era t
Var (String -> Rep era Coin -> Access era Any Coin -> V era Coin
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"depositV" Rep era Coin
forall era. Rep era Coin
CoinR Access era Any Coin
forall era s t. Access era s t
No)

returnAddrV :: Era era => Term era RewardAccount
returnAddrV :: forall era. Era era => Term era RewardAccount
returnAddrV = V era RewardAccount -> Term era RewardAccount
forall era t. V era t -> Term era t
Var (String
-> Rep era RewardAccount
-> Access era Any RewardAccount
-> V era RewardAccount
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"returnAddrV" Rep era RewardAccount
forall era. Era era => Rep era RewardAccount
RewardAccountR Access era Any RewardAccount
forall era s t. Access era s t
No)

actionV :: Era era => Term era (GovAction era)
actionV :: forall era. Era era => Term era (GovAction era)
actionV = V era (GovAction era) -> Term era (GovAction era)
forall era t. V era t -> Term era t
Var (String
-> Rep era (GovAction era)
-> Access era Any (GovAction era)
-> V era (GovAction era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"actionV" Rep era (GovAction era)
forall era. Era era => Rep era (GovAction era)
GovActionR Access era Any (GovAction era)
forall era s t. Access era s t
No)

proposedInV :: Era era => Term era EpochNo
proposedInV :: forall era. Era era => Term era EpochNo
proposedInV = V era EpochNo -> Term era EpochNo
forall era t. V era t -> Term era t
Var (String
-> Rep era EpochNo -> Access era Any EpochNo -> V era EpochNo
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"proposedInV" Rep era EpochNo
forall era. Rep era EpochNo
EpochR Access era Any EpochNo
forall era s t. Access era s t
No)

expiresAfterV :: Era era => Term era EpochNo
expiresAfterV :: forall era. Era era => Term era EpochNo
expiresAfterV = V era EpochNo -> Term era EpochNo
forall era t. V era t -> Term era t
Var (String
-> Rep era EpochNo -> Access era Any EpochNo -> V era EpochNo
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"expiresAfterV" Rep era EpochNo
forall era. Rep era EpochNo
EpochR Access era Any EpochNo
forall era s t. Access era s t
No)

childrenV :: Era era => Term era (Set GovActionId)
childrenV :: forall era. Era era => Term era (Set GovActionId)
childrenV = V era (Set GovActionId) -> Term era (Set GovActionId)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Set GovActionId)
-> Access era Any (Set GovActionId)
-> V era (Set GovActionId)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"childrenV" (Rep era GovActionId -> Rep era (Set GovActionId)
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era GovActionId
forall era. Era era => Rep era GovActionId
GovActionIdR) Access era Any (Set GovActionId)
forall era s t. Access era s t
No)

anchorV :: Era era => Term era Anchor
anchorV :: forall era. Era era => Term era Anchor
anchorV = V era Anchor -> Term era Anchor
forall era t. V era t -> Term era t
Var (String -> Rep era Anchor -> Access era Any Anchor -> V era Anchor
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"anchorV" Rep era Anchor
forall era. Era era => Rep era Anchor
AnchorR Access era Any Anchor
forall era s t. Access era s t
No)

govActionStateTarget ::
  forall era. Era era => RootTarget era (GovActionState era) (GovActionState era)
govActionStateTarget :: forall era.
Era era =>
RootTarget era (GovActionState era) (GovActionState era)
govActionStateTarget =
  String
-> TypeRep (GovActionState era)
-> (GovActionId
    -> Map (Credential 'HotCommitteeRole) Vote
    -> Map (Credential 'DRepRole) Vote
    -> Map (KeyHash 'StakePool) Vote
    -> ProposalProcedure era
    -> EpochNo
    -> EpochNo
    -> GovActionState era)
-> RootTarget
     era
     (GovActionState era)
     (GovActionId
      -> Map (Credential 'HotCommitteeRole) Vote
      -> Map (Credential 'DRepRole) Vote
      -> Map (KeyHash 'StakePool) Vote
      -> ProposalProcedure era
      -> EpochNo
      -> EpochNo
      -> GovActionState era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"GovActionState" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(GovActionState era)) GovActionId
-> Map (Credential 'HotCommitteeRole) Vote
-> Map (Credential 'DRepRole) Vote
-> Map (KeyHash 'StakePool) Vote
-> ProposalProcedure era
-> EpochNo
-> EpochNo
-> GovActionState era
forall era.
GovActionId
-> Map (Credential 'HotCommitteeRole) Vote
-> Map (Credential 'DRepRole) Vote
-> Map (KeyHash 'StakePool) Vote
-> ProposalProcedure era
-> EpochNo
-> EpochNo
-> GovActionState era
GovActionState
    RootTarget
  era
  (GovActionState era)
  (GovActionId
   -> Map (Credential 'HotCommitteeRole) Vote
   -> Map (Credential 'DRepRole) Vote
   -> Map (KeyHash 'StakePool) Vote
   -> ProposalProcedure era
   -> EpochNo
   -> EpochNo
   -> GovActionState era)
-> RootTarget era (GovActionState era) GovActionId
-> RootTarget
     era
     (GovActionState era)
     (Map (Credential 'HotCommitteeRole) Vote
      -> Map (Credential 'DRepRole) Vote
      -> Map (KeyHash 'StakePool) Vote
      -> ProposalProcedure era
      -> EpochNo
      -> EpochNo
      -> GovActionState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era GovActionId
-> SimpleGetter (GovActionState era) GovActionId
-> RootTarget era (GovActionState era) GovActionId
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era GovActionId
forall era. Era era => Term era GovActionId
idV (GovActionId -> Const r GovActionId)
-> GovActionState era -> Const r (GovActionState era)
SimpleGetter (GovActionState era) GovActionId
forall era (f :: * -> *).
Functor f =>
(GovActionId -> f GovActionId)
-> GovActionState era -> f (GovActionState era)
gasIdL
    RootTarget
  era
  (GovActionState era)
  (Map (Credential 'HotCommitteeRole) Vote
   -> Map (Credential 'DRepRole) Vote
   -> Map (KeyHash 'StakePool) Vote
   -> ProposalProcedure era
   -> EpochNo
   -> EpochNo
   -> GovActionState era)
-> RootTarget
     era (GovActionState era) (Map (Credential 'HotCommitteeRole) Vote)
-> RootTarget
     era
     (GovActionState era)
     (Map (Credential 'DRepRole) Vote
      -> Map (KeyHash 'StakePool) Vote
      -> ProposalProcedure era
      -> EpochNo
      -> EpochNo
      -> GovActionState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'HotCommitteeRole) Vote)
-> SimpleGetter
     (GovActionState era) (Map (Credential 'HotCommitteeRole) Vote)
-> RootTarget
     era (GovActionState era) (Map (Credential 'HotCommitteeRole) Vote)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'HotCommitteeRole) Vote)
forall era.
Era era =>
Term era (Map (Credential 'HotCommitteeRole) Vote)
committeeVotesV (Map (Credential 'HotCommitteeRole) Vote
 -> Const r (Map (Credential 'HotCommitteeRole) Vote))
-> GovActionState era -> Const r (GovActionState era)
SimpleGetter
  (GovActionState era) (Map (Credential 'HotCommitteeRole) Vote)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'HotCommitteeRole) Vote
 -> f (Map (Credential 'HotCommitteeRole) Vote))
-> GovActionState era -> f (GovActionState era)
gasCommitteeVotesL
    RootTarget
  era
  (GovActionState era)
  (Map (Credential 'DRepRole) Vote
   -> Map (KeyHash 'StakePool) Vote
   -> ProposalProcedure era
   -> EpochNo
   -> EpochNo
   -> GovActionState era)
-> RootTarget
     era (GovActionState era) (Map (Credential 'DRepRole) Vote)
-> RootTarget
     era
     (GovActionState era)
     (Map (KeyHash 'StakePool) Vote
      -> ProposalProcedure era
      -> EpochNo
      -> EpochNo
      -> GovActionState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'DRepRole) Vote)
-> SimpleGetter
     (GovActionState era) (Map (Credential 'DRepRole) Vote)
-> RootTarget
     era (GovActionState era) (Map (Credential 'DRepRole) Vote)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (Credential 'DRepRole) Vote)
forall era. Era era => Term era (Map (Credential 'DRepRole) Vote)
drepVotesV (Map (Credential 'DRepRole) Vote
 -> Const r (Map (Credential 'DRepRole) Vote))
-> GovActionState era -> Const r (GovActionState era)
SimpleGetter (GovActionState era) (Map (Credential 'DRepRole) Vote)
forall era (f :: * -> *).
Functor f =>
(Map (Credential 'DRepRole) Vote
 -> f (Map (Credential 'DRepRole) Vote))
-> GovActionState era -> f (GovActionState era)
gasDRepVotesL
    RootTarget
  era
  (GovActionState era)
  (Map (KeyHash 'StakePool) Vote
   -> ProposalProcedure era
   -> EpochNo
   -> EpochNo
   -> GovActionState era)
-> RootTarget
     era (GovActionState era) (Map (KeyHash 'StakePool) Vote)
-> RootTarget
     era
     (GovActionState era)
     (ProposalProcedure era -> EpochNo -> EpochNo -> GovActionState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (KeyHash 'StakePool) Vote)
-> SimpleGetter
     (GovActionState era) (Map (KeyHash 'StakePool) Vote)
-> RootTarget
     era (GovActionState era) (Map (KeyHash 'StakePool) Vote)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Map (KeyHash 'StakePool) Vote)
forall era. Era era => Term era (Map (KeyHash 'StakePool) Vote)
stakePoolVotesV (Map (KeyHash 'StakePool) Vote
 -> Const r (Map (KeyHash 'StakePool) Vote))
-> GovActionState era -> Const r (GovActionState era)
SimpleGetter (GovActionState era) (Map (KeyHash 'StakePool) Vote)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash 'StakePool) Vote
 -> f (Map (KeyHash 'StakePool) Vote))
-> GovActionState era -> f (GovActionState era)
gasStakePoolVotesL
    RootTarget
  era
  (GovActionState era)
  (ProposalProcedure era -> EpochNo -> EpochNo -> GovActionState era)
-> RootTarget era (GovActionState era) (ProposalProcedure era)
-> RootTarget
     era (GovActionState era) (EpochNo -> EpochNo -> GovActionState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ RootTarget era (ProposalProcedure era) (ProposalProcedure era)
-> Lens' (GovActionState era) (ProposalProcedure era)
-> RootTarget era (GovActionState era) (ProposalProcedure era)
forall era root2 t root.
RootTarget era root2 t -> Lens' root root2 -> RootTarget era root t
Shift
      ( String
-> TypeRep (ProposalProcedure era)
-> (Coin
    -> RewardAccount
    -> GovAction era
    -> Anchor
    -> ProposalProcedure era)
-> RootTarget
     era
     (ProposalProcedure era)
     (Coin
      -> RewardAccount
      -> GovAction era
      -> Anchor
      -> ProposalProcedure era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"ProposalProcedure" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(ProposalProcedure era)) Coin
-> RewardAccount
-> GovAction era
-> Anchor
-> ProposalProcedure era
forall era.
Coin
-> RewardAccount
-> GovAction era
-> Anchor
-> ProposalProcedure era
ProposalProcedure
          RootTarget
  era
  (ProposalProcedure era)
  (Coin
   -> RewardAccount
   -> GovAction era
   -> Anchor
   -> ProposalProcedure era)
-> RootTarget era (ProposalProcedure era) Coin
-> RootTarget
     era
     (ProposalProcedure era)
     (RewardAccount -> GovAction era -> Anchor -> ProposalProcedure era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era Coin
-> SimpleGetter (ProposalProcedure era) Coin
-> RootTarget era (ProposalProcedure era) Coin
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era Coin
forall era. Era era => Term era Coin
depositV (Coin -> Const r Coin)
-> ProposalProcedure era -> Const r (ProposalProcedure era)
SimpleGetter (ProposalProcedure era) Coin
forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin)
-> ProposalProcedure era -> f (ProposalProcedure era)
pProcDepositL
          RootTarget
  era
  (ProposalProcedure era)
  (RewardAccount -> GovAction era -> Anchor -> ProposalProcedure era)
-> RootTarget era (ProposalProcedure era) RewardAccount
-> RootTarget
     era
     (ProposalProcedure era)
     (GovAction era -> Anchor -> ProposalProcedure era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era RewardAccount
-> SimpleGetter (ProposalProcedure era) RewardAccount
-> RootTarget era (ProposalProcedure era) RewardAccount
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era RewardAccount
forall era. Era era => Term era RewardAccount
returnAddrV (RewardAccount -> Const r RewardAccount)
-> ProposalProcedure era -> Const r (ProposalProcedure era)
SimpleGetter (ProposalProcedure era) RewardAccount
forall era (f :: * -> *).
Functor f =>
(RewardAccount -> f RewardAccount)
-> ProposalProcedure era -> f (ProposalProcedure era)
pProcReturnAddrL
          RootTarget
  era
  (ProposalProcedure era)
  (GovAction era -> Anchor -> ProposalProcedure era)
-> RootTarget era (ProposalProcedure era) (GovAction era)
-> RootTarget
     era (ProposalProcedure era) (Anchor -> ProposalProcedure era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (GovAction era)
-> SimpleGetter (ProposalProcedure era) (GovAction era)
-> RootTarget era (ProposalProcedure era) (GovAction era)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (GovAction era)
forall era. Era era => Term era (GovAction era)
actionV (GovAction era -> Const r (GovAction era))
-> ProposalProcedure era -> Const r (ProposalProcedure era)
SimpleGetter (ProposalProcedure era) (GovAction era)
forall era (f :: * -> *).
Functor f =>
(GovAction era -> f (GovAction era))
-> ProposalProcedure era -> f (ProposalProcedure era)
pProcGovActionL
          RootTarget
  era (ProposalProcedure era) (Anchor -> ProposalProcedure era)
-> RootTarget era (ProposalProcedure era) Anchor
-> RootTarget era (ProposalProcedure era) (ProposalProcedure era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era Anchor
-> SimpleGetter (ProposalProcedure era) Anchor
-> RootTarget era (ProposalProcedure era) Anchor
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era Anchor
forall era. Era era => Term era Anchor
anchorV (Anchor -> Const r Anchor)
-> ProposalProcedure era -> Const r (ProposalProcedure era)
SimpleGetter (ProposalProcedure era) Anchor
forall era (f :: * -> *).
Functor f =>
(Anchor -> f Anchor)
-> ProposalProcedure era -> f (ProposalProcedure era)
pProcAnchorL
      )
      (ProposalProcedure era -> f (ProposalProcedure era))
-> GovActionState era -> f (GovActionState era)
forall era (f :: * -> *).
Functor f =>
(ProposalProcedure era -> f (ProposalProcedure era))
-> GovActionState era -> f (GovActionState era)
Lens' (GovActionState era) (ProposalProcedure era)
gasProposalProcedureL
    RootTarget
  era (GovActionState era) (EpochNo -> EpochNo -> GovActionState era)
-> RootTarget era (GovActionState era) EpochNo
-> RootTarget
     era (GovActionState era) (EpochNo -> GovActionState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era EpochNo
-> SimpleGetter (GovActionState era) EpochNo
-> RootTarget era (GovActionState era) EpochNo
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era EpochNo
forall era. Era era => Term era EpochNo
proposedInV (EpochNo -> Const r EpochNo)
-> GovActionState era -> Const r (GovActionState era)
SimpleGetter (GovActionState era) EpochNo
forall era (f :: * -> *).
Functor f =>
(EpochNo -> f EpochNo)
-> GovActionState era -> f (GovActionState era)
gasProposedInL
    RootTarget era (GovActionState era) (EpochNo -> GovActionState era)
-> RootTarget era (GovActionState era) EpochNo
-> RootTarget era (GovActionState era) (GovActionState era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era EpochNo
-> SimpleGetter (GovActionState era) EpochNo
-> RootTarget era (GovActionState era) EpochNo
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era EpochNo
forall era. Era era => Term era EpochNo
expiresAfterV (EpochNo -> Const r EpochNo)
-> GovActionState era -> Const r (GovActionState era)
SimpleGetter (GovActionState era) EpochNo
forall era (f :: * -> *).
Functor f =>
(EpochNo -> f EpochNo)
-> GovActionState era -> f (GovActionState era)
gasExpiresAfterL

-- ==============================================================
-- Targets for GovAction, The model does not make the distinction
-- the newtype (PrevGovActionId era) and (GovActionId era), The
-- targets provide the coercions to produce the real data from the Model

-- | Lift the Model to the real type
liftId :: Maybe GovActionId -> StrictMaybe (GovPurposeId p era)
liftId :: forall (p :: GovActionPurpose) era.
Maybe GovActionId -> StrictMaybe (GovPurposeId p era)
liftId Maybe GovActionId
x = GovActionId -> GovPurposeId p era
forall (p :: GovActionPurpose) era.
GovActionId -> GovPurposeId p era
GovPurposeId (GovActionId -> GovPurposeId p era)
-> StrictMaybe GovActionId -> StrictMaybe (GovPurposeId p era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe GovActionId -> StrictMaybe GovActionId
forall a. Maybe a -> StrictMaybe a
maybeToStrictMaybe Maybe GovActionId
x)

-- | Drop the real type back to the Model
dropId :: StrictMaybe (GovPurposeId p era) -> Maybe GovActionId
dropId :: forall (p :: GovActionPurpose) era.
StrictMaybe (GovPurposeId p era) -> Maybe GovActionId
dropId StrictMaybe (GovPurposeId p era)
x = GovPurposeId p era -> GovActionId
forall (p :: GovActionPurpose) era.
GovPurposeId p era -> GovActionId
unGovPurposeId (GovPurposeId p era -> GovActionId)
-> Maybe (GovPurposeId p era) -> Maybe GovActionId
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (StrictMaybe (GovPurposeId p era) -> Maybe (GovPurposeId p era)
forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe StrictMaybe (GovPurposeId p era)
x)

-- =====================
-- Variables for the fields of GovAction

gaPrevId :: Era era => Term era (Maybe GovActionId)
gaPrevId :: forall era. Era era => Term era (Maybe GovActionId)
gaPrevId = V era (Maybe GovActionId) -> Term era (Maybe GovActionId)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Maybe GovActionId)
-> Access era Any (Maybe GovActionId)
-> V era (Maybe GovActionId)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"gaPrevId" (Rep era GovActionId -> Rep era (Maybe GovActionId)
forall era t1. Rep era t1 -> Rep era (Maybe t1)
MaybeR Rep era GovActionId
forall era. Era era => Rep era GovActionId
GovActionIdR) Access era Any (Maybe GovActionId)
forall era s t. Access era s t
No)

gaPParamsUpdate :: Reflect era => Term era (PParamsUpdateF era)
gaPParamsUpdate :: forall era. Reflect era => Term era (PParamsUpdateF era)
gaPParamsUpdate = V era (PParamsUpdateF era) -> Term era (PParamsUpdateF era)
forall era t. V era t -> Term era t
Var (String
-> Rep era (PParamsUpdateF era)
-> Access era Any (PParamsUpdateF era)
-> V era (PParamsUpdateF era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"gsPParamsUpdate" (Proof era -> Rep era (PParamsUpdateF era)
forall era. Era era => Proof era -> Rep era (PParamsUpdateF era)
PParamsUpdateR Proof era
forall era. Reflect era => Proof era
reify) Access era Any (PParamsUpdateF era)
forall era s t. Access era s t
No)

gaProtVer :: Reflect era => Term era ProtVer
gaProtVer :: forall era. Reflect era => Term era ProtVer
gaProtVer = V era ProtVer -> Term era ProtVer
forall era t. V era t -> Term era t
Var (String
-> Rep era ProtVer -> Access era Any ProtVer -> V era ProtVer
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"gaProtVer" (Proof era -> Rep era ProtVer
forall era. Era era => Proof era -> Rep era ProtVer
ProtVerR Proof era
forall era. Reflect era => Proof era
reify) Access era Any ProtVer
forall era s t. Access era s t
No)

gaRewardAccount :: Era era => Term era (Map RewardAccount Coin)
gaRewardAccount :: forall era. Era era => Term era (Map RewardAccount Coin)
gaRewardAccount = V era (Map RewardAccount Coin) -> Term era (Map RewardAccount Coin)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map RewardAccount Coin)
-> Access era Any (Map RewardAccount Coin)
-> V era (Map RewardAccount Coin)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"gaRewardAccount" (Rep era RewardAccount
-> Rep era Coin -> Rep era (Map RewardAccount Coin)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era RewardAccount
forall era. Era era => Rep era RewardAccount
RewardAccountR Rep era Coin
forall era. Rep era Coin
CoinR) Access era Any (Map RewardAccount Coin)
forall era s t. Access era s t
No)

gaRemMember :: Era era => Term era (Set (Credential 'ColdCommitteeRole))
gaRemMember :: forall era.
Era era =>
Term era (Set (Credential 'ColdCommitteeRole))
gaRemMember = V era (Set (Credential 'ColdCommitteeRole))
-> Term era (Set (Credential 'ColdCommitteeRole))
forall era t. V era t -> Term era t
Var (String
-> Rep era (Set (Credential 'ColdCommitteeRole))
-> Access era Any (Set (Credential 'ColdCommitteeRole))
-> V era (Set (Credential 'ColdCommitteeRole))
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"gaRemMember" (Rep era (Credential 'ColdCommitteeRole)
-> Rep era (Set (Credential 'ColdCommitteeRole))
forall a era. Ord a => Rep era a -> Rep era (Set a)
SetR Rep era (Credential 'ColdCommitteeRole)
forall era. Era era => Rep era (Credential 'ColdCommitteeRole)
CommColdCredR) Access era Any (Set (Credential 'ColdCommitteeRole))
forall era s t. Access era s t
No)

gaAddMember :: Era era => Term era (Map (Credential 'ColdCommitteeRole) EpochNo)
gaAddMember :: forall era.
Era era =>
Term era (Map (Credential 'ColdCommitteeRole) EpochNo)
gaAddMember = V era (Map (Credential 'ColdCommitteeRole) EpochNo)
-> Term era (Map (Credential 'ColdCommitteeRole) EpochNo)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Map (Credential 'ColdCommitteeRole) EpochNo)
-> Access era Any (Map (Credential 'ColdCommitteeRole) EpochNo)
-> V era (Map (Credential 'ColdCommitteeRole) EpochNo)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"gaAddMember" (Rep era (Credential 'ColdCommitteeRole)
-> Rep era EpochNo
-> Rep era (Map (Credential 'ColdCommitteeRole) EpochNo)
forall a era b.
Ord a =>
Rep era a -> Rep era b -> Rep era (Map a b)
MapR Rep era (Credential 'ColdCommitteeRole)
forall era. Era era => Rep era (Credential 'ColdCommitteeRole)
CommColdCredR Rep era EpochNo
forall era. Rep era EpochNo
EpochR) Access era Any (Map (Credential 'ColdCommitteeRole) EpochNo)
forall era s t. Access era s t
No)

gaThreshold :: Era era => Term era UnitInterval
gaThreshold :: forall era. Era era => Term era UnitInterval
gaThreshold = V era UnitInterval -> Term era UnitInterval
forall era t. V era t -> Term era t
Var (String
-> Rep era UnitInterval
-> Access era Any UnitInterval
-> V era UnitInterval
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"gaThreshold" Rep era UnitInterval
forall era. Rep era UnitInterval
UnitIntervalR Access era Any UnitInterval
forall era s t. Access era s t
No)

gaPolicy :: Era era => Term era (Maybe ScriptHash)
gaPolicy :: forall era. Era era => Term era (Maybe ScriptHash)
gaPolicy = V era (Maybe ScriptHash) -> Term era (Maybe ScriptHash)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Maybe ScriptHash)
-> Access era Any (Maybe ScriptHash)
-> V era (Maybe ScriptHash)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"gaPolicy" (Rep era ScriptHash -> Rep era (Maybe ScriptHash)
forall era t1. Rep era t1 -> Rep era (Maybe t1)
MaybeR Rep era ScriptHash
forall era. Era era => Rep era ScriptHash
ScriptHashR) Access era Any (Maybe ScriptHash)
forall era s t. Access era s t
No)

gaConstitutionAnchor :: Era era => Term era Anchor
gaConstitutionAnchor :: forall era. Era era => Term era Anchor
gaConstitutionAnchor = V era Anchor -> Term era Anchor
forall era t. V era t -> Term era t
Var (String -> Rep era Anchor -> Access era Any Anchor -> V era Anchor
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"gaConstitutionAnchor" Rep era Anchor
forall era. Era era => Rep era Anchor
AnchorR Access era Any Anchor
forall era s t. Access era s t
No)

gaNewConstitution :: Era era => Term era (Constitution era)
gaNewConstitution :: forall era. Era era => Term era (Constitution era)
gaNewConstitution = V era (Constitution era) -> Term era (Constitution era)
forall era t. V era t -> Term era t
Var (String
-> Rep era (Constitution era)
-> Access era Any (Constitution era)
-> V era (Constitution era)
forall era t s.
Era era =>
String -> Rep era t -> Access era s t -> V era t
V String
"gaNewConstitution" Rep era (Constitution era)
forall era. Era era => Rep era (Constitution era)
ConstitutionR Access era Any (Constitution era)
forall era s t. Access era s t
No)

-- ===================================
-- The partial Targets, one for each constructor of GovAction

constitutionT :: forall era. Reflect era => RootTarget era (Constitution era) (Constitution era)
constitutionT :: forall era.
Reflect era =>
RootTarget era (Constitution era) (Constitution era)
constitutionT =
  String
-> TypeRep (Constitution era)
-> (Anchor -> Maybe ScriptHash -> Constitution era)
-> RootTarget
     era
     (Constitution era)
     (Anchor -> Maybe ScriptHash -> Constitution era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"Constitution" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(Constitution era)) (\Anchor
x Maybe ScriptHash
y -> Anchor -> StrictMaybe ScriptHash -> Constitution era
forall era. Anchor -> StrictMaybe ScriptHash -> Constitution era
Constitution Anchor
x (StrictMaybe ScriptHash -> Constitution era)
-> StrictMaybe ScriptHash -> Constitution era
forall a b. (a -> b) -> a -> b
$ Maybe ScriptHash -> StrictMaybe ScriptHash
forall a. Maybe a -> StrictMaybe a
maybeToStrictMaybe Maybe ScriptHash
y)
    RootTarget
  era
  (Constitution era)
  (Anchor -> Maybe ScriptHash -> Constitution era)
-> RootTarget era (Constitution era) Anchor
-> RootTarget
     era (Constitution era) (Maybe ScriptHash -> Constitution era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era Anchor
-> SimpleGetter (Constitution era) Anchor
-> RootTarget era (Constitution era) Anchor
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era Anchor
forall era. Era era => Term era Anchor
gaConstitutionAnchor (Anchor -> Const r Anchor)
-> Constitution era -> Const r (Constitution era)
SimpleGetter (Constitution era) Anchor
forall era (f :: * -> *).
Functor f =>
(Anchor -> f Anchor) -> Constitution era -> f (Constitution era)
constitutionAnchorL
    RootTarget
  era (Constitution era) (Maybe ScriptHash -> Constitution era)
-> RootTarget era (Constitution era) (Maybe ScriptHash)
-> RootTarget era (Constitution era) (Constitution era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Maybe ScriptHash)
-> SimpleGetter (Constitution era) (Maybe ScriptHash)
-> RootTarget era (Constitution era) (Maybe ScriptHash)
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed Term era (Maybe ScriptHash)
forall era. Era era => Term era (Maybe ScriptHash)
gaPolicy ((StrictMaybe ScriptHash -> Const r (StrictMaybe ScriptHash))
-> Constitution era -> Const r (Constitution era)
forall era (f :: * -> *).
Functor f =>
(StrictMaybe ScriptHash -> f (StrictMaybe ScriptHash))
-> Constitution era -> f (Constitution era)
constitutionScriptL ((StrictMaybe ScriptHash -> Const r (StrictMaybe ScriptHash))
 -> Constitution era -> Const r (Constitution era))
-> ((Maybe ScriptHash -> Const r (Maybe ScriptHash))
    -> StrictMaybe ScriptHash -> Const r (StrictMaybe ScriptHash))
-> (Maybe ScriptHash -> Const r (Maybe ScriptHash))
-> Constitution era
-> Const r (Constitution era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe ScriptHash -> Const r (Maybe ScriptHash))
-> StrictMaybe ScriptHash -> Const r (StrictMaybe ScriptHash)
forall x (f :: * -> *).
Functor f =>
(Maybe x -> f (Maybe x)) -> StrictMaybe x -> f (StrictMaybe x)
strictMaybeToMaybeL)

parameterChangeT :: forall era. Reflect era => RootTarget era (GovAction era) (GovAction era)
parameterChangeT :: forall era.
Reflect era =>
RootTarget era (GovAction era) (GovAction era)
parameterChangeT =
  String
-> TypeRep (GovAction era)
-> (Maybe GovActionId
    -> PParamsUpdateF era -> Maybe ScriptHash -> GovAction era)
-> RootTarget
     era
     (GovAction era)
     (Maybe GovActionId
      -> PParamsUpdateF era -> Maybe ScriptHash -> GovAction era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert
    String
"ParameterChange"
    (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(GovAction era))
    (\Maybe GovActionId
x PParamsUpdateF era
y Maybe ScriptHash
c -> StrictMaybe (GovPurposeId 'PParamUpdatePurpose era)
-> PParamsUpdate era -> StrictMaybe ScriptHash -> GovAction era
forall era.
StrictMaybe (GovPurposeId 'PParamUpdatePurpose era)
-> PParamsUpdate era -> StrictMaybe ScriptHash -> GovAction era
ParameterChange (Maybe GovActionId
-> StrictMaybe (GovPurposeId 'PParamUpdatePurpose era)
forall (p :: GovActionPurpose) era.
Maybe GovActionId -> StrictMaybe (GovPurposeId p era)
liftId Maybe GovActionId
x) (PParamsUpdateF era -> PParamsUpdate era
forall era. PParamsUpdateF era -> PParamsUpdate era
unPParamsUpdate PParamsUpdateF era
y) (Maybe ScriptHash -> StrictMaybe ScriptHash
forall a. Maybe a -> StrictMaybe a
maybeToStrictMaybe Maybe ScriptHash
c))
    RootTarget
  era
  (GovAction era)
  (Maybe GovActionId
   -> PParamsUpdateF era -> Maybe ScriptHash -> GovAction era)
-> RootTarget era (GovAction era) (Maybe GovActionId)
-> RootTarget
     era
     (GovAction era)
     (PParamsUpdateF era -> Maybe ScriptHash -> GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Maybe GovActionId)
-> (GovAction era -> Maybe (Maybe GovActionId))
-> RootTarget era (GovAction era) (Maybe GovActionId)
forall era t root.
Term era t -> (root -> Maybe t) -> RootTarget era root t
Partial Term era (Maybe GovActionId)
forall era. Era era => Term era (Maybe GovActionId)
gaPrevId (\case (ParameterChange StrictMaybe (GovPurposeId 'PParamUpdatePurpose era)
x PParamsUpdate era
_ StrictMaybe ScriptHash
_) -> Maybe GovActionId -> Maybe (Maybe GovActionId)
forall a. a -> Maybe a
Just (Maybe GovActionId -> Maybe (Maybe GovActionId))
-> Maybe GovActionId -> Maybe (Maybe GovActionId)
forall a b. (a -> b) -> a -> b
$ StrictMaybe (GovPurposeId 'PParamUpdatePurpose era)
-> Maybe GovActionId
forall (p :: GovActionPurpose) era.
StrictMaybe (GovPurposeId p era) -> Maybe GovActionId
dropId StrictMaybe (GovPurposeId 'PParamUpdatePurpose era)
x; GovAction era
_ -> Maybe (Maybe GovActionId)
forall a. Maybe a
Nothing)
    RootTarget
  era
  (GovAction era)
  (PParamsUpdateF era -> Maybe ScriptHash -> GovAction era)
-> RootTarget era (GovAction era) (PParamsUpdateF era)
-> RootTarget
     era (GovAction era) (Maybe ScriptHash -> GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (PParamsUpdateF era)
-> (GovAction era -> Maybe (PParamsUpdateF era))
-> RootTarget era (GovAction era) (PParamsUpdateF era)
forall era t root.
Term era t -> (root -> Maybe t) -> RootTarget era root t
Partial
      Term era (PParamsUpdateF era)
forall era. Reflect era => Term era (PParamsUpdateF era)
gaPParamsUpdate
      (\case (ParameterChange StrictMaybe (GovPurposeId 'PParamUpdatePurpose era)
_ PParamsUpdate era
y StrictMaybe ScriptHash
_) -> PParamsUpdateF era -> Maybe (PParamsUpdateF era)
forall a. a -> Maybe a
Just (PParamsUpdateF era -> Maybe (PParamsUpdateF era))
-> PParamsUpdateF era -> Maybe (PParamsUpdateF era)
forall a b. (a -> b) -> a -> b
$ Proof era -> PParamsUpdate era -> PParamsUpdateF era
forall era. Proof era -> PParamsUpdate era -> PParamsUpdateF era
PParamsUpdateF Proof era
forall era. Reflect era => Proof era
reify PParamsUpdate era
y; GovAction era
_ -> Maybe (PParamsUpdateF era)
forall a. Maybe a
Nothing)
    RootTarget era (GovAction era) (Maybe ScriptHash -> GovAction era)
-> RootTarget era (GovAction era) (Maybe ScriptHash)
-> RootTarget era (GovAction era) (GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Maybe ScriptHash)
-> (GovAction era -> Maybe (Maybe ScriptHash))
-> RootTarget era (GovAction era) (Maybe ScriptHash)
forall era t root.
Term era t -> (root -> Maybe t) -> RootTarget era root t
Partial Term era (Maybe ScriptHash)
forall era. Era era => Term era (Maybe ScriptHash)
gaPolicy (\case (ParameterChange StrictMaybe (GovPurposeId 'PParamUpdatePurpose era)
_ PParamsUpdate era
_ StrictMaybe ScriptHash
x) -> Maybe ScriptHash -> Maybe (Maybe ScriptHash)
forall a. a -> Maybe a
Just (Maybe ScriptHash -> Maybe (Maybe ScriptHash))
-> Maybe ScriptHash -> Maybe (Maybe ScriptHash)
forall a b. (a -> b) -> a -> b
$ StrictMaybe ScriptHash -> Maybe ScriptHash
forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe StrictMaybe ScriptHash
x; GovAction era
_ -> Maybe (Maybe ScriptHash)
forall a. Maybe a
Nothing)

hardForkInitiationT :: forall era. Reflect era => RootTarget era (GovAction era) (GovAction era)
hardForkInitiationT :: forall era.
Reflect era =>
RootTarget era (GovAction era) (GovAction era)
hardForkInitiationT =
  String
-> TypeRep (GovAction era)
-> (Maybe GovActionId -> ProtVer -> GovAction era)
-> RootTarget
     era (GovAction era) (Maybe GovActionId -> ProtVer -> GovAction era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"HardForkInitiation" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(GovAction era)) (\Maybe GovActionId
x ProtVer
y -> StrictMaybe (GovPurposeId 'HardForkPurpose era)
-> ProtVer -> GovAction era
forall era.
StrictMaybe (GovPurposeId 'HardForkPurpose era)
-> ProtVer -> GovAction era
HardForkInitiation (Maybe GovActionId
-> StrictMaybe (GovPurposeId 'HardForkPurpose era)
forall (p :: GovActionPurpose) era.
Maybe GovActionId -> StrictMaybe (GovPurposeId p era)
liftId Maybe GovActionId
x) ProtVer
y)
    RootTarget
  era (GovAction era) (Maybe GovActionId -> ProtVer -> GovAction era)
-> RootTarget era (GovAction era) (Maybe GovActionId)
-> RootTarget era (GovAction era) (ProtVer -> GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Maybe GovActionId)
-> (GovAction era -> Maybe (Maybe GovActionId))
-> RootTarget era (GovAction era) (Maybe GovActionId)
forall era t root.
Term era t -> (root -> Maybe t) -> RootTarget era root t
Partial Term era (Maybe GovActionId)
forall era. Era era => Term era (Maybe GovActionId)
gaPrevId (\case (HardForkInitiation StrictMaybe (GovPurposeId 'HardForkPurpose era)
x ProtVer
_) -> Maybe GovActionId -> Maybe (Maybe GovActionId)
forall a. a -> Maybe a
Just (Maybe GovActionId -> Maybe (Maybe GovActionId))
-> Maybe GovActionId -> Maybe (Maybe GovActionId)
forall a b. (a -> b) -> a -> b
$ StrictMaybe (GovPurposeId 'HardForkPurpose era)
-> Maybe GovActionId
forall (p :: GovActionPurpose) era.
StrictMaybe (GovPurposeId p era) -> Maybe GovActionId
dropId StrictMaybe (GovPurposeId 'HardForkPurpose era)
x; GovAction era
_ -> Maybe (Maybe GovActionId)
forall a. Maybe a
Nothing)
    RootTarget era (GovAction era) (ProtVer -> GovAction era)
-> RootTarget era (GovAction era) ProtVer
-> RootTarget era (GovAction era) (GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era ProtVer
-> (GovAction era -> Maybe ProtVer)
-> RootTarget era (GovAction era) ProtVer
forall era t root.
Term era t -> (root -> Maybe t) -> RootTarget era root t
Partial Term era ProtVer
forall era. Reflect era => Term era ProtVer
gaProtVer (\case (HardForkInitiation StrictMaybe (GovPurposeId 'HardForkPurpose era)
_ ProtVer
y) -> ProtVer -> Maybe ProtVer
forall a. a -> Maybe a
Just ProtVer
y; GovAction era
_ -> Maybe ProtVer
forall a. Maybe a
Nothing)

treasuryWithdrawalsT :: forall era. Reflect era => RootTarget era (GovAction era) (GovAction era)
treasuryWithdrawalsT :: forall era.
Reflect era =>
RootTarget era (GovAction era) (GovAction era)
treasuryWithdrawalsT =
  String
-> TypeRep (GovAction era)
-> (Map RewardAccount Coin -> Maybe ScriptHash -> GovAction era)
-> RootTarget
     era
     (GovAction era)
     (Map RewardAccount Coin -> Maybe ScriptHash -> GovAction era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert
    String
"TreasuryWithdrawals"
    (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(GovAction era))
    (\Map RewardAccount Coin
x Maybe ScriptHash
y -> Map RewardAccount Coin -> StrictMaybe ScriptHash -> GovAction era
forall era.
Map RewardAccount Coin -> StrictMaybe ScriptHash -> GovAction era
TreasuryWithdrawals Map RewardAccount Coin
x (StrictMaybe ScriptHash -> GovAction era)
-> StrictMaybe ScriptHash -> GovAction era
forall a b. (a -> b) -> a -> b
$ Maybe ScriptHash -> StrictMaybe ScriptHash
forall a. Maybe a -> StrictMaybe a
maybeToStrictMaybe Maybe ScriptHash
y)
    RootTarget
  era
  (GovAction era)
  (Map RewardAccount Coin -> Maybe ScriptHash -> GovAction era)
-> RootTarget era (GovAction era) (Map RewardAccount Coin)
-> RootTarget
     era (GovAction era) (Maybe ScriptHash -> GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map RewardAccount Coin)
-> (GovAction era -> Maybe (Map RewardAccount Coin))
-> RootTarget era (GovAction era) (Map RewardAccount Coin)
forall era t root.
Term era t -> (root -> Maybe t) -> RootTarget era root t
Partial Term era (Map RewardAccount Coin)
forall era. Era era => Term era (Map RewardAccount Coin)
gaRewardAccount (\case (TreasuryWithdrawals Map RewardAccount Coin
x StrictMaybe ScriptHash
_) -> Map RewardAccount Coin -> Maybe (Map RewardAccount Coin)
forall a. a -> Maybe a
Just Map RewardAccount Coin
x; GovAction era
_ -> Maybe (Map RewardAccount Coin)
forall a. Maybe a
Nothing)
    RootTarget era (GovAction era) (Maybe ScriptHash -> GovAction era)
-> RootTarget era (GovAction era) (Maybe ScriptHash)
-> RootTarget era (GovAction era) (GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Maybe ScriptHash)
-> (GovAction era -> Maybe (Maybe ScriptHash))
-> RootTarget era (GovAction era) (Maybe ScriptHash)
forall era t root.
Term era t -> (root -> Maybe t) -> RootTarget era root t
Partial Term era (Maybe ScriptHash)
forall era. Era era => Term era (Maybe ScriptHash)
gaPolicy (\case (TreasuryWithdrawals Map RewardAccount Coin
_ StrictMaybe ScriptHash
y) -> Maybe ScriptHash -> Maybe (Maybe ScriptHash)
forall a. a -> Maybe a
Just (Maybe ScriptHash -> Maybe (Maybe ScriptHash))
-> Maybe ScriptHash -> Maybe (Maybe ScriptHash)
forall a b. (a -> b) -> a -> b
$ StrictMaybe ScriptHash -> Maybe ScriptHash
forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe StrictMaybe ScriptHash
y; GovAction era
_ -> Maybe (Maybe ScriptHash)
forall a. Maybe a
Nothing)

noConfidenceT :: forall era. Reflect era => RootTarget era (GovAction era) (GovAction era)
noConfidenceT :: forall era.
Reflect era =>
RootTarget era (GovAction era) (GovAction era)
noConfidenceT =
  String
-> TypeRep (GovAction era)
-> (Maybe GovActionId -> GovAction era)
-> RootTarget
     era (GovAction era) (Maybe GovActionId -> GovAction era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"NoConfidence" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(GovAction era)) (\Maybe GovActionId
x -> StrictMaybe (GovPurposeId 'CommitteePurpose era) -> GovAction era
forall era.
StrictMaybe (GovPurposeId 'CommitteePurpose era) -> GovAction era
NoConfidence (Maybe GovActionId
-> StrictMaybe (GovPurposeId 'CommitteePurpose era)
forall (p :: GovActionPurpose) era.
Maybe GovActionId -> StrictMaybe (GovPurposeId p era)
liftId Maybe GovActionId
x))
    RootTarget era (GovAction era) (Maybe GovActionId -> GovAction era)
-> RootTarget era (GovAction era) (Maybe GovActionId)
-> RootTarget era (GovAction era) (GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Maybe GovActionId)
-> (GovAction era -> Maybe (Maybe GovActionId))
-> RootTarget era (GovAction era) (Maybe GovActionId)
forall era t root.
Term era t -> (root -> Maybe t) -> RootTarget era root t
Partial Term era (Maybe GovActionId)
forall era. Era era => Term era (Maybe GovActionId)
gaPrevId (\case (NoConfidence StrictMaybe (GovPurposeId 'CommitteePurpose era)
x) -> Maybe GovActionId -> Maybe (Maybe GovActionId)
forall a. a -> Maybe a
Just (Maybe GovActionId -> Maybe (Maybe GovActionId))
-> Maybe GovActionId -> Maybe (Maybe GovActionId)
forall a b. (a -> b) -> a -> b
$ StrictMaybe (GovPurposeId 'CommitteePurpose era)
-> Maybe GovActionId
forall (p :: GovActionPurpose) era.
StrictMaybe (GovPurposeId p era) -> Maybe GovActionId
dropId StrictMaybe (GovPurposeId 'CommitteePurpose era)
x; GovAction era
_ -> Maybe (Maybe GovActionId)
forall a. Maybe a
Nothing)

updateCommitteeT :: forall era. Reflect era => RootTarget era (GovAction era) (GovAction era)
updateCommitteeT :: forall era.
Reflect era =>
RootTarget era (GovAction era) (GovAction era)
updateCommitteeT =
  String
-> TypeRep (GovAction era)
-> (Maybe GovActionId
    -> Set (Credential 'ColdCommitteeRole)
    -> Map (Credential 'ColdCommitteeRole) EpochNo
    -> UnitInterval
    -> GovAction era)
-> RootTarget
     era
     (GovAction era)
     (Maybe GovActionId
      -> Set (Credential 'ColdCommitteeRole)
      -> Map (Credential 'ColdCommitteeRole) EpochNo
      -> UnitInterval
      -> GovAction era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"UpdateCommittee" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(GovAction era)) (\Maybe GovActionId
w Set (Credential 'ColdCommitteeRole)
x Map (Credential 'ColdCommitteeRole) EpochNo
y UnitInterval
z -> StrictMaybe (GovPurposeId 'CommitteePurpose era)
-> Set (Credential 'ColdCommitteeRole)
-> Map (Credential 'ColdCommitteeRole) EpochNo
-> UnitInterval
-> GovAction era
forall era.
StrictMaybe (GovPurposeId 'CommitteePurpose era)
-> Set (Credential 'ColdCommitteeRole)
-> Map (Credential 'ColdCommitteeRole) EpochNo
-> UnitInterval
-> GovAction era
UpdateCommittee (Maybe GovActionId
-> StrictMaybe (GovPurposeId 'CommitteePurpose era)
forall (p :: GovActionPurpose) era.
Maybe GovActionId -> StrictMaybe (GovPurposeId p era)
liftId Maybe GovActionId
w) Set (Credential 'ColdCommitteeRole)
x Map (Credential 'ColdCommitteeRole) EpochNo
y UnitInterval
z)
    RootTarget
  era
  (GovAction era)
  (Maybe GovActionId
   -> Set (Credential 'ColdCommitteeRole)
   -> Map (Credential 'ColdCommitteeRole) EpochNo
   -> UnitInterval
   -> GovAction era)
-> RootTarget era (GovAction era) (Maybe GovActionId)
-> RootTarget
     era
     (GovAction era)
     (Set (Credential 'ColdCommitteeRole)
      -> Map (Credential 'ColdCommitteeRole) EpochNo
      -> UnitInterval
      -> GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Maybe GovActionId)
-> (GovAction era -> Maybe (Maybe GovActionId))
-> RootTarget era (GovAction era) (Maybe GovActionId)
forall era t root.
Term era t -> (root -> Maybe t) -> RootTarget era root t
Partial Term era (Maybe GovActionId)
forall era. Era era => Term era (Maybe GovActionId)
gaPrevId (\case (UpdateCommittee StrictMaybe (GovPurposeId 'CommitteePurpose era)
x Set (Credential 'ColdCommitteeRole)
_ Map (Credential 'ColdCommitteeRole) EpochNo
_ UnitInterval
_) -> Maybe GovActionId -> Maybe (Maybe GovActionId)
forall a. a -> Maybe a
Just (Maybe GovActionId -> Maybe (Maybe GovActionId))
-> Maybe GovActionId -> Maybe (Maybe GovActionId)
forall a b. (a -> b) -> a -> b
$ StrictMaybe (GovPurposeId 'CommitteePurpose era)
-> Maybe GovActionId
forall (p :: GovActionPurpose) era.
StrictMaybe (GovPurposeId p era) -> Maybe GovActionId
dropId StrictMaybe (GovPurposeId 'CommitteePurpose era)
x; GovAction era
_ -> Maybe (Maybe GovActionId)
forall a. Maybe a
Nothing)
    RootTarget
  era
  (GovAction era)
  (Set (Credential 'ColdCommitteeRole)
   -> Map (Credential 'ColdCommitteeRole) EpochNo
   -> UnitInterval
   -> GovAction era)
-> RootTarget
     era (GovAction era) (Set (Credential 'ColdCommitteeRole))
-> RootTarget
     era
     (GovAction era)
     (Map (Credential 'ColdCommitteeRole) EpochNo
      -> UnitInterval -> GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Set (Credential 'ColdCommitteeRole))
-> (GovAction era -> Maybe (Set (Credential 'ColdCommitteeRole)))
-> RootTarget
     era (GovAction era) (Set (Credential 'ColdCommitteeRole))
forall era t root.
Term era t -> (root -> Maybe t) -> RootTarget era root t
Partial Term era (Set (Credential 'ColdCommitteeRole))
forall era.
Era era =>
Term era (Set (Credential 'ColdCommitteeRole))
gaRemMember (\case (UpdateCommittee StrictMaybe (GovPurposeId 'CommitteePurpose era)
_ Set (Credential 'ColdCommitteeRole)
x Map (Credential 'ColdCommitteeRole) EpochNo
_ UnitInterval
_) -> Set (Credential 'ColdCommitteeRole)
-> Maybe (Set (Credential 'ColdCommitteeRole))
forall a. a -> Maybe a
Just Set (Credential 'ColdCommitteeRole)
x; GovAction era
_ -> Maybe (Set (Credential 'ColdCommitteeRole))
forall a. Maybe a
Nothing)
    RootTarget
  era
  (GovAction era)
  (Map (Credential 'ColdCommitteeRole) EpochNo
   -> UnitInterval -> GovAction era)
-> RootTarget
     era (GovAction era) (Map (Credential 'ColdCommitteeRole) EpochNo)
-> RootTarget era (GovAction era) (UnitInterval -> GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Map (Credential 'ColdCommitteeRole) EpochNo)
-> (GovAction era
    -> Maybe (Map (Credential 'ColdCommitteeRole) EpochNo))
-> RootTarget
     era (GovAction era) (Map (Credential 'ColdCommitteeRole) EpochNo)
forall era t root.
Term era t -> (root -> Maybe t) -> RootTarget era root t
Partial Term era (Map (Credential 'ColdCommitteeRole) EpochNo)
forall era.
Era era =>
Term era (Map (Credential 'ColdCommitteeRole) EpochNo)
gaAddMember (\case (UpdateCommittee StrictMaybe (GovPurposeId 'CommitteePurpose era)
_ Set (Credential 'ColdCommitteeRole)
_ Map (Credential 'ColdCommitteeRole) EpochNo
x UnitInterval
_) -> Map (Credential 'ColdCommitteeRole) EpochNo
-> Maybe (Map (Credential 'ColdCommitteeRole) EpochNo)
forall a. a -> Maybe a
Just Map (Credential 'ColdCommitteeRole) EpochNo
x; GovAction era
_ -> Maybe (Map (Credential 'ColdCommitteeRole) EpochNo)
forall a. Maybe a
Nothing)
    RootTarget era (GovAction era) (UnitInterval -> GovAction era)
-> RootTarget era (GovAction era) UnitInterval
-> RootTarget era (GovAction era) (GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era UnitInterval
-> (GovAction era -> Maybe UnitInterval)
-> RootTarget era (GovAction era) UnitInterval
forall era t root.
Term era t -> (root -> Maybe t) -> RootTarget era root t
Partial Term era UnitInterval
forall era. Era era => Term era UnitInterval
gaThreshold (\case (UpdateCommittee StrictMaybe (GovPurposeId 'CommitteePurpose era)
_ Set (Credential 'ColdCommitteeRole)
_ Map (Credential 'ColdCommitteeRole) EpochNo
_ UnitInterval
x) -> UnitInterval -> Maybe UnitInterval
forall a. a -> Maybe a
Just UnitInterval
x; GovAction era
_ -> Maybe UnitInterval
forall a. Maybe a
Nothing)

newConstitutionT :: forall era. Reflect era => RootTarget era (GovAction era) (GovAction era)
newConstitutionT :: forall era.
Reflect era =>
RootTarget era (GovAction era) (GovAction era)
newConstitutionT =
  String
-> TypeRep (GovAction era)
-> (Maybe GovActionId -> Constitution era -> GovAction era)
-> RootTarget
     era
     (GovAction era)
     (Maybe GovActionId -> Constitution era -> GovAction era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"NewConstitution" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(GovAction era)) (\Maybe GovActionId
x Constitution era
y -> StrictMaybe (GovPurposeId 'ConstitutionPurpose era)
-> Constitution era -> GovAction era
forall era.
StrictMaybe (GovPurposeId 'ConstitutionPurpose era)
-> Constitution era -> GovAction era
NewConstitution (Maybe GovActionId
-> StrictMaybe (GovPurposeId 'ConstitutionPurpose era)
forall (p :: GovActionPurpose) era.
Maybe GovActionId -> StrictMaybe (GovPurposeId p era)
liftId Maybe GovActionId
x) Constitution era
y)
    RootTarget
  era
  (GovAction era)
  (Maybe GovActionId -> Constitution era -> GovAction era)
-> RootTarget era (GovAction era) (Maybe GovActionId)
-> RootTarget
     era (GovAction era) (Constitution era -> GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Maybe GovActionId)
-> (GovAction era -> Maybe (Maybe GovActionId))
-> RootTarget era (GovAction era) (Maybe GovActionId)
forall era t root.
Term era t -> (root -> Maybe t) -> RootTarget era root t
Partial Term era (Maybe GovActionId)
forall era. Era era => Term era (Maybe GovActionId)
gaPrevId (\case (UpdateCommittee StrictMaybe (GovPurposeId 'CommitteePurpose era)
x Set (Credential 'ColdCommitteeRole)
_ Map (Credential 'ColdCommitteeRole) EpochNo
_ UnitInterval
_) -> Maybe GovActionId -> Maybe (Maybe GovActionId)
forall a. a -> Maybe a
Just (Maybe GovActionId -> Maybe (Maybe GovActionId))
-> Maybe GovActionId -> Maybe (Maybe GovActionId)
forall a b. (a -> b) -> a -> b
$ StrictMaybe (GovPurposeId 'CommitteePurpose era)
-> Maybe GovActionId
forall (p :: GovActionPurpose) era.
StrictMaybe (GovPurposeId p era) -> Maybe GovActionId
dropId StrictMaybe (GovPurposeId 'CommitteePurpose era)
x; GovAction era
_ -> Maybe (Maybe GovActionId)
forall a. Maybe a
Nothing)
    RootTarget era (GovAction era) (Constitution era -> GovAction era)
-> RootTarget era (GovAction era) (Constitution era)
-> RootTarget era (GovAction era) (GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era (Constitution era)
-> (GovAction era -> Maybe (Constitution era))
-> RootTarget era (GovAction era) (Constitution era)
forall era t root.
Term era t -> (root -> Maybe t) -> RootTarget era root t
Partial Term era (Constitution era)
forall era. Era era => Term era (Constitution era)
gaNewConstitution (\case (NewConstitution StrictMaybe (GovPurposeId 'ConstitutionPurpose era)
_ Constitution era
y) -> Constitution era -> Maybe (Constitution era)
forall a. a -> Maybe a
Just Constitution era
y; GovAction era
_ -> Maybe (Constitution era)
forall a. Maybe a
Nothing)

infoActionT :: forall era. Reflect era => RootTarget era (GovAction era) (GovAction era)
infoActionT :: forall era.
Reflect era =>
RootTarget era (GovAction era) (GovAction era)
infoActionT =
  String
-> TypeRep (GovAction era)
-> (() -> GovAction era)
-> RootTarget era (GovAction era) (() -> GovAction era)
forall root a b era.
String -> TypeRep root -> (a -> b) -> RootTarget era root (a -> b)
Invert String
"InfoAction" (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(GovAction era)) (\() -> GovAction era
forall era. GovAction era
InfoAction)
    RootTarget era (GovAction era) (() -> GovAction era)
-> RootTarget era (GovAction era) ()
-> RootTarget era (GovAction era) (GovAction era)
forall era root a t.
RootTarget era root (a -> t)
-> RootTarget era root a -> RootTarget era root t
:$ Term era ()
-> SimpleGetter (GovAction era) ()
-> RootTarget era (GovAction era) ()
forall era t root.
Term era t -> SimpleGetter root t -> RootTarget era root t
Lensed (Rep era () -> () -> Term era ()
forall era t. Rep era t -> t -> Term era t
Lit Rep era ()
forall era. Rep era ()
UnitR ()) ((GovAction era -> ()) -> SimpleGetter (GovAction era) ()
forall s a. (s -> a) -> SimpleGetter s a
to (() -> GovAction era -> ()
forall a b. a -> b -> a
const ()))