{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableSuperClasses #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Ledger.Conway.State.CertState (
  ConwayCertState (..),
  ConwayEraCertState (..),
  csCommitteeCredsL,
  epochStateRegDrepL,
  mkConwayCertState,
  conwayCertDStateL,
  conwayCertPStateL,
  conwayCertVStateL,
  conwayObligationCertState,
  conwayCertsTotalDepositsTxBody,
  conwayCertsTotalRefundsTxBody,
) where

import Cardano.Ledger.BaseTypes (KeyValuePairs (..), ToKeyValuePairs (..))
import Cardano.Ledger.Binary (
  DecShareCBOR (..),
  EncCBOR (..),
  Interns,
  decSharePlusLensCBOR,
  decodeRecordNamedT,
  encodeListLen,
 )
import Cardano.Ledger.Coin (Coin (..))
import Cardano.Ledger.Conway.Era (ConwayEra)
import Cardano.Ledger.Conway.State.VState
import Cardano.Ledger.Core
import Cardano.Ledger.Credential (Credential (..))
import Cardano.Ledger.Shelley.LedgerState (EpochState (..), esLStateL, lsCertStateL)
import Cardano.Ledger.Shelley.State
import Control.DeepSeq (NFData (..))
import Data.Aeson (ToJSON (..), (.=))
import Data.Default (Default (def))
import qualified Data.Foldable as F
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import GHC.Generics (Generic)
import Lens.Micro (Lens', lens, (&), (.~), (^.), _2)
import NoThunks.Class (NoThunks (..))

data ConwayCertState era = ConwayCertState
  { forall era. ConwayCertState era -> VState era
conwayCertVState :: !(VState era)
  , forall era. ConwayCertState era -> PState era
conwayCertPState :: !(PState era)
  , forall era. ConwayCertState era -> DState era
conwayCertDState :: !(DState era)
  }
  deriving (Int -> ConwayCertState era -> ShowS
[ConwayCertState era] -> ShowS
ConwayCertState era -> String
(Int -> ConwayCertState era -> ShowS)
-> (ConwayCertState era -> String)
-> ([ConwayCertState era] -> ShowS)
-> Show (ConwayCertState era)
forall era. Int -> ConwayCertState era -> ShowS
forall era. [ConwayCertState era] -> ShowS
forall era. ConwayCertState era -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall era. Int -> ConwayCertState era -> ShowS
showsPrec :: Int -> ConwayCertState era -> ShowS
$cshow :: forall era. ConwayCertState era -> String
show :: ConwayCertState era -> String
$cshowList :: forall era. [ConwayCertState era] -> ShowS
showList :: [ConwayCertState era] -> ShowS
Show, ConwayCertState era -> ConwayCertState era -> Bool
(ConwayCertState era -> ConwayCertState era -> Bool)
-> (ConwayCertState era -> ConwayCertState era -> Bool)
-> Eq (ConwayCertState era)
forall era. ConwayCertState era -> ConwayCertState era -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall era. ConwayCertState era -> ConwayCertState era -> Bool
== :: ConwayCertState era -> ConwayCertState era -> Bool
$c/= :: forall era. ConwayCertState era -> ConwayCertState era -> Bool
/= :: ConwayCertState era -> ConwayCertState era -> Bool
Eq, (forall x. ConwayCertState era -> Rep (ConwayCertState era) x)
-> (forall x. Rep (ConwayCertState era) x -> ConwayCertState era)
-> Generic (ConwayCertState era)
forall x. Rep (ConwayCertState era) x -> ConwayCertState era
forall x. ConwayCertState era -> Rep (ConwayCertState era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall era x. Rep (ConwayCertState era) x -> ConwayCertState era
forall era x. ConwayCertState era -> Rep (ConwayCertState era) x
$cfrom :: forall era x. ConwayCertState era -> Rep (ConwayCertState era) x
from :: forall x. ConwayCertState era -> Rep (ConwayCertState era) x
$cto :: forall era x. Rep (ConwayCertState era) x -> ConwayCertState era
to :: forall x. Rep (ConwayCertState era) x -> ConwayCertState era
Generic)
  deriving ([ConwayCertState era] -> Value
[ConwayCertState era] -> Encoding
ConwayCertState era -> Bool
ConwayCertState era -> Value
ConwayCertState era -> Encoding
(ConwayCertState era -> Value)
-> (ConwayCertState era -> Encoding)
-> ([ConwayCertState era] -> Value)
-> ([ConwayCertState era] -> Encoding)
-> (ConwayCertState era -> Bool)
-> ToJSON (ConwayCertState era)
forall era. [ConwayCertState era] -> Value
forall era. [ConwayCertState era] -> Encoding
forall era. ConwayCertState era -> Bool
forall era. ConwayCertState era -> Value
forall era. ConwayCertState era -> Encoding
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: forall era. ConwayCertState era -> Value
toJSON :: ConwayCertState era -> Value
$ctoEncoding :: forall era. ConwayCertState era -> Encoding
toEncoding :: ConwayCertState era -> Encoding
$ctoJSONList :: forall era. [ConwayCertState era] -> Value
toJSONList :: [ConwayCertState era] -> Value
$ctoEncodingList :: forall era. [ConwayCertState era] -> Encoding
toEncodingList :: [ConwayCertState era] -> Encoding
$comitField :: forall era. ConwayCertState era -> Bool
omitField :: ConwayCertState era -> Bool
ToJSON) via KeyValuePairs (ConwayCertState era)

-- ===================================
-- VState

csCommitteeCredsL ::
  Lens' (CommitteeState era) (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
csCommitteeCredsL :: forall era (f :: * -> *).
Functor f =>
(Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
 -> f (Map (Credential 'ColdCommitteeRole) CommitteeAuthorization))
-> CommitteeState era -> f (CommitteeState era)
csCommitteeCredsL = (CommitteeState era
 -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization)
-> (CommitteeState era
    -> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
    -> CommitteeState era)
-> Lens
     (CommitteeState era)
     (CommitteeState 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
cs Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
u -> CommitteeState era
cs {csCommitteeCreds = u})

epochStateRegDrepL ::
  ConwayEraCertState era => Lens' (EpochState era) (Map (Credential 'DRepRole) DRepState)
epochStateRegDrepL :: forall era.
ConwayEraCertState era =>
Lens' (EpochState era) (Map (Credential 'DRepRole) DRepState)
epochStateRegDrepL = (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

class EraCertState era => ConwayEraCertState era where
  certVStateL :: Lens' (CertState era) (VState era)

mkConwayCertState ::
  ConwayEraCertState era => VState era -> PState era -> DState era -> CertState era
mkConwayCertState :: forall era.
ConwayEraCertState era =>
VState era -> PState era -> DState era -> CertState era
mkConwayCertState VState era
v PState era
p DState era
d =
  PState era -> DState era -> CertState era
forall era.
EraCertState era =>
PState era -> DState era -> CertState era
mkShelleyCertState PState era
p DState era
d CertState era -> (CertState era -> CertState era) -> CertState era
forall a b. a -> (a -> b) -> b
& (VState era -> Identity (VState era))
-> CertState era -> Identity (CertState era)
forall era.
ConwayEraCertState era =>
Lens' (CertState era) (VState era)
Lens' (CertState era) (VState era)
certVStateL ((VState era -> Identity (VState era))
 -> CertState era -> Identity (CertState era))
-> VState era -> CertState era -> CertState era
forall s t a b. ASetter s t a b -> b -> s -> t
.~ VState era
v

conwayCertDStateL :: Lens' (ConwayCertState era) (DState era)
conwayCertDStateL :: forall era (f :: * -> *).
Functor f =>
(DState era -> f (DState era))
-> ConwayCertState era -> f (ConwayCertState era)
conwayCertDStateL = (ConwayCertState era -> DState era)
-> (ConwayCertState era -> DState era -> ConwayCertState era)
-> Lens
     (ConwayCertState era)
     (ConwayCertState era)
     (DState era)
     (DState era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ConwayCertState era -> DState era
forall era. ConwayCertState era -> DState era
conwayCertDState (\ConwayCertState era
ds DState era
u -> ConwayCertState era
ds {conwayCertDState = u})
{-# INLINE conwayCertDStateL #-}

conwayCertPStateL :: Lens' (ConwayCertState era) (PState era)
conwayCertPStateL :: forall era (f :: * -> *).
Functor f =>
(PState era -> f (PState era))
-> ConwayCertState era -> f (ConwayCertState era)
conwayCertPStateL = (ConwayCertState era -> PState era)
-> (ConwayCertState era -> PState era -> ConwayCertState era)
-> Lens
     (ConwayCertState era)
     (ConwayCertState era)
     (PState era)
     (PState era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ConwayCertState era -> PState era
forall era. ConwayCertState era -> PState era
conwayCertPState (\ConwayCertState era
ds PState era
u -> ConwayCertState era
ds {conwayCertPState = u})
{-# INLINE conwayCertPStateL #-}

conwayCertVStateL :: Lens' (ConwayCertState era) (VState era)
conwayCertVStateL :: forall era (f :: * -> *).
Functor f =>
(VState era -> f (VState era))
-> ConwayCertState era -> f (ConwayCertState era)
conwayCertVStateL = (ConwayCertState era -> VState era)
-> (ConwayCertState era -> VState era -> ConwayCertState era)
-> Lens
     (ConwayCertState era)
     (ConwayCertState era)
     (VState era)
     (VState era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ConwayCertState era -> VState era
forall era. ConwayCertState era -> VState era
conwayCertVState (\ConwayCertState era
ds VState era
u -> ConwayCertState era
ds {conwayCertVState = u})
{-# INLINE conwayCertVStateL #-}

instance ToKeyValuePairs (ConwayCertState era) where
  toKeyValuePairs :: forall e kv. KeyValue e kv => ConwayCertState era -> [kv]
toKeyValuePairs certState :: ConwayCertState era
certState@(ConwayCertState VState era
_ PState era
_ DState era
_) =
    let ConwayCertState {PState era
DState era
VState era
conwayCertVState :: forall era. ConwayCertState era -> VState era
conwayCertPState :: forall era. ConwayCertState era -> PState era
conwayCertDState :: forall era. ConwayCertState era -> DState era
conwayCertVState :: VState era
conwayCertPState :: PState era
conwayCertDState :: DState era
..} = ConwayCertState era
certState
     in [ Key
"dstate" Key -> DState era -> kv
forall v. ToJSON v => Key -> v -> kv
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= DState era
conwayCertDState
        , Key
"pstate" Key -> PState era -> kv
forall v. ToJSON v => Key -> v -> kv
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= PState era
conwayCertPState
        , Key
"vstate" Key -> VState era -> kv
forall v. ToJSON v => Key -> v -> kv
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= VState era
conwayCertVState
        ]

conwayObligationCertState :: ConwayEraCertState era => CertState era -> Obligations
conwayObligationCertState :: forall era. ConwayEraCertState era => CertState era -> Obligations
conwayObligationCertState CertState era
certState =
  let accum :: Coin -> DRepState -> Coin
accum Coin
ans DRepState
drepState = Coin
ans Coin -> Coin -> Coin
forall a. Semigroup a => a -> a -> a
<> DRepState -> Coin
drepDeposit DRepState
drepState
   in (CertState era -> Obligations
forall era. EraCertState era => CertState era -> Obligations
shelleyObligationCertState CertState era
certState)
        { oblDRep = F.foldl' accum (Coin 0) (certState ^. certVStateL . vsDRepsL)
        }

conwayCertsTotalDepositsTxBody ::
  EraTxBody era => PParams era -> ConwayCertState era -> TxBody era -> Coin
conwayCertsTotalDepositsTxBody :: forall era.
EraTxBody era =>
PParams era -> ConwayCertState era -> TxBody era -> Coin
conwayCertsTotalDepositsTxBody PParams era
pp ConwayCertState {PState era
conwayCertPState :: forall era. ConwayCertState era -> PState era
conwayCertPState :: PState era
conwayCertPState} =
  PParams era -> (KeyHash 'StakePool -> Bool) -> TxBody era -> Coin
forall era.
EraTxBody era =>
PParams era -> (KeyHash 'StakePool -> Bool) -> TxBody era -> Coin
getTotalDepositsTxBody PParams era
pp (KeyHash 'StakePool -> Map (KeyHash 'StakePool) PoolParams -> Bool
forall k a. Ord k => k -> Map k a -> Bool
`Map.member` PState era -> Map (KeyHash 'StakePool) PoolParams
forall era. PState era -> Map (KeyHash 'StakePool) PoolParams
psStakePoolParams PState era
conwayCertPState)

conwayCertsTotalRefundsTxBody ::
  EraTxBody era => PParams era -> ConwayCertState era -> TxBody era -> Coin
conwayCertsTotalRefundsTxBody :: forall era.
EraTxBody era =>
PParams era -> ConwayCertState era -> TxBody era -> Coin
conwayCertsTotalRefundsTxBody PParams era
pp ConwayCertState {DState era
conwayCertDState :: forall era. ConwayCertState era -> DState era
conwayCertDState :: DState era
conwayCertDState, VState era
conwayCertVState :: forall era. ConwayCertState era -> VState era
conwayCertVState :: VState era
conwayCertVState} =
  PParams era
-> (Credential 'Staking -> Maybe Coin)
-> (Credential 'DRepRole -> Maybe Coin)
-> TxBody era
-> Coin
forall era.
EraTxBody era =>
PParams era
-> (Credential 'Staking -> Maybe Coin)
-> (Credential 'DRepRole -> Maybe Coin)
-> TxBody era
-> Coin
getTotalRefundsTxBody
    PParams era
pp
    (DState era -> Credential 'Staking -> Maybe Coin
forall era. DState era -> Credential 'Staking -> Maybe Coin
lookupDepositDState DState era
conwayCertDState)
    (VState era -> Credential 'DRepRole -> Maybe Coin
forall era. VState era -> Credential 'DRepRole -> Maybe Coin
lookupDepositVState VState era
conwayCertVState)

instance EraCertState ConwayEra where
  type CertState ConwayEra = ConwayCertState ConwayEra

  certDStateL :: Lens' (CertState ConwayEra) (DState ConwayEra)
certDStateL = (DState ConwayEra -> f (DState ConwayEra))
-> CertState ConwayEra -> f (CertState ConwayEra)
(DState ConwayEra -> f (DState ConwayEra))
-> ConwayCertState ConwayEra -> f (ConwayCertState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(DState era -> f (DState era))
-> ConwayCertState era -> f (ConwayCertState era)
conwayCertDStateL
  {-# INLINE certDStateL #-}

  certPStateL :: Lens' (CertState ConwayEra) (PState ConwayEra)
certPStateL = (PState ConwayEra -> f (PState ConwayEra))
-> CertState ConwayEra -> f (CertState ConwayEra)
(PState ConwayEra -> f (PState ConwayEra))
-> ConwayCertState ConwayEra -> f (ConwayCertState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(PState era -> f (PState era))
-> ConwayCertState era -> f (ConwayCertState era)
conwayCertPStateL
  {-# INLINE certPStateL #-}

  obligationCertState :: CertState ConwayEra -> Obligations
obligationCertState = CertState ConwayEra -> Obligations
forall era. ConwayEraCertState era => CertState era -> Obligations
conwayObligationCertState

  certsTotalDepositsTxBody :: EraTxBody ConwayEra =>
PParams ConwayEra
-> CertState ConwayEra -> TxBody ConwayEra -> Coin
certsTotalDepositsTxBody = PParams ConwayEra
-> CertState ConwayEra -> TxBody ConwayEra -> Coin
PParams ConwayEra
-> ConwayCertState ConwayEra -> TxBody ConwayEra -> Coin
forall era.
EraTxBody era =>
PParams era -> ConwayCertState era -> TxBody era -> Coin
conwayCertsTotalDepositsTxBody

  certsTotalRefundsTxBody :: EraTxBody ConwayEra =>
PParams ConwayEra
-> CertState ConwayEra -> TxBody ConwayEra -> Coin
certsTotalRefundsTxBody = PParams ConwayEra
-> CertState ConwayEra -> TxBody ConwayEra -> Coin
PParams ConwayEra
-> ConwayCertState ConwayEra -> TxBody ConwayEra -> Coin
forall era.
EraTxBody era =>
PParams era -> ConwayCertState era -> TxBody era -> Coin
conwayCertsTotalRefundsTxBody

instance ConwayEraCertState ConwayEra where
  certVStateL :: Lens' (CertState ConwayEra) (VState ConwayEra)
certVStateL = (VState ConwayEra -> f (VState ConwayEra))
-> CertState ConwayEra -> f (CertState ConwayEra)
(VState ConwayEra -> f (VState ConwayEra))
-> ConwayCertState ConwayEra -> f (ConwayCertState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(VState era -> f (VState era))
-> ConwayCertState era -> f (ConwayCertState era)
conwayCertVStateL
  {-# INLINE certVStateL #-}

instance Era era => EncCBOR (ConwayCertState era) where
  encCBOR :: ConwayCertState era -> Encoding
encCBOR ConwayCertState {PState era
conwayCertPState :: forall era. ConwayCertState era -> PState era
conwayCertPState :: PState era
conwayCertPState, DState era
conwayCertDState :: forall era. ConwayCertState era -> DState era
conwayCertDState :: DState era
conwayCertDState, VState era
conwayCertVState :: forall era. ConwayCertState era -> VState era
conwayCertVState :: VState era
conwayCertVState} =
    Word -> Encoding
encodeListLen Word
3
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> VState era -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR VState era
conwayCertVState
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> PState era -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR PState era
conwayCertPState
      Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> DState era -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR DState era
conwayCertDState

instance Era era => DecShareCBOR (ConwayCertState era) where
  type
    Share (ConwayCertState era) =
      ( Interns (Credential 'Staking)
      , Interns (KeyHash 'StakePool)
      , Interns (Credential 'DRepRole)
      , Interns (Credential 'HotCommitteeRole)
      )
  decSharePlusCBOR :: forall s.
StateT
  (Share (ConwayCertState era)) (Decoder s) (ConwayCertState era)
decSharePlusCBOR = Text
-> (ConwayCertState era -> Int)
-> StateT
     (Share (ConwayCertState era)) (Decoder s) (ConwayCertState era)
-> StateT
     (Share (ConwayCertState era)) (Decoder s) (ConwayCertState era)
forall (m :: (* -> *) -> * -> *) s a.
(MonadTrans m, Monad (m (Decoder s))) =>
Text -> (a -> Int) -> m (Decoder s) a -> m (Decoder s) a
decodeRecordNamedT Text
"ConwayCertState" (Int -> ConwayCertState era -> Int
forall a b. a -> b -> a
const Int
3) (StateT
   (Share (ConwayCertState era)) (Decoder s) (ConwayCertState era)
 -> StateT
      (Share (ConwayCertState era)) (Decoder s) (ConwayCertState era))
-> StateT
     (Share (ConwayCertState era)) (Decoder s) (ConwayCertState era)
-> StateT
     (Share (ConwayCertState era)) (Decoder s) (ConwayCertState era)
forall a b. (a -> b) -> a -> b
$ do
    VState era
conwayCertVState <-
      Lens'
  (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
   Interns (Credential 'DRepRole),
   Interns (Credential 'HotCommitteeRole))
  (Share (VState era))
-> StateT
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
     (Decoder s)
     (VState era)
forall b bs s.
DecShareCBOR b =>
Lens' bs (Share b) -> StateT bs (Decoder s) b
decSharePlusLensCBOR (Lens'
   (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
    Interns (Credential 'DRepRole),
    Interns (Credential 'HotCommitteeRole))
   (Share (VState era))
 -> StateT
      (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
       Interns (Credential 'DRepRole),
       Interns (Credential 'HotCommitteeRole))
      (Decoder s)
      (VState era))
-> Lens'
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
     (Share (VState era))
-> StateT
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
     (Decoder s)
     (VState era)
forall a b. (a -> b) -> a -> b
$
        ((Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
  Interns (Credential 'DRepRole),
  Interns (Credential 'HotCommitteeRole))
 -> (Interns (Credential 'Staking), Interns (Credential 'DRepRole),
     Interns (Credential 'HotCommitteeRole)))
-> ((Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
     Interns (Credential 'DRepRole),
     Interns (Credential 'HotCommitteeRole))
    -> (Interns (Credential 'Staking), Interns (Credential 'DRepRole),
        Interns (Credential 'HotCommitteeRole))
    -> (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
        Interns (Credential 'DRepRole),
        Interns (Credential 'HotCommitteeRole)))
-> Lens
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
     (Interns (Credential 'Staking), Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
     (Interns (Credential 'Staking), Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (\(Interns (Credential 'Staking)
cs, Interns (KeyHash 'StakePool)
_, Interns (Credential 'DRepRole)
cd, Interns (Credential 'HotCommitteeRole)
ch) -> (Interns (Credential 'Staking)
cs, Interns (Credential 'DRepRole)
cd, Interns (Credential 'HotCommitteeRole)
ch)) (\(Interns (Credential 'Staking)
_, Interns (KeyHash 'StakePool)
ks, Interns (Credential 'DRepRole)
_, Interns (Credential 'HotCommitteeRole)
_) (Interns (Credential 'Staking)
cs, Interns (Credential 'DRepRole)
cd, Interns (Credential 'HotCommitteeRole)
ch) -> (Interns (Credential 'Staking)
cs, Interns (KeyHash 'StakePool)
ks, Interns (Credential 'DRepRole)
cd, Interns (Credential 'HotCommitteeRole)
ch))
    PState era
conwayCertPState <- Lens'
  (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
   Interns (Credential 'DRepRole),
   Interns (Credential 'HotCommitteeRole))
  (Share (PState era))
-> StateT
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
     (Decoder s)
     (PState era)
forall b bs s.
DecShareCBOR b =>
Lens' bs (Share b) -> StateT bs (Decoder s) b
decSharePlusLensCBOR (Share (PState era) -> f (Share (PState era)))
-> (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
    Interns (Credential 'DRepRole),
    Interns (Credential 'HotCommitteeRole))
-> f (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
(Interns (KeyHash 'StakePool) -> f (Interns (KeyHash 'StakePool)))
-> (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
    Interns (Credential 'DRepRole),
    Interns (Credential 'HotCommitteeRole))
-> f (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
forall s t a b. Field2 s t a b => Lens s t a b
Lens'
  (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
   Interns (Credential 'DRepRole),
   Interns (Credential 'HotCommitteeRole))
  (Share (PState era))
Lens
  (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
   Interns (Credential 'DRepRole),
   Interns (Credential 'HotCommitteeRole))
  (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
   Interns (Credential 'DRepRole),
   Interns (Credential 'HotCommitteeRole))
  (Interns (KeyHash 'StakePool))
  (Interns (KeyHash 'StakePool))
_2
    DState era
conwayCertDState <-
      Lens'
  (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
   Interns (Credential 'DRepRole),
   Interns (Credential 'HotCommitteeRole))
  (Share (DState era))
-> StateT
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
     (Decoder s)
     (DState era)
forall b bs s.
DecShareCBOR b =>
Lens' bs (Share b) -> StateT bs (Decoder s) b
decSharePlusLensCBOR (Lens'
   (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
    Interns (Credential 'DRepRole),
    Interns (Credential 'HotCommitteeRole))
   (Share (DState era))
 -> StateT
      (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
       Interns (Credential 'DRepRole),
       Interns (Credential 'HotCommitteeRole))
      (Decoder s)
      (DState era))
-> Lens'
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
     (Share (DState era))
-> StateT
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
     (Decoder s)
     (DState era)
forall a b. (a -> b) -> a -> b
$
        ((Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
  Interns (Credential 'DRepRole),
  Interns (Credential 'HotCommitteeRole))
 -> (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
     Interns (Credential 'DRepRole)))
-> ((Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
     Interns (Credential 'DRepRole),
     Interns (Credential 'HotCommitteeRole))
    -> (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
        Interns (Credential 'DRepRole))
    -> (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
        Interns (Credential 'DRepRole),
        Interns (Credential 'HotCommitteeRole)))
-> Lens
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole))
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens (\(Interns (Credential 'Staking)
cs, Interns (KeyHash 'StakePool)
ks, Interns (Credential 'DRepRole)
cd, Interns (Credential 'HotCommitteeRole)
_) -> (Interns (Credential 'Staking)
cs, Interns (KeyHash 'StakePool)
ks, Interns (Credential 'DRepRole)
cd)) (\(Interns (Credential 'Staking)
_, Interns (KeyHash 'StakePool)
_, Interns (Credential 'DRepRole)
_, Interns (Credential 'HotCommitteeRole)
ch) (Interns (Credential 'Staking)
cs, Interns (KeyHash 'StakePool)
ks, Interns (Credential 'DRepRole)
cd) -> (Interns (Credential 'Staking)
cs, Interns (KeyHash 'StakePool)
ks, Interns (Credential 'DRepRole)
cd, Interns (Credential 'HotCommitteeRole)
ch))
    ConwayCertState era
-> StateT
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
     (Decoder s)
     (ConwayCertState era)
forall a.
a
-> StateT
     (Interns (Credential 'Staking), Interns (KeyHash 'StakePool),
      Interns (Credential 'DRepRole),
      Interns (Credential 'HotCommitteeRole))
     (Decoder s)
     a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ConwayCertState {PState era
DState era
VState era
conwayCertVState :: VState era
conwayCertPState :: PState era
conwayCertDState :: DState era
conwayCertVState :: VState era
conwayCertPState :: PState era
conwayCertDState :: DState era
..}

instance Default (ConwayCertState era) where
  def :: ConwayCertState era
def = VState era -> PState era -> DState era -> ConwayCertState era
forall era.
VState era -> PState era -> DState era -> ConwayCertState era
ConwayCertState VState era
forall a. Default a => a
def PState era
forall a. Default a => a
def DState era
forall a. Default a => a
def

instance Era era => NoThunks (ConwayCertState era)

instance Era era => NFData (ConwayCertState era)