{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Ledger.Dijkstra.Translation () where

import Cardano.Ledger.Alonzo.Core (
  AlonzoEraTx (..),
  EraTx (mkBasicTx),
  FuturePParams (..),
 )
import Cardano.Ledger.Binary (DecoderError)
import Cardano.Ledger.Conway (ConwayEra)
import Cardano.Ledger.Conway.Governance (
  ConwayGovState (..),
  DRepPulsingState (..),
  EnactState (..),
  GovAction (..),
  GovActionState (..),
  ProposalProcedure (..),
  Proposals,
  PulsingSnapshot,
  RatifyState (..),
  finishDRepPulser,
  mkEnactState,
  rsEnactStateL,
  setCompleteDRepPulsingState,
  translateProposals,
 )
import Cardano.Ledger.Conway.Governance.DRepPulser (PulsingSnapshot (..))
import Cardano.Ledger.Conway.State (ConwayInstantStake (..), EraCertState (..))
import Cardano.Ledger.Core (
  EraTx (auxDataTxL, bodyTxL, witsTxL),
  EraTxOut (..),
  PParams,
  TranslateEra (..),
  TranslationContext,
  translateEra',
  translateEraThroughCBOR,
  upgradePParams,
 )
import qualified Cardano.Ledger.Core as Core
import Cardano.Ledger.Dijkstra.Era (DijkstraEra)
import Cardano.Ledger.Dijkstra.Genesis (DijkstraGenesis)
import Cardano.Ledger.Dijkstra.Governance ()
import Cardano.Ledger.Dijkstra.State.CertState ()
import Cardano.Ledger.Dijkstra.Tx ()
import Cardano.Ledger.Dijkstra.TxAuxData ()
import Cardano.Ledger.Dijkstra.TxBody (upgradeGovAction, upgradeProposals)
import Cardano.Ledger.Dijkstra.TxWits ()
import qualified Cardano.Ledger.Shelley.API as API
import Cardano.Ledger.Shelley.LedgerState (
  DState (..),
  EpochState (..),
  NewEpochState (..),
  PState (..),
  UTxOState (..),
  epochStateGovStateL,
  lsCertStateL,
  lsUTxOStateL,
 )
import qualified Cardano.Ledger.UMap as UM
import Data.Coerce (coerce)
import Data.Default (Default (..))
import qualified Data.Map.Strict as Map
import Lens.Micro ((&), (.~), (^.))

type instance TranslationContext DijkstraEra = DijkstraGenesis

newtype Tx era = Tx (Core.Tx era)

instance TranslateEra DijkstraEra Tx where
  type TranslationError DijkstraEra Tx = DecoderError
  translateEra :: TranslationContext DijkstraEra
-> Tx (PreviousEra DijkstraEra)
-> Except (TranslationError DijkstraEra Tx) (Tx DijkstraEra)
translateEra TranslationContext DijkstraEra
_ctxt (Tx Tx (PreviousEra DijkstraEra)
tx) = do
    -- Note that this does not preserve the hidden bytes field of the transaction.
    -- This is under the premise that this is irrelevant for TxInBlocks, which are
    -- not transmitted as contiguous chunks.
    TxBody DijkstraEra
txBody <- Text
-> TxBody (PreviousEra DijkstraEra)
-> Except DecoderError (TxBody DijkstraEra)
forall era (ti :: * -> *) (to :: * -> *).
(Era era, ToCBOR (ti (PreviousEra era)),
 DecCBOR (Annotator (to era))) =>
Text -> ti (PreviousEra era) -> Except DecoderError (to era)
translateEraThroughCBOR Text
"TxBody" (TxBody (PreviousEra DijkstraEra)
 -> Except DecoderError (TxBody DijkstraEra))
-> TxBody (PreviousEra DijkstraEra)
-> Except DecoderError (TxBody DijkstraEra)
forall a b. (a -> b) -> a -> b
$ Tx (PreviousEra DijkstraEra)
AlonzoTx ConwayEra
tx AlonzoTx ConwayEra
-> Getting
     (TxBody (PreviousEra DijkstraEra))
     (AlonzoTx ConwayEra)
     (TxBody (PreviousEra DijkstraEra))
-> TxBody (PreviousEra DijkstraEra)
forall s a. s -> Getting a s a -> a
^. (TxBody (PreviousEra DijkstraEra)
 -> Const
      (TxBody (PreviousEra DijkstraEra))
      (TxBody (PreviousEra DijkstraEra)))
-> Tx (PreviousEra DijkstraEra)
-> Const
     (TxBody (PreviousEra DijkstraEra)) (Tx (PreviousEra DijkstraEra))
Getting
  (TxBody (PreviousEra DijkstraEra))
  (AlonzoTx ConwayEra)
  (TxBody (PreviousEra DijkstraEra))
forall era. EraTx era => Lens' (Tx era) (TxBody era)
Lens'
  (Tx (PreviousEra DijkstraEra)) (TxBody (PreviousEra DijkstraEra))
bodyTxL
    AlonzoTxWits DijkstraEra
txWits <- Text
-> AlonzoTxWits (PreviousEra DijkstraEra)
-> Except DecoderError (AlonzoTxWits DijkstraEra)
forall era (ti :: * -> *) (to :: * -> *).
(Era era, ToCBOR (ti (PreviousEra era)),
 DecCBOR (Annotator (to era))) =>
Text -> ti (PreviousEra era) -> Except DecoderError (to era)
translateEraThroughCBOR Text
"TxWits" (AlonzoTxWits (PreviousEra DijkstraEra)
 -> Except DecoderError (AlonzoTxWits DijkstraEra))
-> AlonzoTxWits (PreviousEra DijkstraEra)
-> Except DecoderError (AlonzoTxWits DijkstraEra)
forall a b. (a -> b) -> a -> b
$ Tx (PreviousEra DijkstraEra)
AlonzoTx ConwayEra
tx AlonzoTx ConwayEra
-> Getting
     (AlonzoTxWits (PreviousEra DijkstraEra))
     (AlonzoTx ConwayEra)
     (AlonzoTxWits (PreviousEra DijkstraEra))
-> AlonzoTxWits (PreviousEra DijkstraEra)
forall s a. s -> Getting a s a -> a
^. (TxWits ConwayEra
 -> Const
      (AlonzoTxWits (PreviousEra DijkstraEra)) (TxWits ConwayEra))
-> Tx ConwayEra
-> Const (AlonzoTxWits (PreviousEra DijkstraEra)) (Tx ConwayEra)
Getting
  (AlonzoTxWits (PreviousEra DijkstraEra))
  (AlonzoTx ConwayEra)
  (AlonzoTxWits (PreviousEra DijkstraEra))
forall era. EraTx era => Lens' (Tx era) (TxWits era)
Lens' (Tx ConwayEra) (TxWits ConwayEra)
witsTxL
    StrictMaybe (AlonzoTxAuxData DijkstraEra)
auxData <- (AlonzoTxAuxData (PreviousEra DijkstraEra)
 -> ExceptT DecoderError Identity (AlonzoTxAuxData DijkstraEra))
-> StrictMaybe (AlonzoTxAuxData (PreviousEra DijkstraEra))
-> ExceptT
     DecoderError Identity (StrictMaybe (AlonzoTxAuxData DijkstraEra))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> StrictMaybe a -> m (StrictMaybe b)
mapM (Text
-> AlonzoTxAuxData (PreviousEra DijkstraEra)
-> ExceptT DecoderError Identity (AlonzoTxAuxData DijkstraEra)
forall era (ti :: * -> *) (to :: * -> *).
(Era era, ToCBOR (ti (PreviousEra era)),
 DecCBOR (Annotator (to era))) =>
Text -> ti (PreviousEra era) -> Except DecoderError (to era)
translateEraThroughCBOR Text
"TxAuxData") (Tx (PreviousEra DijkstraEra)
AlonzoTx ConwayEra
tx AlonzoTx ConwayEra
-> Getting
     (StrictMaybe (AlonzoTxAuxData (PreviousEra DijkstraEra)))
     (AlonzoTx ConwayEra)
     (StrictMaybe (AlonzoTxAuxData (PreviousEra DijkstraEra)))
-> StrictMaybe (AlonzoTxAuxData (PreviousEra DijkstraEra))
forall s a. s -> Getting a s a -> a
^. (StrictMaybe (TxAuxData ConwayEra)
 -> Const
      (StrictMaybe (AlonzoTxAuxData (PreviousEra DijkstraEra)))
      (StrictMaybe (TxAuxData ConwayEra)))
-> Tx ConwayEra
-> Const
     (StrictMaybe (AlonzoTxAuxData (PreviousEra DijkstraEra)))
     (Tx ConwayEra)
Getting
  (StrictMaybe (AlonzoTxAuxData (PreviousEra DijkstraEra)))
  (AlonzoTx ConwayEra)
  (StrictMaybe (AlonzoTxAuxData (PreviousEra DijkstraEra)))
forall era.
EraTx era =>
Lens' (Tx era) (StrictMaybe (TxAuxData era))
Lens' (Tx ConwayEra) (StrictMaybe (TxAuxData ConwayEra))
auxDataTxL)
    let isValidTx :: IsValid
isValidTx = Tx (PreviousEra DijkstraEra)
AlonzoTx ConwayEra
tx AlonzoTx ConwayEra
-> Getting IsValid (AlonzoTx ConwayEra) IsValid -> IsValid
forall s a. s -> Getting a s a -> a
^. (IsValid -> Const IsValid IsValid)
-> Tx ConwayEra -> Const IsValid (Tx ConwayEra)
Getting IsValid (AlonzoTx ConwayEra) IsValid
forall era. AlonzoEraTx era => Lens' (Tx era) IsValid
Lens' (Tx ConwayEra) IsValid
isValidTxL
        newTx :: AlonzoTx DijkstraEra
newTx =
          TxBody DijkstraEra -> Tx DijkstraEra
forall era. EraTx era => TxBody era -> Tx era
mkBasicTx TxBody DijkstraEra
txBody
            AlonzoTx DijkstraEra
-> (AlonzoTx DijkstraEra -> AlonzoTx DijkstraEra)
-> AlonzoTx DijkstraEra
forall a b. a -> (a -> b) -> b
& (TxWits DijkstraEra -> Identity (TxWits DijkstraEra))
-> Tx DijkstraEra -> Identity (Tx DijkstraEra)
(TxWits DijkstraEra -> Identity (AlonzoTxWits DijkstraEra))
-> AlonzoTx DijkstraEra -> Identity (AlonzoTx DijkstraEra)
forall era. EraTx era => Lens' (Tx era) (TxWits era)
Lens' (Tx DijkstraEra) (TxWits DijkstraEra)
witsTxL ((TxWits DijkstraEra -> Identity (AlonzoTxWits DijkstraEra))
 -> AlonzoTx DijkstraEra -> Identity (AlonzoTx DijkstraEra))
-> AlonzoTxWits DijkstraEra
-> AlonzoTx DijkstraEra
-> AlonzoTx DijkstraEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ AlonzoTxWits DijkstraEra
txWits
            AlonzoTx DijkstraEra
-> (AlonzoTx DijkstraEra -> AlonzoTx DijkstraEra)
-> AlonzoTx DijkstraEra
forall a b. a -> (a -> b) -> b
& (IsValid -> Identity IsValid)
-> Tx DijkstraEra -> Identity (Tx DijkstraEra)
(IsValid -> Identity IsValid)
-> AlonzoTx DijkstraEra -> Identity (AlonzoTx DijkstraEra)
forall era. AlonzoEraTx era => Lens' (Tx era) IsValid
Lens' (Tx DijkstraEra) IsValid
isValidTxL ((IsValid -> Identity IsValid)
 -> AlonzoTx DijkstraEra -> Identity (AlonzoTx DijkstraEra))
-> IsValid -> AlonzoTx DijkstraEra -> AlonzoTx DijkstraEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ IsValid
isValidTx
            AlonzoTx DijkstraEra
-> (AlonzoTx DijkstraEra -> AlonzoTx DijkstraEra)
-> AlonzoTx DijkstraEra
forall a b. a -> (a -> b) -> b
& (StrictMaybe (TxAuxData DijkstraEra)
 -> Identity (StrictMaybe (TxAuxData DijkstraEra)))
-> Tx DijkstraEra -> Identity (Tx DijkstraEra)
(StrictMaybe (TxAuxData DijkstraEra)
 -> Identity (StrictMaybe (AlonzoTxAuxData DijkstraEra)))
-> AlonzoTx DijkstraEra -> Identity (AlonzoTx DijkstraEra)
forall era.
EraTx era =>
Lens' (Tx era) (StrictMaybe (TxAuxData era))
Lens' (Tx DijkstraEra) (StrictMaybe (TxAuxData DijkstraEra))
auxDataTxL ((StrictMaybe (TxAuxData DijkstraEra)
  -> Identity (StrictMaybe (AlonzoTxAuxData DijkstraEra)))
 -> AlonzoTx DijkstraEra -> Identity (AlonzoTx DijkstraEra))
-> StrictMaybe (AlonzoTxAuxData DijkstraEra)
-> AlonzoTx DijkstraEra
-> AlonzoTx DijkstraEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ StrictMaybe (AlonzoTxAuxData DijkstraEra)
auxData
    Tx DijkstraEra -> ExceptT DecoderError Identity (Tx DijkstraEra)
forall a. a -> ExceptT DecoderError Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Tx DijkstraEra -> ExceptT DecoderError Identity (Tx DijkstraEra))
-> Tx DijkstraEra -> ExceptT DecoderError Identity (Tx DijkstraEra)
forall a b. (a -> b) -> a -> b
$ Tx DijkstraEra -> Tx DijkstraEra
forall era. Tx era -> Tx era
Tx Tx DijkstraEra
AlonzoTx DijkstraEra
newTx

