{-# 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, (&), (.~), (^.), _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 ((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 {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 :: 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 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, EraAccounts era) => PParams era -> ConwayCertState era -> TxBody era -> Coin
conwayCertsTotalRefundsTxBody :: forall era.
(EraTxBody era, EraAccounts 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.
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 :: 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, EraAccounts 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 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
    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 (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)