{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Ledger.CanonicalState.Conway.Export () where

import Cardano.Ledger.BaseTypes (StrictMaybe (..), strictMaybeToMaybe)
import Cardano.Ledger.CanonicalState.Conway (
  fromGovActionState,
  mkCanonicalAccountState,
  mkCanonicalConstitution,
  mkCanonicalGovActionId,
 )
import Cardano.Ledger.CanonicalState.Export (
  ExportCanonicalNamespace (..),
  ExportCanonicalState (..),
  addNamespaceToPlan,
 )
import Cardano.Ledger.CanonicalState.Namespace.Blocks.V0 (BlockIn (BlockIn), BlockOut (BlockOut))
import Cardano.Ledger.CanonicalState.Namespace.EntitiesAccounts.V0 (
  EntitiesAccountsIn (EntitiesAccountsIn),
  EntitiesAccountsOut (EntitiesAccountsOut),
 )
import Cardano.Ledger.CanonicalState.Namespace.EntitiesCommittee.V0 (
  CanonicalCommitteeState (..),
  EntitiesCommitteeIn (..),
  EntitiesCommitteeOut (..),
  mkCanonicalCommitteeAuthorization,
 )
import Cardano.Ledger.CanonicalState.Namespace.EntitiesDReps.V0 (
  EntitiesDRepsIn (EntitiesDRepsIn),
  EntitiesDRepsOut (EntitiesDRepsOut),
  mkCanonicalDRepState,
 )
import Cardano.Ledger.CanonicalState.Namespace.EntitiesStakePools.V0 (
  CanonicalStakePool (..),
  EntitiesStakePoolsIn (..),
  EntitiesStakePoolsOut (..),
  mkCanonicalStakePoolParams,
  mkCanonicalStakePoolState,
 )
import Cardano.Ledger.CanonicalState.Namespace.EntitiesStakePools.VRFKeyHashes.V0 (
  EntitiesStakePoolsVRFKeyHashesIn (EntitiesStakePoolsVRFKeyHashesIn),
  EntitiesStakePoolsVRFKeyHashesOut (EntitiesStakePoolsVRFKeyHashesOut),
 )
import Cardano.Ledger.CanonicalState.Namespace.GovCommittee.V0 (
  CanonicalCommittee (..),
  GovCommitteeIn (..),
  GovCommitteeOut (..),
 )
import Cardano.Ledger.CanonicalState.Namespace.GovConstitution.V0 (
  GovConstitutionIn (..),
  GovConstitutionOut (..),
 )
import Cardano.Ledger.CanonicalState.Namespace.GovPParams.V0 (
  GovPParamsIn (..),
  GovPParamsOut (..),
 )
import Cardano.Ledger.CanonicalState.Namespace.GovProposals.Roots.V0 (
  GovProposalsRootsIn (..),
  GovProposalsRootsOut (GovProposalsRootsOut),
 )
import Cardano.Ledger.CanonicalState.Namespace.UTxO.V0 (UtxoIn (UtxoKeyIn), mkUtxo)
import Cardano.Ledger.Conway (ConwayEra)
import Cardano.Ledger.Conway.Governance (
  Committee (..),
  ConwayEraGov (constitutionGovStateL),
  GovPurposeId (unGovPurposeId),
  cgsCommitteeL,
  cgsProposalsL,
  grCommitteeL,
  grConstitutionL,
  grHardForkL,
  grPParamUpdateL,
  pRootsL,
  proposalsActions,
  toPrevGovActionIds,
 )
import Cardano.Ledger.Conway.Rules (updateDormantDRepExpiry)
import Cardano.Ledger.Conway.State (
  CanGetUTxO (utxoG),
  CanSetAccounts (accountsL),
  ConwayEraCertState (certVStateL),
  EraAccounts (accountsMapL),
  EraCertState (certDStateL, certPStateL),
  FuturePParams (..),
  UTxO (unUTxO),
  csCommitteeCredsL,
  psFutureStakePoolParamsL,
  psRetiringL,
  psStakePoolsL,
  psVRFKeyHashesL,
  vsCommitteeStateL,
  vsDRepsL,
 )
import Cardano.Ledger.Shelley.LedgerState (
  NewEpochState,
  curPParamsEpochStateL,
  esLStateL,
  futurePParamsEpochStateL,
  lsCertStateL,
  nesBcurL,
  nesELL,
  nesEpochStateL,
  nesEsL,
  newEpochStateGovStateL,
  prevPParamsEpochStateL,
 )
import Cardano.SCLS.Internal.Entry.ChunkEntry (ChunkEntry (ChunkEntry))
import Cardano.SCLS.Internal.Serializer.Dump.Plan (
  defaultSerializationPlan,
 )
import Data.Foldable (Foldable (toList))
import Data.Functor ((<&>))
import qualified Data.Map.Merge.Strict as Map
import qualified Data.Map.Strict as Map
import Lens.Micro ((%~), (&), (^.))
import qualified Streaming.Prelude as S

instance ExportCanonicalNamespace ConwayEra "utxo/v0" where
  canonicalNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry (NamespaceKey "utxo/v0") (NamespaceEntry "utxo/v0")))
     m
     ()
canonicalNamespaceEntries State ConwayEra
nes =
    [(TxIn, TxOut ConwayEra)]
-> Stream (Of (TxIn, TxOut ConwayEra)) m ()
forall (m :: * -> *) (f :: * -> *) a.
(Monad m, Foldable f) =>
f a -> Stream (Of a) m ()
S.each (Map TxIn (TxOut ConwayEra) -> [(TxIn, TxOut ConwayEra)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map TxIn (TxOut ConwayEra) -> [(TxIn, TxOut ConwayEra)])
-> Map TxIn (TxOut ConwayEra) -> [(TxIn, TxOut ConwayEra)]
forall a b. (a -> b) -> a -> b
$ UTxO ConwayEra -> Map TxIn (TxOut ConwayEra)
forall era. UTxO era -> Map TxIn (TxOut era)
unUTxO (UTxO ConwayEra -> Map TxIn (TxOut ConwayEra))
-> UTxO ConwayEra -> Map TxIn (TxOut ConwayEra)
forall a b. (a -> b) -> a -> b
$ NewEpochState ConwayEra
State ConwayEra
nes NewEpochState ConwayEra
-> Getting
     (UTxO ConwayEra) (NewEpochState ConwayEra) (UTxO ConwayEra)
-> UTxO ConwayEra
forall s a. s -> Getting a s a -> a
^. Getting (UTxO ConwayEra) (NewEpochState ConwayEra) (UTxO ConwayEra)
forall era. SimpleGetter (NewEpochState era) (UTxO era)
forall (t :: * -> *) era.
CanGetUTxO t =>
SimpleGetter (t era) (UTxO era)
utxoG)
      Stream (Of (TxIn, TxOut ConwayEra)) m ()
-> (Stream (Of (TxIn, TxOut ConwayEra)) m ()
    -> Stream (Of (ChunkEntry UtxoIn (UtxoOut ConwayEra))) m ())
-> Stream (Of (ChunkEntry UtxoIn (UtxoOut ConwayEra))) m ()
forall a b. a -> (a -> b) -> b
& ((TxIn, TxOut ConwayEra) -> ChunkEntry UtxoIn (UtxoOut ConwayEra))
-> Stream (Of (TxIn, TxOut ConwayEra)) m ()
-> Stream (Of (ChunkEntry UtxoIn (UtxoOut ConwayEra))) m ()
forall (m :: * -> *) a b r.
Monad m =>
(a -> b) -> Stream (Of a) m r -> Stream (Of b) m r
S.map (\(TxIn
txIn, TxOut ConwayEra
txOut) -> UtxoIn
-> UtxoOut ConwayEra -> ChunkEntry UtxoIn (UtxoOut ConwayEra)
forall k v. k -> v -> ChunkEntry k v
ChunkEntry (TxIn -> UtxoIn
UtxoKeyIn TxIn
txIn) (TxOut ConwayEra -> UtxoOut ConwayEra
forall era. EraTxOut era => TxOut era -> UtxoOut era
mkUtxo TxOut ConwayEra
txOut))

instance ExportCanonicalNamespace ConwayEra "blocks/v0" where
  canonicalNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "blocks/v0") (NamespaceEntry "blocks/v0")))
     m
     ()
canonicalNamespaceEntries State ConwayEra
nes = Stream (Of (ChunkEntry BlockIn BlockOut)) m ()
Stream
  (Of
     (ChunkEntry
        (NamespaceKey "blocks/v0") (NamespaceEntry "blocks/v0")))
  m
  ()
blocks
    where
      epochNo :: EpochNo
epochNo = NewEpochState ConwayEra
State ConwayEra
nes NewEpochState ConwayEra
-> Getting EpochNo (NewEpochState ConwayEra) EpochNo -> EpochNo
forall s a. s -> Getting a s a -> a
^. Getting EpochNo (NewEpochState ConwayEra) EpochNo
forall era (f :: * -> *).
Functor f =>
(EpochNo -> f EpochNo)
-> NewEpochState era -> f (NewEpochState era)
nesELL
      blocks :: Stream (Of (ChunkEntry BlockIn BlockOut)) m ()
blocks =
        [(KeyHash StakePool, Natural)]
-> Stream (Of (KeyHash StakePool, Natural)) m ()
forall (m :: * -> *) (f :: * -> *) a.
(Monad m, Foldable f) =>
f a -> Stream (Of a) m ()
S.each (Map (KeyHash StakePool) Natural -> [(KeyHash StakePool, Natural)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map (KeyHash StakePool) Natural -> [(KeyHash StakePool, Natural)])
-> Map (KeyHash StakePool) Natural
-> [(KeyHash StakePool, Natural)]
forall a b. (a -> b) -> a -> b
$ NewEpochState ConwayEra
State ConwayEra
nes NewEpochState ConwayEra
-> Getting
     (Map (KeyHash StakePool) Natural)
     (NewEpochState ConwayEra)
     (Map (KeyHash StakePool) Natural)
-> Map (KeyHash StakePool) Natural
forall s a. s -> Getting a s a -> a
^. Getting
  (Map (KeyHash StakePool) Natural)
  (NewEpochState ConwayEra)
  (Map (KeyHash StakePool) Natural)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash StakePool) Natural
 -> f (Map (KeyHash StakePool) Natural))
-> NewEpochState era -> f (NewEpochState era)
nesBcurL)
          Stream (Of (KeyHash StakePool, Natural)) m ()
-> (Stream (Of (KeyHash StakePool, Natural)) m ()
    -> Stream (Of (ChunkEntry BlockIn BlockOut)) m ())
-> Stream (Of (ChunkEntry BlockIn BlockOut)) m ()
forall a b. a -> (a -> b) -> b
& ((KeyHash StakePool, Natural) -> ChunkEntry BlockIn BlockOut)
-> Stream (Of (KeyHash StakePool, Natural)) m ()
-> Stream (Of (ChunkEntry BlockIn BlockOut)) m ()
forall (m :: * -> *) a b r.
Monad m =>
(a -> b) -> Stream (Of a) m r -> Stream (Of b) m r
S.map (\(KeyHash StakePool
keyHash, Natural
n) -> BlockIn -> BlockOut -> ChunkEntry BlockIn BlockOut
forall k v. k -> v -> ChunkEntry k v
ChunkEntry (KeyHash StakePool -> EpochNo -> BlockIn
BlockIn KeyHash StakePool
keyHash EpochNo
epochNo) (Natural -> BlockOut
BlockOut Natural
n))

instance ExportCanonicalNamespace ConwayEra "entities/committee/v0" where
  canonicalNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "entities/committee/v0")
           (NamespaceEntry "entities/committee/v0")))
     m
     ()
canonicalNamespaceEntries State ConwayEra
nes =
    ChunkEntry EntitiesCommitteeIn EntitiesCommitteeOut
-> Stream
     (Of (ChunkEntry EntitiesCommitteeIn EntitiesCommitteeOut)) m ()
forall (m :: * -> *) a. Monad m => a -> Stream (Of a) m ()
S.yield (EntitiesCommitteeIn
-> EntitiesCommitteeOut
-> ChunkEntry EntitiesCommitteeIn EntitiesCommitteeOut
forall k v. k -> v -> ChunkEntry k v
ChunkEntry EntitiesCommitteeIn
EntitiesCommitteeIn (CanonicalCommitteeState -> EntitiesCommitteeOut
EntitiesCommitteeOut CanonicalCommitteeState
committeeState))
    where
      committeeState :: CanonicalCommitteeState
committeeState =
        Map (Credential ColdCommitteeRole) CanonicalCommitteeAuthorization
-> CanonicalCommitteeState
CanonicalCommitteeState (Map (Credential ColdCommitteeRole) CanonicalCommitteeAuthorization
 -> CanonicalCommitteeState)
-> Map
     (Credential ColdCommitteeRole) CanonicalCommitteeAuthorization
-> CanonicalCommitteeState
forall a b. (a -> b) -> a -> b
$
          (CommitteeAuthorization -> CanonicalCommitteeAuthorization)
-> Map (Credential ColdCommitteeRole) CommitteeAuthorization
-> Map
     (Credential ColdCommitteeRole) CanonicalCommitteeAuthorization
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map CommitteeAuthorization -> CanonicalCommitteeAuthorization
mkCanonicalCommitteeAuthorization (Map (Credential ColdCommitteeRole) CommitteeAuthorization
 -> Map
      (Credential ColdCommitteeRole) CanonicalCommitteeAuthorization)
-> Map (Credential ColdCommitteeRole) CommitteeAuthorization
-> Map
     (Credential ColdCommitteeRole) CanonicalCommitteeAuthorization
forall a b. (a -> b) -> a -> b
$
            NewEpochState ConwayEra
State ConwayEra
nes
              NewEpochState ConwayEra
-> Getting
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
     (NewEpochState ConwayEra)
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
-> Map (Credential ColdCommitteeRole) CommitteeAuthorization
forall s a. s -> Getting a s a -> a
^. (EpochState ConwayEra
 -> Const
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
      (EpochState ConwayEra))