instance TranslateEra DijkstraEra NewEpochState where
  translateEra :: TranslationContext DijkstraEra
-> NewEpochState (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra NewEpochState)
     (NewEpochState DijkstraEra)
translateEra TranslationContext DijkstraEra
ctxt NewEpochState (PreviousEra DijkstraEra)
nes = do
    let es :: EpochState DijkstraEra
es = TranslationContext DijkstraEra
-> EpochState (PreviousEra DijkstraEra) -> EpochState DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctxt (EpochState (PreviousEra DijkstraEra) -> EpochState DijkstraEra)
-> EpochState (PreviousEra DijkstraEra) -> EpochState DijkstraEra
forall a b. (a -> b) -> a -> b
$ NewEpochState ConwayEra -> EpochState ConwayEra
forall era. NewEpochState era -> EpochState era
nesEs NewEpochState (PreviousEra DijkstraEra)
NewEpochState ConwayEra
nes
        -- We need to ensure that we have the same initial EnactState in the pulser as
        -- well as in the current EnactState, otherwise in the very first EPOCH rule call
        -- the pulser will reset it.
        ratifyState :: RatifyState DijkstraEra
ratifyState =
          RatifyState DijkstraEra
forall a. Default a => a
def
            RatifyState DijkstraEra
-> (RatifyState DijkstraEra -> RatifyState DijkstraEra)
-> RatifyState DijkstraEra
forall a b. a -> (a -> b) -> b
& (EnactState DijkstraEra -> Identity (EnactState DijkstraEra))
-> RatifyState DijkstraEra -> Identity (RatifyState DijkstraEra)
forall era (f :: * -> *).
Functor f =>
(EnactState era -> f (EnactState era))
-> RatifyState era -> f (RatifyState era)
rsEnactStateL ((EnactState DijkstraEra -> Identity (EnactState DijkstraEra))
 -> RatifyState DijkstraEra -> Identity (RatifyState DijkstraEra))
