{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# 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.Compactible (Compactible (..))
import Cardano.Ledger.Conway.Era (ConwayEra)
import Cardano.Ledger.Conway.State.Account (ConwayEraAccounts)
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, (&), (.~), (^.))
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 ((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 instance Eq (Accounts era) => Eq (ConwayCertState era)

deriving instance Show (Accounts era) => Show (ConwayCertState era)

deriving via
  KeyValuePairs (ConwayCertState era)
  instance
    ToJSON (Accounts era) => ToJSON (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, ConwayEraAccounts 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 ToJSON (Accounts era) => 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 {DState era
PState 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 :: CompactForm Coin -> DRepState -> CompactForm Coin
accum CompactForm Coin
ans DRepState
drepState = CompactForm Coin
ans CompactForm Coin -> CompactForm Coin -> CompactForm Coin
forall a. Semigroup a => a -> a -> a
<> DRepState -> CompactForm Coin
drepDeposit DRepState
drepState
   in (CertState era -> Obligations
forall era. EraCertState era => CertState era -> Obligations
shelleyObligationCertState CertState era
certState)
        { oblDRep = fromCompact $ F.foldl' accum mempty (certState ^. certVStateL . vsDRepsL)
        }

conwayCertsTotalDepositsTxBody ::
  EraTxBody era => PParams era -> ConwayCertState era -> TxBody l era -> Coin
conwayCertsTotalDepositsTxBody :: forall era (l :: TxLevel).
EraTxBody era =>
PParams era -> ConwayCertState era -> TxBody l 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 l era -> Coin
forall era (l :: TxLevel).
EraTxBody era =>
PParams era -> (KeyHash StakePool -> Bool) -> TxBody l era -> Coin
forall (l :: TxLevel).
PParams era -> (KeyHash StakePool -> Bool) -> TxBody l era -> Coin
getTotalDepositsTxBody PParams era
pp (KeyHash StakePool -> Map (KeyHash StakePool) StakePoolState -> Bool
forall k a. Ord k => k -> Map k a -> Bool
`Map.member` PState era -> Map (KeyHash StakePool) StakePoolState
forall era. PState era -> Map (KeyHash StakePool) StakePoolState
psStakePools PState era
conwayCertPState)

conwayCertsTotalRefundsTxBody ::
  (EraTxBody era, EraAccounts era) => PParams era -> ConwayCertState era -> TxBody l era -> Coin
conwayCertsTotalRefundsTxBody :: forall era (l :: TxLevel).
(EraTxBody era, EraAccounts era) =>
PParams era -> ConwayCertState era -> TxBody l 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 l era
-> Coin
forall era (l :: TxLevel).
EraTxBody era =>
PParams era
-> (Credential Staking -> Maybe Coin)
-> (Credential DRepRole -> Maybe Coin)
-> TxBody l era
-> Coin
forall (l :: TxLevel).
PParams era
-> (Credential Staking -> Maybe Coin)
-> (Credential DRepRole -> Maybe Coin)
-> TxBody l era
-> Coin
getTotalRefundsTxBody
    PParams era
pp
    (DState era -> Credential Staking -> Maybe Coin
forall era.
EraAccounts 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 :: forall (t :: TxLevel).
EraTxBody ConwayEra =>
PParams ConwayEra
-> CertState ConwayEra -> TxBody t ConwayEra -> Coin
certsTotalDepositsTxBody = PParams ConwayEra
-> CertState ConwayEra -> TxBody t ConwayEra -> Coin
PParams ConwayEra
-> ConwayCertState ConwayEra -> TxBody t ConwayEra -> Coin
forall era (l :: TxLevel).
EraTxBody era =>
PParams era -> ConwayCertState era -> TxBody l era -> Coin
conwayCertsTotalDepositsTxBody

  certsTotalRefundsTxBody :: forall (t :: TxLevel).
EraTxBody ConwayEra =>
PParams ConwayEra
-> CertState ConwayEra -> TxBody t ConwayEra -> Coin
certsTotalRefundsTxBody = PParams ConwayEra
-> CertState ConwayEra -> TxBody t ConwayEra -> Coin
PParams ConwayEra
-> ConwayCertState ConwayEra -> TxBody t ConwayEra -> Coin
forall era (l :: TxLevel).
(EraTxBody era, EraAccounts era) =>
PParams era -> ConwayCertState era -> TxBody l 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 EraAccounts 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 EraAccounts 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
    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))
    conwayCertPState <-
      decSharePlusLensCBOR $
        lens (\(Interns (Credential Staking)
_, Interns (KeyHash StakePool)
ks, Interns (Credential DRepRole)
_, Interns (Credential HotCommitteeRole)
_) -> (Interns (VRFVerKeyHash StakePoolVRF)
forall a. Monoid a => a
mempty, Interns (KeyHash StakePool)
ks)) (\(Interns (Credential Staking)
cs, Interns (KeyHash StakePool)
_, Interns (Credential DRepRole)
cd, Interns (Credential HotCommitteeRole)
ch) (Interns (VRFVerKeyHash StakePoolVRF)
_, Interns (KeyHash StakePool)
ks) -> (Interns (Credential Staking)
cs, Interns (KeyHash StakePool)
ks, Interns (Credential DRepRole)
cd, Interns (Credential HotCommitteeRole)
ch))
    conwayCertDState <-
      decSharePlusLensCBOR $
        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))
    pure ConwayCertState {..}

instance Default (Accounts era) => 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 (Accounts era)) => NoThunks (ConwayCertState era)

instance (Era era, NFData (Accounts era)) => NFData (ConwayCertState era)