{-# LANGUAGE AllowAmbiguousTypes #-}
{-# 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.Import () where

import Cardano.Ledger.BaseTypes (
  SlotNo (SlotNo),
  StrictMaybe (SJust),
  strictMaybe,
 )
import Cardano.Ledger.CanonicalState.BasicTypes (OnChain (getValue))
import Cardano.Ledger.CanonicalState.Conway (
  fromCanonicalAccountState,
  fromCanonicalGovActionId,
  toGovActionState,
 )
import Cardano.Ledger.CanonicalState.Conway.Export ()
import Cardano.Ledger.CanonicalState.Export (ExportCanonicalState (State))
import Cardano.Ledger.CanonicalState.Import (
  ImportCanonicalNamespace (..),
  ImportCanonicalState (importCanonicalState),
  importNamespaceFromHandle,
 )
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 (CanonicalCommitteeState),
  EntitiesCommitteeIn (..),
  EntitiesCommitteeOut (..),
  fromCanonicalCommitteeAuthorization,
 )
import Cardano.Ledger.CanonicalState.Namespace.EntitiesDReps.V0 (
  EntitiesDRepsIn (EntitiesDRepsIn),
  EntitiesDRepsOut (EntitiesDRepsOut),
  fromCanonicalDRepState,
 )
import Cardano.Ledger.CanonicalState.Namespace.EntitiesStakePools.V0 (
  CanonicalStakePool (CanonicalStakePool),
  EntitiesStakePoolsIn (EntitiesStakePoolsIn),
  EntitiesStakePoolsOut (EntitiesStakePoolsOut),
  fromCanonicalStakePoolParams,
  fromCanonicalStakePoolState,
 )
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 (
  CanonicalConstitution (..),
  GovConstitutionIn (..),
  GovConstitutionOut (..),
 )
import Cardano.Ledger.CanonicalState.Namespace.GovPParams.V0 (
  GovPParamsIn (..),
  GovPParamsOut (..),
 )
import Cardano.Ledger.CanonicalState.Namespace.GovProposals.Roots.V0 (
  GovProposalsRootsIn (..),
  GovProposalsRootsOut (..),
 )
import Cardano.Ledger.CanonicalState.Namespace.UTxO.V0 (
  UtxoIn (UtxoKeyIn),
  UtxoOut (UtxoOut),
 )
import Cardano.Ledger.Conway (ConwayEra)
import Cardano.Ledger.Conway.Governance (
  Committee (..),
  Constitution (..),
  ConwayEraGov (constitutionGovStateL),
  GovPurposeId (GovPurposeId),
  cgsCommitteeL,
  cgsProposalsL,
  fromPrevGovActionIds,
  grCommitteeL,
  grConstitutionL,
  grHardForkL,
  grPParamUpdateL,
  mkProposals,
  pPropsL,
  pRootsL,
  toPrevGovActionIds,
 )
import Cardano.Ledger.Conway.State (
  CanSetAccounts (accountsL),
  CanSetUTxO (utxoL),
  ConwayEraCertState (certVStateL),
  EraAccounts (accountsMapL),
  EraCertState (certDStateL, certPStateL),
  FuturePParams (..),
  UTxO (UTxO),
  csCommitteeCredsL,
  psFutureStakePoolParamsL,
  psRetiringL,
  psStakePoolsL,
  psVRFKeyHashesL,
  vsCommitteeStateL,
  vsDRepsL,
 )
import Cardano.Ledger.Shelley.LedgerState (
  NewEpochState (..),
  curPParamsEpochStateL,
  esLStateL,
  futurePParamsEpochStateL,
  lsCertStateL,
  lsUTxOStateL,
  nesBcurL,
  nesEpochStateL,
  nesEsL,
  newEpochStateGovStateL,
  prevPParamsEpochStateL,
  totalObligation,
  utxosDepositedL,
 )
import Cardano.SCLS.Internal.Entry.ChunkEntry (
  ChunkEntry (ChunkEntry),
 )
import Cardano.SCLS.Internal.Reader (
  withLatestManifestFrame,
 )
import Cardano.SCLS.Internal.Record.Manifest (Manifest (..))
import qualified Cardano.Types.SlotNo as SSlotNo
import Data.Data (Proxy (Proxy))
import Data.Default (def)
import Data.List (sortOn)
import qualified Data.Map as Map
import qualified Data.OMap.Strict as OMap
import GHC.TypeLits (KnownSymbol)
import Lens.Micro ((&), (.~), (^.))
import qualified Streaming.Prelude as S
import System.IO (Handle, IOMode (ReadMode), withBinaryFile)

instance ImportCanonicalNamespace ConwayEra "utxo/v0" where
  importNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry (NamespaceKey "utxo/v0") (NamespaceEntry "utxo/v0")))
     m
     ()
-> m (State ConwayEra)
importNamespaceEntries State ConwayEra
nes =
    (Map TxIn (BabbageTxOut ConwayEra)
 -> ChunkEntry UtxoIn (UtxoOut ConwayEra)
 -> Map TxIn (BabbageTxOut ConwayEra))
-> Map TxIn (BabbageTxOut ConwayEra)
-> (Map TxIn (BabbageTxOut ConwayEra) -> NewEpochState ConwayEra)
-> Stream (Of (ChunkEntry UtxoIn (UtxoOut ConwayEra))) m ()
-> m (NewEpochState ConwayEra)
forall (m :: * -> *) x a b r.
Monad m =>
(x -> a -> x) -> x -> (x -> b) -> Stream (Of a) m r -> m b
S.fold_
      (\Map TxIn (BabbageTxOut ConwayEra)
utxos (ChunkEntry (UtxoKeyIn TxIn
k) (UtxoOut OnChain (TxOut ConwayEra)
v)) -> TxIn
-> BabbageTxOut ConwayEra
-> Map TxIn (BabbageTxOut ConwayEra)
-> Map TxIn (BabbageTxOut ConwayEra)
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert TxIn
k (OnChain (BabbageTxOut ConwayEra) -> BabbageTxOut ConwayEra
forall a. OnChain a -> a
getValue OnChain (TxOut ConwayEra)
OnChain (BabbageTxOut ConwayEra)
v) Map TxIn (BabbageTxOut ConwayEra)
utxos)
      Map TxIn (BabbageTxOut ConwayEra)
forall a. Monoid a => a
mempty
      (\Map TxIn (BabbageTxOut ConwayEra)
utxos -> NewEpochState ConwayEra
State ConwayEra
nes NewEpochState ConwayEra
-> (NewEpochState ConwayEra -> NewEpochState ConwayEra)
-> NewEpochState ConwayEra
forall a b. a -> (a -> b) -> b
& (UTxO ConwayEra -> Identity (UTxO ConwayEra))
-> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra)
forall era. Lens' (NewEpochState era) (UTxO era)
forall (t :: * -> *) era. CanSetUTxO t => Lens' (t era) (UTxO era)
utxoL ((UTxO ConwayEra -> Identity (UTxO ConwayEra))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> UTxO ConwayEra
-> NewEpochState ConwayEra
-> NewEpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Map TxIn (TxOut ConwayEra) -> UTxO ConwayEra
forall era. Map TxIn (TxOut era) -> UTxO era
UTxO Map TxIn (TxOut ConwayEra)
Map TxIn (BabbageTxOut ConwayEra)
utxos)

instance ImportCanonicalNamespace ConwayEra "blocks/v0" where
  importNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "blocks/v0") (NamespaceEntry "blocks/v0")))
     m
     ()
-> m (State ConwayEra)
importNamespaceEntries State ConwayEra
nes =
    (Map (KeyHash StakePool) Natural
 -> ChunkEntry BlockIn BlockOut -> Map (KeyHash StakePool) Natural)
-> Map (KeyHash StakePool) Natural
-> (Map (KeyHash StakePool) Natural -> NewEpochState ConwayEra)
-> Stream (Of (ChunkEntry BlockIn BlockOut)) m ()
-> m (NewEpochState ConwayEra)
forall (m :: * -> *) x a b r.
Monad m =>
(x -> a -> x) -> x -> (x -> b) -> Stream (Of a) m r -> m b
S.fold_
      ( \Map (KeyHash StakePool) Natural
blocks (ChunkEntry (BlockIn KeyHash StakePool
keyHash EpochNo
_epochNo) (BlockOut Natural
n)) ->
          KeyHash StakePool
-> Natural
-> Map (KeyHash StakePool) Natural
-> Map (KeyHash StakePool) Natural
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert KeyHash StakePool
keyHash Natural
n Map (KeyHash StakePool) Natural
blocks
      )
      Map (KeyHash StakePool) Natural
forall a. Monoid a => a
mempty
      (\Map (KeyHash StakePool) Natural
blocks -> NewEpochState ConwayEra
State ConwayEra
nes NewEpochState ConwayEra
-> (NewEpochState ConwayEra -> NewEpochState ConwayEra)
-> NewEpochState ConwayEra
forall a b. a -> (a -> b) -> b
& (Map (KeyHash StakePool) Natural
 -> Identity (Map (KeyHash StakePool) Natural))
-> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash StakePool) Natural
 -> f (Map (KeyHash StakePool) Natural))
-> NewEpochState era -> f (NewEpochState era)
nesBcurL ((Map (KeyHash StakePool) Natural
  -> Identity (Map (KeyHash StakePool) Natural))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> Map (KeyHash StakePool) Natural
-> NewEpochState ConwayEra
-> NewEpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Map (KeyHash StakePool) Natural
blocks)

instance ImportCanonicalNamespace ConwayEra "entities/committee/v0" where
  importNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "entities/committee/v0")
           (NamespaceEntry "entities/committee/v0")))
     m
     ()
-> m (State ConwayEra)
importNamespaceEntries State ConwayEra
nes Stream
  (Of
     (ChunkEntry
        (NamespaceKey "entities/committee/v0")
        (NamespaceEntry "entities/committee/v0")))
  m
  ()
s =
    NewEpochState ConwayEra
-> (ChunkEntry EntitiesCommitteeIn EntitiesCommitteeOut
    -> NewEpochState ConwayEra)
-> Maybe (ChunkEntry EntitiesCommitteeIn EntitiesCommitteeOut)
-> NewEpochState ConwayEra
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
      NewEpochState ConwayEra
State ConwayEra
nes
      ( \( ChunkEntry
             EntitiesCommitteeIn
EntitiesCommitteeIn
             (EntitiesCommitteeOut (CanonicalCommitteeState Map (Credential ColdCommitteeRole) CanonicalCommitteeAuthorization
canonicalCreds))
           ) ->
            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))
-> ((Map (Credential ColdCommitteeRole) CommitteeAuthorization
     -> Identity
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
    -> EpochState ConwayEra -> Identity (EpochState ConwayEra))
-> (Map (Credential ColdCommitteeRole) CommitteeAuthorization
    -> Identity
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
-> 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))
-> ((Map (Credential ColdCommitteeRole) CommitteeAuthorization
     -> Identity
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
    -> LedgerState ConwayEra -> Identity (LedgerState ConwayEra))
-> (Map (Credential ColdCommitteeRole) CommitteeAuthorization
    -> Identity
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
-> 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))
-> ((Map (Credential ColdCommitteeRole) CommitteeAuthorization
     -> Identity
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
    -> ConwayCertState ConwayEra
    -> Identity (ConwayCertState ConwayEra))
-> (Map (Credential ColdCommitteeRole) CommitteeAuthorization
    -> Identity
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
-> 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))
 -> ConwayCertState ConwayEra
 -> Identity (ConwayCertState ConwayEra))