-> EnactState DijkstraEra
-> RatifyState DijkstraEra
-> RatifyState DijkstraEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ GovState DijkstraEra -> EnactState DijkstraEra
forall era. ConwayEraGov era => GovState era -> EnactState era
mkEnactState (EpochState DijkstraEra
es EpochState DijkstraEra
-> Getting
     (ConwayGovState DijkstraEra)
     (EpochState DijkstraEra)
     (ConwayGovState DijkstraEra)
-> ConwayGovState DijkstraEra
forall s a. s -> Getting a s a -> a
^. (GovState DijkstraEra
 -> Const (ConwayGovState DijkstraEra) (GovState DijkstraEra))
-> EpochState DijkstraEra
-> Const (ConwayGovState DijkstraEra) (EpochState DijkstraEra)
Getting
  (ConwayGovState DijkstraEra)
  (EpochState DijkstraEra)
  (ConwayGovState DijkstraEra)
forall era (f :: * -> *).
Functor f =>
(GovState era -> f (GovState era))
-> EpochState era -> f (EpochState era)
epochStateGovStateL)
    NewEpochState DijkstraEra
-> Except
     (TranslationError DijkstraEra NewEpochState)
     (NewEpochState DijkstraEra)
forall a.
a
-> ExceptT (TranslationError DijkstraEra NewEpochState) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NewEpochState DijkstraEra
 -> Except
      (TranslationError DijkstraEra NewEpochState)
      (NewEpochState DijkstraEra))
-> NewEpochState DijkstraEra
-> Except
     (TranslationError DijkstraEra NewEpochState)
     (NewEpochState DijkstraEra)
forall a b. (a -> b) -> a -> b
$
      NewEpochState
        { nesEL :: EpochNo
nesEL = NewEpochState ConwayEra -> EpochNo
forall era. NewEpochState era -> EpochNo
nesEL NewEpochState (PreviousEra DijkstraEra)
NewEpochState ConwayEra
nes
        , nesBprev :: BlocksMade
nesBprev = NewEpochState ConwayEra -> BlocksMade
forall era. NewEpochState era -> BlocksMade
nesBprev NewEpochState (PreviousEra DijkstraEra)
NewEpochState ConwayEra
nes
        , nesBcur :: BlocksMade
nesBcur = NewEpochState ConwayEra -> BlocksMade
forall era. NewEpochState era -> BlocksMade
nesBcur NewEpochState (PreviousEra DijkstraEra)
NewEpochState ConwayEra
nes
        , nesEs :: EpochState DijkstraEra
nesEs = PulsingSnapshot DijkstraEra
-> RatifyState DijkstraEra
-> EpochState DijkstraEra
-> EpochState DijkstraEra
forall era.
(GovState era ~ ConwayGovState era) =>
PulsingSnapshot era
-> RatifyState era -> EpochState era -> EpochState era
setCompleteDRepPulsingState PulsingSnapshot DijkstraEra
forall a. Default a => a
def RatifyState DijkstraEra
ratifyState EpochState DijkstraEra
es
        , nesRu :: StrictMaybe PulsingRewUpdate
nesRu = NewEpochState ConwayEra -> StrictMaybe PulsingRewUpdate
forall era. NewEpochState era -> StrictMaybe PulsingRewUpdate
nesRu NewEpochState (PreviousEra DijkstraEra)
NewEpochState ConwayEra
nes
        , nesPd :: PoolDistr
nesPd = NewEpochState ConwayEra -> PoolDistr
forall era. NewEpochState era -> PoolDistr
nesPd NewEpochState (PreviousEra DijkstraEra)
NewEpochState ConwayEra
nes
        , stashedAVVMAddresses :: StashedAVVMAddresses DijkstraEra
stashedAVVMAddresses = ()
        }

--------------------------------------------------------------------------------
-- Auxiliary instances and functions
--------------------------------------------------------------------------------

instance TranslateEra DijkstraEra PParams where
  translateEra :: TranslationContext DijkstraEra
-> PParams (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra PParams) (PParams DijkstraEra)
translateEra TranslationContext DijkstraEra
_ = PParams DijkstraEra -> ExceptT Void Identity (PParams DijkstraEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PParams DijkstraEra
 -> ExceptT Void Identity (PParams DijkstraEra))