-> NewEpochState ConwayEra
-> Const
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
     (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEpochStateL
                ((EpochState ConwayEra
  -> Const
       (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
       (EpochState ConwayEra))
 -> NewEpochState ConwayEra
 -> Const
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
      (NewEpochState ConwayEra))
-> ((Map (Credential ColdCommitteeRole) CommitteeAuthorization
     -> Const
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
    -> EpochState ConwayEra
    -> Const
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
         (EpochState ConwayEra))
-> Getting
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
     (NewEpochState ConwayEra)
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState ConwayEra
 -> Const
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
      (LedgerState ConwayEra))
-> EpochState ConwayEra
-> Const
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
     (EpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL
                ((LedgerState ConwayEra
  -> Const
       (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
       (LedgerState ConwayEra))
 -> EpochState ConwayEra
 -> Const
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
      (EpochState ConwayEra))
-> ((Map (Credential ColdCommitteeRole) CommitteeAuthorization
     -> Const
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
    -> LedgerState ConwayEra
    -> Const
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
         (LedgerState ConwayEra))
-> (Map (Credential ColdCommitteeRole) CommitteeAuthorization
    -> Const
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
-> EpochState ConwayEra
-> Const
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
     (EpochState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState ConwayEra
 -> Const
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
      (CertState ConwayEra))
-> LedgerState ConwayEra
-> Const
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
     (LedgerState ConwayEra)
(ConwayCertState ConwayEra
 -> Const
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
      (ConwayCertState ConwayEra))
-> LedgerState ConwayEra
-> Const
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
     (LedgerState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL
                ((ConwayCertState ConwayEra
  -> Const
       (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
       (ConwayCertState ConwayEra))
 -> LedgerState ConwayEra
 -> Const
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
      (LedgerState ConwayEra))
-> ((Map (Credential ColdCommitteeRole) CommitteeAuthorization
     -> Const
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
    -> ConwayCertState ConwayEra
    -> Const
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
         (ConwayCertState ConwayEra))
-> (Map (Credential ColdCommitteeRole) CommitteeAuthorization
    -> Const
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
-> LedgerState ConwayEra
-> Const
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
     (LedgerState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VState ConwayEra
 -> Const
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
      (VState ConwayEra))
-> CertState ConwayEra
-> Const
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
     (CertState ConwayEra)
(VState ConwayEra
 -> Const
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
      (VState ConwayEra))
-> ConwayCertState ConwayEra
-> Const
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
     (ConwayCertState ConwayEra)
forall era.
ConwayEraCertState era =>
Lens' (CertState era) (VState era)
Lens' (CertState ConwayEra) (VState ConwayEra)
certVStateL
                ((VState ConwayEra
  -> Const
       (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
       (VState ConwayEra))
 -> ConwayCertState ConwayEra
 -> Const
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
      (ConwayCertState ConwayEra))
-> ((Map (Credential ColdCommitteeRole) CommitteeAuthorization
     -> Const
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
    -> VState ConwayEra
    -> Const
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
         (VState ConwayEra))
-> (Map (Credential ColdCommitteeRole) CommitteeAuthorization
    -> Const
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
-> ConwayCertState ConwayEra
-> Const
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
     (ConwayCertState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CommitteeState ConwayEra
 -> Const
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
      (CommitteeState ConwayEra))
-> VState ConwayEra
-> Const
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
     (VState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(CommitteeState era -> f (CommitteeState era))
-> VState era -> f (VState era)
vsCommitteeStateL
                ((CommitteeState ConwayEra
  -> Const
       (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
       (CommitteeState ConwayEra))
 -> VState ConwayEra
 -> Const
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
      (VState ConwayEra))
-> ((Map (Credential ColdCommitteeRole) CommitteeAuthorization
     -> Const
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
    -> CommitteeState ConwayEra
    -> Const
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
         (CommitteeState ConwayEra))
-> (Map (Credential ColdCommitteeRole) CommitteeAuthorization
    -> Const
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
-> VState ConwayEra
-> Const
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
     (VState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential ColdCommitteeRole) CommitteeAuthorization
 -> Const
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
-> CommitteeState ConwayEra
-> Const
     (Map (Credential ColdCommitteeRole) CommitteeAuthorization)
     (CommitteeState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Map (Credential ColdCommitteeRole) CommitteeAuthorization
 -> f (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
-> CommitteeState era -> f (CommitteeState era)
csCommitteeCredsL

instance ExportCanonicalNamespace ConwayEra "gov/committee/v0" where
  canonicalNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "gov/committee/v0")
           (NamespaceEntry "gov/committee/v0")))
     m
     ()
canonicalNamespaceEntries State ConwayEra
nes =
    ChunkEntry GovCommitteeIn GovCommitteeOut
-> Stream (Of (ChunkEntry GovCommitteeIn GovCommitteeOut)) m ()
forall (m :: * -> *) a. Monad m => a -> Stream (Of a) m ()
S.yield (GovCommitteeIn
-> GovCommitteeOut -> ChunkEntry GovCommitteeIn GovCommitteeOut
forall k v. k -> v -> ChunkEntry k v
ChunkEntry GovCommitteeIn
GovCommitteeIn (StrictMaybe CanonicalCommittee -> GovCommitteeOut
GovCommitteeOut StrictMaybe CanonicalCommittee
committee))
    where
      committee :: StrictMaybe CanonicalCommittee
committee =
        (Committee ConwayEra -> CanonicalCommittee)
-> StrictMaybe (Committee ConwayEra)
-> StrictMaybe CanonicalCommittee
forall a b. (a -> b) -> StrictMaybe a -> StrictMaybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
          (\Committee {Map (Credential ColdCommitteeRole) EpochNo
UnitInterval
committeeMembers :: Map (Credential ColdCommitteeRole) EpochNo
committeeThreshold :: UnitInterval
committeeThreshold :: forall era. Committee era -> UnitInterval
committeeMembers :: forall era.
Committee era -> Map (Credential ColdCommitteeRole) EpochNo
..} -> CanonicalCommittee {Map (Credential ColdCommitteeRole) EpochNo
committeeMembers :: Map (Credential ColdCommitteeRole) EpochNo
committeeMembers :: Map (Credential ColdCommitteeRole) EpochNo
committeeMembers, UnitInterval
committeeThreshold :: UnitInterval
committeeThreshold :: UnitInterval
committeeThreshold})
          (StrictMaybe (Committee ConwayEra)
 -> StrictMaybe CanonicalCommittee)
-> StrictMaybe (Committee ConwayEra)
-> StrictMaybe CanonicalCommittee
forall a b. (a -> b) -> a -> b
$ NewEpochState ConwayEra
State ConwayEra
nes
            NewEpochState ConwayEra
-> Getting
     (StrictMaybe (Committee ConwayEra))
     (NewEpochState ConwayEra)
     (StrictMaybe (Committee ConwayEra))
-> StrictMaybe (Committee ConwayEra)
forall s a. s -> Getting a s a -> a
^. (GovState ConwayEra
 -> Const (StrictMaybe (Committee ConwayEra)) (GovState ConwayEra))
-> NewEpochState ConwayEra
-> Const
     (StrictMaybe (Committee ConwayEra)) (NewEpochState ConwayEra)
(ConwayGovState ConwayEra
 -> Const
      (StrictMaybe (Committee ConwayEra)) (ConwayGovState ConwayEra))
-> NewEpochState ConwayEra
-> Const
     (StrictMaybe (Committee ConwayEra)) (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> NewEpochState era -> f (NewEpochState era)
newEpochStateGovStateL
              ((ConwayGovState ConwayEra
  -> Const
       (StrictMaybe (Committee ConwayEra)) (ConwayGovState ConwayEra))
 -> NewEpochState ConwayEra
 -> Const
      (StrictMaybe (Committee ConwayEra)) (NewEpochState ConwayEra))
-> ((StrictMaybe (Committee ConwayEra)
     -> Const
          (StrictMaybe (Committee ConwayEra))
          (StrictMaybe (Committee ConwayEra)))
    -> ConwayGovState ConwayEra
    -> Const
         (StrictMaybe (Committee ConwayEra)) (ConwayGovState ConwayEra))
-> Getting
     (StrictMaybe (Committee ConwayEra))
     (NewEpochState ConwayEra)
     (StrictMaybe (Committee ConwayEra))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StrictMaybe (Committee ConwayEra)
 -> Const
      (StrictMaybe (Committee ConwayEra))
      (StrictMaybe (Committee ConwayEra)))
-> ConwayGovState ConwayEra
-> Const
     (StrictMaybe (Committee ConwayEra)) (ConwayGovState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(StrictMaybe (Committee era) -> f (StrictMaybe (Committee era)))
-> ConwayGovState era -> f (ConwayGovState era)
cgsCommitteeL

instance ExportCanonicalNamespace ConwayEra "gov/constitution/v0" where
  canonicalNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "gov/constitution/v0")
           (NamespaceEntry "gov/constitution/v0")))
     m
     ()
canonicalNamespaceEntries State ConwayEra
nes =
    ChunkEntry GovConstitutionIn GovConstitutionOut
-> Stream
     (Of (ChunkEntry GovConstitutionIn GovConstitutionOut)) m ()
forall (m :: * -> *) a. Monad m => a -> Stream (Of a) m ()
S.yield (GovConstitutionIn
-> GovConstitutionOut
-> ChunkEntry GovConstitutionIn GovConstitutionOut
forall k v. k -> v -> ChunkEntry k v
ChunkEntry GovConstitutionIn
GovConstitutionIn (CanonicalConstitution -> GovConstitutionOut
GovConstitutionOut CanonicalConstitution
canonicalConstitution))
    where
      constitution :: Constitution ConwayEra
constitution = NewEpochState ConwayEra
State ConwayEra
nes NewEpochState ConwayEra
-> Getting
     (Constitution ConwayEra)
     (NewEpochState ConwayEra)
     (Constitution ConwayEra)
-> Constitution ConwayEra
forall s a. s -> Getting a s a -> a
^. (GovState ConwayEra
 -> Const (Constitution ConwayEra) (GovState ConwayEra))
-> NewEpochState ConwayEra
-> Const (Constitution ConwayEra) (NewEpochState ConwayEra)
(ConwayGovState ConwayEra
 -> Const (Constitution ConwayEra) (ConwayGovState ConwayEra))
-> NewEpochState ConwayEra
-> Const (Constitution ConwayEra) (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> NewEpochState era -> f (NewEpochState era)
newEpochStateGovStateL ((ConwayGovState ConwayEra
  -> Const (Constitution ConwayEra) (ConwayGovState ConwayEra))
 -> NewEpochState ConwayEra
 -> Const (Constitution ConwayEra) (NewEpochState ConwayEra))
-> ((Constitution ConwayEra
     -> Const (Constitution ConwayEra) (Constitution ConwayEra))
    -> ConwayGovState ConwayEra
    -> Const (Constitution ConwayEra) (ConwayGovState ConwayEra))
-> Getting
     (Constitution ConwayEra)
     (NewEpochState ConwayEra)
     (Constitution ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Constitution ConwayEra
 -> Const (Constitution ConwayEra) (Constitution ConwayEra))
-> GovState ConwayEra
-> Const (Constitution ConwayEra) (GovState ConwayEra)
(Constitution ConwayEra
 -> Const (Constitution ConwayEra) (Constitution ConwayEra))
-> ConwayGovState ConwayEra
-> Const (Constitution ConwayEra) (ConwayGovState ConwayEra)
forall era.
ConwayEraGov era =>
Lens' (GovState era) (Constitution era)
Lens' (GovState ConwayEra) (Constitution ConwayEra)
constitutionGovStateL
      canonicalConstitution :: CanonicalConstitution
canonicalConstitution = Constitution ConwayEra -> CanonicalConstitution
forall era. Constitution era -> CanonicalConstitution
mkCanonicalConstitution Constitution ConwayEra
constitution

instance ExportCanonicalNamespace ConwayEra "gov/pparams/v0" where
  canonicalNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "gov/pparams/v0") (NamespaceEntry "gov/pparams/v0")))
     m
     ()
canonicalNamespaceEntries State ConwayEra
nes =
    [ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)]
-> Stream
     (Of (ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra))) m ()
forall (m :: * -> *) (f :: * -> *) a.
(Monad m, Foldable f) =>
f a -> Stream (Of a) m ()
S.each [ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)]
pparams
    where
      epochState :: EpochState ConwayEra
epochState = NewEpochState ConwayEra
State ConwayEra
nes NewEpochState ConwayEra
-> Getting
     (EpochState ConwayEra)
     (NewEpochState ConwayEra)
     (EpochState ConwayEra)
-> EpochState ConwayEra
forall s a. s -> Getting a s a -> a
^. Getting
  (EpochState ConwayEra)
  (NewEpochState ConwayEra)
  (EpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL
      currPParams :: PParams ConwayEra
currPParams = EpochState ConwayEra
epochState EpochState ConwayEra
-> Getting
     (PParams ConwayEra) (EpochState ConwayEra) (PParams ConwayEra)
-> PParams ConwayEra
forall s a. s -> Getting a s a -> a
^. Getting
  (PParams ConwayEra) (EpochState ConwayEra) (PParams ConwayEra)
forall era. EraGov era => Lens' (EpochState era) (PParams era)
Lens' (EpochState ConwayEra) (PParams ConwayEra)
curPParamsEpochStateL
      prevPParams :: PParams ConwayEra
prevPParams = EpochState ConwayEra
epochState EpochState ConwayEra
-> Getting
     (PParams ConwayEra) (EpochState ConwayEra) (PParams ConwayEra)
-> PParams ConwayEra
forall s a. s -> Getting a s a -> a
^. Getting
  (PParams ConwayEra) (EpochState ConwayEra) (PParams ConwayEra)
forall era. EraGov era => Lens' (EpochState era) (PParams era)
Lens' (EpochState ConwayEra) (PParams ConwayEra)
prevPParamsEpochStateL
      ([ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)]
futurePossiblePParams, [ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)]
futureDefinitePParams) = case EpochState ConwayEra
epochState EpochState ConwayEra
-> Getting
     (FuturePParams ConwayEra)
     (EpochState ConwayEra)
     (FuturePParams ConwayEra)
-> FuturePParams ConwayEra
forall s a. s -> Getting a s a -> a
^. Getting
  (FuturePParams ConwayEra)
  (EpochState ConwayEra)
  (FuturePParams ConwayEra)
forall era.
EraGov era =>
Lens' (EpochState era) (FuturePParams era)
Lens' (EpochState ConwayEra) (FuturePParams ConwayEra)
futurePParamsEpochStateL of
        FuturePParams ConwayEra
NoPParamsUpdate -> ([], [])
        DefinitePParamsUpdate PParams ConwayEra
p -> ([], [GovPParamsIn
-> GovPParamsOut ConwayEra
-> ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)
forall k v. k -> v -> ChunkEntry k v
ChunkEntry GovPParamsIn
GovPParamsInDefiniteFuture (PParams ConwayEra -> GovPParamsOut ConwayEra
forall era. PParams era -> GovPParamsOut era
GovPParamsOut PParams ConwayEra
p)])
        PotentialPParamsUpdate (Just PParams ConwayEra
p) -> ([GovPParamsIn
-> GovPParamsOut ConwayEra
-> ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)
forall k v. k -> v -> ChunkEntry k v
ChunkEntry GovPParamsIn
GovPParamsInPossibleFuture (PParams ConwayEra -> GovPParamsOut ConwayEra
forall era. PParams era -> GovPParamsOut era
GovPParamsOut PParams ConwayEra
p)], [])
        PotentialPParamsUpdate Maybe (PParams ConwayEra)
Nothing -> ([], [])
      pparams :: [ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)]
pparams =
        [ GovPParamsIn
-> GovPParamsOut ConwayEra
-> ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)
forall k v. k -> v -> ChunkEntry k v
ChunkEntry GovPParamsIn
GovPParamsInPrev (PParams ConwayEra -> GovPParamsOut ConwayEra
forall era. PParams era -> GovPParamsOut era
GovPParamsOut PParams ConwayEra
prevPParams)
        , GovPParamsIn
-> GovPParamsOut ConwayEra
-> ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)
forall k v. k -> v -> ChunkEntry k v
ChunkEntry GovPParamsIn
GovPParamsInCurr (PParams ConwayEra -> GovPParamsOut ConwayEra
forall era. PParams era -> GovPParamsOut era
GovPParamsOut PParams ConwayEra
currPParams)
        ]
          [ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)]
-> [ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)]
-> [ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)]
forall a. [a] -> [a] -> [a]
++ [ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)]
futurePossiblePParams
          [ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)]