-> ((Map (Credential ColdCommitteeRole) CommitteeAuthorization
     -> Identity
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
    -> VState ConwayEra -> Identity (VState ConwayEra))
-> (Map (Credential ColdCommitteeRole) CommitteeAuthorization
    -> Identity
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
-> ConwayCertState ConwayEra
-> Identity (ConwayCertState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CommitteeState ConwayEra -> Identity (CommitteeState ConwayEra))
-> VState ConwayEra -> Identity (VState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(CommitteeState era -> f (CommitteeState era))
-> VState era -> f (VState era)
vsCommitteeStateL
                ((CommitteeState ConwayEra -> Identity (CommitteeState ConwayEra))
 -> VState ConwayEra -> Identity (VState ConwayEra))
-> ((Map (Credential ColdCommitteeRole) CommitteeAuthorization
     -> Identity
          (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
    -> CommitteeState ConwayEra -> Identity (CommitteeState ConwayEra))
-> (Map (Credential ColdCommitteeRole) CommitteeAuthorization
    -> Identity
         (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
-> VState ConwayEra
-> Identity (VState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential ColdCommitteeRole) CommitteeAuthorization
 -> Identity
      (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
-> CommitteeState ConwayEra -> Identity (CommitteeState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Map (Credential ColdCommitteeRole) CommitteeAuthorization
 -> f (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
-> CommitteeState era -> f (CommitteeState era)
csCommitteeCredsL
                ((Map (Credential ColdCommitteeRole) CommitteeAuthorization
  -> Identity
       (Map (Credential ColdCommitteeRole) CommitteeAuthorization))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> Map (Credential ColdCommitteeRole) CommitteeAuthorization
-> NewEpochState ConwayEra
-> NewEpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ (CanonicalCommitteeAuthorization -> CommitteeAuthorization)
-> Map
     (Credential ColdCommitteeRole) CanonicalCommitteeAuthorization
-> Map (Credential ColdCommitteeRole) CommitteeAuthorization
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map CanonicalCommitteeAuthorization -> CommitteeAuthorization
fromCanonicalCommitteeAuthorization Map (Credential ColdCommitteeRole) CanonicalCommitteeAuthorization
canonicalCreds
      )
      (Maybe (ChunkEntry EntitiesCommitteeIn EntitiesCommitteeOut)
 -> NewEpochState ConwayEra)
-> m (Maybe (ChunkEntry EntitiesCommitteeIn EntitiesCommitteeOut))
-> m (NewEpochState ConwayEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Stream
  (Of (ChunkEntry EntitiesCommitteeIn EntitiesCommitteeOut)) m ()
-> m (Maybe (ChunkEntry EntitiesCommitteeIn EntitiesCommitteeOut))
forall (m :: * -> *) a r.
Monad m =>
Stream (Of a) m r -> m (Maybe a)
S.head_ Stream
  (Of (ChunkEntry EntitiesCommitteeIn EntitiesCommitteeOut)) m ()
Stream
  (Of
     (ChunkEntry
        (NamespaceKey "entities/committee/v0")
        (NamespaceEntry "entities/committee/v0")))
  m
  ()
s

instance ImportCanonicalNamespace ConwayEra "gov/committee/v0" where
  importNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "gov/committee/v0")
           (NamespaceEntry "gov/committee/v0")))
     m
     ()
-> m (State ConwayEra)
importNamespaceEntries State ConwayEra
nes Stream
  (Of
     (ChunkEntry
        (NamespaceKey "gov/committee/v0")
        (NamespaceEntry "gov/committee/v0")))
  m
  ()
s =
    NewEpochState ConwayEra
-> (ChunkEntry GovCommitteeIn GovCommitteeOut
    -> NewEpochState ConwayEra)
-> Maybe (ChunkEntry GovCommitteeIn GovCommitteeOut)
-> NewEpochState ConwayEra
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
      NewEpochState ConwayEra
State ConwayEra
nes
      ( \( ChunkEntry
             GovCommitteeIn
GovCommitteeIn
             (GovCommitteeOut StrictMaybe CanonicalCommittee
mCommittee)
           ) ->
            NewEpochState ConwayEra
State ConwayEra
nes
              NewEpochState ConwayEra
-> (NewEpochState ConwayEra -> NewEpochState ConwayEra)
-> NewEpochState ConwayEra
forall a b. a -> (a -> b) -> b
& (GovState ConwayEra -> Identity (GovState ConwayEra))
-> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra)
(ConwayGovState ConwayEra -> Identity (ConwayGovState ConwayEra))
-> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> NewEpochState era -> f (NewEpochState era)
newEpochStateGovStateL
                ((ConwayGovState ConwayEra -> Identity (ConwayGovState ConwayEra))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> ((StrictMaybe (Committee ConwayEra)
     -> Identity (StrictMaybe (Committee ConwayEra)))
    -> ConwayGovState ConwayEra -> Identity (ConwayGovState ConwayEra))
-> (StrictMaybe (Committee ConwayEra)
    -> Identity (StrictMaybe (Committee ConwayEra)))
-> NewEpochState ConwayEra
-> Identity (NewEpochState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StrictMaybe (Committee ConwayEra)
 -> Identity (StrictMaybe (Committee ConwayEra)))
-> ConwayGovState ConwayEra -> Identity (ConwayGovState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(StrictMaybe (Committee era) -> f (StrictMaybe (Committee era)))
-> ConwayGovState era -> f (ConwayGovState era)
cgsCommitteeL
                ((StrictMaybe (Committee ConwayEra)
  -> Identity (StrictMaybe (Committee ConwayEra)))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> StrictMaybe (Committee ConwayEra)
-> NewEpochState ConwayEra
-> NewEpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ (CanonicalCommittee -> Committee ConwayEra)
-> StrictMaybe CanonicalCommittee
-> StrictMaybe (Committee ConwayEra)
forall a b. (a -> b) -> StrictMaybe a -> StrictMaybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\CanonicalCommittee {Map (Credential ColdCommitteeRole) EpochNo
UnitInterval
committeeMembers :: Map (Credential ColdCommitteeRole) EpochNo
committeeThreshold :: UnitInterval
committeeThreshold :: CanonicalCommittee -> UnitInterval
committeeMembers :: CanonicalCommittee -> Map (Credential ColdCommitteeRole) EpochNo
..} -> Committee {Map (Credential ColdCommitteeRole) EpochNo
UnitInterval
committeeMembers :: Map (Credential ColdCommitteeRole) EpochNo
committeeThreshold :: UnitInterval
committeeThreshold :: UnitInterval
committeeMembers :: Map (Credential ColdCommitteeRole) EpochNo
..}) StrictMaybe CanonicalCommittee
mCommittee
      )
      (Maybe (ChunkEntry GovCommitteeIn GovCommitteeOut)
 -> NewEpochState ConwayEra)
-> m (Maybe (ChunkEntry GovCommitteeIn GovCommitteeOut))
-> m (NewEpochState ConwayEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Stream (Of (ChunkEntry GovCommitteeIn GovCommitteeOut)) m ()
-> m (Maybe (ChunkEntry GovCommitteeIn GovCommitteeOut))
forall (m :: * -> *) a r.
Monad m =>
Stream (Of a) m r -> m (Maybe a)
S.head_ Stream (Of (ChunkEntry GovCommitteeIn GovCommitteeOut)) m ()
Stream
  (Of
     (ChunkEntry
        (NamespaceKey "gov/committee/v0")
        (NamespaceEntry "gov/committee/v0")))
  m
  ()
s

instance ImportCanonicalNamespace ConwayEra "gov/constitution/v0" where
  importNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "gov/constitution/v0")
           (NamespaceEntry "gov/constitution/v0")))
     m
     ()
-> m (State ConwayEra)
importNamespaceEntries State ConwayEra
nes Stream
  (Of
     (ChunkEntry
        (NamespaceKey "gov/constitution/v0")
        (NamespaceEntry "gov/constitution/v0")))
  m
  ()
s =
    NewEpochState ConwayEra
-> (ChunkEntry GovConstitutionIn GovConstitutionOut
    -> NewEpochState ConwayEra)
-> Maybe (ChunkEntry GovConstitutionIn GovConstitutionOut)
-> NewEpochState ConwayEra
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
      NewEpochState ConwayEra
State ConwayEra
nes
      ( \(ChunkEntry GovConstitutionIn
GovConstitutionIn (GovConstitutionOut CanonicalConstitution {StrictMaybe ScriptHash
Anchor
constitutionAnchor :: Anchor
constitutionGuardrailsScriptHash :: StrictMaybe ScriptHash
constitutionGuardrailsScriptHash :: CanonicalConstitution -> StrictMaybe ScriptHash
constitutionAnchor :: CanonicalConstitution -> Anchor
..})) ->
          NewEpochState ConwayEra
State ConwayEra
nes NewEpochState ConwayEra
-> (NewEpochState ConwayEra -> NewEpochState ConwayEra)
-> NewEpochState ConwayEra
forall a b. a -> (a -> b) -> b
& (GovState ConwayEra -> Identity (GovState ConwayEra))
-> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra)
(ConwayGovState ConwayEra -> Identity (ConwayGovState ConwayEra))
-> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> NewEpochState era -> f (NewEpochState era)
newEpochStateGovStateL ((ConwayGovState ConwayEra -> Identity (ConwayGovState ConwayEra))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> ((Constitution ConwayEra -> Identity (Constitution ConwayEra))
    -> ConwayGovState ConwayEra -> Identity (ConwayGovState ConwayEra))
-> (Constitution ConwayEra -> Identity (Constitution ConwayEra))
-> NewEpochState ConwayEra
-> Identity (NewEpochState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Constitution ConwayEra -> Identity (Constitution ConwayEra))
-> GovState ConwayEra -> Identity (GovState ConwayEra)
(Constitution ConwayEra -> Identity (Constitution ConwayEra))
-> ConwayGovState ConwayEra -> Identity (ConwayGovState ConwayEra)
forall era.
ConwayEraGov era =>
Lens' (GovState era) (Constitution era)
Lens' (GovState ConwayEra) (Constitution ConwayEra)
constitutionGovStateL ((Constitution ConwayEra -> Identity (Constitution ConwayEra))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> Constitution ConwayEra
-> NewEpochState ConwayEra
-> NewEpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Constitution {StrictMaybe ScriptHash
Anchor
constitutionAnchor :: Anchor
constitutionGuardrailsScriptHash :: StrictMaybe ScriptHash
constitutionGuardrailsScriptHash :: StrictMaybe ScriptHash
constitutionAnchor :: Anchor
..}
      )
      (Maybe (ChunkEntry GovConstitutionIn GovConstitutionOut)
 -> NewEpochState ConwayEra)
-> m (Maybe (ChunkEntry GovConstitutionIn GovConstitutionOut))
-> m (NewEpochState ConwayEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Stream (Of (ChunkEntry GovConstitutionIn GovConstitutionOut)) m ()
-> m (Maybe (ChunkEntry GovConstitutionIn GovConstitutionOut))
forall (m :: * -> *) a r.
Monad m =>
Stream (Of a) m r -> m (Maybe a)
S.head_ Stream (Of (ChunkEntry GovConstitutionIn GovConstitutionOut)) m ()
Stream
  (Of
     (ChunkEntry
        (NamespaceKey "gov/constitution/v0")
        (NamespaceEntry "gov/constitution/v0")))
  m
  ()
s

instance ImportCanonicalNamespace ConwayEra "gov/pparams/v0" where
  importNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "gov/pparams/v0") (NamespaceEntry "gov/pparams/v0")))
     m
     ()
-> m (State ConwayEra)
importNamespaceEntries State ConwayEra
nes =
    (EpochState ConwayEra
 -> ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra)
 -> EpochState ConwayEra)
-> EpochState ConwayEra
-> (EpochState ConwayEra -> NewEpochState ConwayEra)
-> Stream
     (Of (ChunkEntry GovPParamsIn (GovPParamsOut ConwayEra))) m ()
-> m (NewEpochState ConwayEra)
forall (m :: * -> *) x a b r.
Monad m =>
(x -> a -> x) -> x -> (x -> b) -> Stream (Of a) m r -> m b
S.fold_
      ( \EpochState ConwayEra
es (ChunkEntry GovPParamsIn
key (GovPParamsOut PParams ConwayEra
pp)) -> case GovPParamsIn
key of
          GovPParamsIn
GovPParamsInPrev -> EpochState ConwayEra
es EpochState ConwayEra
-> (EpochState ConwayEra -> EpochState ConwayEra)
-> EpochState ConwayEra
forall a b. a -> (a -> b) -> b
& (PParams ConwayEra -> Identity (PParams ConwayEra))
-> EpochState ConwayEra -> Identity (EpochState ConwayEra)
forall era. EraGov era => Lens' (EpochState era) (PParams era)
Lens' (EpochState ConwayEra) (PParams ConwayEra)
prevPParamsEpochStateL ((PParams ConwayEra -> Identity (PParams ConwayEra))
 -> EpochState ConwayEra -> Identity (EpochState ConwayEra))
-> PParams ConwayEra
-> EpochState ConwayEra
-> EpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ PParams ConwayEra
pp
          GovPParamsIn
GovPParamsInCurr -> EpochState ConwayEra
es EpochState ConwayEra
-> (EpochState ConwayEra -> EpochState ConwayEra)
-> EpochState ConwayEra
forall a b. a -> (a -> b) -> b
& (PParams ConwayEra -> Identity (PParams ConwayEra))
-> EpochState ConwayEra -> Identity (EpochState ConwayEra)
forall era. EraGov era => Lens' (EpochState era) (PParams era)
Lens' (EpochState ConwayEra) (PParams ConwayEra)
curPParamsEpochStateL ((PParams ConwayEra -> Identity (PParams ConwayEra))
 -> EpochState ConwayEra -> Identity (EpochState ConwayEra))
-> PParams ConwayEra
-> EpochState ConwayEra
-> EpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ PParams ConwayEra
pp
          GovPParamsIn
GovPParamsInPossibleFuture -> EpochState ConwayEra
es EpochState ConwayEra
-> (EpochState ConwayEra -> EpochState ConwayEra)
-> EpochState ConwayEra
forall a b. a -> (a -> b) -> b
& (FuturePParams ConwayEra -> Identity (FuturePParams ConwayEra))
-> EpochState ConwayEra -> Identity (EpochState ConwayEra)
forall era.
EraGov era =>
Lens' (EpochState era) (FuturePParams era)
Lens' (EpochState ConwayEra) (FuturePParams ConwayEra)
futurePParamsEpochStateL ((FuturePParams ConwayEra -> Identity (FuturePParams ConwayEra))
 -> EpochState ConwayEra -> Identity (EpochState ConwayEra))
-> FuturePParams ConwayEra
-> EpochState ConwayEra
-> EpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe (PParams ConwayEra) -> FuturePParams ConwayEra
forall era. Maybe (PParams era) -> FuturePParams era
PotentialPParamsUpdate (PParams ConwayEra -> Maybe (PParams ConwayEra)
forall a. a -> Maybe a
Just PParams ConwayEra
pp)
          GovPParamsIn
GovPParamsInDefiniteFuture -> EpochState ConwayEra
es EpochState ConwayEra
-> (EpochState ConwayEra -> EpochState ConwayEra)
-> EpochState ConwayEra
forall a b. a -> (a -> b) -> b
& (FuturePParams ConwayEra -> Identity (FuturePParams ConwayEra))
-> EpochState ConwayEra -> Identity (EpochState ConwayEra)
forall era.
EraGov era =>
Lens' (EpochState era) (FuturePParams era)
Lens' (EpochState ConwayEra) (FuturePParams ConwayEra)
futurePParamsEpochStateL ((FuturePParams ConwayEra -> Identity (FuturePParams ConwayEra))
 -> EpochState ConwayEra -> Identity (EpochState ConwayEra))
-> FuturePParams ConwayEra
-> EpochState ConwayEra
-> EpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ PParams ConwayEra -> FuturePParams ConwayEra
forall era. PParams era -> FuturePParams era
DefinitePParamsUpdate PParams ConwayEra
pp
      )
      (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)
      (\EpochState ConwayEra
es -> 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)
nesEsL ((EpochState ConwayEra -> Identity (EpochState ConwayEra))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> EpochState ConwayEra
-> NewEpochState ConwayEra
-> NewEpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ EpochState ConwayEra
es)

instance ImportCanonicalNamespace ConwayEra "gov/proposals/v0" where
  importNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "gov/proposals/v0")
           (NamespaceEntry "gov/proposals/v0")))
     m
     ()
-> m (State ConwayEra)
importNamespaceEntries State ConwayEra
nes Stream
  (Of
     (ChunkEntry
        (NamespaceKey "gov/proposals/v0")
        (NamespaceEntry "gov/proposals/v0")))
  m
  ()
s = do
    proposals <-
      (ChunkEntry GovProposalIn (GovProposalOut CanonicalGovActionState)
 -> (Word64, GovActionState ConwayEra))
-> Stream
     (Of
        (ChunkEntry
           GovProposalIn (GovProposalOut CanonicalGovActionState)))
     m
     ()
-> Stream (Of (Word64, GovActionState ConwayEra)) m ()
forall (m :: * -> *) a b r.
Monad m =>
(a -> b) -> Stream (Of a) m r -> Stream (Of b) m r
S.map
        (\(ChunkEntry GovProposalIn
govIn GovProposalOut CanonicalGovActionState
govOut) -> (GovProposalIn, GovProposalOut CanonicalGovActionState)
-> (Word64, GovActionState ConwayEra)
toGovActionState (GovProposalIn
govIn, GovProposalOut CanonicalGovActionState
govOut))
        Stream
  (Of
     (ChunkEntry
        GovProposalIn (GovProposalOut CanonicalGovActionState)))
  m
  ()
Stream
  (Of
     (ChunkEntry
        (NamespaceKey "gov/proposals/v0")
        (NamespaceEntry "gov/proposals/v0")))
  m
  ()
s
        Stream (Of (Word64, GovActionState ConwayEra)) m ()
-> (Stream (Of (Word64, GovActionState ConwayEra)) m ()
    -> m [(Word64, GovActionState ConwayEra)])
-> m [(Word64, GovActionState ConwayEra)]
forall a b. a -> (a -> b) -> b
& Stream (Of (Word64, GovActionState ConwayEra)) m ()
-> m [(Word64, GovActionState ConwayEra)]
forall (m :: * -> *) a r. Monad m => Stream (Of a) m r -> m [a]
S.toList_
    let proposalsMap = [GovActionState ConwayEra]
-> OMap GovActionId (GovActionState ConwayEra)
forall (f :: * -> *) k v.
(Foldable f, HasOKey k v) =>
f v -> OMap k v
OMap.fromFoldable ([GovActionState ConwayEra]
 -> OMap GovActionId (GovActionState ConwayEra))
-> ([(Word64, GovActionState ConwayEra)]
    -> [GovActionState ConwayEra])
-> [(Word64, GovActionState ConwayEra)]
-> OMap GovActionId (GovActionState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Word64, GovActionState ConwayEra) -> GovActionState ConwayEra)
-> [(Word64, GovActionState ConwayEra)]
-> [GovActionState ConwayEra]
forall a b. (a -> b) -> [a] -> [b]
map (Word64, GovActionState ConwayEra) -> GovActionState ConwayEra
forall a b. (a, b) -> b
snd ([(Word64, GovActionState ConwayEra)]
 -> [GovActionState ConwayEra])
-> ([(Word64, GovActionState ConwayEra)]
    -> [(Word64, GovActionState ConwayEra)])
-> [(Word64, GovActionState ConwayEra)]
-> [GovActionState ConwayEra]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Word64, GovActionState ConwayEra) -> Word64)
-> [(Word64, GovActionState ConwayEra)]
-> [(Word64, GovActionState ConwayEra)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn (Word64, GovActionState ConwayEra) -> Word64
forall a b. (a, b) -> a
fst ([(Word64, GovActionState ConwayEra)]
 -> OMap GovActionId (GovActionState ConwayEra))
-> [(Word64, GovActionState ConwayEra)]
-> OMap GovActionId (GovActionState ConwayEra)
forall a b. (a -> b) -> a -> b
$ [(Word64, GovActionState ConwayEra)]
proposals
    pure $ nes & newEpochStateGovStateL . cgsProposalsL . pPropsL .~ proposalsMap

instance ImportCanonicalNamespace ConwayEra "gov/proposals/roots/v0" where
  importNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "gov/proposals/roots/v0")
           (NamespaceEntry "gov/proposals/roots/v0")))
     m
     ()