-> (PParams ConwayEra -> PParams DijkstraEra)
-> PParams ConwayEra
-> ExceptT Void Identity (PParams DijkstraEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UpgradePParams Identity DijkstraEra
-> PParams (PreviousEra DijkstraEra) -> PParams DijkstraEra
forall era.
(EraPParams era, EraPParams (PreviousEra era)) =>
UpgradePParams Identity era
-> PParams (PreviousEra era) -> PParams era
upgradePParams ()

instance TranslateEra DijkstraEra FuturePParams where
  translateEra :: TranslationContext DijkstraEra
-> FuturePParams (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra FuturePParams)
     (FuturePParams DijkstraEra)
translateEra TranslationContext DijkstraEra
ctxt = \case
    FuturePParams (PreviousEra DijkstraEra)
NoPParamsUpdate -> FuturePParams DijkstraEra
-> ExceptT Void Identity (FuturePParams DijkstraEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure FuturePParams DijkstraEra
forall era. FuturePParams era
NoPParamsUpdate
    DefinitePParamsUpdate PParams (PreviousEra DijkstraEra)
pp -> PParams DijkstraEra -> FuturePParams DijkstraEra
forall era. PParams era -> FuturePParams era
DefinitePParamsUpdate (PParams DijkstraEra -> FuturePParams DijkstraEra)
-> ExceptT Void Identity (PParams DijkstraEra)
-> ExceptT Void Identity (FuturePParams DijkstraEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TranslationContext DijkstraEra
-> PParams (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra PParams) (PParams DijkstraEra)
forall era (f :: * -> *).
TranslateEra era f =>
TranslationContext era
-> f (PreviousEra era) -> Except (TranslationError era f) (f era)
translateEra TranslationContext DijkstraEra
ctxt PParams (PreviousEra DijkstraEra)
pp
    PotentialPParamsUpdate Maybe (PParams (PreviousEra DijkstraEra))
mpp -> Maybe (PParams DijkstraEra) -> FuturePParams DijkstraEra
forall era. Maybe (PParams era) -> FuturePParams era
PotentialPParamsUpdate (Maybe (PParams DijkstraEra) -> FuturePParams DijkstraEra)
-> ExceptT Void Identity (Maybe (PParams DijkstraEra))
-> ExceptT Void Identity (FuturePParams DijkstraEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PParams ConwayEra -> ExceptT Void Identity (PParams DijkstraEra))
-> Maybe (PParams ConwayEra)
-> ExceptT Void Identity (Maybe (PParams DijkstraEra))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Maybe a -> m (Maybe b)
mapM (TranslationContext DijkstraEra
-> PParams (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra PParams) (PParams DijkstraEra)
forall era (f :: * -> *).
TranslateEra era f =>
TranslationContext era
-> f (PreviousEra era) -> Except (TranslationError era f) (f era)
translateEra TranslationContext DijkstraEra
ctxt) Maybe (PParams (PreviousEra DijkstraEra))
Maybe (PParams ConwayEra)
mpp

instance TranslateEra DijkstraEra EpochState where
  translateEra :: TranslationContext DijkstraEra
-> EpochState (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra EpochState) (EpochState DijkstraEra)
translateEra TranslationContext DijkstraEra
ctxt EpochState (PreviousEra DijkstraEra)
es =
    EpochState DijkstraEra
-> Except
     (TranslationError DijkstraEra EpochState) (EpochState DijkstraEra)
forall a.
a -> ExceptT (TranslationError DijkstraEra EpochState) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (EpochState DijkstraEra
 -> Except
      (TranslationError DijkstraEra EpochState) (EpochState DijkstraEra))
-> EpochState DijkstraEra
-> Except
     (TranslationError DijkstraEra EpochState) (EpochState DijkstraEra)
forall a b. (a -> b) -> a -> b
$
      EpochState
        { esChainAccountState :: ChainAccountState
esChainAccountState = EpochState ConwayEra -> ChainAccountState
forall era. EpochState era -> ChainAccountState
esChainAccountState EpochState (PreviousEra DijkstraEra)
EpochState ConwayEra
es
        , esSnapshots :: SnapShots
esSnapshots = EpochState ConwayEra -> SnapShots
forall era. EpochState era -> SnapShots
esSnapshots EpochState (PreviousEra DijkstraEra)
EpochState ConwayEra
es
        , esLState :: LedgerState DijkstraEra
esLState = TranslationContext DijkstraEra
-> LedgerState (PreviousEra DijkstraEra) -> LedgerState DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctxt (LedgerState (PreviousEra DijkstraEra) -> LedgerState DijkstraEra)
-> LedgerState (PreviousEra DijkstraEra) -> LedgerState DijkstraEra
forall a b. (a -> b) -> a -> b
$ EpochState ConwayEra -> LedgerState ConwayEra
forall era. EpochState era -> LedgerState era
esLState EpochState (PreviousEra DijkstraEra)
EpochState ConwayEra
es
        , esNonMyopic :: NonMyopic
esNonMyopic = EpochState ConwayEra -> NonMyopic
forall era. EpochState era -> NonMyopic
esNonMyopic EpochState (PreviousEra DijkstraEra)
EpochState ConwayEra
es
        }

instance TranslateEra DijkstraEra DState where
  translateEra :: TranslationContext DijkstraEra
-> DState (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra DState) (DState DijkstraEra)
translateEra TranslationContext DijkstraEra
_ DState {dsUnified :: forall era. DState era -> UMap
dsUnified = UMap
umap, Map FutureGenDeleg GenDelegPair
InstantaneousRewards
GenDelegs
dsFutureGenDelegs :: Map FutureGenDeleg GenDelegPair
dsGenDelegs :: GenDelegs
dsIRewards :: InstantaneousRewards
dsFutureGenDelegs :: forall era. DState era -> Map FutureGenDeleg GenDelegPair
dsGenDelegs :: forall era. DState era -> GenDelegs
dsIRewards :: forall era. DState era -> InstantaneousRewards
..} = DState DijkstraEra -> ExceptT Void Identity (DState DijkstraEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure DState {dsUnified :: UMap
dsUnified = UMap
umap', Map FutureGenDeleg GenDelegPair
InstantaneousRewards
GenDelegs
dsFutureGenDelegs :: Map FutureGenDeleg GenDelegPair
dsGenDelegs :: GenDelegs
dsIRewards :: InstantaneousRewards
dsFutureGenDelegs :: Map FutureGenDeleg GenDelegPair
dsGenDelegs :: GenDelegs
dsIRewards :: InstantaneousRewards
..}
    where
      umap' :: UMap
umap' =
        UMap
umap
          { UM.umElems =
              Map.map (\(UM.UMElem StrictMaybe RDPair
rd Set Ptr
_ StrictMaybe (KeyHash 'StakePool)
poolId StrictMaybe DRep
drep) -> StrictMaybe RDPair
-> Set Ptr
-> StrictMaybe (KeyHash 'StakePool)
-> StrictMaybe DRep
-> UMElem
UM.UMElem StrictMaybe RDPair
rd Set Ptr
forall a. Monoid a => a
mempty StrictMaybe (KeyHash 'StakePool)
poolId StrictMaybe DRep
drep) (UM.umElems umap)
          , UM.umPtrs = mempty
          }

instance TranslateEra DijkstraEra PState where
  translateEra :: TranslationContext DijkstraEra
-> PState (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra PState) (PState DijkstraEra)
translateEra TranslationContext DijkstraEra
_ PState {Map (KeyHash 'StakePool) Coin
Map (KeyHash 'StakePool) EpochNo
Map (KeyHash 'StakePool) PoolParams
psStakePoolParams :: Map (KeyHash 'StakePool) PoolParams
psFutureStakePoolParams :: Map (KeyHash 'StakePool) PoolParams
psRetiring :: Map (KeyHash 'StakePool) EpochNo
psDeposits :: Map (KeyHash 'StakePool) Coin
psStakePoolParams :: forall era. PState era -> Map (KeyHash 'StakePool) PoolParams
psFutureStakePoolParams :: forall era. PState era -> Map (KeyHash 'StakePool) PoolParams
psRetiring :: forall era. PState era -> Map (KeyHash 'StakePool) EpochNo
psDeposits :: forall era. PState era -> Map (KeyHash 'StakePool) Coin
..} = PState DijkstraEra -> ExceptT Void Identity (PState DijkstraEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PState {Map (KeyHash 'StakePool) Coin
Map (KeyHash 'StakePool) EpochNo
Map (KeyHash 'StakePool) PoolParams
psStakePoolParams :: Map (KeyHash 'StakePool) PoolParams
psFutureStakePoolParams :: Map (KeyHash 'StakePool) PoolParams
psRetiring :: Map (KeyHash 'StakePool) EpochNo
psDeposits :: Map (KeyHash 'StakePool) Coin
psStakePoolParams :: Map (KeyHash 'StakePool) PoolParams
psFutureStakePoolParams :: Map (KeyHash 'StakePool) PoolParams
psRetiring :: Map (KeyHash 'StakePool) EpochNo
psDeposits :: Map (KeyHash 'StakePool) Coin
..}

instance TranslateEra DijkstraEra API.LedgerState where
  translateEra :: TranslationContext DijkstraEra
-> LedgerState (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra LedgerState)
     (LedgerState DijkstraEra)
translateEra TranslationContext DijkstraEra
ctx LedgerState (PreviousEra DijkstraEra)
ls =
    LedgerState DijkstraEra
-> ExceptT Void Identity (LedgerState DijkstraEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
      API.LedgerState
        { lsUTxOState :: UTxOState DijkstraEra
API.lsUTxOState = TranslationContext DijkstraEra
-> UTxOState (PreviousEra DijkstraEra) -> UTxOState DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctx (UTxOState (PreviousEra DijkstraEra) -> UTxOState DijkstraEra)
-> UTxOState (PreviousEra DijkstraEra) -> UTxOState DijkstraEra
forall a b. (a -> b) -> a -> b
$ LedgerState (PreviousEra DijkstraEra)
LedgerState ConwayEra
ls LedgerState ConwayEra
-> Getting
     (UTxOState ConwayEra) (LedgerState ConwayEra) (UTxOState ConwayEra)
-> UTxOState ConwayEra
forall s a. s -> Getting a s a -> a
^. Getting
  (UTxOState ConwayEra) (LedgerState ConwayEra) (UTxOState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(UTxOState era -> f (UTxOState era))
-> LedgerState era -> f (LedgerState era)
lsUTxOStateL
        , lsCertState :: CertState DijkstraEra
API.lsCertState = TranslationContext DijkstraEra
-> CertState ConwayEra -> CertState DijkstraEra
translateCertState TranslationContext DijkstraEra
ctx (CertState ConwayEra -> CertState DijkstraEra)
-> CertState ConwayEra -> CertState DijkstraEra
forall a b. (a -> b) -> a -> b
$ LedgerState (PreviousEra DijkstraEra)
LedgerState ConwayEra
ls LedgerState ConwayEra
-> Getting
     (ConwayCertState ConwayEra)
     (LedgerState ConwayEra)
     (ConwayCertState ConwayEra)
-> ConwayCertState ConwayEra
forall s a. s -> Getting a s a -> a
^. (CertState ConwayEra
 -> Const (ConwayCertState ConwayEra) (CertState ConwayEra))
-> LedgerState ConwayEra
-> Const (ConwayCertState ConwayEra) (LedgerState ConwayEra)
Getting
  (ConwayCertState ConwayEra)
  (LedgerState ConwayEra)
  (ConwayCertState ConwayEra)
forall era (f :: * -> *).
Functor f =>
(CertState era -> f (CertState era))
-> LedgerState era -> f (LedgerState era)
lsCertStateL
        }

translateCertState ::
  TranslationContext DijkstraEra ->
  API.CertState ConwayEra ->
  API.CertState DijkstraEra
translateCertState :: TranslationContext DijkstraEra
-> CertState ConwayEra -> CertState DijkstraEra
translateCertState TranslationContext DijkstraEra
ctx CertState ConwayEra
scert =
  CertState DijkstraEra
forall a. Default a => a
def
    CertState DijkstraEra
-> (CertState DijkstraEra -> CertState DijkstraEra)
-> CertState DijkstraEra
forall a b. a -> (a -> b) -> b
& (DState DijkstraEra -> Identity (DState DijkstraEra))
-> CertState DijkstraEra -> Identity (CertState DijkstraEra)
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens' (CertState DijkstraEra) (DState DijkstraEra)
certDStateL ((DState DijkstraEra -> Identity (DState DijkstraEra))
 -> CertState DijkstraEra -> Identity (CertState DijkstraEra))
-> DState DijkstraEra
-> CertState DijkstraEra
-> CertState DijkstraEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TranslationContext DijkstraEra
-> DState (PreviousEra DijkstraEra) -> DState DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctx (CertState ConwayEra
ConwayCertState ConwayEra
scert ConwayCertState ConwayEra
-> Getting
     (DState (PreviousEra DijkstraEra))
     (ConwayCertState ConwayEra)
     (DState (PreviousEra DijkstraEra))
-> DState (PreviousEra DijkstraEra)
forall s a. s -> Getting a s a -> a
^. (DState (PreviousEra DijkstraEra)
 -> Const
      (DState (PreviousEra DijkstraEra))
      (DState (PreviousEra DijkstraEra)))
-> CertState (PreviousEra DijkstraEra)
-> Const
     (DState (PreviousEra DijkstraEra))
     (CertState (PreviousEra DijkstraEra))
Getting
  (DState (PreviousEra DijkstraEra))
  (ConwayCertState ConwayEra)
  (DState (PreviousEra DijkstraEra))
forall era. EraCertState era => Lens' (CertState era) (DState era)
Lens'
  (CertState (PreviousEra DijkstraEra))
  (DState (PreviousEra DijkstraEra))
certDStateL)
    CertState DijkstraEra
-> (CertState DijkstraEra -> ConwayCertState DijkstraEra)
-> ConwayCertState DijkstraEra
forall a b. a -> (a -> b) -> b
& (PState DijkstraEra -> Identity (PState DijkstraEra))
-> CertState DijkstraEra -> Identity (CertState DijkstraEra)
(PState DijkstraEra -> Identity (PState DijkstraEra))
-> CertState DijkstraEra -> Identity (ConwayCertState DijkstraEra)
forall era. EraCertState era => Lens' (CertState era) (PState era)
Lens' (CertState DijkstraEra) (PState DijkstraEra)
certPStateL ((PState DijkstraEra -> Identity (PState DijkstraEra))
 -> CertState DijkstraEra -> Identity (ConwayCertState DijkstraEra))
-> PState DijkstraEra
-> CertState DijkstraEra
-> ConwayCertState DijkstraEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TranslationContext DijkstraEra
-> PState (PreviousEra DijkstraEra) -> PState DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctx (CertState ConwayEra
ConwayCertState ConwayEra
scert ConwayCertState ConwayEra
-> Getting
     (PState ConwayEra) (ConwayCertState ConwayEra) (PState ConwayEra)
-> PState ConwayEra
forall s a. s -> Getting a s a -> a
^. (PState ConwayEra -> Const (PState ConwayEra) (PState ConwayEra))
-> CertState ConwayEra
-> Const (PState ConwayEra) (CertState ConwayEra)
Getting
  (PState ConwayEra) (ConwayCertState ConwayEra) (PState ConwayEra)
forall era. EraCertState era => Lens' (CertState era) (PState era)
Lens' (CertState ConwayEra) (PState ConwayEra)
certPStateL)

instance TranslateEra DijkstraEra GovAction where
  translateEra :: TranslationContext DijkstraEra
-> GovAction (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra GovAction) (GovAction DijkstraEra)
translateEra TranslationContext DijkstraEra
_ = GovAction DijkstraEra
-> ExceptT Void Identity (GovAction DijkstraEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (GovAction DijkstraEra
 -> ExceptT Void Identity (GovAction DijkstraEra))
-> (GovAction ConwayEra -> GovAction DijkstraEra)
-> GovAction ConwayEra
-> ExceptT Void Identity (GovAction DijkstraEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GovAction (PreviousEra DijkstraEra) -> GovAction DijkstraEra
GovAction ConwayEra -> GovAction DijkstraEra
forall era.
Coercible
  (PParamsHKD StrictMaybe (PreviousEra era))
  (PParamsHKD StrictMaybe era) =>
GovAction (PreviousEra era) -> GovAction era
upgradeGovAction

instance TranslateEra DijkstraEra ProposalProcedure where
  translateEra :: TranslationContext DijkstraEra
-> ProposalProcedure (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra ProposalProcedure)
     (ProposalProcedure DijkstraEra)
translateEra TranslationContext DijkstraEra
_ = ProposalProcedure DijkstraEra
-> ExceptT Void Identity (ProposalProcedure DijkstraEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ProposalProcedure DijkstraEra
 -> ExceptT Void Identity (ProposalProcedure DijkstraEra))
-> (ProposalProcedure ConwayEra -> ProposalProcedure DijkstraEra)
-> ProposalProcedure ConwayEra
-> ExceptT Void Identity (ProposalProcedure DijkstraEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProposalProcedure ConwayEra -> ProposalProcedure DijkstraEra
upgradeProposals

instance TranslateEra DijkstraEra GovActionState where
  translateEra :: TranslationContext DijkstraEra
-> GovActionState (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra GovActionState)
     (GovActionState DijkstraEra)
translateEra TranslationContext DijkstraEra
ctxt GovActionState {Map (KeyHash 'StakePool) Vote
Map (Credential 'DRepRole) Vote
Map (Credential 'HotCommitteeRole) Vote
ProposalProcedure (PreviousEra DijkstraEra)
GovActionId
EpochNo
gasId :: GovActionId
gasCommitteeVotes :: Map (Credential 'HotCommitteeRole) Vote
gasDRepVotes :: Map (Credential 'DRepRole) Vote
gasStakePoolVotes :: Map (KeyHash 'StakePool) Vote
gasProposalProcedure :: ProposalProcedure (PreviousEra DijkstraEra)
gasProposedIn :: EpochNo
gasExpiresAfter :: EpochNo
gasId :: forall era. GovActionState era -> GovActionId
gasCommitteeVotes :: forall era.
GovActionState era -> Map (Credential 'HotCommitteeRole) Vote
gasDRepVotes :: forall era. GovActionState era -> Map (Credential 'DRepRole) Vote
gasStakePoolVotes :: forall era. GovActionState era -> Map (KeyHash 'StakePool) Vote
gasProposalProcedure :: forall era. GovActionState era -> ProposalProcedure era
gasProposedIn :: forall era. GovActionState era -> EpochNo
gasExpiresAfter :: forall era. GovActionState era -> EpochNo
..} =
    GovActionState DijkstraEra
-> Except
     (TranslationError DijkstraEra GovActionState)
     (GovActionState DijkstraEra)
forall a.
a
-> ExceptT (TranslationError DijkstraEra GovActionState) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (GovActionState DijkstraEra
 -> Except
      (TranslationError DijkstraEra GovActionState)
      (GovActionState DijkstraEra))
-> GovActionState DijkstraEra
-> Except
     (TranslationError DijkstraEra GovActionState)
     (GovActionState DijkstraEra)
forall a b. (a -> b) -> a -> b
$
      GovActionState
        { gasId :: GovActionId
gasId = GovActionId
gasId
        , gasCommitteeVotes :: Map (Credential 'HotCommitteeRole) Vote
gasCommitteeVotes = Map (Credential 'HotCommitteeRole) Vote
gasCommitteeVotes
        , gasDRepVotes :: Map (Credential 'DRepRole) Vote
gasDRepVotes = Map (Credential 'DRepRole) Vote
gasDRepVotes
        , gasStakePoolVotes :: Map (KeyHash 'StakePool) Vote
gasStakePoolVotes = Map (KeyHash 'StakePool) Vote
gasStakePoolVotes
        , gasProposalProcedure :: ProposalProcedure DijkstraEra
gasProposalProcedure = TranslationContext DijkstraEra
-> ProposalProcedure (PreviousEra DijkstraEra)
-> ProposalProcedure DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctxt ProposalProcedure (PreviousEra DijkstraEra)
gasProposalProcedure
        , gasProposedIn :: EpochNo
gasProposedIn = EpochNo
gasProposedIn
        , gasExpiresAfter :: EpochNo
gasExpiresAfter = EpochNo
gasExpiresAfter
        }

instance TranslateEra DijkstraEra Proposals where
  translateEra :: TranslationContext DijkstraEra
-> Proposals (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra Proposals) (Proposals DijkstraEra)
translateEra TranslationContext DijkstraEra
ctxt = Proposals DijkstraEra
-> ExceptT Void Identity (Proposals DijkstraEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Proposals DijkstraEra
 -> ExceptT Void Identity (Proposals DijkstraEra))
-> (Proposals ConwayEra -> Proposals DijkstraEra)
-> Proposals ConwayEra
-> ExceptT Void Identity (Proposals DijkstraEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era.
(TranslateEra era GovActionState,
 TranslationError era GovActionState ~ Void) =>
TranslationContext era
-> Proposals (PreviousEra era) -> Proposals era
translateProposals @DijkstraEra TranslationContext DijkstraEra
ctxt

instance TranslateEra DijkstraEra PulsingSnapshot where
  translateEra :: TranslationContext DijkstraEra
-> PulsingSnapshot (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra PulsingSnapshot)
     (PulsingSnapshot DijkstraEra)
translateEra TranslationContext DijkstraEra
ctxt PulsingSnapshot {Map (KeyHash 'StakePool) (CompactForm Coin)
Map DRep (CompactForm Coin)
Map (Credential 'DRepRole) DRepState
StrictSeq (GovActionState (PreviousEra DijkstraEra))
psProposals :: StrictSeq (GovActionState (PreviousEra DijkstraEra))
psDRepDistr :: Map DRep (CompactForm Coin)
psDRepState :: Map (Credential 'DRepRole) DRepState
psPoolDistr :: Map (KeyHash 'StakePool) (CompactForm Coin)
psProposals :: forall era. PulsingSnapshot era -> StrictSeq (GovActionState era)
psDRepDistr :: forall era. PulsingSnapshot era -> Map DRep (CompactForm Coin)
psDRepState :: forall era.
PulsingSnapshot era -> Map (Credential 'DRepRole) DRepState
psPoolDistr :: forall era.
PulsingSnapshot era -> Map (KeyHash 'StakePool) (CompactForm Coin)
..} =
    PulsingSnapshot DijkstraEra
-> Except
     (TranslationError DijkstraEra PulsingSnapshot)
     (PulsingSnapshot DijkstraEra)
forall a.
a
-> ExceptT
     (TranslationError DijkstraEra PulsingSnapshot) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PulsingSnapshot DijkstraEra
 -> Except
      (TranslationError DijkstraEra PulsingSnapshot)
      (PulsingSnapshot DijkstraEra))
-> PulsingSnapshot DijkstraEra
-> Except
     (TranslationError DijkstraEra PulsingSnapshot)
     (PulsingSnapshot DijkstraEra)
forall a b. (a -> b) -> a -> b
$
      PulsingSnapshot
        { psProposals :: StrictSeq (GovActionState DijkstraEra)
psProposals = TranslationContext DijkstraEra
-> GovActionState (PreviousEra DijkstraEra)
-> GovActionState DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctxt (GovActionState ConwayEra -> GovActionState DijkstraEra)
-> StrictSeq (GovActionState ConwayEra)
-> StrictSeq (GovActionState DijkstraEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StrictSeq (GovActionState (PreviousEra DijkstraEra))
StrictSeq (GovActionState ConwayEra)
psProposals
        , psDRepDistr :: Map DRep (CompactForm Coin)
psDRepDistr = Map DRep (CompactForm Coin)
psDRepDistr
        , psDRepState :: Map (Credential 'DRepRole) DRepState
psDRepState = Map (Credential 'DRepRole) DRepState
psDRepState
        , psPoolDistr :: Map (KeyHash 'StakePool) (CompactForm Coin)
psPoolDistr = Map (KeyHash 'StakePool) (CompactForm Coin)
psPoolDistr
        }

instance TranslateEra DijkstraEra EnactState where
  translateEra :: TranslationContext DijkstraEra
-> EnactState (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra EnactState) (EnactState DijkstraEra)
translateEra TranslationContext DijkstraEra
_ EnactState {Map (Credential 'Staking) Coin
StrictMaybe (Committee (PreviousEra DijkstraEra))
PParams (PreviousEra DijkstraEra)
Constitution (PreviousEra DijkstraEra)
GovRelation StrictMaybe
Coin
ensCommittee :: StrictMaybe (Committee (PreviousEra DijkstraEra))
ensConstitution :: Constitution (PreviousEra DijkstraEra)
ensCurPParams :: PParams (PreviousEra DijkstraEra)
ensPrevPParams :: PParams (PreviousEra DijkstraEra)
ensTreasury :: Coin
ensWithdrawals :: Map (Credential 'Staking) Coin
ensPrevGovActionIds :: GovRelation StrictMaybe
ensCommittee :: forall era. EnactState era -> StrictMaybe (Committee era)
ensConstitution :: forall era. EnactState era -> Constitution era
ensCurPParams :: forall era. EnactState era -> PParams era
ensPrevPParams :: forall era. EnactState era -> PParams era
ensTreasury :: forall era. EnactState era -> Coin
ensWithdrawals :: forall era. EnactState era -> Map (Credential 'Staking) Coin
ensPrevGovActionIds :: forall era. EnactState era -> GovRelation StrictMaybe
..} =
    EnactState DijkstraEra
-> Except
     (TranslationError DijkstraEra EnactState) (EnactState DijkstraEra)
forall a.
a -> ExceptT (TranslationError DijkstraEra EnactState) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (EnactState DijkstraEra
 -> Except
      (TranslationError DijkstraEra EnactState) (EnactState DijkstraEra))
-> EnactState DijkstraEra
-> Except
     (TranslationError DijkstraEra EnactState) (EnactState DijkstraEra)
forall a b. (a -> b) -> a -> b
$
      EnactState
        { ensCommittee :: StrictMaybe (Committee DijkstraEra)
ensCommittee = StrictMaybe (Committee ConwayEra)
-> StrictMaybe (Committee DijkstraEra)
forall a b. Coercible a b => a -> b
coerce StrictMaybe (Committee (PreviousEra DijkstraEra))
StrictMaybe (Committee ConwayEra)
ensCommittee
        , ensConstitution :: Constitution DijkstraEra
ensConstitution = Constitution ConwayEra -> Constitution DijkstraEra
forall a b. Coercible a b => a -> b
coerce Constitution (PreviousEra DijkstraEra)
Constitution ConwayEra
ensConstitution
        , ensCurPParams :: PParams DijkstraEra
ensCurPParams = PParams ConwayEra -> PParams DijkstraEra
forall a b. Coercible a b => a -> b
coerce PParams (PreviousEra DijkstraEra)
PParams ConwayEra
ensCurPParams
        , ensPrevPParams :: PParams DijkstraEra
ensPrevPParams = PParams ConwayEra -> PParams DijkstraEra
forall a b. Coercible a b => a -> b
coerce PParams (PreviousEra DijkstraEra)
PParams ConwayEra
ensPrevPParams
        , ensTreasury :: Coin
ensTreasury = Coin
ensTreasury
        , ensWithdrawals :: Map (Credential 'Staking) Coin
ensWithdrawals = Map (Credential 'Staking) Coin
ensWithdrawals
        , ensPrevGovActionIds :: GovRelation StrictMaybe
ensPrevGovActionIds = GovRelation StrictMaybe
ensPrevGovActionIds
        }

instance TranslateEra DijkstraEra RatifyState where
  translateEra :: TranslationContext DijkstraEra
-> RatifyState (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra RatifyState)
     (RatifyState DijkstraEra)
translateEra TranslationContext DijkstraEra
ctxt RatifyState {Bool
Set GovActionId
Seq (GovActionState (PreviousEra DijkstraEra))
EnactState (PreviousEra DijkstraEra)
rsEnactState :: EnactState (PreviousEra DijkstraEra)
rsEnacted :: Seq (GovActionState (PreviousEra DijkstraEra))
rsExpired :: Set GovActionId
rsDelayed :: Bool
rsEnactState :: forall era. RatifyState era -> EnactState era
rsEnacted :: forall era. RatifyState era -> Seq (GovActionState era)
rsExpired :: forall era. RatifyState era -> Set GovActionId
rsDelayed :: forall era. RatifyState era -> Bool
..} =
    RatifyState DijkstraEra
-> Except
     (TranslationError DijkstraEra RatifyState)
     (RatifyState DijkstraEra)
forall a.
a -> ExceptT (TranslationError DijkstraEra RatifyState) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RatifyState DijkstraEra
 -> Except
      (TranslationError DijkstraEra RatifyState)
      (RatifyState DijkstraEra))
-> RatifyState DijkstraEra
-> Except
     (TranslationError DijkstraEra RatifyState)
     (RatifyState DijkstraEra)
forall a b. (a -> b) -> a -> b
$
      RatifyState
        { rsEnactState :: EnactState DijkstraEra
rsEnactState = TranslationContext DijkstraEra
-> EnactState (PreviousEra DijkstraEra) -> EnactState DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctxt EnactState (PreviousEra DijkstraEra)
rsEnactState
        , rsEnacted :: Seq (GovActionState DijkstraEra)
rsEnacted = TranslationContext DijkstraEra
-> GovActionState (PreviousEra DijkstraEra)
-> GovActionState DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctxt (GovActionState ConwayEra -> GovActionState DijkstraEra)
-> Seq (GovActionState ConwayEra)
-> Seq (GovActionState DijkstraEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Seq (GovActionState (PreviousEra DijkstraEra))
Seq (GovActionState ConwayEra)
rsEnacted
        , rsExpired :: Set GovActionId
rsExpired = Set GovActionId
rsExpired
        , rsDelayed :: Bool
rsDelayed = Bool
rsDelayed
        }

instance TranslateEra DijkstraEra DRepPulsingState where
  translateEra :: TranslationContext DijkstraEra
-> DRepPulsingState (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra DRepPulsingState)
     (DRepPulsingState DijkstraEra)
translateEra TranslationContext DijkstraEra
ctxt DRepPulsingState (PreviousEra DijkstraEra)
dps = DRepPulsingState DijkstraEra
-> Except
     (TranslationError DijkstraEra DRepPulsingState)
     (DRepPulsingState DijkstraEra)
forall a.
a
-> ExceptT
     (TranslationError DijkstraEra DRepPulsingState) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (DRepPulsingState DijkstraEra
 -> Except
      (TranslationError DijkstraEra DRepPulsingState)
      (DRepPulsingState DijkstraEra))
-> DRepPulsingState DijkstraEra
-> Except
     (TranslationError DijkstraEra DRepPulsingState)
     (DRepPulsingState DijkstraEra)
forall a b. (a -> b) -> a -> b
$ PulsingSnapshot DijkstraEra
-> RatifyState DijkstraEra -> DRepPulsingState DijkstraEra
forall era.
PulsingSnapshot era -> RatifyState era -> DRepPulsingState era
DRComplete (TranslationContext DijkstraEra
-> PulsingSnapshot (PreviousEra DijkstraEra)
-> PulsingSnapshot DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctxt PulsingSnapshot (PreviousEra DijkstraEra)
PulsingSnapshot ConwayEra
x) (TranslationContext DijkstraEra
-> RatifyState (PreviousEra DijkstraEra) -> RatifyState DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctxt RatifyState (PreviousEra DijkstraEra)
RatifyState ConwayEra
y)
    where
      (PulsingSnapshot ConwayEra
x, RatifyState ConwayEra
y) = DRepPulsingState ConwayEra
-> (PulsingSnapshot ConwayEra, RatifyState ConwayEra)
forall era.
EraStake era =>
DRepPulsingState era -> (PulsingSnapshot era, RatifyState era)
finishDRepPulser DRepPulsingState (PreviousEra DijkstraEra)
DRepPulsingState ConwayEra
dps

instance TranslateEra DijkstraEra ConwayGovState where
  translateEra :: TranslationContext DijkstraEra
-> ConwayGovState (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra ConwayGovState)
     (ConwayGovState DijkstraEra)
translateEra TranslationContext DijkstraEra
ctxt ConwayGovState {StrictMaybe (Committee (PreviousEra DijkstraEra))
PParams (PreviousEra DijkstraEra)
FuturePParams (PreviousEra DijkstraEra)
Constitution (PreviousEra DijkstraEra)
Proposals (PreviousEra DijkstraEra)
DRepPulsingState (PreviousEra DijkstraEra)
cgsProposals :: Proposals (PreviousEra DijkstraEra)
cgsCommittee :: StrictMaybe (Committee (PreviousEra DijkstraEra))
cgsConstitution :: Constitution (PreviousEra DijkstraEra)
cgsCurPParams :: PParams (PreviousEra DijkstraEra)
cgsPrevPParams :: PParams (PreviousEra DijkstraEra)
cgsFuturePParams :: FuturePParams (PreviousEra DijkstraEra)
cgsDRepPulsingState :: DRepPulsingState (PreviousEra DijkstraEra)
cgsProposals :: forall era. ConwayGovState era -> Proposals era
cgsCommittee :: forall era. ConwayGovState era -> StrictMaybe (Committee era)
cgsConstitution :: forall era. ConwayGovState era -> Constitution era
cgsCurPParams :: forall era. ConwayGovState era -> PParams era
cgsPrevPParams :: forall era. ConwayGovState era -> PParams era
cgsFuturePParams :: forall era. ConwayGovState era -> FuturePParams era
cgsDRepPulsingState :: forall era. ConwayGovState era -> DRepPulsingState era
..} =
    ConwayGovState DijkstraEra
-> Except
     (TranslationError DijkstraEra ConwayGovState)
     (ConwayGovState DijkstraEra)
forall a.
a
-> ExceptT (TranslationError DijkstraEra ConwayGovState) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ConwayGovState DijkstraEra
 -> Except
      (TranslationError DijkstraEra ConwayGovState)
      (ConwayGovState DijkstraEra))
-> ConwayGovState DijkstraEra
-> Except
     (TranslationError DijkstraEra ConwayGovState)
     (ConwayGovState DijkstraEra)
forall a b. (a -> b) -> a -> b
$
      ConwayGovState
        { cgsCommittee :: StrictMaybe (Committee DijkstraEra)
cgsCommittee = StrictMaybe (Committee ConwayEra)
-> StrictMaybe (Committee DijkstraEra)
forall a b. Coercible a b => a -> b
coerce StrictMaybe (Committee (PreviousEra DijkstraEra))
StrictMaybe (Committee ConwayEra)
cgsCommittee
        , cgsProposals :: Proposals DijkstraEra
cgsProposals = TranslationContext DijkstraEra
-> Proposals (PreviousEra DijkstraEra) -> Proposals DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctxt Proposals (PreviousEra DijkstraEra)
cgsProposals
        , cgsConstitution :: Constitution DijkstraEra
cgsConstitution = Constitution ConwayEra -> Constitution DijkstraEra
forall a b. Coercible a b => a -> b
coerce Constitution (PreviousEra DijkstraEra)
Constitution ConwayEra
cgsConstitution
        , cgsCurPParams :: PParams DijkstraEra
cgsCurPParams = PParams ConwayEra -> PParams DijkstraEra
forall a b. Coercible a b => a -> b
coerce PParams (PreviousEra DijkstraEra)
PParams ConwayEra
cgsCurPParams
        , cgsPrevPParams :: PParams DijkstraEra
cgsPrevPParams = PParams ConwayEra -> PParams DijkstraEra
forall a b. Coercible a b => a -> b
coerce PParams (PreviousEra DijkstraEra)
PParams ConwayEra
cgsPrevPParams
        , cgsFuturePParams :: FuturePParams DijkstraEra
cgsFuturePParams = TranslationContext DijkstraEra
-> FuturePParams (PreviousEra DijkstraEra)
-> FuturePParams DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctxt FuturePParams (PreviousEra DijkstraEra)
cgsFuturePParams
        , cgsDRepPulsingState :: DRepPulsingState DijkstraEra
cgsDRepPulsingState = TranslationContext DijkstraEra
-> DRepPulsingState (PreviousEra DijkstraEra)
-> DRepPulsingState DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctxt DRepPulsingState (PreviousEra DijkstraEra)
cgsDRepPulsingState
        }

instance TranslateEra DijkstraEra UTxOState where
  translateEra :: TranslationContext DijkstraEra
-> UTxOState (PreviousEra DijkstraEra)
-> Except
     (TranslationError DijkstraEra UTxOState) (UTxOState DijkstraEra)
translateEra TranslationContext DijkstraEra
ctxt UTxOState (PreviousEra DijkstraEra)
us =
    UTxOState DijkstraEra
-> ExceptT Void Identity (UTxOState DijkstraEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
      UTxOState
        { utxosUtxo :: UTxO DijkstraEra
API.utxosUtxo = TranslationContext DijkstraEra
-> UTxO (PreviousEra DijkstraEra) -> UTxO DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctxt (UTxO (PreviousEra DijkstraEra) -> UTxO DijkstraEra)
-> UTxO (PreviousEra DijkstraEra) -> UTxO DijkstraEra
forall a b. (a -> b) -> a -> b
$ UTxOState ConwayEra -> UTxO ConwayEra
forall era. UTxOState era -> UTxO era
API.utxosUtxo UTxOState (PreviousEra DijkstraEra)
UTxOState ConwayEra
us
        , utxosDeposited :: Coin
API.utxosDeposited = UTxOState ConwayEra -> Coin
forall era. UTxOState era -> Coin
API.utxosDeposited UTxOState (PreviousEra DijkstraEra)
UTxOState ConwayEra
us
        , utxosFees :: Coin
API.utxosFees = UTxOState ConwayEra -> Coin
forall era. UTxOState era -> Coin
API.utxosFees UTxOState (PreviousEra DijkstraEra)
UTxOState ConwayEra
us
        , utxosGovState :: GovState DijkstraEra
API.utxosGovState = TranslationContext DijkstraEra
-> ConwayGovState (PreviousEra DijkstraEra)
-> ConwayGovState DijkstraEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext DijkstraEra
ctxt (ConwayGovState (PreviousEra DijkstraEra)
 -> ConwayGovState DijkstraEra)
-> ConwayGovState (PreviousEra DijkstraEra)
-> ConwayGovState DijkstraEra
forall a b. (a -> b) -> a -> b
$ UTxOState ConwayEra -> GovState ConwayEra
forall era. UTxOState era -> GovState era
API.utxosGovState UTxOState (PreviousEra DijkstraEra)
UTxOState ConwayEra
us
        , utxosInstantStake :: InstantStake DijkstraEra
API.utxosInstantStake = InstantStake ConwayEra -> InstantStake DijkstraEra
forall a b. Coercible a b => a -> b
coerce (InstantStake ConwayEra -> InstantStake DijkstraEra)
-> InstantStake ConwayEra -> InstantStake DijkstraEra
forall a b. (a -> b) -> a -> b
$ UTxOState ConwayEra -> InstantStake ConwayEra
forall era. UTxOState era -> InstantStake era
API.utxosInstantStake UTxOState (PreviousEra DijkstraEra)
UTxOState ConwayEra
us
        , utxosDonation :: Coin
API.utxosDonation = UTxOState ConwayEra -> Coin
forall era. UTxOState era -> Coin
API.utxosDonation UTxOState (PreviousEra DijkstraEra)
UTxOState ConwayEra
us
        }

instance TranslateEra DijkstraEra API.UTxO where
  translateEra :: TranslationContext DijkstraEra
-> UTxO (PreviousEra DijkstraEra)
-> Except (TranslationError DijkstraEra UTxO) (UTxO DijkstraEra)
translateEra TranslationContext DijkstraEra
_ctxt UTxO (PreviousEra DijkstraEra)
utxo =
    UTxO DijkstraEra
-> Except (TranslationError DijkstraEra UTxO) (UTxO DijkstraEra)
forall a.
a -> ExceptT (TranslationError DijkstraEra UTxO) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (UTxO DijkstraEra
 -> Except (TranslationError DijkstraEra UTxO) (UTxO DijkstraEra))
-> UTxO DijkstraEra
-> Except (TranslationError DijkstraEra UTxO) (UTxO DijkstraEra)
forall a b. (a -> b) -> a -> b
$ Map TxIn (TxOut DijkstraEra) -> UTxO DijkstraEra
forall era. Map TxIn (TxOut era) -> UTxO era
API.UTxO (Map TxIn (TxOut DijkstraEra) -> UTxO DijkstraEra)
-> Map TxIn (TxOut DijkstraEra) -> UTxO DijkstraEra
forall a b. (a -> b) -> a -> b
$ TxOut (PreviousEra DijkstraEra) -> TxOut DijkstraEra
TxOut (PreviousEra DijkstraEra) -> BabbageTxOut DijkstraEra
forall era.
(EraTxOut era, EraTxOut (PreviousEra era)) =>
TxOut (PreviousEra era) -> TxOut era
upgradeTxOut (TxOut (PreviousEra DijkstraEra) -> BabbageTxOut DijkstraEra)
-> Map TxIn (TxOut (PreviousEra DijkstraEra))
-> Map TxIn (BabbageTxOut DijkstraEra)
forall a b k. (a -> b) -> Map k a -> Map k b
`Map.map` UTxO ConwayEra -> Map TxIn (TxOut ConwayEra)
forall era. UTxO era -> Map TxIn (TxOut era)
API.unUTxO UTxO (PreviousEra DijkstraEra)
UTxO ConwayEra
utxo