-> [ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)]
-> [ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)]
forall a. [a] -> [a] -> [a]
++ [ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)]
futureDefinitePParams

instance ExportCanonicalNamespace ConwayEra "gov/proposals/v0" where
  canonicalNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "gov/proposals/v0")
           (NamespaceEntry "gov/proposals/v0")))
     m
     ()
canonicalNamespaceEntries State ConwayEra
nes = do
    [ChunkEntry GovProposalIn (GovProposalOut CanonicalGovActionState)]
-> Stream
     (Of
        (ChunkEntry
           GovProposalIn (GovProposalOut CanonicalGovActionState)))
     m
     ()
forall (m :: * -> *) (f :: * -> *) a.
(Monad m, Foldable f) =>
f a -> Stream (Of a) m ()
S.each
      [ (GovProposalIn
 -> GovProposalOut CanonicalGovActionState
 -> ChunkEntry
      GovProposalIn (GovProposalOut CanonicalGovActionState))
-> (GovProposalIn, GovProposalOut CanonicalGovActionState)
-> ChunkEntry
     GovProposalIn (GovProposalOut CanonicalGovActionState)
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry GovProposalIn
-> GovProposalOut CanonicalGovActionState
-> ChunkEntry
     GovProposalIn (GovProposalOut CanonicalGovActionState)
forall k v. k -> v -> ChunkEntry k v
ChunkEntry ((GovProposalIn, GovProposalOut CanonicalGovActionState)
 -> ChunkEntry
      GovProposalIn (GovProposalOut CanonicalGovActionState))
-> (GovProposalIn, GovProposalOut CanonicalGovActionState)
-> ChunkEntry
     GovProposalIn (GovProposalOut CanonicalGovActionState)
forall a b. (a -> b) -> a -> b
$ Word64
-> GovActionState ConwayEra
-> (GovProposalIn, GovProposalOut CanonicalGovActionState)
fromGovActionState Word64
n GovActionState ConwayEra
govActionState
      | (Word64
n, GovActionState ConwayEra
govActionState) <-
          [Word64]
-> [GovActionState ConwayEra]
-> [(Word64, GovActionState ConwayEra)]
forall a b. [a] -> [b] -> [(a, b)]
zip
            [Word64
0 ..]
            (StrictSeq (GovActionState ConwayEra) -> [GovActionState ConwayEra]
forall a. StrictSeq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (StrictSeq (GovActionState ConwayEra)
 -> [GovActionState ConwayEra])
-> StrictSeq (GovActionState ConwayEra)
-> [GovActionState ConwayEra]
forall a b. (a -> b) -> a -> b
$ Proposals ConwayEra -> StrictSeq (GovActionState ConwayEra)
forall era. Proposals era -> StrictSeq (GovActionState era)
proposalsActions (NewEpochState ConwayEra
State ConwayEra
nes NewEpochState ConwayEra
-> Getting
     (Proposals ConwayEra)
     (NewEpochState ConwayEra)
     (Proposals ConwayEra)
-> Proposals ConwayEra
forall s a. s -> Getting a s a -> a
^. (GovState ConwayEra
 -> Const (Proposals ConwayEra) (GovState ConwayEra))
-> NewEpochState ConwayEra
-> Const (Proposals ConwayEra) (NewEpochState ConwayEra)
(ConwayGovState ConwayEra
 -> Const (Proposals ConwayEra) (ConwayGovState ConwayEra))
-> NewEpochState ConwayEra
-> Const (Proposals ConwayEra) (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> NewEpochState era -> f (NewEpochState era)
newEpochStateGovStateL ((ConwayGovState ConwayEra
  -> Const (Proposals ConwayEra) (ConwayGovState ConwayEra))
 -> NewEpochState ConwayEra
 -> Const (Proposals ConwayEra) (NewEpochState ConwayEra))
-> ((Proposals ConwayEra
     -> Const (Proposals ConwayEra) (Proposals ConwayEra))
    -> ConwayGovState ConwayEra
    -> Const (Proposals ConwayEra) (ConwayGovState ConwayEra))
-> Getting
     (Proposals ConwayEra)
     (NewEpochState ConwayEra)
     (Proposals ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Proposals ConwayEra
 -> Const (Proposals ConwayEra) (Proposals ConwayEra))
-> ConwayGovState ConwayEra
-> Const (Proposals ConwayEra) (ConwayGovState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Proposals era -> f (Proposals era))
-> ConwayGovState era -> f (ConwayGovState era)
cgsProposalsL))
      ]

instance ExportCanonicalNamespace ConwayEra "gov/proposals/roots/v0" where
  canonicalNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "gov/proposals/roots/v0")
           (NamespaceEntry "gov/proposals/roots/v0")))
     m
     ()
canonicalNamespaceEntries State ConwayEra
nes =
    [(GovProposalsRootsIn, StrictMaybe GovActionId)]
