{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Ledger.Allegra.Translation (shelleyToAllegraAVVMsToDelete) where

import Cardano.Ledger.Allegra.Era (AllegraEra)
import Cardano.Ledger.Allegra.Tx ()
import Cardano.Ledger.Binary (DecoderError)
import Cardano.Ledger.CertState (CommitteeState (..))
import Cardano.Ledger.Crypto (Crypto)
import Cardano.Ledger.Genesis (NoGenesis (..))
import Cardano.Ledger.Shelley (ShelleyEra)
import Cardano.Ledger.Shelley.Core
import Cardano.Ledger.Shelley.LedgerState (
  CertState (..),
  DState (..),
  EpochState (..),
  LedgerState (..),
  NewEpochState (..),
  PState (..),
  UTxOState (..),
  VState (..),
  returnRedeemAddrsToReserves,
 )
import Cardano.Ledger.Shelley.PParams (ProposedPPUpdates (..), Update (..))
import Cardano.Ledger.Shelley.Tx (ShelleyTx)
import Cardano.Ledger.Shelley.TxOut (ShelleyTxOut)
import Cardano.Ledger.Shelley.TxWits (ShelleyTxWits)
import Cardano.Ledger.UTxO (UTxO (..))
import Data.Coerce (coerce)
import qualified Data.Map.Strict as Map

--------------------------------------------------------------------------------
-- Translation from Shelley to Allegra
--
-- The instances below are needed by the consensus layer. Do not remove any of
-- them without coordinating with consensus.
--
-- Please add auxiliary instances and other declarations at the bottom of this
-- module, not in the list below so that it remains clear which instances the
-- consensus layer needs.
--
-- WARNING: when a translation instance currently uses the default
-- 'TranslationError', i.e., 'Void', it means the consensus layer relies on it
-- being total. Do not change it!
--------------------------------------------------------------------------------

-- | Return the subset of UTxO corresponding to Byron-era AVVM addresses, which
-- are to be removed on the Shelley/Allegra boundary. This set will be passed
-- _back_ to the translation functions as the UTxO, allowing these addresses to
-- be removed. This is needed because we cannot do a full scan on the UTxO at
-- this point, since it has been persisted to disk.
shelleyToAllegraAVVMsToDelete :: NewEpochState (ShelleyEra c) -> UTxO (ShelleyEra c)
shelleyToAllegraAVVMsToDelete :: forall c. NewEpochState (ShelleyEra c) -> UTxO (ShelleyEra c)
shelleyToAllegraAVVMsToDelete = forall era. NewEpochState era -> StashedAVVMAddresses era
stashedAVVMAddresses

instance Crypto c => TranslateEra (AllegraEra c) NewEpochState where
  translateEra :: TranslationContext (AllegraEra c)
-> NewEpochState (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) NewEpochState)
     (NewEpochState (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
ctxt NewEpochState (PreviousEra (AllegraEra c))
nes =
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
      NewEpochState
        { nesEL :: EpochNo
nesEL = forall era. NewEpochState era -> EpochNo
nesEL NewEpochState (PreviousEra (AllegraEra c))
nes
        , nesBprev :: BlocksMade (EraCrypto (AllegraEra c))
nesBprev = forall era. NewEpochState era -> BlocksMade (EraCrypto era)
nesBprev NewEpochState (PreviousEra (AllegraEra c))
nes
        , nesBcur :: BlocksMade (EraCrypto (AllegraEra c))
nesBcur = forall era. NewEpochState era -> BlocksMade (EraCrypto era)
nesBcur NewEpochState (PreviousEra (AllegraEra c))
nes
        , nesEs :: EpochState (AllegraEra c)
nesEs = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b. (a -> b) -> a -> b
$ forall era. EraTxOut era => EpochState era -> EpochState era
returnRedeemAddrsToReserves forall a b. (a -> b) -> a -> b
$ forall era. NewEpochState era -> EpochState era
nesEs NewEpochState (PreviousEra (AllegraEra c))
nes
        , nesRu :: StrictMaybe (PulsingRewUpdate (EraCrypto (AllegraEra c)))
nesRu = forall era.
NewEpochState era -> StrictMaybe (PulsingRewUpdate (EraCrypto era))
nesRu NewEpochState (PreviousEra (AllegraEra c))
nes
        , nesPd :: PoolDistr (EraCrypto (AllegraEra c))
nesPd = forall era. NewEpochState era -> PoolDistr (EraCrypto era)
nesPd NewEpochState (PreviousEra (AllegraEra c))
nes
        , -- At this point, the consensus layer has passed in our stashed AVVM
          -- addresses as our UTxO, and we have deleted them above (with
          -- 'returnRedeemAddrsToReserves'), so we may safely discard this map.
          stashedAVVMAddresses :: StashedAVVMAddresses (AllegraEra c)
stashedAVVMAddresses = ()
        }

instance forall c. Crypto c => TranslateEra (AllegraEra c) ShelleyTx where
  type TranslationError (AllegraEra c) ShelleyTx = DecoderError
  translateEra :: TranslationContext (AllegraEra c)
-> ShelleyTx (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) ShelleyTx)
     (ShelleyTx (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
_ctx = forall era (ti :: * -> *) (to :: * -> *).
(Era era, ToCBOR (ti (PreviousEra era)),
 DecCBOR (Annotator (to era))) =>
Text -> ti (PreviousEra era) -> Except DecoderError (to era)
translateEraThroughCBOR Text
"ShelleyTx"

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

instance Crypto c => TranslateEra (AllegraEra c) PParams

instance Crypto c => TranslateEra (AllegraEra c) PParamsUpdate

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

instance Crypto c => TranslateEra (AllegraEra c) ProposedPPUpdates where
  translateEra :: TranslationContext (AllegraEra c)
-> ProposedPPUpdates (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) ProposedPPUpdates)
     (ProposedPPUpdates (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
ctxt (ProposedPPUpdates Map
  (KeyHash 'Genesis (EraCrypto (PreviousEra (AllegraEra c))))
  (PParamsUpdate (PreviousEra (AllegraEra c)))
ppup) =
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall era.
Map (KeyHash 'Genesis (EraCrypto era)) (PParamsUpdate era)
-> ProposedPPUpdates era
ProposedPPUpdates forall a b. (a -> b) -> a -> b
$ forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt) Map
  (KeyHash 'Genesis (EraCrypto (PreviousEra (AllegraEra c))))
  (PParamsUpdate (PreviousEra (AllegraEra c)))
ppup

instance Crypto c => TranslateEra (AllegraEra c) ShelleyGovState where
  translateEra :: TranslationContext (AllegraEra c)
-> ShelleyGovState (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) ShelleyGovState)
     (ShelleyGovState (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
ctxt ShelleyGovState (PreviousEra (AllegraEra c))
ps =
    forall (m :: * -> *) a. Monad m => a -> m a
return
      ShelleyGovState
        { sgsCurProposals :: ProposedPPUpdates (AllegraEra c)
sgsCurProposals = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b. (a -> b) -> a -> b
$ forall era. ShelleyGovState era -> ProposedPPUpdates era
sgsCurProposals ShelleyGovState (PreviousEra (AllegraEra c))
ps
        , sgsFutureProposals :: ProposedPPUpdates (AllegraEra c)
sgsFutureProposals = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b. (a -> b) -> a -> b
$ forall era. ShelleyGovState era -> ProposedPPUpdates era
sgsFutureProposals ShelleyGovState (PreviousEra (AllegraEra c))
ps
        , sgsCurPParams :: PParams (AllegraEra c)
sgsCurPParams = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b. (a -> b) -> a -> b
$ forall era. ShelleyGovState era -> PParams era
sgsCurPParams ShelleyGovState (PreviousEra (AllegraEra c))
ps
        , sgsPrevPParams :: PParams (AllegraEra c)
sgsPrevPParams = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b. (a -> b) -> a -> b
$ forall era. ShelleyGovState era -> PParams era
sgsPrevPParams ShelleyGovState (PreviousEra (AllegraEra c))
ps
        , sgsFuturePParams :: FuturePParams (AllegraEra c)
sgsFuturePParams = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b. (a -> b) -> a -> b
$ forall era. ShelleyGovState era -> FuturePParams era
sgsFuturePParams ShelleyGovState (PreviousEra (AllegraEra c))
ps
        }

instance Crypto c => TranslateEra (AllegraEra c) ShelleyTxOut where
  translateEra :: TranslationContext (AllegraEra c)
-> ShelleyTxOut (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) ShelleyTxOut)
     (ShelleyTxOut (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
NoGenesis (AllegraEra c)
NoGenesis = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era.
(EraTxOut era, EraTxOut (PreviousEra era)) =>
TxOut (PreviousEra era) -> TxOut era
upgradeTxOut

instance Crypto c => TranslateEra (AllegraEra c) UTxO where
  translateEra :: TranslationContext (AllegraEra c)
-> UTxO (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) UTxO) (UTxO (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
ctxt UTxO (PreviousEra (AllegraEra c))
utxo =
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall era. Map (TxIn (EraCrypto era)) (TxOut era) -> UTxO era
UTxO (forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b k. (a -> b) -> Map k a -> Map k b
`Map.map` forall era. UTxO era -> Map (TxIn (EraCrypto era)) (TxOut era)
unUTxO UTxO (PreviousEra (AllegraEra c))
utxo)

instance Crypto c => TranslateEra (AllegraEra c) UTxOState where
  translateEra :: TranslationContext (AllegraEra c)
-> UTxOState (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) UTxOState)
     (UTxOState (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
ctxt UTxOState (PreviousEra (AllegraEra c))
us =
    forall (m :: * -> *) a. Monad m => a -> m a
return
      UTxOState
        { utxosUtxo :: UTxO (AllegraEra c)
utxosUtxo = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b. (a -> b) -> a -> b
$ forall era. UTxOState era -> UTxO era
utxosUtxo UTxOState (PreviousEra (AllegraEra c))
us
        , utxosDeposited :: Coin
utxosDeposited = forall era. UTxOState era -> Coin
utxosDeposited UTxOState (PreviousEra (AllegraEra c))
us
        , utxosFees :: Coin
utxosFees = forall era. UTxOState era -> Coin
utxosFees UTxOState (PreviousEra (AllegraEra c))
us
        , utxosGovState :: GovState (AllegraEra c)
utxosGovState = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b. (a -> b) -> a -> b
$ forall era. UTxOState era -> GovState era
utxosGovState UTxOState (PreviousEra (AllegraEra c))
us
        , utxosStakeDistr :: IncrementalStake (EraCrypto (AllegraEra c))
utxosStakeDistr = forall era. UTxOState era -> IncrementalStake (EraCrypto era)
utxosStakeDistr UTxOState (PreviousEra (AllegraEra c))
us
        , utxosDonation :: Coin
utxosDonation = forall era. UTxOState era -> Coin
utxosDonation UTxOState (PreviousEra (AllegraEra c))
us
        }

instance Crypto c => TranslateEra (AllegraEra c) DState where
  translateEra :: TranslationContext (AllegraEra c)
-> DState (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) DState) (DState (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
_ DState {Map
  (FutureGenDeleg (EraCrypto (PreviousEra (AllegraEra c))))
  (GenDelegPair (EraCrypto (PreviousEra (AllegraEra c))))
InstantaneousRewards (EraCrypto (PreviousEra (AllegraEra c)))
UMap (EraCrypto (PreviousEra (AllegraEra c)))
GenDelegs (EraCrypto (PreviousEra (AllegraEra c)))
dsUnified :: forall era. DState era -> UMap (EraCrypto era)
dsFutureGenDelegs :: forall era.
DState era
-> Map
     (FutureGenDeleg (EraCrypto era)) (GenDelegPair (EraCrypto era))
dsGenDelegs :: forall era. DState era -> GenDelegs (EraCrypto era)
dsIRewards :: forall era. DState era -> InstantaneousRewards (EraCrypto era)
dsIRewards :: InstantaneousRewards (EraCrypto (PreviousEra (AllegraEra c)))
dsGenDelegs :: GenDelegs (EraCrypto (PreviousEra (AllegraEra c)))
dsFutureGenDelegs :: Map
  (FutureGenDeleg (EraCrypto (PreviousEra (AllegraEra c))))
  (GenDelegPair (EraCrypto (PreviousEra (AllegraEra c))))
dsUnified :: UMap (EraCrypto (PreviousEra (AllegraEra c)))
..} = forall (f :: * -> *) a. Applicative f => a -> f a
pure DState {Map
  (FutureGenDeleg (EraCrypto (PreviousEra (AllegraEra c))))
  (GenDelegPair (EraCrypto (PreviousEra (AllegraEra c))))
InstantaneousRewards (EraCrypto (PreviousEra (AllegraEra c)))
UMap (EraCrypto (PreviousEra (AllegraEra c)))
GenDelegs (EraCrypto (PreviousEra (AllegraEra c)))
dsUnified :: UMap (EraCrypto (AllegraEra c))
dsFutureGenDelegs :: Map
  (FutureGenDeleg (EraCrypto (AllegraEra c)))
  (GenDelegPair (EraCrypto (AllegraEra c)))
dsGenDelegs :: GenDelegs (EraCrypto (AllegraEra c))
dsIRewards :: InstantaneousRewards (EraCrypto (AllegraEra c))
dsIRewards :: InstantaneousRewards (EraCrypto (PreviousEra (AllegraEra c)))
dsGenDelegs :: GenDelegs (EraCrypto (PreviousEra (AllegraEra c)))
dsFutureGenDelegs :: Map
  (FutureGenDeleg (EraCrypto (PreviousEra (AllegraEra c))))
  (GenDelegPair (EraCrypto (PreviousEra (AllegraEra c))))
dsUnified :: UMap (EraCrypto (PreviousEra (AllegraEra c)))
..}

instance Crypto c => TranslateEra (AllegraEra c) CommitteeState where
  translateEra :: TranslationContext (AllegraEra c)
-> CommitteeState (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) CommitteeState)
     (CommitteeState (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
_ CommitteeState {Map
  (Credential
     'ColdCommitteeRole (EraCrypto (PreviousEra (AllegraEra c))))
  (CommitteeAuthorization (EraCrypto (PreviousEra (AllegraEra c))))
csCommitteeCreds :: forall era.
CommitteeState era
-> Map
     (Credential 'ColdCommitteeRole (EraCrypto era))
     (CommitteeAuthorization (EraCrypto era))
csCommitteeCreds :: Map
  (Credential
     'ColdCommitteeRole (EraCrypto (PreviousEra (AllegraEra c))))
  (CommitteeAuthorization (EraCrypto (PreviousEra (AllegraEra c))))
..} = forall (f :: * -> *) a. Applicative f => a -> f a
pure CommitteeState {Map
  (Credential
     'ColdCommitteeRole (EraCrypto (PreviousEra (AllegraEra c))))
  (CommitteeAuthorization (EraCrypto (PreviousEra (AllegraEra c))))
csCommitteeCreds :: Map
  (Credential 'ColdCommitteeRole (EraCrypto (AllegraEra c)))
  (CommitteeAuthorization (EraCrypto (AllegraEra c)))
csCommitteeCreds :: Map
  (Credential
     'ColdCommitteeRole (EraCrypto (PreviousEra (AllegraEra c))))
  (CommitteeAuthorization (EraCrypto (PreviousEra (AllegraEra c))))
..}

instance Crypto c => TranslateEra (AllegraEra c) VState where
  translateEra :: TranslationContext (AllegraEra c)
-> VState (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) VState) (VState (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
ctx VState {Map
  (Credential 'DRepRole (EraCrypto (PreviousEra (AllegraEra c))))
  (DRepState (EraCrypto (PreviousEra (AllegraEra c))))
CommitteeState (PreviousEra (AllegraEra c))
EpochNo
vsDReps :: forall era.
VState era
-> Map
     (Credential 'DRepRole (EraCrypto era)) (DRepState (EraCrypto era))
vsCommitteeState :: forall era. VState era -> CommitteeState era
vsNumDormantEpochs :: forall era. VState era -> EpochNo
vsNumDormantEpochs :: EpochNo
vsCommitteeState :: CommitteeState (PreviousEra (AllegraEra c))
vsDReps :: Map
  (Credential 'DRepRole (EraCrypto (PreviousEra (AllegraEra c))))
  (DRepState (EraCrypto (PreviousEra (AllegraEra c))))
..} = do
    CommitteeState (AllegraEra c)
committeeState <- forall era (f :: * -> *).
TranslateEra era f =>
TranslationContext era
-> f (PreviousEra era) -> Except (TranslationError era f) (f era)
translateEra TranslationContext (AllegraEra c)
ctx CommitteeState (PreviousEra (AllegraEra c))
vsCommitteeState
    forall (f :: * -> *) a. Applicative f => a -> f a
pure VState {vsCommitteeState :: CommitteeState (AllegraEra c)
vsCommitteeState = CommitteeState (AllegraEra c)
committeeState, Map
  (Credential 'DRepRole (EraCrypto (PreviousEra (AllegraEra c))))
  (DRepState (EraCrypto (PreviousEra (AllegraEra c))))
EpochNo
vsDReps :: Map
  (Credential 'DRepRole (EraCrypto (AllegraEra c)))
  (DRepState (EraCrypto (AllegraEra c)))
vsNumDormantEpochs :: EpochNo
vsNumDormantEpochs :: EpochNo
vsDReps :: Map
  (Credential 'DRepRole (EraCrypto (PreviousEra (AllegraEra c))))
  (DRepState (EraCrypto (PreviousEra (AllegraEra c))))
..}

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

instance Crypto c => TranslateEra (AllegraEra c) CertState where
  translateEra :: TranslationContext (AllegraEra c)
-> CertState (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) CertState)
     (CertState (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
ctxt CertState (PreviousEra (AllegraEra c))
ls =
    forall (f :: * -> *) a. Applicative f => a -> f a
pure
      CertState
        { certDState :: DState (AllegraEra c)
certDState = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b. (a -> b) -> a -> b
$ forall era. CertState era -> DState era
certDState CertState (PreviousEra (AllegraEra c))
ls
        , certPState :: PState (AllegraEra c)
certPState = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b. (a -> b) -> a -> b
$ forall era. CertState era -> PState era
certPState CertState (PreviousEra (AllegraEra c))
ls
        , certVState :: VState (AllegraEra c)
certVState = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b. (a -> b) -> a -> b
$ forall era. CertState era -> VState era
certVState CertState (PreviousEra (AllegraEra c))
ls
        }

instance Crypto c => TranslateEra (AllegraEra c) LedgerState where
  translateEra :: TranslationContext (AllegraEra c)
-> LedgerState (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) LedgerState)
     (LedgerState (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
ctxt LedgerState (PreviousEra (AllegraEra c))
ls =
    forall (m :: * -> *) a. Monad m => a -> m a
return
      LedgerState
        { lsUTxOState :: UTxOState (AllegraEra c)
lsUTxOState = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b. (a -> b) -> a -> b
$ forall era. LedgerState era -> UTxOState era
lsUTxOState LedgerState (PreviousEra (AllegraEra c))
ls
        , lsCertState :: CertState (AllegraEra c)
lsCertState = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b. (a -> b) -> a -> b
$ forall era. LedgerState era -> CertState era
lsCertState LedgerState (PreviousEra (AllegraEra c))
ls
        }

instance Crypto c => TranslateEra (AllegraEra c) EpochState where
  translateEra :: TranslationContext (AllegraEra c)
-> EpochState (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) EpochState)
     (EpochState (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
ctxt EpochState (PreviousEra (AllegraEra c))
es =
    forall (m :: * -> *) a. Monad m => a -> m a
return
      EpochState
        { esAccountState :: AccountState
esAccountState = forall era. EpochState era -> AccountState
esAccountState EpochState (PreviousEra (AllegraEra c))
es
        , esSnapshots :: SnapShots (EraCrypto (AllegraEra c))
esSnapshots = forall era. EpochState era -> SnapShots (EraCrypto era)
esSnapshots EpochState (PreviousEra (AllegraEra c))
es
        , esLState :: LedgerState (AllegraEra c)
esLState = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext (AllegraEra c)
ctxt forall a b. (a -> b) -> a -> b
$ forall era. EpochState era -> LedgerState era
esLState EpochState (PreviousEra (AllegraEra c))
es
        , esNonMyopic :: NonMyopic (EraCrypto (AllegraEra c))
esNonMyopic = forall era. EpochState era -> NonMyopic (EraCrypto era)
esNonMyopic EpochState (PreviousEra (AllegraEra c))
es
        }

instance Crypto c => TranslateEra (AllegraEra c) ShelleyTxWits where
  type TranslationError (AllegraEra c) ShelleyTxWits = DecoderError
  translateEra :: TranslationContext (AllegraEra c)
-> ShelleyTxWits (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) ShelleyTxWits)
     (ShelleyTxWits (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
_ctx = forall era (ti :: * -> *) (to :: * -> *).
(Era era, ToCBOR (ti (PreviousEra era)),
 DecCBOR (Annotator (to era))) =>
Text -> ti (PreviousEra era) -> Except DecoderError (to era)
translateEraThroughCBOR Text
"ShelleyTxWits"

instance Crypto c => TranslateEra (AllegraEra c) Update where
  translateEra :: TranslationContext (AllegraEra c)
-> Update (PreviousEra (AllegraEra c))
-> Except
     (TranslationError (AllegraEra c) Update) (Update (AllegraEra c))
translateEra TranslationContext (AllegraEra c)
_ (Update ProposedPPUpdates (PreviousEra (AllegraEra c))
pp EpochNo
en) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall era. ProposedPPUpdates era -> EpochNo -> Update era
Update (coerce :: forall a b. Coercible a b => a -> b
coerce ProposedPPUpdates (PreviousEra (AllegraEra c))
pp) EpochNo
en