-> m (State ConwayEra)
importNamespaceEntries State ConwayEra
nes = do
    (GovRelation StrictMaybe
 -> ChunkEntry GovProposalsRootsIn GovProposalsRootsOut
 -> GovRelation StrictMaybe)
-> GovRelation StrictMaybe
-> (GovRelation StrictMaybe -> NewEpochState ConwayEra)
-> Stream
     (Of (ChunkEntry GovProposalsRootsIn GovProposalsRootsOut)) m ()
-> m (NewEpochState ConwayEra)
forall (m :: * -> *) x a b r.
Monad m =>
(x -> a -> x) -> x -> (x -> b) -> Stream (Of a) m r -> m b
S.fold_
      ( \GovRelation StrictMaybe
govRelation
         (ChunkEntry GovProposalsRootsIn
govProposalsRootsIn (GovProposalsRootsOut CanonicalGovActionId
canonicalGovActionId)) ->
            case GovProposalsRootsIn
govProposalsRootsIn of
              GovProposalsRootsIn
GovProposalsRootsInPParamUpdate ->
                GovRelation StrictMaybe
govRelation
                  GovRelation StrictMaybe
-> (GovRelation StrictMaybe -> GovRelation StrictMaybe)
-> GovRelation StrictMaybe
forall a b. a -> (a -> b) -> b
& (StrictMaybe (GovPurposeId 'PParamUpdatePurpose)
 -> Identity (StrictMaybe (GovPurposeId 'PParamUpdatePurpose)))
-> GovRelation StrictMaybe -> Identity (GovRelation StrictMaybe)
forall (f1 :: * -> *) (f2 :: * -> *).
Functor f2 =>
(f1 (GovPurposeId 'PParamUpdatePurpose)
 -> f2 (f1 (GovPurposeId 'PParamUpdatePurpose)))
-> GovRelation f1 -> f2 (GovRelation f1)
grPParamUpdateL
                    ((StrictMaybe (GovPurposeId 'PParamUpdatePurpose)
  -> Identity (StrictMaybe (GovPurposeId 'PParamUpdatePurpose)))
 -> GovRelation StrictMaybe -> Identity (GovRelation StrictMaybe))
-> StrictMaybe (GovPurposeId 'PParamUpdatePurpose)
-> GovRelation StrictMaybe
-> GovRelation StrictMaybe
forall s t a b. ASetter s t a b -> b -> s -> t
.~ GovPurposeId 'PParamUpdatePurpose
-> StrictMaybe (GovPurposeId 'PParamUpdatePurpose)
forall a. a -> StrictMaybe a
SJust (GovActionId -> GovPurposeId 'PParamUpdatePurpose
forall (p :: GovActionPurpose). GovActionId -> GovPurposeId p
GovPurposeId (CanonicalGovActionId -> GovActionId
fromCanonicalGovActionId CanonicalGovActionId
canonicalGovActionId))
              GovProposalsRootsIn
GovProposalsRootsInHardFork ->
                GovRelation StrictMaybe
govRelation
                  GovRelation StrictMaybe
-> (GovRelation StrictMaybe -> GovRelation StrictMaybe)
-> GovRelation StrictMaybe
forall a b. a -> (a -> b) -> b
& (StrictMaybe (GovPurposeId 'HardForkPurpose)
 -> Identity (StrictMaybe (GovPurposeId 'HardForkPurpose)))
-> GovRelation StrictMaybe -> Identity (GovRelation StrictMaybe)
forall (f1 :: * -> *) (f2 :: * -> *).
Functor f2 =>
(f1 (GovPurposeId 'HardForkPurpose)
 -> f2 (f1 (GovPurposeId 'HardForkPurpose)))
-> GovRelation f1 -> f2 (GovRelation f1)
grHardForkL
                    ((StrictMaybe (GovPurposeId 'HardForkPurpose)
  -> Identity (StrictMaybe (GovPurposeId 'HardForkPurpose)))
 -> GovRelation StrictMaybe -> Identity (GovRelation StrictMaybe))
-> StrictMaybe (GovPurposeId 'HardForkPurpose)
-> GovRelation StrictMaybe
-> GovRelation StrictMaybe
forall s t a b. ASetter s t a b -> b -> s -> t
.~ GovPurposeId 'HardForkPurpose
-> StrictMaybe (GovPurposeId 'HardForkPurpose)
forall a. a -> StrictMaybe a
SJust (GovActionId -> GovPurposeId 'HardForkPurpose
forall (p :: GovActionPurpose). GovActionId -> GovPurposeId p
GovPurposeId (CanonicalGovActionId -> GovActionId
fromCanonicalGovActionId CanonicalGovActionId
canonicalGovActionId))
              GovProposalsRootsIn
GovProposalsRootsInCommittee ->
                GovRelation StrictMaybe
govRelation
                  GovRelation StrictMaybe
-> (GovRelation StrictMaybe -> GovRelation StrictMaybe)
-> GovRelation StrictMaybe
forall a b. a -> (a -> b) -> b
& (StrictMaybe (GovPurposeId 'CommitteePurpose)
 -> Identity (StrictMaybe (GovPurposeId 'CommitteePurpose)))
-> GovRelation StrictMaybe -> Identity (GovRelation StrictMaybe)
forall (f1 :: * -> *) (f2 :: * -> *).
Functor f2 =>
(f1 (GovPurposeId 'CommitteePurpose)
 -> f2 (f1 (GovPurposeId 'CommitteePurpose)))
-> GovRelation f1 -> f2 (GovRelation f1)
grCommitteeL
                    ((StrictMaybe (GovPurposeId 'CommitteePurpose)
  -> Identity (StrictMaybe (GovPurposeId 'CommitteePurpose)))
 -> GovRelation StrictMaybe -> Identity (GovRelation StrictMaybe))
-> StrictMaybe (GovPurposeId 'CommitteePurpose)
-> GovRelation StrictMaybe
-> GovRelation StrictMaybe
forall s t a b. ASetter s t a b -> b -> s -> t
.~ GovPurposeId 'CommitteePurpose
-> StrictMaybe (GovPurposeId 'CommitteePurpose)
forall a. a -> StrictMaybe a
SJust (GovActionId -> GovPurposeId 'CommitteePurpose
forall (p :: GovActionPurpose). GovActionId -> GovPurposeId p
GovPurposeId (CanonicalGovActionId -> GovActionId
fromCanonicalGovActionId CanonicalGovActionId
canonicalGovActionId))
              GovProposalsRootsIn
GovProposalsRootsInConstitution ->
                GovRelation StrictMaybe
govRelation
                  GovRelation StrictMaybe
-> (GovRelation StrictMaybe -> GovRelation StrictMaybe)
-> GovRelation StrictMaybe
forall a b. a -> (a -> b) -> b
& (StrictMaybe (GovPurposeId 'ConstitutionPurpose)
 -> Identity (StrictMaybe (GovPurposeId 'ConstitutionPurpose)))
-> GovRelation StrictMaybe -> Identity (GovRelation StrictMaybe)
forall (f1 :: * -> *) (f2 :: * -> *).
Functor f2 =>
(f1 (GovPurposeId 'ConstitutionPurpose)
 -> f2 (f1 (GovPurposeId 'ConstitutionPurpose)))
-> GovRelation f1 -> f2 (GovRelation f1)
grConstitutionL
                    ((StrictMaybe (GovPurposeId 'ConstitutionPurpose)
  -> Identity (StrictMaybe (GovPurposeId 'ConstitutionPurpose)))
 -> GovRelation StrictMaybe -> Identity (GovRelation StrictMaybe))
-> StrictMaybe (GovPurposeId 'ConstitutionPurpose)
-> GovRelation StrictMaybe
-> GovRelation StrictMaybe
forall s t a b. ASetter s t a b -> b -> s -> t
.~ GovPurposeId 'ConstitutionPurpose
-> StrictMaybe (GovPurposeId 'ConstitutionPurpose)
forall a. a -> StrictMaybe a
SJust (GovActionId -> GovPurposeId 'ConstitutionPurpose
forall (p :: GovActionPurpose). GovActionId -> GovPurposeId p
GovPurposeId (CanonicalGovActionId -> GovActionId
fromCanonicalGovActionId CanonicalGovActionId
canonicalGovActionId))
      )
      GovRelation StrictMaybe
forall a. Default a => a
def
      ( \GovRelation StrictMaybe
govRelation ->
          NewEpochState ConwayEra
State ConwayEra
nes
            NewEpochState ConwayEra
-> (NewEpochState ConwayEra -> NewEpochState ConwayEra)
-> NewEpochState ConwayEra
forall a b. a -> (a -> b) -> b
& (GovState ConwayEra -> Identity (GovState ConwayEra))
-> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra)
(ConwayGovState ConwayEra -> Identity (ConwayGovState ConwayEra))
-> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> NewEpochState era -> f (NewEpochState era)
newEpochStateGovStateL
              ((ConwayGovState ConwayEra -> Identity (ConwayGovState ConwayEra))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> ((GovRelation PRoot -> Identity (GovRelation PRoot))
    -> ConwayGovState ConwayEra -> Identity (ConwayGovState ConwayEra))
-> (GovRelation PRoot -> Identity (GovRelation PRoot))
-> NewEpochState ConwayEra
-> Identity (NewEpochState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Proposals ConwayEra -> Identity (Proposals ConwayEra))
-> ConwayGovState ConwayEra -> Identity (ConwayGovState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Proposals era -> f (Proposals era))
-> ConwayGovState era -> f (ConwayGovState era)
cgsProposalsL
              ((Proposals ConwayEra -> Identity (Proposals ConwayEra))
 -> ConwayGovState ConwayEra -> Identity (ConwayGovState ConwayEra))
-> ((GovRelation PRoot -> Identity (GovRelation PRoot))
    -> Proposals ConwayEra -> Identity (Proposals ConwayEra))
-> (GovRelation PRoot -> Identity (GovRelation PRoot))
-> ConwayGovState ConwayEra
-> Identity (ConwayGovState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GovRelation PRoot -> Identity (GovRelation PRoot))
-> Proposals ConwayEra -> Identity (Proposals ConwayEra)
forall era (f :: * -> *).
Functor f =>
(GovRelation PRoot -> f (GovRelation PRoot))
-> Proposals era -> f (Proposals era)
pRootsL
              ((GovRelation PRoot -> Identity (GovRelation PRoot))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> GovRelation PRoot
-> NewEpochState ConwayEra
-> NewEpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ GovRelation StrictMaybe -> GovRelation PRoot
fromPrevGovActionIds GovRelation StrictMaybe
govRelation
      )

instance ImportCanonicalNamespace ConwayEra "entities/accounts/v0" where
  importNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "entities/accounts/v0")
           (NamespaceEntry "entities/accounts/v0")))
     m
     ()
-> m (State ConwayEra)
importNamespaceEntries State ConwayEra
nes =
    (Map (Credential Staking) (ConwayAccountState ConwayEra)
 -> ChunkEntry EntitiesAccountsIn EntitiesAccountsOut
 -> Map (Credential Staking) (ConwayAccountState ConwayEra))
-> Map (Credential Staking) (ConwayAccountState ConwayEra)
-> (Map (Credential Staking) (ConwayAccountState ConwayEra)
    -> NewEpochState ConwayEra)
-> Stream
     (Of (ChunkEntry EntitiesAccountsIn EntitiesAccountsOut)) m ()
-> m (NewEpochState ConwayEra)
forall (m :: * -> *) x a b r.
Monad m =>
(x -> a -> x) -> x -> (x -> b) -> Stream (Of a) m r -> m b
S.fold_
      ( \Map (Credential Staking) (ConwayAccountState ConwayEra)
accountsMap
         (ChunkEntry (EntitiesAccountsIn Credential Staking
credential) (EntitiesAccountsOut CanonicalAccountState
accountState)) ->
            Credential Staking
-> ConwayAccountState ConwayEra
-> Map (Credential Staking) (ConwayAccountState ConwayEra)
-> Map (Credential Staking) (ConwayAccountState ConwayEra)
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Credential Staking
credential (CanonicalAccountState -> ConwayAccountState ConwayEra
forall era. CanonicalAccountState -> ConwayAccountState era
fromCanonicalAccountState CanonicalAccountState
accountState) Map (Credential Staking) (ConwayAccountState ConwayEra)
accountsMap
      )
      Map (Credential Staking) (ConwayAccountState ConwayEra)
forall a. Monoid a => a
mempty
      ( \Map (Credential Staking) (ConwayAccountState ConwayEra)
accountsMap ->
          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)
nesEsL
              ((EpochState ConwayEra -> Identity (EpochState ConwayEra))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> ((Map (Credential Staking) (AccountState ConwayEra)
     -> Identity
          (Map (Credential Staking) (ConwayAccountState ConwayEra)))
    -> EpochState ConwayEra -> Identity (EpochState ConwayEra))
-> (Map (Credential Staking) (AccountState ConwayEra)
    -> Identity
         (Map (Credential Staking) (ConwayAccountState 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))
-> ((Map (Credential Staking) (AccountState ConwayEra)
     -> Identity
          (Map (Credential Staking) (ConwayAccountState ConwayEra)))
    -> LedgerState ConwayEra -> Identity (LedgerState ConwayEra))
-> (Map (Credential Staking) (AccountState ConwayEra)
    -> Identity
         (Map (Credential Staking) (ConwayAccountState 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))
-> ((Map (Credential Staking) (AccountState ConwayEra)
     -> Identity
          (Map (Credential Staking) (ConwayAccountState ConwayEra)))
    -> ConwayCertState ConwayEra
    -> Identity (ConwayCertState ConwayEra))
-> (Map (Credential Staking) (AccountState ConwayEra)
    -> Identity
         (Map (Credential Staking) (ConwayAccountState ConwayEra)))
-> LedgerState ConwayEra
-> Identity (LedgerState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DState ConwayEra -> Identity (DState ConwayEra))
-> CertState ConwayEra -> Identity (CertState ConwayEra)
(DState ConwayEra -> Identity (DState ConwayEra))
-> ConwayCertState ConwayEra
-> Identity (ConwayCertState ConwayEra)
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens' (CertState ConwayEra) (DState ConwayEra)
certDStateL
              ((DState ConwayEra -> Identity (DState ConwayEra))
 -> ConwayCertState ConwayEra
 -> Identity (ConwayCertState ConwayEra))
-> ((Map (Credential Staking) (AccountState ConwayEra)
     -> Identity
          (Map (Credential Staking) (ConwayAccountState ConwayEra)))
    -> DState ConwayEra -> Identity (DState ConwayEra))
-> (Map (Credential Staking) (AccountState ConwayEra)
    -> Identity
         (Map (Credential Staking) (ConwayAccountState ConwayEra)))
-> ConwayCertState ConwayEra
-> Identity (ConwayCertState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Accounts ConwayEra -> Identity (Accounts ConwayEra))
-> DState ConwayEra -> Identity (DState ConwayEra)
(ConwayAccounts ConwayEra -> Identity (ConwayAccounts ConwayEra))
-> DState ConwayEra -> Identity (DState ConwayEra)
forall era. Lens' (DState era) (Accounts era)
forall (t :: * -> *) era.
CanSetAccounts t =>
Lens' (t era) (Accounts era)
accountsL
              ((ConwayAccounts ConwayEra -> Identity (ConwayAccounts ConwayEra))
 -> DState ConwayEra -> Identity (DState ConwayEra))
-> ((Map (Credential Staking) (AccountState ConwayEra)
     -> Identity
          (Map (Credential Staking) (ConwayAccountState ConwayEra)))
    -> ConwayAccounts ConwayEra -> Identity (ConwayAccounts ConwayEra))
-> (Map (Credential Staking) (AccountState ConwayEra)
    -> Identity
         (Map (Credential Staking) (ConwayAccountState ConwayEra)))
-> DState ConwayEra
-> Identity (DState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential Staking) (AccountState ConwayEra)
 -> Identity (Map (Credential Staking) (AccountState ConwayEra)))
-> Accounts ConwayEra -> Identity (Accounts ConwayEra)
(Map (Credential Staking) (AccountState ConwayEra)
 -> Identity
      (Map (Credential Staking) (ConwayAccountState ConwayEra)))
-> ConwayAccounts ConwayEra -> Identity (ConwayAccounts ConwayEra)
forall era.
EraAccounts era =>
Lens' (Accounts era) (Map (Credential Staking) (AccountState era))
Lens'
  (Accounts ConwayEra)
  (Map (Credential Staking) (AccountState ConwayEra))
accountsMapL
              ((Map (Credential Staking) (AccountState ConwayEra)
  -> Identity
       (Map (Credential Staking) (ConwayAccountState ConwayEra)))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> Map (Credential Staking) (ConwayAccountState ConwayEra)
-> NewEpochState ConwayEra
-> NewEpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Map (Credential Staking) (ConwayAccountState ConwayEra)
accountsMap
      )

instance ImportCanonicalNamespace ConwayEra "entities/dreps/v0" where
  importNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "entities/dreps/v0")
           (NamespaceEntry "entities/dreps/v0")))
     m
     ()
-> m (State ConwayEra)
importNamespaceEntries State ConwayEra
nes =
    (Map (Credential DRepRole) DRepState
 -> ChunkEntry EntitiesDRepsIn EntitiesDRepsOut
 -> Map (Credential DRepRole) DRepState)
-> Map (Credential DRepRole) DRepState
-> (Map (Credential DRepRole) DRepState -> NewEpochState ConwayEra)
-> Stream (Of (ChunkEntry EntitiesDRepsIn EntitiesDRepsOut)) m ()
-> m (NewEpochState ConwayEra)
forall (m :: * -> *) x a b r.
Monad m =>
(x -> a -> x) -> x -> (x -> b) -> Stream (Of a) m r -> m b
S.fold_
      ( \Map (Credential DRepRole) DRepState
dreps
         ( ChunkEntry
             (EntitiesDRepsIn Credential DRepRole
cred)
             (EntitiesDRepsOut CanonicalDRepState
canonicalDRepState)
           ) ->
            Credential DRepRole
-> DRepState
-> Map (Credential DRepRole) DRepState
-> Map (Credential DRepRole) DRepState
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Credential DRepRole
cred (CanonicalDRepState -> DRepState
fromCanonicalDRepState CanonicalDRepState
canonicalDRepState) Map (Credential DRepRole) DRepState
dreps
      )
      Map (Credential DRepRole) DRepState
forall a. Monoid a => a
mempty
      ( \Map (Credential DRepRole) DRepState
dreps ->
          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)
nesEsL
              ((EpochState ConwayEra -> Identity (EpochState ConwayEra))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> ((Map (Credential DRepRole) DRepState
     -> Identity (Map (Credential DRepRole) DRepState))
    -> EpochState ConwayEra -> Identity (EpochState ConwayEra))
-> (Map (Credential DRepRole) DRepState
    -> Identity (Map (Credential DRepRole) DRepState))
-> 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))
-> ((Map (Credential DRepRole) DRepState
     -> Identity (Map (Credential DRepRole) DRepState))
    -> LedgerState ConwayEra -> Identity (LedgerState ConwayEra))
-> (Map (Credential DRepRole) DRepState
    -> Identity (Map (Credential DRepRole) DRepState))
-> 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))
-> ((Map (Credential DRepRole) DRepState
     -> Identity (Map (Credential DRepRole) DRepState))
    -> ConwayCertState ConwayEra
    -> Identity (ConwayCertState ConwayEra))
-> (Map (Credential DRepRole) DRepState
    -> Identity (Map (Credential DRepRole) DRepState))
-> 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))
 -> ConwayCertState ConwayEra
 -> Identity (ConwayCertState ConwayEra))
-> ((Map (Credential DRepRole) DRepState
     -> Identity (Map (Credential DRepRole) DRepState))
    -> VState ConwayEra -> Identity (VState ConwayEra))
-> (Map (Credential DRepRole) DRepState
    -> Identity (Map (Credential DRepRole) DRepState))
-> ConwayCertState ConwayEra
-> Identity (ConwayCertState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (Credential DRepRole) DRepState
 -> Identity (Map (Credential DRepRole) DRepState))
-> VState ConwayEra -> Identity (VState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Map (Credential DRepRole) DRepState
 -> f (Map (Credential DRepRole) DRepState))
-> VState era -> f (VState era)
vsDRepsL
              ((Map (Credential DRepRole) DRepState
  -> Identity (Map (Credential DRepRole) DRepState))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> Map (Credential DRepRole) DRepState
-> NewEpochState ConwayEra
-> NewEpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Map (Credential DRepRole) DRepState
dreps
      )

instance ImportCanonicalNamespace ConwayEra "entities/stake_pools/v0" where
  importNamespaceEntries :: forall (m :: * -> *).
Monad m =>
State ConwayEra
-> Stream
     (Of
        (ChunkEntry
           (NamespaceKey "entities/stake_pools/v0")
           (NamespaceEntry "entities/stake_pools/v0")))
     m
     ()
-> m (State ConwayEra)
importNamespaceEntries State ConwayEra
nes =
    ((Map (KeyHash StakePool) StakePoolState,
  Map (KeyHash StakePool) EpochNo,
  Map (KeyHash StakePool) StakePoolParams)
 -> ChunkEntry EntitiesStakePoolsIn EntitiesStakePoolsOut
 -> (Map (KeyHash StakePool) StakePoolState,
     Map (KeyHash StakePool) EpochNo,
     Map (KeyHash StakePool) StakePoolParams))
-> (Map (KeyHash StakePool) StakePoolState,
    Map (KeyHash StakePool) EpochNo,
    Map (KeyHash StakePool) StakePoolParams)
-> ((Map (KeyHash StakePool) StakePoolState,
     Map (KeyHash StakePool) EpochNo,
     Map (KeyHash StakePool) StakePoolParams)
    -> NewEpochState ConwayEra)
-> Stream
     (Of (ChunkEntry EntitiesStakePoolsIn EntitiesStakePoolsOut)) m ()
-> m (NewEpochState ConwayEra)
forall (m :: * -> *) x a b r.
Monad m =>
(x -> a -> x) -> x -> (x -> b) -> Stream (Of a) m r -> m b
S.fold_
      ( \(Map (KeyHash StakePool) StakePoolState
stakePoolStates, Map (KeyHash StakePool) EpochNo
retiringEpochNos, Map (KeyHash StakePool) StakePoolParams
futureStakePoolParams)
         ( ChunkEntry
             (EntitiesStakePoolsIn KeyHash StakePool
k)
             (EntitiesStakePoolsOut (CanonicalStakePool StrictMaybe CanonicalStakePoolState
mStakePoolState StrictMaybe CanonicalStakePoolParams
mFutureStakePoolParams StrictMaybe EpochNo
mRetiringEpochNo))
           ) ->
            let stakePoolStates' :: Map (KeyHash StakePool) StakePoolState
stakePoolStates' =
                  Map (KeyHash StakePool) StakePoolState
-> (CanonicalStakePoolState
    -> Map (KeyHash StakePool) StakePoolState)
-> StrictMaybe CanonicalStakePoolState
-> Map (KeyHash StakePool) StakePoolState
forall a b. a -> (b -> a) -> StrictMaybe b -> a
strictMaybe
                    Map (KeyHash StakePool) StakePoolState
stakePoolStates
                    ((StakePoolState
 -> Map (KeyHash StakePool) StakePoolState
 -> Map (KeyHash StakePool) StakePoolState)
-> Map (KeyHash StakePool) StakePoolState
-> StakePoolState
-> Map (KeyHash StakePool) StakePoolState
forall a b c. (a -> b -> c) -> b -> a -> c
flip (KeyHash StakePool
-> StakePoolState
-> Map (KeyHash StakePool) StakePoolState
-> Map (KeyHash StakePool) StakePoolState
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert KeyHash StakePool
k) Map (KeyHash StakePool) StakePoolState
stakePoolStates (StakePoolState -> Map (KeyHash StakePool) StakePoolState)
-> (CanonicalStakePoolState -> StakePoolState)
-> CanonicalStakePoolState
-> Map (KeyHash StakePool) StakePoolState
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CanonicalStakePoolState -> StakePoolState
fromCanonicalStakePoolState)
                    StrictMaybe CanonicalStakePoolState
mStakePoolState
                retiringEpochNos' :: Map (KeyHash StakePool) EpochNo
retiringEpochNos' = Map (KeyHash StakePool) EpochNo
-> (EpochNo -> Map (KeyHash StakePool) EpochNo)
-> StrictMaybe EpochNo
-> Map (KeyHash StakePool) EpochNo
forall a b. a -> (b -> a) -> StrictMaybe b -> a
strictMaybe Map (KeyHash StakePool) EpochNo
retiringEpochNos ((EpochNo
 -> Map (KeyHash StakePool) EpochNo
 -> Map (KeyHash StakePool) EpochNo)
-> Map (KeyHash StakePool) EpochNo
-> EpochNo
-> Map (KeyHash StakePool) EpochNo
forall a b c. (a -> b -> c) -> b -> a -> c
flip (KeyHash StakePool
-> EpochNo
-> Map (KeyHash StakePool) EpochNo
-> Map (KeyHash StakePool) EpochNo
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert KeyHash StakePool
k) Map (KeyHash StakePool) EpochNo
retiringEpochNos) StrictMaybe EpochNo
mRetiringEpochNo
                futureStakePoolParams' :: Map (KeyHash StakePool) StakePoolParams
futureStakePoolParams' =
                  Map (KeyHash StakePool) StakePoolParams
-> (CanonicalStakePoolParams
    -> Map (KeyHash StakePool) StakePoolParams)
-> StrictMaybe CanonicalStakePoolParams
-> Map (KeyHash StakePool) StakePoolParams
forall a b. a -> (b -> a) -> StrictMaybe b -> a
strictMaybe
                    Map (KeyHash StakePool) StakePoolParams
futureStakePoolParams
                    ((StakePoolParams
 -> Map (KeyHash StakePool) StakePoolParams
 -> Map (KeyHash StakePool) StakePoolParams)
-> Map (KeyHash StakePool) StakePoolParams
-> StakePoolParams
-> Map (KeyHash StakePool) StakePoolParams
forall a b c. (a -> b -> c) -> b -> a -> c
flip (KeyHash StakePool
-> StakePoolParams
-> Map (KeyHash StakePool) StakePoolParams
-> Map (KeyHash StakePool) StakePoolParams
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert KeyHash StakePool
k) Map (KeyHash StakePool) StakePoolParams
futureStakePoolParams (StakePoolParams -> Map (KeyHash StakePool) StakePoolParams)
-> (CanonicalStakePoolParams -> StakePoolParams)
-> CanonicalStakePoolParams
-> Map (KeyHash StakePool) StakePoolParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CanonicalStakePoolParams -> StakePoolParams
fromCanonicalStakePoolParams)
                    StrictMaybe CanonicalStakePoolParams
mFutureStakePoolParams
             in (Map (KeyHash StakePool) StakePoolState
stakePoolStates', Map (KeyHash StakePool) EpochNo
retiringEpochNos', Map (KeyHash StakePool) StakePoolParams
futureStakePoolParams')
      )
      (Map (KeyHash StakePool) StakePoolState,
 Map (KeyHash StakePool) EpochNo,
 Map (KeyHash StakePool) StakePoolParams)
forall a. Monoid a => a
mempty
      ( \(Map (KeyHash StakePool) StakePoolState
stakePoolStates, Map (KeyHash StakePool) EpochNo
retiringEpochNos, Map (KeyHash StakePool) StakePoolParams
futureStakePoolParams) ->
          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)
nesEsL
              ((EpochState ConwayEra -> Identity (EpochState ConwayEra))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> ((Map (KeyHash StakePool) StakePoolState
     -> Identity (Map (KeyHash StakePool) StakePoolState))
    -> EpochState ConwayEra -> Identity (EpochState ConwayEra))
-> (Map (KeyHash StakePool) StakePoolState
    -> Identity (Map (KeyHash StakePool) StakePoolState))
-> 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))
-> ((Map (KeyHash StakePool) StakePoolState
     -> Identity (Map (KeyHash StakePool) StakePoolState))
    -> LedgerState ConwayEra -> Identity (LedgerState ConwayEra))
-> (Map (KeyHash StakePool) StakePoolState
    -> Identity (Map (KeyHash StakePool) StakePoolState))
-> 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))
-> ((Map (KeyHash StakePool) StakePoolState
     -> Identity (Map (KeyHash StakePool) StakePoolState))
    -> ConwayCertState ConwayEra
    -> Identity (ConwayCertState ConwayEra))
-> (Map (KeyHash StakePool) StakePoolState
    -> Identity (Map (KeyHash StakePool) StakePoolState))
-> LedgerState ConwayEra
-> Identity (LedgerState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PState ConwayEra -> Identity (PState ConwayEra))
-> CertState ConwayEra -> Identity (CertState ConwayEra)
(PState ConwayEra -> Identity (PState ConwayEra))
-> ConwayCertState ConwayEra
-> Identity (ConwayCertState ConwayEra)
forall era. EraCertState era => Lens' (CertState era) (PState era)
Lens' (CertState ConwayEra) (PState ConwayEra)
certPStateL
              ((PState ConwayEra -> Identity (PState ConwayEra))
 -> ConwayCertState ConwayEra
 -> Identity (ConwayCertState ConwayEra))
-> ((Map (KeyHash StakePool) StakePoolState
     -> Identity (Map (KeyHash StakePool) StakePoolState))
    -> PState ConwayEra -> Identity (PState ConwayEra))
-> (Map (KeyHash StakePool) StakePoolState
    -> Identity (Map (KeyHash StakePool) StakePoolState))
-> ConwayCertState ConwayEra
-> Identity (ConwayCertState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash StakePool) StakePoolState
 -> Identity (Map (KeyHash StakePool) StakePoolState))
-> PState ConwayEra -> Identity (PState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash StakePool) StakePoolState
 -> f (Map (KeyHash StakePool) StakePoolState))
-> PState era -> f (PState era)
psStakePoolsL
              ((Map (KeyHash StakePool) StakePoolState
  -> Identity (Map (KeyHash StakePool) StakePoolState))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> Map (KeyHash StakePool) StakePoolState
-> NewEpochState ConwayEra
-> NewEpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Map (KeyHash StakePool) StakePoolState
stakePoolStates
            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)
nesEsL
              ((EpochState ConwayEra -> Identity (EpochState ConwayEra))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> ((Map (KeyHash StakePool) EpochNo
     -> Identity (Map (KeyHash StakePool) EpochNo))
    -> EpochState ConwayEra -> Identity (EpochState ConwayEra))
-> (Map (KeyHash StakePool) EpochNo
    -> Identity (Map (KeyHash StakePool) EpochNo))
-> 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))
-> ((Map (KeyHash StakePool) EpochNo
     -> Identity (Map (KeyHash StakePool) EpochNo))
    -> LedgerState ConwayEra -> Identity (LedgerState ConwayEra))
-> (Map (KeyHash StakePool) EpochNo
    -> Identity (Map (KeyHash StakePool) EpochNo))
-> 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))
-> ((Map (KeyHash StakePool) EpochNo
     -> Identity (Map (KeyHash StakePool) EpochNo))
    -> ConwayCertState ConwayEra
    -> Identity (ConwayCertState ConwayEra))
-> (Map (KeyHash StakePool) EpochNo
    -> Identity (Map (KeyHash StakePool) EpochNo))
-> LedgerState ConwayEra
-> Identity (LedgerState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PState ConwayEra -> Identity (PState ConwayEra))
-> CertState ConwayEra -> Identity (CertState ConwayEra)
(PState ConwayEra -> Identity (PState ConwayEra))
-> ConwayCertState ConwayEra
-> Identity (ConwayCertState ConwayEra)
forall era. EraCertState era => Lens' (CertState era) (PState era)
Lens' (CertState ConwayEra) (PState ConwayEra)
certPStateL
              ((PState ConwayEra -> Identity (PState ConwayEra))
 -> ConwayCertState ConwayEra
 -> Identity (ConwayCertState ConwayEra))
-> ((Map (KeyHash StakePool) EpochNo
     -> Identity (Map (KeyHash StakePool) EpochNo))
    -> PState ConwayEra -> Identity (PState ConwayEra))
-> (Map (KeyHash StakePool) EpochNo
    -> Identity (Map (KeyHash StakePool) EpochNo))
-> ConwayCertState ConwayEra
-> Identity (ConwayCertState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash StakePool) EpochNo
 -> Identity (Map (KeyHash StakePool) EpochNo))
-> PState ConwayEra -> Identity (PState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Map (KeyHash StakePool) EpochNo
 -> f (Map (KeyHash StakePool) EpochNo))
-> PState era -> f (PState era)
psRetiringL
              ((Map (KeyHash StakePool) EpochNo
  -> Identity (Map (KeyHash StakePool) EpochNo))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> Map (KeyHash StakePool) EpochNo
-> NewEpochState ConwayEra
-> NewEpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Map (KeyHash StakePool) EpochNo
retiringEpochNos
            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)
nesEsL
              ((EpochState ConwayEra -> Identity (EpochState ConwayEra))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> ((Map (KeyHash StakePool) StakePoolParams
     -> Identity (Map (KeyHash StakePool) StakePoolParams))
    -> EpochState ConwayEra -> Identity (EpochState ConwayEra))
-> (Map (KeyHash StakePool) StakePoolParams
    -> Identity (Map (KeyHash StakePool) StakePoolParams))
-> 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))
-> ((Map (KeyHash StakePool) StakePoolParams
     -> Identity (Map (KeyHash StakePool) StakePoolParams))
    -> LedgerState ConwayEra -> Identity (LedgerState ConwayEra))
-> (Map (KeyHash StakePool) StakePoolParams
    -> Identity (Map (KeyHash StakePool) StakePoolParams))
-> 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))
-> ((Map (KeyHash StakePool) StakePoolParams
     -> Identity (Map (KeyHash StakePool) StakePoolParams))
    -> ConwayCertState ConwayEra
    -> Identity (ConwayCertState ConwayEra))
-> (Map (KeyHash StakePool) StakePoolParams
    -> Identity (Map (KeyHash StakePool) StakePoolParams))
-> LedgerState ConwayEra
-> Identity (LedgerState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PState ConwayEra -> Identity (PState ConwayEra))
-> CertState ConwayEra -> Identity (CertState ConwayEra)
(PState ConwayEra -> Identity (PState ConwayEra))
-> ConwayCertState ConwayEra
-> Identity (ConwayCertState ConwayEra)
forall era. EraCertState era => Lens' (CertState era) (PState era)
Lens' (CertState ConwayEra) (PState ConwayEra)
certPStateL
              ((PState ConwayEra -> Identity (PState ConwayEra))
 -> ConwayCertState ConwayEra
 -> Identity (ConwayCertState ConwayEra))
-> ((Map (KeyHash StakePool) StakePoolParams
     -> Identity (Map (KeyHash StakePool) StakePoolParams))
    -> PState ConwayEra -> Identity (PState ConwayEra))
-> (Map (KeyHash StakePool) StakePoolParams
    -> Identity (Map (KeyHash StakePool) StakePoolParams))
-> ConwayCertState ConwayEra
-> Identity (ConwayCertState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (KeyHash StakePool) StakePoolParams
 -> Identity (Map (KeyHash StakePool) StakePoolParams))
-> PState ConwayEra -> Identity (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) StakePoolParams
  -> Identity (Map (KeyHash StakePool) StakePoolParams))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> Map (KeyHash StakePool) StakePoolParams
-> NewEpochState ConwayEra
-> NewEpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Map (KeyHash StakePool) StakePoolParams
futureStakePoolParams
      )

instance ImportCanonicalNamespace ConwayEra "entities/stake_pools/vrf_key_hashes/v0" where
  importNamespaceEntries :: 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
     ()
-> m (State ConwayEra)
importNamespaceEntries State ConwayEra
nes =
    (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
 -> ChunkEntry
      EntitiesStakePoolsVRFKeyHashesIn EntitiesStakePoolsVRFKeyHashesOut
 -> Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64))
-> Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
-> (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
    -> NewEpochState ConwayEra)
-> Stream
     (Of
        (ChunkEntry
           EntitiesStakePoolsVRFKeyHashesIn
           EntitiesStakePoolsVRFKeyHashesOut))
     m
     ()
-> m (NewEpochState ConwayEra)
forall (m :: * -> *) x a b r.
Monad m =>
(x -> a -> x) -> x -> (x -> b) -> Stream (Of a) m r -> m b
S.fold_
      ( \Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
stakePoolsVrfKeyHashes
         ( ChunkEntry
             (EntitiesStakePoolsVRFKeyHashesIn VRFVerKeyHash StakePoolVRF
k)
             (EntitiesStakePoolsVRFKeyHashesOut NonZero Word64
n)
           ) ->
            VRFVerKeyHash StakePoolVRF
-> NonZero Word64
-> Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
-> Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert VRFVerKeyHash StakePoolVRF
k NonZero Word64
n Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
stakePoolsVrfKeyHashes
      )
      Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
forall a. Monoid a => a
mempty
      ( \Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
stakePoolsVrfKeyHashes ->
          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)
nesEsL
              ((EpochState ConwayEra -> Identity (EpochState ConwayEra))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> ((Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
     -> Identity (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
    -> EpochState ConwayEra -> Identity (EpochState ConwayEra))
-> (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
    -> Identity (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
-> 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))
-> ((Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
     -> Identity (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
    -> LedgerState ConwayEra -> Identity (LedgerState ConwayEra))
-> (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
    -> Identity (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
-> 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))
-> ((Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
     -> Identity (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
    -> ConwayCertState ConwayEra
    -> Identity (ConwayCertState ConwayEra))
-> (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
    -> Identity (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
-> LedgerState ConwayEra
-> Identity (LedgerState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PState ConwayEra -> Identity (PState ConwayEra))
-> CertState ConwayEra -> Identity (CertState ConwayEra)
(PState ConwayEra -> Identity (PState ConwayEra))
-> ConwayCertState ConwayEra
-> Identity (ConwayCertState ConwayEra)
forall era. EraCertState era => Lens' (CertState era) (PState era)
Lens' (CertState ConwayEra) (PState ConwayEra)
certPStateL
              ((PState ConwayEra -> Identity (PState ConwayEra))
 -> ConwayCertState ConwayEra
 -> Identity (ConwayCertState ConwayEra))
-> ((Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
     -> Identity (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
    -> PState ConwayEra -> Identity (PState ConwayEra))
-> (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
    -> Identity (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
-> ConwayCertState ConwayEra
-> Identity (ConwayCertState ConwayEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
 -> Identity (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
-> PState ConwayEra -> Identity (PState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
 -> f (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
-> PState era -> f (PState era)
psVRFKeyHashesL
              ((Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
  -> Identity (Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)))
 -> NewEpochState ConwayEra -> Identity (NewEpochState ConwayEra))
-> Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
-> NewEpochState ConwayEra
-> NewEpochState ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
stakePoolsVrfKeyHashes
      )

instance ImportCanonicalState ConwayEra where
  importCanonicalState :: FilePath -> EpochNo -> IO (SlotNo, State ConwayEra)
importCanonicalState FilePath
filepath EpochNo
epochNo = do
    ((Manifest -> IO (SlotNo, NewEpochState ConwayEra))
 -> FilePath -> IO (SlotNo, State ConwayEra))
-> FilePath
-> (Manifest -> IO (SlotNo, NewEpochState ConwayEra))
-> IO (SlotNo, State ConwayEra)
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Manifest -> IO (SlotNo, NewEpochState ConwayEra))
-> FilePath -> IO (SlotNo, NewEpochState ConwayEra)
(Manifest -> IO (SlotNo, NewEpochState ConwayEra))
-> FilePath -> IO (SlotNo, State ConwayEra)
forall r. (Manifest -> IO r) -> FilePath -> IO r
withLatestManifestFrame FilePath
filepath ((Manifest -> IO (SlotNo, NewEpochState ConwayEra))
 -> IO (SlotNo, State ConwayEra))
-> (Manifest -> IO (SlotNo, NewEpochState ConwayEra))
-> IO (SlotNo, State ConwayEra)
forall a b. (a -> b) -> a -> b
$ \Manifest {SlotNo
slotNo :: SlotNo
slotNo :: Manifest -> SlotNo
slotNo} ->
      FilePath
-> IOMode
-> (Handle -> IO (SlotNo, NewEpochState ConwayEra))
-> IO (SlotNo, NewEpochState ConwayEra)
forall r. FilePath -> IOMode -> (Handle -> IO r) -> IO r
withBinaryFile FilePath
filepath IOMode
ReadMode ((Handle -> IO (SlotNo, NewEpochState ConwayEra))
 -> IO (SlotNo, NewEpochState ConwayEra))
-> (Handle -> IO (SlotNo, NewEpochState ConwayEra))
-> IO (SlotNo, NewEpochState ConwayEra)
forall a b. (a -> b) -> a -> b
$ \Handle
h ->
        forall (v :: Symbol).
(ImportCanonicalNamespace ConwayEra v, KnownSymbol v) =>
Handle -> State ConwayEra -> IO (State ConwayEra)
importNs @"utxo/v0" Handle
h NewEpochState ConwayEra
State ConwayEra
defaultNes
          IO (NewEpochState ConwayEra)
-> (NewEpochState ConwayEra -> IO (NewEpochState ConwayEra))
-> IO (NewEpochState ConwayEra)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (v :: Symbol).
(ImportCanonicalNamespace ConwayEra v, KnownSymbol v) =>
Handle -> State ConwayEra -> IO (State ConwayEra)
importNs @"blocks/v0" Handle
h
          IO (NewEpochState ConwayEra)
-> (NewEpochState ConwayEra -> IO (NewEpochState ConwayEra))
-> IO (NewEpochState ConwayEra)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (v :: Symbol).
(ImportCanonicalNamespace ConwayEra v, KnownSymbol v) =>
Handle -> State ConwayEra -> IO (State ConwayEra)
importNs @"gov/committee/v0" Handle
h
          IO (NewEpochState ConwayEra)
-> (NewEpochState ConwayEra -> IO (NewEpochState ConwayEra))
-> IO (NewEpochState ConwayEra)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (v :: Symbol).
(ImportCanonicalNamespace ConwayEra v, KnownSymbol v) =>
Handle -> State ConwayEra -> IO (State ConwayEra)
importNs @"gov/constitution/v0" Handle
h
          IO (NewEpochState ConwayEra)
-> (NewEpochState ConwayEra -> IO (NewEpochState ConwayEra))
-> IO (NewEpochState ConwayEra)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (v :: Symbol).
(ImportCanonicalNamespace ConwayEra v, KnownSymbol v) =>
Handle -> State ConwayEra -> IO (State ConwayEra)
importNs @"gov/pparams/v0" Handle
h
          IO (NewEpochState ConwayEra)
-> (NewEpochState ConwayEra -> IO (NewEpochState ConwayEra))
-> IO (NewEpochState ConwayEra)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (v :: Symbol).
(ImportCanonicalNamespace ConwayEra v, KnownSymbol v) =>
Handle -> State ConwayEra -> IO (State ConwayEra)
importNs @"gov/proposals/roots/v0" Handle
h
          IO (NewEpochState ConwayEra)
-> (NewEpochState ConwayEra -> IO (NewEpochState ConwayEra))
-> IO (NewEpochState ConwayEra)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (v :: Symbol).
(ImportCanonicalNamespace ConwayEra v, KnownSymbol v) =>
Handle -> State ConwayEra -> IO (State ConwayEra)
importNs @"gov/proposals/v0" Handle
h
          IO (NewEpochState ConwayEra)
-> (NewEpochState ConwayEra -> IO (NewEpochState ConwayEra))
-> IO (NewEpochState ConwayEra)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (v :: Symbol).
(ImportCanonicalNamespace ConwayEra v, KnownSymbol v) =>
Handle -> State ConwayEra -> IO (State ConwayEra)
importNs @"entities/accounts/v0" Handle
h
          IO (NewEpochState ConwayEra)
-> (NewEpochState ConwayEra -> IO (NewEpochState ConwayEra))
-> IO (NewEpochState ConwayEra)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (v :: Symbol).
(ImportCanonicalNamespace ConwayEra v, KnownSymbol v) =>
Handle -> State ConwayEra -> IO (State ConwayEra)
importNs @"entities/dreps/v0" Handle
h
          IO (NewEpochState ConwayEra)
-> (NewEpochState ConwayEra -> IO (NewEpochState ConwayEra))
-> IO (NewEpochState ConwayEra)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (v :: Symbol).
(ImportCanonicalNamespace ConwayEra v, KnownSymbol v) =>
Handle -> State ConwayEra -> IO (State ConwayEra)
importNs @"entities/committee/v0" Handle
h
          IO (NewEpochState ConwayEra)
-> (NewEpochState ConwayEra -> IO (NewEpochState ConwayEra))
-> IO (NewEpochState ConwayEra)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (v :: Symbol).
(ImportCanonicalNamespace ConwayEra v, KnownSymbol v) =>
Handle -> State ConwayEra -> IO (State ConwayEra)
importNs @"entities/stake_pools/v0" Handle
h
          IO (NewEpochState ConwayEra)
-> (NewEpochState ConwayEra -> IO (NewEpochState ConwayEra))
-> IO (NewEpochState ConwayEra)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (v :: Symbol).
(ImportCanonicalNamespace ConwayEra v, KnownSymbol v) =>
Handle -> State ConwayEra -> IO (State ConwayEra)
importNs @"entities/stake_pools/vrf_key_hashes/v0" Handle
h
          IO (NewEpochState ConwayEra)
-> (NewEpochState ConwayEra
    -> IO (SlotNo, NewEpochState ConwayEra))
-> IO (SlotNo, NewEpochState ConwayEra)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \NewEpochState ConwayEra
nes -> do
            -- Finalize the state with the data that requires computation/cross-namespace data
            nes' <- NewEpochState ConwayEra -> NewEpochState ConwayEra
forall {era}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 EraGov era, EraCertState era) =>
NewEpochState era -> NewEpochState era
computeTotalObligation (NewEpochState ConwayEra -> NewEpochState ConwayEra)
-> IO (NewEpochState ConwayEra) -> IO (NewEpochState ConwayEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NewEpochState ConwayEra -> IO (NewEpochState ConwayEra)
forall {era} {era} {m :: * -> *}.
(GovState era ~ ConwayGovState era,
 Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat 0 (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 EraPParams era, MonadFail m) =>
NewEpochState era -> m (NewEpochState era)
recreateProposals NewEpochState ConwayEra
nes
            pure (SlotNo (SSlotNo.unSlotNo slotNo), nes')
    where
      importNs ::
        forall v.
        (ImportCanonicalNamespace ConwayEra v, KnownSymbol v) =>
        Handle -> State ConwayEra -> IO (State ConwayEra)
      importNs :: forall (v :: Symbol).
(ImportCanonicalNamespace ConwayEra v, KnownSymbol v) =>
Handle -> State ConwayEra -> IO (State ConwayEra)
importNs Handle
h = forall era (v :: Symbol) (m :: * -> *).
(KnownSymbol v, ImportCanonicalNamespace era v, MonadIO m,
 MonadFail m) =>
Handle -> Proxy v -> State era -> m (State era)
importNamespaceFromHandle @ConwayEra Handle
h (Proxy v
forall {k} (t :: k). Proxy t
Proxy :: Proxy v)
      defaultNes :: NewEpochState ConwayEra
defaultNes =
        (forall a. Default a => a
def @(NewEpochState ConwayEra))
          { nesEL = epochNo
          }
      recreateProposals :: NewEpochState era -> m (NewEpochState era)
recreateProposals NewEpochState era
nes = do
        let govState :: ConwayGovState era
govState = NewEpochState era
nes NewEpochState era
-> Getting
     (ConwayGovState era) (NewEpochState era) (ConwayGovState era)
-> ConwayGovState era
forall s a. s -> Getting a s a -> a
^. (GovState era -> Const (ConwayGovState era) (GovState era))
-> NewEpochState era
-> Const (ConwayGovState era) (NewEpochState era)
Getting
  (ConwayGovState era) (NewEpochState era) (ConwayGovState era)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> NewEpochState era -> f (NewEpochState era)
newEpochStateGovStateL
            proposalsMap :: OMap GovActionId (GovActionState era)
proposalsMap = ConwayGovState era
govState ConwayGovState era
-> Getting
     (OMap GovActionId (GovActionState era))
     (ConwayGovState era)
     (OMap GovActionId (GovActionState era))
-> OMap GovActionId (GovActionState era)
forall s a. s -> Getting a s a -> a
^. (Proposals era
 -> Const (OMap GovActionId (GovActionState era)) (Proposals era))
-> ConwayGovState era
-> Const
     (OMap GovActionId (GovActionState era)) (ConwayGovState era)
forall era (f :: * -> *).
Functor f =>
(Proposals era -> f (Proposals era))
-> ConwayGovState era -> f (ConwayGovState era)
cgsProposalsL ((Proposals era
  -> Const (OMap GovActionId (GovActionState era)) (Proposals era))
 -> ConwayGovState era
 -> Const
      (OMap GovActionId (GovActionState era)) (ConwayGovState era))
-> ((OMap GovActionId (GovActionState era)
     -> Const
          (OMap GovActionId (GovActionState era))
          (OMap GovActionId (GovActionState era)))
    -> Proposals era
    -> Const (OMap GovActionId (GovActionState era)) (Proposals era))
-> Getting
     (OMap GovActionId (GovActionState era))
     (ConwayGovState era)
     (OMap GovActionId (GovActionState era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (OMap GovActionId (GovActionState era)
 -> Const
      (OMap GovActionId (GovActionState era))
      (OMap GovActionId (GovActionState era)))
-> Proposals era
-> Const (OMap GovActionId (GovActionState era)) (Proposals era)
forall era (f :: * -> *).
Functor f =>
(OMap GovActionId (GovActionState era)
 -> f (OMap GovActionId (GovActionState era)))
-> Proposals era -> f (Proposals era)
pPropsL
            prevActionsIds :: GovRelation StrictMaybe
prevActionsIds = GovRelation PRoot -> GovRelation StrictMaybe
toPrevGovActionIds (ConwayGovState era
govState ConwayGovState era
-> Getting
     (GovRelation PRoot) (ConwayGovState era) (GovRelation PRoot)
-> GovRelation PRoot
forall s a. s -> Getting a s a -> a
^. (Proposals era -> Const (GovRelation PRoot) (Proposals era))
-> ConwayGovState era
-> Const (GovRelation PRoot) (ConwayGovState era)
forall era (f :: * -> *).
Functor f =>
(Proposals era -> f (Proposals era))
-> ConwayGovState era -> f (ConwayGovState era)
cgsProposalsL ((Proposals era -> Const (GovRelation PRoot) (Proposals era))
 -> ConwayGovState era
 -> Const (GovRelation PRoot) (ConwayGovState era))
-> ((GovRelation PRoot
     -> Const (GovRelation PRoot) (GovRelation PRoot))
    -> Proposals era -> Const (GovRelation PRoot) (Proposals era))
-> Getting
     (GovRelation PRoot) (ConwayGovState era) (GovRelation PRoot)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GovRelation PRoot
 -> Const (GovRelation PRoot) (GovRelation PRoot))
-> Proposals era -> Const (GovRelation PRoot) (Proposals era)
forall era (f :: * -> *).
Functor f =>
(GovRelation PRoot -> f (GovRelation PRoot))
-> Proposals era -> f (Proposals era)
pRootsL)
        proposals <- GovRelation StrictMaybe
-> OMap GovActionId (GovActionState era) -> m (Proposals era)
forall era (m :: * -> *).
(EraPParams era, MonadFail m) =>
GovRelation StrictMaybe
-> OMap GovActionId (GovActionState era) -> m (Proposals era)
mkProposals GovRelation StrictMaybe
prevActionsIds OMap GovActionId (GovActionState era)
proposalsMap
        pure (nes & newEpochStateGovStateL . cgsProposalsL .~ proposals)
      computeTotalObligation :: NewEpochState era -> NewEpochState era
computeTotalObligation NewEpochState era
nes =
        let certState :: CertState era
certState = NewEpochState era
nes NewEpochState era
-> Getting (CertState era) (NewEpochState era) (CertState era)
-> CertState era
forall s a. s -> Getting a s a -> a
^. (EpochState era -> Const (CertState era) (EpochState era))
-> NewEpochState era -> Const (CertState era) (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL ((EpochState era -> Const (CertState era) (EpochState era))
 -> NewEpochState era -> Const (CertState era) (NewEpochState era))
-> ((CertState era -> Const (CertState era) (CertState era))
    -> EpochState era -> Const (CertState era) (EpochState era))
-> Getting (CertState era) (NewEpochState era) (CertState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> Const (CertState era) (LedgerState era))
-> EpochState era -> Const (CertState era) (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL ((LedgerState era -> Const (CertState era) (LedgerState era))
 -> EpochState era -> Const (CertState era) (EpochState era))
-> ((CertState era -> Const (CertState era) (CertState era))
    -> LedgerState era -> Const (CertState era) (LedgerState era))
-> (CertState era -> Const (CertState era) (CertState era))
-> EpochState era
-> Const (CertState era) (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CertState era -> Const (CertState era) (CertState era))
-> LedgerState era -> Const (CertState era) (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL
            govState :: GovState era
govState = NewEpochState era
nes NewEpochState era
-> Getting (GovState era) (NewEpochState era) (GovState era)
-> GovState era
forall s a. s -> Getting a s a -> a
^. Getting (GovState era) (NewEpochState era) (GovState era)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> NewEpochState era -> f (NewEpochState era)
newEpochStateGovStateL
         in NewEpochState era
nes
              NewEpochState era
-> (NewEpochState era -> NewEpochState era) -> NewEpochState era
forall a b. a -> (a -> b) -> b
& (EpochState era -> Identity (EpochState era))
-> NewEpochState era -> Identity (NewEpochState era)
forall era (f :: * -> *).
Functor f =>
(EpochState era -> f (EpochState era))
-> NewEpochState era -> f (NewEpochState era)
nesEsL
                ((EpochState era -> Identity (EpochState era))
 -> NewEpochState era -> Identity (NewEpochState era))
-> ((Coin -> Identity Coin)
    -> EpochState era -> Identity (EpochState era))
-> (Coin -> Identity Coin)
-> NewEpochState era
-> Identity (NewEpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LedgerState era -> Identity (LedgerState era))
-> EpochState era -> Identity (EpochState era)
forall era (f :: * -> *).
Functor f =>
(LedgerState era -> f (LedgerState era))
-> EpochState era -> f (EpochState era)
esLStateL
                ((LedgerState era -> Identity (LedgerState era))
 -> EpochState era -> Identity (EpochState era))
-> ((Coin -> Identity Coin)
    -> LedgerState era -> Identity (LedgerState era))
-> (Coin -> Identity Coin)
-> EpochState era
-> Identity (EpochState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UTxOState era -> Identity (UTxOState era))
-> LedgerState era -> Identity (LedgerState era)
forall era (f :: * -> *).
Functor f =>
(UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
lsUTxOStateL
                ((UTxOState era -> Identity (UTxOState era))
 -> LedgerState era -> Identity (LedgerState era))
-> ((Coin -> Identity Coin)
    -> UTxOState era -> Identity (UTxOState era))
-> (Coin -> Identity Coin)
-> LedgerState era
-> Identity (LedgerState era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Coin -> Identity Coin)
-> UTxOState era -> Identity (UTxOState era)
forall era (f :: * -> *).
Functor f =>
(Coin -> f Coin) -> UTxOState era -> f (UTxOState era)
utxosDepositedL
                ((Coin -> Identity Coin)
 -> NewEpochState era -> Identity (NewEpochState era))
-> Coin -> NewEpochState era -> NewEpochState era
forall s t a b. ASetter s t a b -> b -> s -> t
.~ CertState era -> GovState era -> Coin
forall era.
(EraGov era, EraCertState era) =>
CertState era -> GovState era -> Coin
totalObligation CertState era
certState GovState era
govState