-> Stream (Of (GovProposalsRootsIn, StrictMaybe GovActionId)) m ()
forall (m :: * -> *) (f :: * -> *) a.
(Monad m, Foldable f) =>
f a -> Stream (Of a) m ()
S.each
      [
        ( GovProposalsRootsIn
GovProposalsRootsInPParamUpdate
        , (GovPurposeId 'PParamUpdatePurpose -> GovActionId)
-> StrictMaybe (GovPurposeId 'PParamUpdatePurpose)
-> StrictMaybe GovActionId
forall a b. (a -> b) -> StrictMaybe a -> StrictMaybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GovPurposeId 'PParamUpdatePurpose -> GovActionId
forall (p :: GovActionPurpose). GovPurposeId p -> GovActionId
unGovPurposeId (StrictMaybe (GovPurposeId 'PParamUpdatePurpose)
 -> StrictMaybe GovActionId)
-> StrictMaybe (GovPurposeId 'PParamUpdatePurpose)
-> StrictMaybe GovActionId
forall a b. (a -> b) -> a -> b
$
            GovRelation StrictMaybe
prevGovActionIds GovRelation StrictMaybe
-> Getting
     (StrictMaybe (GovPurposeId 'PParamUpdatePurpose))
     (GovRelation StrictMaybe)
     (StrictMaybe (GovPurposeId 'PParamUpdatePurpose))
-> StrictMaybe (GovPurposeId 'PParamUpdatePurpose)
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe (GovPurposeId 'PParamUpdatePurpose))
  (GovRelation StrictMaybe)
  (StrictMaybe (GovPurposeId 'PParamUpdatePurpose))
forall (f1 :: * -> *) (f2 :: * -> *).
Functor f2 =>
(f1 (GovPurposeId 'PParamUpdatePurpose)
 -> f2 (f1 (GovPurposeId 'PParamUpdatePurpose)))
-> GovRelation f1 -> f2 (GovRelation f1)
grPParamUpdateL
        )
      ,
        ( GovProposalsRootsIn
GovProposalsRootsInHardFork
        , (GovPurposeId 'HardForkPurpose -> GovActionId)
-> StrictMaybe (GovPurposeId 'HardForkPurpose)
-> StrictMaybe GovActionId
forall a b. (a -> b) -> StrictMaybe a -> StrictMaybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GovPurposeId 'HardForkPurpose -> GovActionId
forall (p :: GovActionPurpose). GovPurposeId p -> GovActionId
unGovPurposeId (StrictMaybe (GovPurposeId 'HardForkPurpose)
 -> StrictMaybe GovActionId)
-> StrictMaybe (GovPurposeId 'HardForkPurpose)
-> StrictMaybe GovActionId
forall a b. (a -> b) -> a -> b
$
            GovRelation StrictMaybe
prevGovActionIds GovRelation StrictMaybe
-> Getting
     (StrictMaybe (GovPurposeId 'HardForkPurpose))
     (GovRelation StrictMaybe)
     (StrictMaybe (GovPurposeId 'HardForkPurpose))
-> StrictMaybe (GovPurposeId 'HardForkPurpose)
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe (GovPurposeId 'HardForkPurpose))
  (GovRelation StrictMaybe)
  (StrictMaybe (GovPurposeId 'HardForkPurpose))
forall (f1 :: * -> *) (f2 :: * -> *).
Functor f2 =>
(f1 (GovPurposeId 'HardForkPurpose)
 -> f2 (f1 (GovPurposeId 'HardForkPurpose)))
-> GovRelation f1 -> f2 (GovRelation f1)
grHardForkL
        )
      ,
        ( GovProposalsRootsIn
GovProposalsRootsInCommittee
        , (GovPurposeId 'CommitteePurpose -> GovActionId)
-> StrictMaybe (GovPurposeId 'CommitteePurpose)
-> StrictMaybe GovActionId
forall a b. (a -> b) -> StrictMaybe a -> StrictMaybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GovPurposeId 'CommitteePurpose -> GovActionId
forall (p :: GovActionPurpose). GovPurposeId p -> GovActionId
unGovPurposeId (StrictMaybe (GovPurposeId 'CommitteePurpose)
 -> StrictMaybe GovActionId)
-> StrictMaybe (GovPurposeId 'CommitteePurpose)
-> StrictMaybe GovActionId
forall a b. (a -> b) -> a -> b
$
            GovRelation StrictMaybe
prevGovActionIds GovRelation StrictMaybe
-> Getting
     (StrictMaybe (GovPurposeId 'CommitteePurpose))
     (GovRelation StrictMaybe)
     (StrictMaybe (GovPurposeId 'CommitteePurpose))
-> StrictMaybe (GovPurposeId 'CommitteePurpose)
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe (GovPurposeId 'CommitteePurpose))
  (GovRelation StrictMaybe)
  (StrictMaybe (GovPurposeId 'CommitteePurpose))
forall (f1 :: * -> *) (f2 :: * -> *).
Functor f2 =>
(f1 (GovPurposeId 'CommitteePurpose)
 -> f2 (f1 (GovPurposeId 'CommitteePurpose)))
-> GovRelation f1 -> f2 (GovRelation f1)
grCommitteeL
        )
      ,
        ( GovProposalsRootsIn
GovProposalsRootsInConstitution
        , (GovPurposeId 'ConstitutionPurpose -> GovActionId)
-> StrictMaybe (GovPurposeId 'ConstitutionPurpose)
-> StrictMaybe GovActionId
forall a b. (a -> b) -> StrictMaybe a -> StrictMaybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GovPurposeId 'ConstitutionPurpose -> GovActionId
forall (p :: GovActionPurpose). GovPurposeId p -> GovActionId
unGovPurposeId (StrictMaybe (GovPurposeId 'ConstitutionPurpose)
 -> StrictMaybe GovActionId)
-> StrictMaybe (GovPurposeId 'ConstitutionPurpose)
-> StrictMaybe GovActionId
forall a b. (a -> b) -> a -> b
$
            GovRelation StrictMaybe
prevGovActionIds GovRelation StrictMaybe
-> Getting
     (StrictMaybe (GovPurposeId 'ConstitutionPurpose))
     (GovRelation StrictMaybe)
     (StrictMaybe (GovPurposeId 'ConstitutionPurpose))
-> StrictMaybe (GovPurposeId 'ConstitutionPurpose)
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe (GovPurposeId 'ConstitutionPurpose))
  (GovRelation StrictMaybe)
  (StrictMaybe (GovPurposeId 'ConstitutionPurpose))
forall (f1 :: * -> *) (f2 :: * -> *).
Functor f2 =>
(f1 (GovPurposeId 'ConstitutionPurpose)
 -> f2 (f1 (GovPurposeId 'ConstitutionPurpose)))
-> GovRelation f1 -> f2 (GovRelation f1)
grConstitutionL
        )
      ]
      Stream (Of (GovProposalsRootsIn, StrictMaybe GovActionId)) m ()
-> (Stream (Of (GovProposalsRootsIn, StrictMaybe GovActionId)) m ()
    -> Stream
         (Of (ChunkEntry GovProposalsRootsIn GovProposalsRootsOut)) m ())
-> Stream
     (Of (ChunkEntry GovProposalsRootsIn GovProposalsRootsOut)) m ()
forall a b. a -> (a -> b) -> b
& ((GovProposalsRootsIn, StrictMaybe GovActionId)
 -> Maybe (ChunkEntry GovProposalsRootsIn GovProposalsRootsOut))
-> Stream (Of (GovProposalsRootsIn, StrictMaybe GovActionId)) m ()
-> Stream
     (Of (ChunkEntry GovProposalsRootsIn GovProposalsRootsOut)) m ()
forall (m :: * -> *) a b r.
Monad m =>
(a -> Maybe b) -> Stream (Of a) m r -> Stream (Of b) m r
S.mapMaybe
        ( \(GovProposalsRootsIn
k, StrictMaybe GovActionId
mGovActionId) ->
            StrictMaybe GovActionId -> Maybe GovActionId
forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe StrictMaybe GovActionId
mGovActionId
              Maybe GovActionId
-> (GovActionId
    -> ChunkEntry GovProposalsRootsIn GovProposalsRootsOut)
-> Maybe (ChunkEntry GovProposalsRootsIn GovProposalsRootsOut)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \GovActionId
govActionId ->
                GovProposalsRootsIn
-> GovProposalsRootsOut
-> ChunkEntry GovProposalsRootsIn GovProposalsRootsOut
forall k v. k -> v -> ChunkEntry k v
ChunkEntry GovProposalsRootsIn
k (CanonicalGovActionId -> GovProposalsRootsOut
GovProposalsRootsOut (GovActionId -> CanonicalGovActionId
mkCanonicalGovActionId GovActionId
govActionId))
        )
    where
      prevGovActionIds :: GovRelation StrictMaybe
prevGovActionIds =
        GovRelation PRoot -> GovRelation StrictMaybe
toPrevGovActionIds (GovRelation PRoot -> GovRelation StrictMaybe)
-> GovRelation PRoot -> GovRelation StrictMaybe
forall a b. (a -> b) -> a -> b
$ NewEpochState ConwayEra
State ConwayEra
nes NewEpochState ConwayEra
-> Getting
     (GovRelation PRoot) (NewEpochState ConwayEra) (GovRelation PRoot)
-> GovRelation PRoot
forall s a. s -> Getting a s a -> a
^. (GovState ConwayEra
 -> Const (GovRelation PRoot) (GovState ConwayEra))
-> NewEpochState ConwayEra
-> Const (GovRelation PRoot) (NewEpochState ConwayEra)
(ConwayGovState ConwayEra
 -> Const (GovRelation PRoot) (ConwayGovState ConwayEra))
-> NewEpochState ConwayEra
-> Const (GovRelation PRoot) (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> NewEpochState era -> f (NewEpochState era)
newEpochStateGovStateL ((ConwayGovState ConwayEra
  -> Const (GovRelation PRoot) (ConwayGovState ConwayEra))
 -> NewEpochState ConwayEra
 -> Const (GovRelation PRoot) (NewEpochState ConwayEra))
-> ((GovRelation PRoot
     -> Const (GovRelation PRoot) (GovRelation PRoot))
    -> ConwayGovState ConwayEra
    -> Const (GovRelation PRoot) (ConwayGovState ConwayEra))
-> Getting
     (GovRelation PRoot) (NewEpochState ConwayEra) (GovRelation PRoot)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Proposals ConwayEra
 -> Const (GovRelation PRoot) (Proposals ConwayEra))
-> ConwayGovState ConwayEra
-> Const (GovRelation PRoot) (ConwayGovState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Proposals era -> f (Proposals era))
-> ConwayGovState era -> f (ConwayGovState era)
cgsProposalsL ((Proposals ConwayEra
  -> Const (GovRelation PRoot) (Proposals ConwayEra))
 -> ConwayGovState ConwayEra
 -> Const (GovRelation PRoot) (ConwayGovState ConwayEra))
-> ((GovRelation PRoot
     -> Const (GovRelation PRoot) (GovRelation PRoot))
    -> Proposals ConwayEra
    -> Const (GovRelation PRoot) (Proposals ConwayEra))
-> (GovRelation PRoot
    -> Const (GovRelation PRoot) (GovRelation PRoot))
-> ConwayGovState ConwayEra
-> Const (GovRelation PRoot) (ConwayGovState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GovRelation PRoot
 -> Const (GovRelation PRoot) (GovRelation PRoot))
-> Proposals ConwayEra
-> Const (GovRelation PRoot) (Proposals ConwayEra)
forall era (f :: * -> *).
Functor f =>
(GovRelation PRoot -> f (GovRelation PRoot))
-> Proposals era -> f (Proposals era)
pRootsL

instance ExportCanonicalNamespace ConwayEra "entities/accounts/v0" where
  canonicalNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "entities/accounts/v0")
           (NamespaceEntry "entities/accounts/v0")))
     m
     ()
canonicalNamespaceEntries State ConwayEra
nes =
    ((Credential Staking, ConwayAccountState ConwayEra)
 -> ChunkEntry
      (NamespaceKey "entities/accounts/v0")
      (NamespaceEntry "entities/accounts/v0"))
-> Stream
     (Of (Credential Staking, ConwayAccountState ConwayEra)) m ()
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "entities/accounts/v0")
           (NamespaceEntry "entities/accounts/v0")))
     m
     ()
forall (m :: * -> *) a b r.
Monad m =>
(a -> b) -> Stream (Of a) m r -> Stream (Of b) m r
S.map
      ( \(Credential Staking
cred, ConwayAccountState ConwayEra
accountState) ->
          EntitiesAccountsIn
-> EntitiesAccountsOut
-> ChunkEntry EntitiesAccountsIn EntitiesAccountsOut
forall k v. k -> v -> ChunkEntry k v
ChunkEntry (Credential Staking -> EntitiesAccountsIn
EntitiesAccountsIn Credential Staking
cred) (CanonicalAccountState -> EntitiesAccountsOut
EntitiesAccountsOut (CanonicalAccountState -> EntitiesAccountsOut)
-> CanonicalAccountState -> EntitiesAccountsOut
forall a b. (a -> b) -> a -> b
$ ConwayAccountState ConwayEra -> CanonicalAccountState
forall era. ConwayAccountState era -> CanonicalAccountState
mkCanonicalAccountState ConwayAccountState ConwayEra
accountState)
      )
      (Stream
   (Of (Credential Staking, ConwayAccountState ConwayEra)) m ()
 -> Stream
      (Of
         (ChunkEntry
            (NamespaceKey "entities/accounts/v0")
            (NamespaceEntry "entities/accounts/v0")))
      m
      ())
-> Stream
     (Of (Credential Staking, ConwayAccountState ConwayEra)) m ()
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "entities/accounts/v0")
           (NamespaceEntry "entities/accounts/v0")))
     m
     ()
forall a b. (a -> b) -> a -> b
$ [(Credential Staking, ConwayAccountState ConwayEra)]
-> Stream
     (Of (Credential Staking, ConwayAccountState ConwayEra)) m ()
forall (m :: * -> *) (f :: * -> *) a.
(Monad m, Foldable f) =>
f a -> Stream (Of a) m ()
S.each
      ([(Credential Staking, ConwayAccountState ConwayEra)]
 -> Stream
      (Of (Credential Staking, ConwayAccountState ConwayEra)) m ())
-> [(Credential Staking, ConwayAccountState ConwayEra)]
-> Stream
     (Of (Credential Staking, ConwayAccountState ConwayEra)) m ()
forall a b. (a -> b) -> a -> b
$ Map (Credential Staking) (ConwayAccountState ConwayEra)
-> [(Credential Staking, ConwayAccountState ConwayEra)]
forall k a. Map k a -> [(k, a)]
Map.toList
      (Map (Credential Staking) (ConwayAccountState ConwayEra)
 -> [(Credential Staking, ConwayAccountState ConwayEra)])
-> Map (Credential Staking) (ConwayAccountState ConwayEra)
-> [(Credential Staking, ConwayAccountState ConwayEra)]
forall a b. (a -> b) -> a -> b
$ NewEpochState ConwayEra
State ConwayEra
nes
        NewEpochState ConwayEra
-> Getting
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (NewEpochState ConwayEra)
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
-> Map (Credential Staking) (ConwayAccountState ConwayEra)
forall s a. s -> Getting a s a -> a
^. (EpochState ConwayEra
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (EpochState ConwayEra))
-> NewEpochState ConwayEra
-> Const
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL
          ((EpochState ConwayEra
  -> Const
       (Map (Credential Staking) (ConwayAccountState ConwayEra))
       (EpochState ConwayEra))
 -> NewEpochState ConwayEra
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (NewEpochState ConwayEra))
-> ((Map (Credential Staking) (ConwayAccountState ConwayEra)
     -> Const
          (Map (Credential Staking) (ConwayAccountState ConwayEra))
          (Map (Credential Staking) (ConwayAccountState ConwayEra)))
    -> EpochState ConwayEra
    -> Const
         (Map (Credential Staking) (ConwayAccountState ConwayEra))
         (EpochState ConwayEra))
-> Getting
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (NewEpochState ConwayEra)
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState ConwayEra
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (LedgerState ConwayEra))
-> EpochState ConwayEra
-> Const
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (EpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL
          ((LedgerState ConwayEra
  -> Const
       (Map (Credential Staking) (ConwayAccountState ConwayEra))
       (LedgerState ConwayEra))
 -> EpochState ConwayEra
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (EpochState ConwayEra))
-> ((Map (Credential Staking) (ConwayAccountState ConwayEra)
     -> Const
          (Map (Credential Staking) (ConwayAccountState ConwayEra))
          (Map (Credential Staking) (ConwayAccountState ConwayEra)))
    -> LedgerState ConwayEra
    -> Const
         (Map (Credential Staking) (ConwayAccountState ConwayEra))
         (LedgerState ConwayEra))
-> (Map (Credential Staking) (ConwayAccountState ConwayEra)
    -> Const
         (Map (Credential Staking) (ConwayAccountState ConwayEra))
         (Map (Credential Staking) (ConwayAccountState ConwayEra)))
-> EpochState ConwayEra
-> Const
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (EpochState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState ConwayEra
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (CertState ConwayEra))
-> LedgerState ConwayEra
-> Const
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (LedgerState ConwayEra)
(ConwayCertState ConwayEra
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (ConwayCertState ConwayEra))
-> LedgerState ConwayEra
-> Const
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (LedgerState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL
          ((ConwayCertState ConwayEra
  -> Const
       (Map (Credential Staking) (ConwayAccountState ConwayEra))
       (ConwayCertState ConwayEra))
 -> LedgerState ConwayEra
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (LedgerState ConwayEra))
-> ((Map (Credential Staking) (ConwayAccountState ConwayEra)
     -> Const
          (Map (Credential Staking) (ConwayAccountState ConwayEra))
          (Map (Credential Staking) (ConwayAccountState ConwayEra)))
    -> ConwayCertState ConwayEra
    -> Const
         (Map (Credential Staking) (ConwayAccountState ConwayEra))
         (ConwayCertState ConwayEra))
-> (Map (Credential Staking) (ConwayAccountState ConwayEra)
    -> Const
         (Map (Credential Staking) (ConwayAccountState ConwayEra))
         (Map (Credential Staking) (ConwayAccountState ConwayEra)))
-> LedgerState ConwayEra
-> Const
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (LedgerState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DState ConwayEra
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (DState ConwayEra))
-> CertState ConwayEra
-> Const
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (CertState ConwayEra)
(DState ConwayEra
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (DState ConwayEra))
-> ConwayCertState ConwayEra
-> Const
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (ConwayCertState ConwayEra)
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens' (CertState ConwayEra) (DState ConwayEra)
certDStateL
          ((DState ConwayEra
  -> Const
       (Map (Credential Staking) (ConwayAccountState ConwayEra))
       (DState ConwayEra))
 -> ConwayCertState ConwayEra
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (ConwayCertState ConwayEra))
-> ((Map (Credential Staking) (ConwayAccountState ConwayEra)
     -> Const
          (Map (Credential Staking) (ConwayAccountState ConwayEra))
          (Map (Credential Staking) (ConwayAccountState ConwayEra)))
    -> DState ConwayEra
    -> Const
         (Map (Credential Staking) (ConwayAccountState ConwayEra))
         (DState ConwayEra))
-> (Map (Credential Staking) (ConwayAccountState ConwayEra)
    -> Const
         (Map (Credential Staking) (ConwayAccountState ConwayEra))
         (Map (Credential Staking) (ConwayAccountState ConwayEra)))
-> ConwayCertState ConwayEra
-> Const
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (ConwayCertState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Accounts ConwayEra
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (Accounts ConwayEra))
-> DState ConwayEra
-> Const
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (DState ConwayEra)
(ConwayAccounts ConwayEra
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (ConwayAccounts ConwayEra))
-> DState ConwayEra
-> Const
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (DState ConwayEra)
forall era. Lens' (DState era) (Accounts era)
forall (t :: * -> *) era.
CanSetAccounts t =>
Lens' (t era) (Accounts era)
accountsL
          ((ConwayAccounts ConwayEra
  -> Const
       (Map (Credential Staking) (ConwayAccountState ConwayEra))
       (ConwayAccounts ConwayEra))
 -> DState ConwayEra
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (DState ConwayEra))
-> ((Map (Credential Staking) (ConwayAccountState ConwayEra)
     -> Const
          (Map (Credential Staking) (ConwayAccountState ConwayEra))
          (Map (Credential Staking) (ConwayAccountState ConwayEra)))
    -> ConwayAccounts ConwayEra
    -> Const
         (Map (Credential Staking) (ConwayAccountState ConwayEra))
         (ConwayAccounts ConwayEra))
-> (Map (Credential Staking) (ConwayAccountState ConwayEra)
    -> Const
         (Map (Credential Staking) (ConwayAccountState ConwayEra))
         (Map (Credential Staking) (ConwayAccountState ConwayEra)))
-> DState ConwayEra
-> Const
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (DState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential Staking) (AccountState ConwayEra)
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (Map (Credential Staking) (AccountState ConwayEra)))
-> Accounts ConwayEra
-> Const
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (Accounts ConwayEra)
(Map (Credential Staking) (ConwayAccountState ConwayEra)
 -> Const
      (Map (Credential Staking) (ConwayAccountState ConwayEra))
      (Map (Credential Staking) (ConwayAccountState ConwayEra)))
-> ConwayAccounts ConwayEra
-> Const
     (Map (Credential Staking) (ConwayAccountState ConwayEra))
     (ConwayAccounts ConwayEra)
forall era.
EraAccounts era =>
Lens' (Accounts era) (Map (Credential Staking) (AccountState era))
Lens'
  (Accounts ConwayEra)
  (Map (Credential Staking) (AccountState ConwayEra))
accountsMapL

instance ExportCanonicalNamespace ConwayEra "entities/dreps/v0" where
  canonicalNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "entities/dreps/v0")
           (NamespaceEntry "entities/dreps/v0")))
     m
     ()
canonicalNamespaceEntries State ConwayEra
nes =
    [(Credential DRepRole, DRepState)]
-> Stream (Of (Credential DRepRole, DRepState)) m ()
forall (m :: * -> *) (f :: * -> *) a.
(Monad m, Foldable f) =>
f a -> Stream (Of a) m ()
S.each
      ( Map (Credential DRepRole) DRepState
-> [(Credential DRepRole, DRepState)]
forall k a. Map k a -> [(k, a)]
Map.toList
          ( NewEpochState ConwayEra
State ConwayEra
nes
              NewEpochState ConwayEra
-> Getting
     (Map (Credential DRepRole) DRepState)
     (NewEpochState ConwayEra)
     (Map (Credential DRepRole) DRepState)
-> Map (Credential DRepRole) DRepState
forall s a. s -> Getting a s a -> a
^. (EpochState ConwayEra
 -> Const
      (Map (Credential DRepRole) DRepState) (EpochState ConwayEra))
-> NewEpochState ConwayEra
-> Const
     (Map (Credential DRepRole) DRepState) (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL
                ((EpochState ConwayEra
  -> Const
       (Map (Credential DRepRole) DRepState) (EpochState ConwayEra))
 -> NewEpochState ConwayEra
 -> Const
      (Map (Credential DRepRole) DRepState) (NewEpochState ConwayEra))
-> ((Map (Credential DRepRole) DRepState
     -> Const
          (Map (Credential DRepRole) DRepState)
          (Map (Credential DRepRole) DRepState))
    -> EpochState ConwayEra
    -> Const
         (Map (Credential DRepRole) DRepState) (EpochState ConwayEra))
-> Getting
     (Map (Credential DRepRole) DRepState)
     (NewEpochState ConwayEra)
     (Map (Credential DRepRole) DRepState)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState ConwayEra
 -> Const
      (Map (Credential DRepRole) DRepState) (LedgerState ConwayEra))
-> EpochState ConwayEra
-> Const
     (Map (Credential DRepRole) DRepState) (EpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL
                ((LedgerState ConwayEra
  -> Const
       (Map (Credential DRepRole) DRepState) (LedgerState ConwayEra))
 -> EpochState ConwayEra
 -> Const
      (Map (Credential DRepRole) DRepState) (EpochState ConwayEra))
-> ((Map (Credential DRepRole) DRepState
     -> Const
          (Map (Credential DRepRole) DRepState)
          (Map (Credential DRepRole) DRepState))
    -> LedgerState ConwayEra
    -> Const
         (Map (Credential DRepRole) DRepState) (LedgerState ConwayEra))
-> (Map (Credential DRepRole) DRepState
    -> Const
         (Map (Credential DRepRole) DRepState)
         (Map (Credential DRepRole) DRepState))
-> EpochState ConwayEra
-> Const
     (Map (Credential DRepRole) DRepState) (EpochState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState ConwayEra
 -> Const
      (Map (Credential DRepRole) DRepState) (CertState ConwayEra))
-> LedgerState ConwayEra
-> Const
     (Map (Credential DRepRole) DRepState) (LedgerState ConwayEra)
(ConwayCertState ConwayEra
 -> Const
      (Map (Credential DRepRole) DRepState) (ConwayCertState ConwayEra))
-> LedgerState ConwayEra
-> Const
     (Map (Credential DRepRole) DRepState) (LedgerState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL
                ((ConwayCertState ConwayEra
  -> Const
       (Map (Credential DRepRole) DRepState) (ConwayCertState ConwayEra))
 -> LedgerState ConwayEra
 -> Const
      (Map (Credential DRepRole) DRepState) (LedgerState ConwayEra))
-> ((Map (Credential DRepRole) DRepState
     -> Const
          (Map (Credential DRepRole) DRepState)
          (Map (Credential DRepRole) DRepState))
    -> ConwayCertState ConwayEra
    -> Const
         (Map (Credential DRepRole) DRepState) (ConwayCertState ConwayEra))
-> (Map (Credential DRepRole) DRepState
    -> Const
         (Map (Credential DRepRole) DRepState)
         (Map (Credential DRepRole) DRepState))
-> LedgerState ConwayEra
-> Const
     (Map (Credential DRepRole) DRepState) (LedgerState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VState ConwayEra
 -> Const (Map (Credential DRepRole) DRepState) (VState ConwayEra))
-> CertState ConwayEra
-> Const
     (Map (Credential DRepRole) DRepState) (CertState ConwayEra)
(VState ConwayEra
 -> Const (Map (Credential DRepRole) DRepState) (VState ConwayEra))
-> ConwayCertState ConwayEra
-> Const
     (Map (Credential DRepRole) DRepState) (ConwayCertState ConwayEra)
forall era.
ConwayEraCertState era =>
Lens' (CertState era) (VState era)
Lens' (CertState ConwayEra) (VState ConwayEra)
certVStateL
                ((VState ConwayEra
  -> Const (Map (Credential DRepRole) DRepState) (VState ConwayEra))
 -> ConwayCertState ConwayEra
 -> Const
      (Map (Credential DRepRole) DRepState) (ConwayCertState ConwayEra))
-> ((Map (Credential DRepRole) DRepState
     -> Const
          (Map (Credential DRepRole) DRepState)
          (Map (Credential DRepRole) DRepState))
    -> VState ConwayEra
    -> Const (Map (Credential DRepRole) DRepState) (VState ConwayEra))
-> (Map (Credential DRepRole) DRepState
    -> Const
         (Map (Credential DRepRole) DRepState)
         (Map (Credential DRepRole) DRepState))
-> ConwayCertState ConwayEra
-> Const
     (Map (Credential DRepRole) DRepState) (ConwayCertState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential DRepRole) DRepState
 -> Const
      (Map (Credential DRepRole) DRepState)
      (Map (Credential DRepRole) DRepState))
-> VState ConwayEra
-> Const (Map (Credential DRepRole) DRepState) (VState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Map (Credential DRepRole) DRepState
 -> f (Map (Credential DRepRole) DRepState))
-> VState era -> f (VState era)
vsDRepsL
          )
      )
      Stream (Of (Credential DRepRole, DRepState)) m ()
-> (Stream (Of (Credential DRepRole, DRepState)) m ()
    -> Stream (Of (ChunkEntry EntitiesDRepsIn EntitiesDRepsOut)) m ())
-> Stream (Of (ChunkEntry EntitiesDRepsIn EntitiesDRepsOut)) m ()
forall a b. a -> (a -> b) -> b
& ((Credential DRepRole, DRepState)
 -> ChunkEntry EntitiesDRepsIn EntitiesDRepsOut)
-> Stream (Of (Credential DRepRole, DRepState)) m ()
-> Stream (Of (ChunkEntry EntitiesDRepsIn EntitiesDRepsOut)) m ()
forall (m :: * -> *) a b r.
Monad m =>
(a -> b) -> Stream (Of a) m r -> Stream (Of b) m r
S.map
        ( \(Credential DRepRole
cred, DRepState
drepState) -> EntitiesDRepsIn
-> EntitiesDRepsOut -> ChunkEntry EntitiesDRepsIn EntitiesDRepsOut
forall k v. k -> v -> ChunkEntry k v
ChunkEntry (Credential DRepRole -> EntitiesDRepsIn
EntitiesDRepsIn Credential DRepRole
cred) (CanonicalDRepState -> EntitiesDRepsOut
EntitiesDRepsOut (CanonicalDRepState -> EntitiesDRepsOut)
-> CanonicalDRepState -> EntitiesDRepsOut
forall a b. (a -> b) -> a -> b
$ DRepState -> CanonicalDRepState
mkCanonicalDRepState DRepState
drepState)
        )

instance ExportCanonicalNamespace ConwayEra "entities/stake_pools/v0" where
  canonicalNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "entities/stake_pools/v0")
           (NamespaceEntry "entities/stake_pools/v0")))
     m
     ()
canonicalNamespaceEntries State ConwayEra
nes =
    Stream
  (Of (ChunkEntry EntitiesStakePoolsIn EntitiesStakePoolsOut)) m ()
Stream
  (Of
     (ChunkEntry
        (NamespaceKey "entities/stake_pools/v0")
        (NamespaceEntry "entities/stake_pools/v0")))
  m
  ()
stakePoolsEntries
    where
      stakePools :: Stream
  (Of
     (KeyHash StakePool,
      (StrictMaybe StakePoolState, StrictMaybe EpochNo,
       StrictMaybe StakePoolParams)))
  m
  ()
stakePools =
        [(KeyHash StakePool,
  (StrictMaybe StakePoolState, StrictMaybe EpochNo,
   StrictMaybe StakePoolParams))]
-> Stream
     (Of
        (KeyHash StakePool,
         (StrictMaybe StakePoolState, StrictMaybe EpochNo,
          StrictMaybe StakePoolParams)))
     m
     ()
forall (m :: * -> *) (f :: * -> *) a.
(Monad m, Foldable f) =>
f a -> Stream (Of a) m ()
S.each
          ([(KeyHash StakePool,
   (StrictMaybe StakePoolState, StrictMaybe EpochNo,
    StrictMaybe StakePoolParams))]
 -> Stream
      (Of
         (KeyHash StakePool,
          (StrictMaybe StakePoolState, StrictMaybe EpochNo,
           StrictMaybe StakePoolParams)))
      m
      ())
-> [(KeyHash StakePool,
     (StrictMaybe StakePoolState, StrictMaybe EpochNo,
      StrictMaybe StakePoolParams))]
-> Stream
     (Of
        (KeyHash StakePool,
         (StrictMaybe StakePoolState, StrictMaybe EpochNo,
          StrictMaybe StakePoolParams)))
     m
     ()
forall a b. (a -> b) -> a -> b
$ Map
  (KeyHash StakePool)
  (StrictMaybe StakePoolState, StrictMaybe EpochNo,
   StrictMaybe StakePoolParams)
-> [(KeyHash StakePool,
     (StrictMaybe StakePoolState, StrictMaybe EpochNo,
      StrictMaybe StakePoolParams))]
forall k a. Map k a -> [(k, a)]
Map.toList
          (Map
   (KeyHash StakePool)
   (StrictMaybe StakePoolState, StrictMaybe EpochNo,
    StrictMaybe StakePoolParams)
 -> [(KeyHash StakePool,
      (StrictMaybe StakePoolState, StrictMaybe EpochNo,
       StrictMaybe StakePoolParams))])
-> Map
     (KeyHash StakePool)
     (StrictMaybe StakePoolState, StrictMaybe EpochNo,
      StrictMaybe StakePoolParams)
-> [(KeyHash StakePool,
     (StrictMaybe StakePoolState, StrictMaybe EpochNo,
      StrictMaybe StakePoolParams))]
forall a b. (a -> b) -> a -> b
$ SimpleWhenMissing
  (KeyHash StakePool)
  StakePoolParams
  (StrictMaybe StakePoolState, StrictMaybe EpochNo,
   StrictMaybe StakePoolParams)
-> SimpleWhenMissing
     (KeyHash StakePool)
     (StrictMaybe StakePoolState, StrictMaybe EpochNo)
     (StrictMaybe StakePoolState, StrictMaybe EpochNo,
      StrictMaybe StakePoolParams)
-> SimpleWhenMatched
     (KeyHash StakePool)
     StakePoolParams
     (StrictMaybe StakePoolState, StrictMaybe EpochNo)
     (StrictMaybe StakePoolState, StrictMaybe EpochNo,
      StrictMaybe StakePoolParams)
-> Map (KeyHash StakePool) StakePoolParams
-> Map
     (KeyHash StakePool)
     (StrictMaybe StakePoolState, StrictMaybe EpochNo)
-> Map
     (KeyHash StakePool)
     (StrictMaybe StakePoolState, StrictMaybe EpochNo,
      StrictMaybe StakePoolParams)
forall k a c b.
Ord k =>
SimpleWhenMissing k a c
-> SimpleWhenMissing k b c
-> SimpleWhenMatched k a b c
-> Map k a
-> Map k b
-> Map k c
Map.merge
            ((KeyHash StakePool
 -> StakePoolParams
 -> (StrictMaybe StakePoolState, StrictMaybe EpochNo,
     StrictMaybe StakePoolParams))
-> SimpleWhenMissing
     (KeyHash StakePool)
     StakePoolParams
     (StrictMaybe StakePoolState, StrictMaybe EpochNo,
      StrictMaybe StakePoolParams)
forall (f :: * -> *) k x y.
Applicative f =>
(k -> x -> y) -> WhenMissing f k x y
Map.mapMissing (\KeyHash StakePool
_ StakePoolParams
v -> (StrictMaybe StakePoolState
forall a. StrictMaybe a
SNothing, StrictMaybe EpochNo
forall a. StrictMaybe a
SNothing, StakePoolParams -> StrictMaybe StakePoolParams
forall a. a -> StrictMaybe a
SJust StakePoolParams
v)))
            ((KeyHash StakePool
 -> (StrictMaybe StakePoolState, StrictMaybe EpochNo)
 -> (StrictMaybe StakePoolState, StrictMaybe EpochNo,
     StrictMaybe StakePoolParams))
-> SimpleWhenMissing
     (KeyHash StakePool)
     (StrictMaybe StakePoolState, StrictMaybe EpochNo)
     (StrictMaybe StakePoolState, StrictMaybe EpochNo,
      StrictMaybe StakePoolParams)
forall (f :: * -> *) k x y.
Applicative f =>
(k -> x -> y) -> WhenMissing f k x y
Map.mapMissing (\KeyHash StakePool
_ (StrictMaybe StakePoolState
x, StrictMaybe EpochNo
y) -> (StrictMaybe StakePoolState
x, StrictMaybe EpochNo
y, StrictMaybe StakePoolParams
forall a. StrictMaybe a
SNothing)))
            ( (KeyHash StakePool
 -> StakePoolParams
 -> (StrictMaybe StakePoolState, StrictMaybe EpochNo)
 -> (StrictMaybe StakePoolState, StrictMaybe EpochNo,
     StrictMaybe StakePoolParams))
-> SimpleWhenMatched
     (KeyHash StakePool)
     StakePoolParams
     (StrictMaybe StakePoolState, StrictMaybe EpochNo)
     (StrictMaybe StakePoolState, StrictMaybe EpochNo,
      StrictMaybe StakePoolParams)
forall (f :: * -> *) k x y z.
Applicative f =>
(k -> x -> y -> z) -> WhenMatched f k x y z
Map.zipWithMatched
                ( \KeyHash StakePool
_ StakePoolParams
futureStakePoolParams (StrictMaybe StakePoolState
stakePoolState, StrictMaybe EpochNo
retiringEpochNo) -> (StrictMaybe StakePoolState
stakePoolState, StrictMaybe EpochNo
retiringEpochNo, StakePoolParams -> StrictMaybe StakePoolParams
forall a. a -> StrictMaybe a
SJust StakePoolParams
futureStakePoolParams)
                )
            )
            ( NewEpochState ConwayEra
State ConwayEra
nes
                NewEpochState ConwayEra
-> Getting
     (Map (KeyHash StakePool) StakePoolParams)
     (NewEpochState ConwayEra)
     (Map (KeyHash StakePool) StakePoolParams)
-> Map (KeyHash StakePool) StakePoolParams
forall s a. s -> Getting a s a -> a
^. (EpochState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolParams) (EpochState ConwayEra))
-> NewEpochState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolParams) (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL
                  ((EpochState ConwayEra
  -> Const
       (Map (KeyHash StakePool) StakePoolParams) (EpochState ConwayEra))
 -> NewEpochState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolParams)
      (NewEpochState ConwayEra))
-> ((Map (KeyHash StakePool) StakePoolParams
     -> Const
          (Map (KeyHash StakePool) StakePoolParams)
          (Map (KeyHash StakePool) StakePoolParams))
    -> EpochState ConwayEra
    -> Const
         (Map (KeyHash StakePool) StakePoolParams) (EpochState ConwayEra))
-> Getting
     (Map (KeyHash StakePool) StakePoolParams)
     (NewEpochState ConwayEra)
     (Map (KeyHash StakePool) StakePoolParams)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolParams) (LedgerState ConwayEra))
-> EpochState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolParams) (EpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL
                  ((LedgerState ConwayEra
  -> Const
       (Map (KeyHash StakePool) StakePoolParams) (LedgerState ConwayEra))
 -> EpochState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolParams) (EpochState ConwayEra))
-> ((Map (KeyHash StakePool) StakePoolParams
     -> Const
          (Map (KeyHash StakePool) StakePoolParams)
          (Map (KeyHash StakePool) StakePoolParams))
    -> LedgerState ConwayEra
    -> Const
         (Map (KeyHash StakePool) StakePoolParams) (LedgerState ConwayEra))
-> (Map (KeyHash StakePool) StakePoolParams
    -> Const
         (Map (KeyHash StakePool) StakePoolParams)
         (Map (KeyHash StakePool) StakePoolParams))
-> EpochState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolParams) (EpochState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolParams) (CertState ConwayEra))
-> LedgerState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolParams) (LedgerState ConwayEra)
(ConwayCertState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolParams)
      (ConwayCertState ConwayEra))
-> LedgerState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolParams) (LedgerState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL
                  ((ConwayCertState ConwayEra
  -> Const
       (Map (KeyHash StakePool) StakePoolParams)
       (ConwayCertState ConwayEra))
 -> LedgerState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolParams) (LedgerState ConwayEra))
-> ((Map (KeyHash StakePool) StakePoolParams
     -> Const
          (Map (KeyHash StakePool) StakePoolParams)
          (Map (KeyHash StakePool) StakePoolParams))
    -> ConwayCertState ConwayEra
    -> Const
         (Map (KeyHash StakePool) StakePoolParams)
         (ConwayCertState ConwayEra))
-> (Map (KeyHash StakePool) StakePoolParams
    -> Const
         (Map (KeyHash StakePool) StakePoolParams)
         (Map (KeyHash StakePool) StakePoolParams))
-> LedgerState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolParams) (LedgerState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolParams) (PState ConwayEra))
-> CertState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolParams) (CertState ConwayEra)
(PState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolParams) (PState ConwayEra))
-> ConwayCertState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolParams)
     (ConwayCertState ConwayEra)
forall era. EraCertState era => Lens' (CertState era) (PState era)
Lens' (CertState ConwayEra) (PState ConwayEra)
certPStateL
                  ((PState ConwayEra
  -> Const
       (Map (KeyHash StakePool) StakePoolParams) (PState ConwayEra))
 -> ConwayCertState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolParams)
      (ConwayCertState ConwayEra))
-> ((Map (KeyHash StakePool) StakePoolParams
     -> Const
          (Map (KeyHash StakePool) StakePoolParams)
          (Map (KeyHash StakePool) StakePoolParams))
    -> PState ConwayEra
    -> Const
         (Map (KeyHash StakePool) StakePoolParams) (PState ConwayEra))
-> (Map (KeyHash StakePool) StakePoolParams
    -> Const
         (Map (KeyHash StakePool) StakePoolParams)
         (Map (KeyHash StakePool) StakePoolParams))
-> ConwayCertState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolParams)
     (ConwayCertState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash StakePool) StakePoolParams
 -> Const
      (Map (KeyHash StakePool) StakePoolParams)
      (Map (KeyHash StakePool) StakePoolParams))
-> PState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolParams) (PState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash StakePool) StakePoolParams
 -> f (Map (KeyHash StakePool) StakePoolParams))
-> PState era -> f (PState era)
psFutureStakePoolParamsL
            )
          (Map
   (KeyHash StakePool)
   (StrictMaybe StakePoolState, StrictMaybe EpochNo)
 -> Map
      (KeyHash StakePool)
      (StrictMaybe StakePoolState, StrictMaybe EpochNo,
       StrictMaybe StakePoolParams))
-> Map
     (KeyHash StakePool)
     (StrictMaybe StakePoolState, StrictMaybe EpochNo)
-> Map
     (KeyHash StakePool)
     (StrictMaybe StakePoolState, StrictMaybe EpochNo,
      StrictMaybe StakePoolParams)
forall a b. (a -> b) -> a -> b
$ SimpleWhenMissing
  (KeyHash StakePool)
  StakePoolState
  (StrictMaybe StakePoolState, StrictMaybe EpochNo)
-> SimpleWhenMissing
     (KeyHash StakePool)
     EpochNo
     (StrictMaybe StakePoolState, StrictMaybe EpochNo)
-> SimpleWhenMatched
     (KeyHash StakePool)
     StakePoolState
     EpochNo
     (StrictMaybe StakePoolState, StrictMaybe EpochNo)
-> Map (KeyHash StakePool) StakePoolState
-> Map (KeyHash StakePool) EpochNo
-> Map
     (KeyHash StakePool)
     (StrictMaybe StakePoolState, StrictMaybe EpochNo)
forall k a c b.
Ord k =>
SimpleWhenMissing k a c
-> SimpleWhenMissing k b c
-> SimpleWhenMatched k a b c
-> Map k a
-> Map k b
-> Map k c
Map.merge
            ((KeyHash StakePool
 -> StakePoolState
 -> (StrictMaybe StakePoolState, StrictMaybe EpochNo))
-> SimpleWhenMissing
     (KeyHash StakePool)
     StakePoolState
     (StrictMaybe StakePoolState, StrictMaybe EpochNo)
forall (f :: * -> *) k x y.
Applicative f =>
(k -> x -> y) -> WhenMissing f k x y
Map.mapMissing (\KeyHash StakePool
_ StakePoolState
v -> (StakePoolState -> StrictMaybe StakePoolState
forall a. a -> StrictMaybe a
SJust StakePoolState
v, StrictMaybe EpochNo
forall a. StrictMaybe a
SNothing)))
            ((KeyHash StakePool
 -> EpochNo -> (StrictMaybe StakePoolState, StrictMaybe EpochNo))
-> SimpleWhenMissing
     (KeyHash StakePool)
     EpochNo
     (StrictMaybe StakePoolState, StrictMaybe EpochNo)
forall (f :: * -> *) k x y.
Applicative f =>
(k -> x -> y) -> WhenMissing f k x y
Map.mapMissing (\KeyHash StakePool
_ EpochNo
v -> (StrictMaybe StakePoolState
forall a. StrictMaybe a
SNothing, EpochNo -> StrictMaybe EpochNo
forall a. a -> StrictMaybe a
SJust EpochNo
v)))
            ( (KeyHash StakePool
 -> StakePoolState
 -> EpochNo
 -> (StrictMaybe StakePoolState, StrictMaybe EpochNo))
-> SimpleWhenMatched
     (KeyHash StakePool)
     StakePoolState
     EpochNo
     (StrictMaybe StakePoolState, StrictMaybe EpochNo)
forall (f :: * -> *) k x y z.
Applicative f =>
(k -> x -> y -> z) -> WhenMatched f k x y z
Map.zipWithMatched
                (\KeyHash StakePool
_ StakePoolState
stakePoolState EpochNo
retiringEpochNo -> (StakePoolState -> StrictMaybe StakePoolState
forall a. a -> StrictMaybe a
SJust StakePoolState
stakePoolState, EpochNo -> StrictMaybe EpochNo
forall a. a -> StrictMaybe a
SJust EpochNo
retiringEpochNo))
            )
            ( NewEpochState ConwayEra
State ConwayEra
nes
                NewEpochState ConwayEra
-> Getting
     (Map (KeyHash StakePool) StakePoolState)
     (NewEpochState ConwayEra)
     (Map (KeyHash StakePool) StakePoolState)
-> Map (KeyHash StakePool) StakePoolState
forall s a. s -> Getting a s a -> a
^. (EpochState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolState) (EpochState ConwayEra))
-> NewEpochState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolState) (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL
                  ((EpochState ConwayEra
  -> Const
       (Map (KeyHash StakePool) StakePoolState) (EpochState ConwayEra))
 -> NewEpochState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolState) (NewEpochState ConwayEra))
-> ((Map (KeyHash StakePool) StakePoolState
     -> Const
          (Map (KeyHash StakePool) StakePoolState)
          (Map (KeyHash StakePool) StakePoolState))
    -> EpochState ConwayEra
    -> Const
         (Map (KeyHash StakePool) StakePoolState) (EpochState ConwayEra))
-> Getting
     (Map (KeyHash StakePool) StakePoolState)
     (NewEpochState ConwayEra)
     (Map (KeyHash StakePool) StakePoolState)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolState) (LedgerState ConwayEra))
-> EpochState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolState) (EpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL
                  ((LedgerState ConwayEra
  -> Const
       (Map (KeyHash StakePool) StakePoolState) (LedgerState ConwayEra))
 -> EpochState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolState) (EpochState ConwayEra))
-> ((Map (KeyHash StakePool) StakePoolState
     -> Const
          (Map (KeyHash StakePool) StakePoolState)
          (Map (KeyHash StakePool) StakePoolState))
    -> LedgerState ConwayEra
    -> Const
         (Map (KeyHash StakePool) StakePoolState) (LedgerState ConwayEra))
-> (Map (KeyHash StakePool) StakePoolState
    -> Const
         (Map (KeyHash StakePool) StakePoolState)
         (Map (KeyHash StakePool) StakePoolState))
-> EpochState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolState) (EpochState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolState) (CertState ConwayEra))
-> LedgerState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolState) (LedgerState ConwayEra)
(ConwayCertState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolState)
      (ConwayCertState ConwayEra))
-> LedgerState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolState) (LedgerState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL
                  ((ConwayCertState ConwayEra
  -> Const
       (Map (KeyHash StakePool) StakePoolState)
       (ConwayCertState ConwayEra))
 -> LedgerState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolState) (LedgerState ConwayEra))
-> ((Map (KeyHash StakePool) StakePoolState
     -> Const
          (Map (KeyHash StakePool) StakePoolState)
          (Map (KeyHash StakePool) StakePoolState))
    -> ConwayCertState ConwayEra
    -> Const
         (Map (KeyHash StakePool) StakePoolState)
         (ConwayCertState ConwayEra))
-> (Map (KeyHash StakePool) StakePoolState
    -> Const
         (Map (KeyHash StakePool) StakePoolState)
         (Map (KeyHash StakePool) StakePoolState))
-> LedgerState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolState) (LedgerState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolState) (PState ConwayEra))
-> CertState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolState) (CertState ConwayEra)
(PState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolState) (PState ConwayEra))
-> ConwayCertState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolState)
     (ConwayCertState ConwayEra)
forall era. EraCertState era => Lens' (CertState era) (PState era)
Lens' (CertState ConwayEra) (PState ConwayEra)
certPStateL
                  ((PState ConwayEra
  -> Const
       (Map (KeyHash StakePool) StakePoolState) (PState ConwayEra))
 -> ConwayCertState ConwayEra
 -> Const
      (Map (KeyHash StakePool) StakePoolState)
      (ConwayCertState ConwayEra))
-> ((Map (KeyHash StakePool) StakePoolState
     -> Const
          (Map (KeyHash StakePool) StakePoolState)
          (Map (KeyHash StakePool) StakePoolState))
    -> PState ConwayEra
    -> Const
         (Map (KeyHash StakePool) StakePoolState) (PState ConwayEra))
-> (Map (KeyHash StakePool) StakePoolState
    -> Const
         (Map (KeyHash StakePool) StakePoolState)
         (Map (KeyHash StakePool) StakePoolState))
-> ConwayCertState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolState)
     (ConwayCertState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash StakePool) StakePoolState
 -> Const
      (Map (KeyHash StakePool) StakePoolState)
      (Map (KeyHash StakePool) StakePoolState))
-> PState ConwayEra
-> Const
     (Map (KeyHash StakePool) StakePoolState) (PState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash StakePool) StakePoolState
 -> f (Map (KeyHash StakePool) StakePoolState))
-> PState era -> f (PState era)
psStakePoolsL
            )
            ( NewEpochState ConwayEra
State ConwayEra
nes
                NewEpochState ConwayEra
-> Getting
     (Map (KeyHash StakePool) EpochNo)
     (NewEpochState ConwayEra)
     (Map (KeyHash StakePool) EpochNo)
-> Map (KeyHash StakePool) EpochNo
forall s a. s -> Getting a s a -> a
^. (EpochState ConwayEra
 -> Const (Map (KeyHash StakePool) EpochNo) (EpochState ConwayEra))
-> NewEpochState ConwayEra
-> Const
     (Map (KeyHash StakePool) EpochNo) (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL
                  ((EpochState ConwayEra
  -> Const (Map (KeyHash StakePool) EpochNo) (EpochState ConwayEra))
 -> NewEpochState ConwayEra
 -> Const
      (Map (KeyHash StakePool) EpochNo) (NewEpochState ConwayEra))
-> ((Map (KeyHash StakePool) EpochNo
     -> Const
          (Map (KeyHash StakePool) EpochNo)
          (Map (KeyHash StakePool) EpochNo))
    -> EpochState ConwayEra
    -> Const (Map (KeyHash StakePool) EpochNo) (EpochState ConwayEra))
-> Getting
     (Map (KeyHash StakePool) EpochNo)
     (NewEpochState ConwayEra)
     (Map (KeyHash StakePool) EpochNo)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState ConwayEra
 -> Const (Map (KeyHash StakePool) EpochNo) (LedgerState ConwayEra))
-> EpochState ConwayEra
-> Const (Map (KeyHash StakePool) EpochNo) (EpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL
                  ((LedgerState ConwayEra
  -> Const (Map (KeyHash StakePool) EpochNo) (LedgerState ConwayEra))
 -> EpochState ConwayEra
 -> Const (Map (KeyHash StakePool) EpochNo) (EpochState ConwayEra))
-> ((Map (KeyHash StakePool) EpochNo
     -> Const
          (Map (KeyHash StakePool) EpochNo)
          (Map (KeyHash StakePool) EpochNo))
    -> LedgerState ConwayEra
    -> Const (Map (KeyHash StakePool) EpochNo) (LedgerState ConwayEra))
-> (Map (KeyHash StakePool) EpochNo
    -> Const
         (Map (KeyHash StakePool) EpochNo)
         (Map (KeyHash StakePool) EpochNo))
-> EpochState ConwayEra
-> Const (Map (KeyHash StakePool) EpochNo) (EpochState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState ConwayEra
 -> Const (Map (KeyHash StakePool) EpochNo) (CertState ConwayEra))
-> LedgerState ConwayEra
-> Const (Map (KeyHash StakePool) EpochNo) (LedgerState ConwayEra)
(ConwayCertState ConwayEra
 -> Const
      (Map (KeyHash StakePool) EpochNo) (ConwayCertState ConwayEra))
-> LedgerState ConwayEra
-> Const (Map (KeyHash StakePool) EpochNo) (LedgerState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL
                  ((ConwayCertState ConwayEra
  -> Const
       (Map (KeyHash StakePool) EpochNo) (ConwayCertState ConwayEra))
 -> LedgerState ConwayEra
 -> Const (Map (KeyHash StakePool) EpochNo) (LedgerState ConwayEra))
-> ((Map (KeyHash StakePool) EpochNo
     -> Const
          (Map (KeyHash StakePool) EpochNo)
          (Map (KeyHash StakePool) EpochNo))
    -> ConwayCertState ConwayEra
    -> Const
         (Map (KeyHash StakePool) EpochNo) (ConwayCertState ConwayEra))
-> (Map (KeyHash StakePool) EpochNo
    -> Const
         (Map (KeyHash StakePool) EpochNo)
         (Map (KeyHash StakePool) EpochNo))
-> LedgerState ConwayEra
-> Const (Map (KeyHash StakePool) EpochNo) (LedgerState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PState ConwayEra
 -> Const (Map (KeyHash StakePool) EpochNo) (PState ConwayEra))
-> CertState ConwayEra
-> Const (Map (KeyHash StakePool) EpochNo) (CertState ConwayEra)
(PState ConwayEra
 -> Const (Map (KeyHash StakePool) EpochNo) (PState ConwayEra))
-> ConwayCertState ConwayEra
-> Const
     (Map (KeyHash StakePool) EpochNo) (ConwayCertState ConwayEra)
forall era. EraCertState era => Lens' (CertState era) (PState era)
Lens' (CertState ConwayEra) (PState ConwayEra)
certPStateL
                  ((PState ConwayEra
  -> Const (Map (KeyHash StakePool) EpochNo) (PState ConwayEra))
 -> ConwayCertState ConwayEra
 -> Const
      (Map (KeyHash StakePool) EpochNo) (ConwayCertState ConwayEra))
-> ((Map (KeyHash StakePool) EpochNo
     -> Const
          (Map (KeyHash StakePool) EpochNo)
          (Map (KeyHash StakePool) EpochNo))
    -> PState ConwayEra
    -> Const (Map (KeyHash StakePool) EpochNo) (PState ConwayEra))
-> (Map (KeyHash StakePool) EpochNo
    -> Const
         (Map (KeyHash StakePool) EpochNo)
         (Map (KeyHash StakePool) EpochNo))
-> ConwayCertState ConwayEra
-> Const
     (Map (KeyHash StakePool) EpochNo) (ConwayCertState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash StakePool) EpochNo
 -> Const
      (Map (KeyHash StakePool) EpochNo)
      (Map (KeyHash StakePool) EpochNo))
-> PState ConwayEra
-> Const (Map (KeyHash StakePool) EpochNo) (PState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash StakePool) EpochNo
 -> f (Map (KeyHash StakePool) EpochNo))
-> PState era -> f (PState era)
psRetiringL
            )
      stakePoolsEntries :: Stream
  (Of (ChunkEntry EntitiesStakePoolsIn EntitiesStakePoolsOut)) m ()
stakePoolsEntries =
        ((KeyHash StakePool,
  (StrictMaybe StakePoolState, StrictMaybe EpochNo,
   StrictMaybe StakePoolParams))
 -> ChunkEntry EntitiesStakePoolsIn EntitiesStakePoolsOut)
-> Stream
     (Of
        (KeyHash StakePool,
         (StrictMaybe StakePoolState, StrictMaybe EpochNo,
          StrictMaybe StakePoolParams)))
     m
     ()
-> Stream
     (Of (ChunkEntry EntitiesStakePoolsIn EntitiesStakePoolsOut)) m ()
forall (m :: * -> *) a b r.
Monad m =>
(a -> b) -> Stream (Of a) m r -> Stream (Of b) m r
S.map
          ( \(KeyHash StakePool
k, (StrictMaybe StakePoolState
stakePoolState, StrictMaybe EpochNo
retiringEpochNo, StrictMaybe StakePoolParams
futureStakePoolParams)) ->
              EntitiesStakePoolsIn
-> EntitiesStakePoolsOut
-> ChunkEntry EntitiesStakePoolsIn EntitiesStakePoolsOut
forall k v. k -> v -> ChunkEntry k v
ChunkEntry
                (KeyHash StakePool -> EntitiesStakePoolsIn
EntitiesStakePoolsIn KeyHash StakePool
k)
                ( CanonicalStakePool -> EntitiesStakePoolsOut
EntitiesStakePoolsOut (CanonicalStakePool -> EntitiesStakePoolsOut)
-> CanonicalStakePool -> EntitiesStakePoolsOut
forall a b. (a -> b) -> a -> b
$
                    CanonicalStakePool
                      { cspStakePoolState :: StrictMaybe CanonicalStakePoolState
cspStakePoolState = (StakePoolState -> CanonicalStakePoolState)
-> StrictMaybe StakePoolState
-> StrictMaybe CanonicalStakePoolState
forall a b. (a -> b) -> StrictMaybe a -> StrictMaybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap StakePoolState -> CanonicalStakePoolState
mkCanonicalStakePoolState StrictMaybe StakePoolState
stakePoolState
                      , cspRetiringEpochNo :: StrictMaybe EpochNo
cspRetiringEpochNo = StrictMaybe EpochNo
retiringEpochNo
                      , cspFutureStakePoolParams :: StrictMaybe CanonicalStakePoolParams
cspFutureStakePoolParams = (StakePoolParams -> CanonicalStakePoolParams)
-> StrictMaybe StakePoolParams
-> StrictMaybe CanonicalStakePoolParams
forall a b. (a -> b) -> StrictMaybe a -> StrictMaybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap StakePoolParams -> CanonicalStakePoolParams
mkCanonicalStakePoolParams StrictMaybe StakePoolParams
futureStakePoolParams
                      }
                )
          )
          Stream
  (Of
     (KeyHash StakePool,
      (StrictMaybe StakePoolState, StrictMaybe EpochNo,
       StrictMaybe StakePoolParams)))
  m
  ()
stakePools

instance ExportCanonicalNamespace ConwayEra "entities/stake_pools/vrf_key_hashes/v0" where
  canonicalNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "entities/stake_pools/vrf_key_hashes/v0")
           (NamespaceEntry "entities/stake_pools/vrf_key_hashes/v0")))
     m
     ()
canonicalNamespaceEntries State ConwayEra
nes =
    Stream
  (Of
     (ChunkEntry
        EntitiesStakePoolsVRFKeyHashesIn
        EntitiesStakePoolsVRFKeyHashesOut))
  m
  ()
Stream
  (Of
     (ChunkEntry
        (NamespaceKey "entities/stake_pools/vrf_key_hashes/v0")
        (NamespaceEntry "entities/stake_pools/vrf_key_hashes/v0")))
  m
  ()
stakePoolsVRFKeyHashesEntries
    where
      stakePoolsVRFKeyHashes :: Stream (Of (VRFVerKeyHash StakePoolVRF, NonZero Word64)) m ()
stakePoolsVRFKeyHashes =
        [(VRFVerKeyHash StakePoolVRF, NonZero Word64)]
-> Stream (Of (VRFVerKeyHash StakePoolVRF, NonZero Word64)) m ()
forall (m :: * -> *) (f :: * -> *) a.
(Monad m, Foldable f) =>
f a -> Stream (Of a) m ()
S.each ([(VRFVerKeyHash StakePoolVRF, NonZero Word64)]
 -> Stream (Of (VRFVerKeyHash StakePoolVRF, NonZero Word64)) m ())
-> [(VRFVerKeyHash StakePoolVRF, NonZero Word64)]
-> Stream (Of (VRFVerKeyHash StakePoolVRF, NonZero Word64)) m ()
forall a b. (a -> b) -> a -> b
$
          Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
-> [(VRFVerKeyHash StakePoolVRF, NonZero Word64)]
forall k a. Map k a -> [(k, a)]
Map.toList
            ( NewEpochState ConwayEra
State ConwayEra
nes
                NewEpochState ConwayEra
-> Getting
     (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
     (NewEpochState ConwayEra)
     (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
-> Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
forall s a. s -> Getting a s a -> a
^. (EpochState ConwayEra
 -> Const
      (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
      (EpochState ConwayEra))
-> NewEpochState ConwayEra
-> Const
     (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
     (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL
                  ((EpochState ConwayEra
  -> Const
       (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
       (EpochState ConwayEra))
 -> NewEpochState ConwayEra
 -> Const
      (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
      (NewEpochState ConwayEra))
-> ((Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
     -> Const
          (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
          (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
    -> EpochState ConwayEra
    -> Const
         (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
         (EpochState ConwayEra))
-> Getting
     (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
     (NewEpochState ConwayEra)
     (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState ConwayEra
 -> Const
      (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
      (LedgerState ConwayEra))
-> EpochState ConwayEra
-> Const
     (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
     (EpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL
                  ((LedgerState ConwayEra
  -> Const
       (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
       (LedgerState ConwayEra))
 -> EpochState ConwayEra
 -> Const
      (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
      (EpochState ConwayEra))
-> ((Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
     -> Const
          (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
          (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
    -> LedgerState ConwayEra
    -> Const
         (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
         (LedgerState ConwayEra))
-> (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
    -> Const
         (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
         (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
-> EpochState ConwayEra
-> Const
     (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
     (EpochState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState ConwayEra
 -> Const
      (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
      (CertState ConwayEra))
-> LedgerState ConwayEra
-> Const
     (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
     (LedgerState ConwayEra)
(ConwayCertState ConwayEra
 -> Const
      (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
      (ConwayCertState ConwayEra))
-> LedgerState ConwayEra
-> Const
     (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
     (LedgerState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL
                  ((ConwayCertState ConwayEra
  -> Const
       (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
       (ConwayCertState ConwayEra))
 -> LedgerState ConwayEra
 -> Const
      (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
      (LedgerState ConwayEra))
-> ((Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
     -> Const
          (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
          (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
    -> ConwayCertState ConwayEra
    -> Const
         (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
         (ConwayCertState ConwayEra))
-> (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
    -> Const
         (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
         (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
-> LedgerState ConwayEra
-> Const
     (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
     (LedgerState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PState ConwayEra
 -> Const
      (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
      (PState ConwayEra))
-> CertState ConwayEra
-> Const
     (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
     (CertState ConwayEra)
(PState ConwayEra
 -> Const
      (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
      (PState ConwayEra))
-> ConwayCertState ConwayEra
-> Const
     (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
     (ConwayCertState ConwayEra)
forall era. EraCertState era => Lens' (CertState era) (PState era)
Lens' (CertState ConwayEra) (PState ConwayEra)
certPStateL
                  ((PState ConwayEra
  -> Const
       (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
       (PState ConwayEra))
 -> ConwayCertState ConwayEra
 -> Const
      (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
      (ConwayCertState ConwayEra))
-> ((Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
     -> Const
          (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
          (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
    -> PState ConwayEra
    -> Const
         (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
         (PState ConwayEra))
-> (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
    -> Const
         (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
         (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
-> ConwayCertState ConwayEra
-> Const
     (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
     (ConwayCertState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
 -> Const
      (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
      (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
-> PState ConwayEra
-> Const
     (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
     (PState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
 -> f (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
-> PState era -> f (PState era)
psVRFKeyHashesL
            )
      stakePoolsVRFKeyHashesEntries :: Stream
  (Of
     (ChunkEntry
        EntitiesStakePoolsVRFKeyHashesIn
        EntitiesStakePoolsVRFKeyHashesOut))
  m
  ()
stakePoolsVRFKeyHashesEntries =
        ((VRFVerKeyHash StakePoolVRF, NonZero Word64)
 -> ChunkEntry
      EntitiesStakePoolsVRFKeyHashesIn EntitiesStakePoolsVRFKeyHashesOut)
-> Stream (Of (VRFVerKeyHash StakePoolVRF, NonZero Word64)) m ()
-> Stream
     (Of
        (ChunkEntry
           EntitiesStakePoolsVRFKeyHashesIn
           EntitiesStakePoolsVRFKeyHashesOut))
     m
     ()
forall (m :: * -> *) a b r.
Monad m =>
(a -> b) -> Stream (Of a) m r -> Stream (Of b) m r
S.map
          ( \(VRFVerKeyHash StakePoolVRF
k, NonZero Word64
n) ->
              EntitiesStakePoolsVRFKeyHashesIn
-> EntitiesStakePoolsVRFKeyHashesOut
-> ChunkEntry
     EntitiesStakePoolsVRFKeyHashesIn EntitiesStakePoolsVRFKeyHashesOut
forall k v. k -> v -> ChunkEntry k v
ChunkEntry
                (VRFVerKeyHash StakePoolVRF -> EntitiesStakePoolsVRFKeyHashesIn
EntitiesStakePoolsVRFKeyHashesIn VRFVerKeyHash StakePoolVRF
k)
                (NonZero Word64 -> EntitiesStakePoolsVRFKeyHashesOut
EntitiesStakePoolsVRFKeyHashesOut NonZero Word64
n)
          )
          Stream (Of (VRFVerKeyHash StakePoolVRF, NonZero Word64)) m ()
stakePoolsVRFKeyHashes

instance ExportCanonicalState ConwayEra where
  type State ConwayEra = NewEpochState ConwayEra
  stateSerializationPlan :: forall (m :: * -> *).
Monad m =>
State ConwayEra -> SerializationPlan (SomeChunkEntry RawBytes) m
stateSerializationPlan State ConwayEra
nes =
    SerializationPlan (SomeChunkEntry RawBytes) m
forall (m :: * -> *) a. Monad m => SerializationPlan a m
defaultSerializationPlan
      SerializationPlan (SomeChunkEntry RawBytes) m
-> (SerializationPlan (SomeChunkEntry RawBytes) m
    -> SerializationPlan (SomeChunkEntry RawBytes) m)
-> SerializationPlan (SomeChunkEntry RawBytes) m
forall a b. a -> (a -> b) -> b
& forall era (ns :: Symbol) (m :: * -> *).
(Monad m, KnownSymbol ns, ExportCanonicalNamespace era ns) =>
State era
-> SerializationPlan (SomeChunkEntry RawBytes) m
-> SerializationPlan (SomeChunkEntry RawBytes) m
addNamespaceToPlan @ConwayEra @"utxo/v0" NewEpochState ConwayEra
State ConwayEra
updatedNes
      SerializationPlan (SomeChunkEntry RawBytes) m
-> (SerializationPlan (SomeChunkEntry RawBytes) m
    -> SerializationPlan (SomeChunkEntry RawBytes) m)
-> SerializationPlan (SomeChunkEntry RawBytes) m
forall a b. a -> (a -> b) -> b
& forall era (ns :: Symbol) (m :: * -> *).
(Monad m, KnownSymbol ns, ExportCanonicalNamespace era ns) =>
State era
-> SerializationPlan (SomeChunkEntry RawBytes) m
-> SerializationPlan (SomeChunkEntry RawBytes) m
addNamespaceToPlan @ConwayEra @"blocks/v0" NewEpochState ConwayEra
State ConwayEra
updatedNes
      SerializationPlan (SomeChunkEntry RawBytes) m
-> (SerializationPlan (SomeChunkEntry RawBytes) m
    -> SerializationPlan (SomeChunkEntry RawBytes) m)
-> SerializationPlan (SomeChunkEntry RawBytes) m
forall a b. a -> (a -> b) -> b
& forall era (ns :: Symbol) (m :: * -> *).
(Monad m, KnownSymbol ns, ExportCanonicalNamespace era ns) =>
State era
-> SerializationPlan (SomeChunkEntry RawBytes) m
-> SerializationPlan (SomeChunkEntry RawBytes) m
addNamespaceToPlan @ConwayEra @"gov/committee/v0" NewEpochState ConwayEra
State ConwayEra
updatedNes
      SerializationPlan (SomeChunkEntry RawBytes) m
-> (SerializationPlan (SomeChunkEntry RawBytes) m
    -> SerializationPlan (SomeChunkEntry RawBytes) m)
-> SerializationPlan (SomeChunkEntry RawBytes) m
forall a b. a -> (a -> b) -> b
& forall era (ns :: Symbol) (m :: * -> *).
(Monad m, KnownSymbol ns, ExportCanonicalNamespace era ns) =>
State era
-> SerializationPlan (SomeChunkEntry RawBytes) m
-> SerializationPlan (SomeChunkEntry RawBytes) m
addNamespaceToPlan @ConwayEra @"gov/constitution/v0" NewEpochState ConwayEra
State ConwayEra
updatedNes
      SerializationPlan (SomeChunkEntry RawBytes) m
-> (SerializationPlan (SomeChunkEntry RawBytes) m
    -> SerializationPlan (SomeChunkEntry RawBytes) m)
-> SerializationPlan (SomeChunkEntry RawBytes) m
forall a b. a -> (a -> b) -> b
& forall era (ns :: Symbol) (m :: * -> *).
(Monad m, KnownSymbol ns, ExportCanonicalNamespace era ns) =>
State era
-> SerializationPlan (SomeChunkEntry RawBytes) m
-> SerializationPlan (SomeChunkEntry RawBytes) m
addNamespaceToPlan @ConwayEra @"gov/pparams/v0" NewEpochState ConwayEra
State ConwayEra
updatedNes
      SerializationPlan (SomeChunkEntry RawBytes) m
-> (SerializationPlan (SomeChunkEntry RawBytes) m
    -> SerializationPlan (SomeChunkEntry RawBytes) m)
-> SerializationPlan (SomeChunkEntry RawBytes) m
forall a b. a -> (a -> b) -> b
& forall era (ns :: Symbol) (m :: * -> *).
(Monad m, KnownSymbol ns, ExportCanonicalNamespace era ns) =>
State era
-> SerializationPlan (SomeChunkEntry RawBytes) m
-> SerializationPlan (SomeChunkEntry RawBytes) m
addNamespaceToPlan @ConwayEra @"gov/proposals/v0" NewEpochState ConwayEra
State ConwayEra
updatedNes
      SerializationPlan (SomeChunkEntry RawBytes) m
-> (SerializationPlan (SomeChunkEntry RawBytes) m
    -> SerializationPlan (SomeChunkEntry RawBytes) m)
-> SerializationPlan (SomeChunkEntry RawBytes) m
forall a b. a -> (a -> b) -> b
& forall era (ns :: Symbol) (m :: * -> *).
(Monad m, KnownSymbol ns, ExportCanonicalNamespace era ns) =>
State era
-> SerializationPlan (SomeChunkEntry RawBytes) m
-> SerializationPlan (SomeChunkEntry RawBytes) m
addNamespaceToPlan @ConwayEra @"gov/proposals/roots/v0" NewEpochState ConwayEra
State ConwayEra
updatedNes
      SerializationPlan (SomeChunkEntry RawBytes) m
-> (SerializationPlan (SomeChunkEntry RawBytes) m
    -> SerializationPlan (SomeChunkEntry RawBytes) m)
-> SerializationPlan (SomeChunkEntry RawBytes) m
forall a b. a -> (a -> b) -> b
& forall era (ns :: Symbol) (m :: * -> *).
(Monad m, KnownSymbol ns, ExportCanonicalNamespace era ns) =>
State era
-> SerializationPlan (SomeChunkEntry RawBytes) m
-> SerializationPlan (SomeChunkEntry RawBytes) m
addNamespaceToPlan @ConwayEra @"entities/accounts/v0" NewEpochState ConwayEra
State ConwayEra
updatedNes
      SerializationPlan (SomeChunkEntry RawBytes) m
-> (SerializationPlan (SomeChunkEntry RawBytes) m
    -> SerializationPlan (SomeChunkEntry RawBytes) m)
-> SerializationPlan (SomeChunkEntry RawBytes) m
forall a b. a -> (a -> b) -> b
& forall era (ns :: Symbol) (m :: * -> *).
(Monad m, KnownSymbol ns, ExportCanonicalNamespace era ns) =>
State era
-> SerializationPlan (SomeChunkEntry RawBytes) m
-> SerializationPlan (SomeChunkEntry RawBytes) m
addNamespaceToPlan @ConwayEra @"entities/dreps/v0" NewEpochState ConwayEra
State ConwayEra
updatedNes
      SerializationPlan (SomeChunkEntry RawBytes) m
-> (SerializationPlan (SomeChunkEntry RawBytes) m
    -> SerializationPlan (SomeChunkEntry RawBytes) m)
-> SerializationPlan (SomeChunkEntry RawBytes) m
forall a b. a -> (a -> b) -> b
& forall era (ns :: Symbol) (m :: * -> *).
(Monad m, KnownSymbol ns, ExportCanonicalNamespace era ns) =>
State era
-> SerializationPlan (SomeChunkEntry RawBytes) m
-> SerializationPlan (SomeChunkEntry RawBytes) m
addNamespaceToPlan @ConwayEra @"entities/committee/v0" NewEpochState ConwayEra
State ConwayEra
updatedNes
      SerializationPlan (SomeChunkEntry RawBytes) m
-> (SerializationPlan (SomeChunkEntry RawBytes) m
    -> SerializationPlan (SomeChunkEntry RawBytes) m)
-> SerializationPlan (SomeChunkEntry RawBytes) m
forall a b. a -> (a -> b) -> b
& forall era (ns :: Symbol) (m :: * -> *).
(Monad m, KnownSymbol ns, ExportCanonicalNamespace era ns) =>
State era
-> SerializationPlan (SomeChunkEntry RawBytes) m
-> SerializationPlan (SomeChunkEntry RawBytes) m
addNamespaceToPlan @ConwayEra @"entities/stake_pools/v0" NewEpochState ConwayEra
State ConwayEra
updatedNes
      SerializationPlan (SomeChunkEntry RawBytes) m
-> (SerializationPlan (SomeChunkEntry RawBytes) m
    -> SerializationPlan (SomeChunkEntry RawBytes) m)
-> SerializationPlan (SomeChunkEntry RawBytes) m
forall a b. a -> (a -> b) -> b
& forall era (ns :: Symbol) (m :: * -> *).
(Monad m, KnownSymbol ns, ExportCanonicalNamespace era ns) =>
State era
-> SerializationPlan (SomeChunkEntry RawBytes) m
-> SerializationPlan (SomeChunkEntry RawBytes) m
addNamespaceToPlan @ConwayEra @"entities/stake_pools/vrf_key_hashes/v0" NewEpochState ConwayEra
State ConwayEra
updatedNes
    where
      epochNo :: EpochNo
epochNo = NewEpochState ConwayEra
State ConwayEra
nes NewEpochState ConwayEra
-> Getting EpochNo (NewEpochState ConwayEra) EpochNo -> EpochNo
forall s a. s -> Getting a s a -> a
^. Getting EpochNo (NewEpochState ConwayEra) EpochNo
forall era (f :: * -> *).
Functor f =>
(EpochNo -> f EpochNo)
-> NewEpochState era -> f (NewEpochState era)
nesELL
      -- Update DRep expiry before exporting
      updatedNes :: NewEpochState ConwayEra
updatedNes =
        NewEpochState ConwayEra
State ConwayEra
nes
          NewEpochState ConwayEra
-> (NewEpochState ConwayEra -> NewEpochState ConwayEra)
-> NewEpochState ConwayEra
forall a b. a -> (a -> b) -> b
& (EpochState ConwayEra -> Identity (EpochState ConwayEra))
-> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEpochStateL
            ((EpochState ConwayEra -> Identity (EpochState ConwayEra))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> ((VState ConwayEra -> Identity (VState ConwayEra))
    -> EpochState ConwayEra -> Identity (EpochState ConwayEra))
-> (VState ConwayEra -> Identity (VState ConwayEra))
-> NewEpochState ConwayEra
-> Identity (NewEpochState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState ConwayEra -> Identity (LedgerState ConwayEra))
-> EpochState ConwayEra -> Identity (EpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL
            ((LedgerState ConwayEra -> Identity (LedgerState ConwayEra))
 -> EpochState ConwayEra -> Identity (EpochState ConwayEra))
-> ((VState ConwayEra -> Identity (VState ConwayEra))
    -> LedgerState ConwayEra -> Identity (LedgerState ConwayEra))
-> (VState ConwayEra -> Identity (VState ConwayEra))
-> EpochState ConwayEra
-> Identity (EpochState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState ConwayEra -> Identity (CertState ConwayEra))
-> LedgerState ConwayEra -> Identity (LedgerState ConwayEra)
(ConwayCertState ConwayEra -> Identity (ConwayCertState ConwayEra))
-> LedgerState ConwayEra -> Identity (LedgerState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL
            ((ConwayCertState ConwayEra
  -> Identity (ConwayCertState ConwayEra))
 -> LedgerState ConwayEra -> Identity (LedgerState ConwayEra))
-> ((VState ConwayEra -> Identity (VState ConwayEra))
    -> ConwayCertState ConwayEra
    -> Identity (ConwayCertState ConwayEra))
-> (VState ConwayEra -> Identity (VState ConwayEra))
-> LedgerState ConwayEra
-> Identity (LedgerState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VState ConwayEra -> Identity (VState ConwayEra))
-> CertState ConwayEra -> Identity (CertState ConwayEra)
(VState ConwayEra -> Identity (VState ConwayEra))
-> ConwayCertState ConwayEra
-> Identity (ConwayCertState ConwayEra)
forall era.
ConwayEraCertState era =>
Lens' (CertState era) (VState era)
Lens' (CertState ConwayEra) (VState ConwayEra)
certVStateL
            ((VState ConwayEra -> Identity (VState ConwayEra))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> (VState ConwayEra -> VState ConwayEra)
-> NewEpochState ConwayEra
-> NewEpochState ConwayEra
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ EpochNo -> VState ConwayEra -> VState ConwayEra
forall era. EpochNo -> VState era -> VState era
updateDormantDRepExpiry EpochNo
epochNo

  getEpochNo :: State ConwayEra -> EpochNo
getEpochNo State ConwayEra
nes = NewEpochState ConwayEra
State ConwayEra
nes NewEpochState ConwayEra
-> Getting EpochNo (NewEpochState ConwayEra) EpochNo -> EpochNo
forall s a. s -> Getting a s a -> a
^. Getting EpochNo (NewEpochState ConwayEra) EpochNo
forall era (f :: * -> *).
Functor f =>
(EpochNo -> f EpochNo)
-> NewEpochState era -> f (NewEpochState era)
nesELL