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

module Cardano.Ledger.Mary.Translation where

import Cardano.Ledger.Binary (DecoderError)
import Cardano.Ledger.Genesis (NoGenesis (..))
import Cardano.Ledger.Mary.Core
import Cardano.Ledger.Mary.Era (MaryEra)
import Cardano.Ledger.Mary.Scripts (Timelock, translateTimelock)
import Cardano.Ledger.Mary.State
import Cardano.Ledger.Mary.TxAuxData (AllegraTxAuxData (..))
import Cardano.Ledger.Shelley.LedgerState (
  EpochState (..),
  LedgerState (..),
  NewEpochState (..),
  UTxOState (..),
 )
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 Data.Coerce (coerce)
import qualified Data.Map.Strict as Map

--------------------------------------------------------------------------------
-- Translation from Allegra to Mary
--
-- 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!
--------------------------------------------------------------------------------

instance TranslateEra MaryEra NewEpochState where
  translateEra :: TranslationContext MaryEra
-> NewEpochState (PreviousEra MaryEra)
-> Except
     (TranslationError MaryEra NewEpochState) (NewEpochState MaryEra)
translateEra TranslationContext MaryEra
ctxt NewEpochState (PreviousEra MaryEra)
nes =
    NewEpochState MaryEra
-> Except
     (TranslationError MaryEra NewEpochState) (NewEpochState MaryEra)
forall a.
a -> ExceptT (TranslationError MaryEra NewEpochState) Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (NewEpochState MaryEra
 -> Except
      (TranslationError MaryEra NewEpochState) (NewEpochState MaryEra))
-> NewEpochState MaryEra
-> Except
     (TranslationError MaryEra NewEpochState) (NewEpochState MaryEra)
forall a b. (a -> b) -> a -> b
$
      NewEpochState
        { nesEL :: EpochNo
nesEL = NewEpochState AllegraEra -> EpochNo
forall era. NewEpochState era -> EpochNo
nesEL NewEpochState AllegraEra
NewEpochState (PreviousEra MaryEra)
nes
        , nesBprev :: BlocksMade
nesBprev = NewEpochState AllegraEra -> BlocksMade
forall era. NewEpochState era -> BlocksMade
nesBprev NewEpochState AllegraEra
NewEpochState (PreviousEra MaryEra)
nes
        , nesBcur :: BlocksMade
nesBcur = NewEpochState AllegraEra -> BlocksMade
forall era. NewEpochState era -> BlocksMade
nesBcur NewEpochState AllegraEra
NewEpochState (PreviousEra MaryEra)
nes
        , nesEs :: EpochState MaryEra
nesEs = TranslationContext MaryEra
-> EpochState (PreviousEra MaryEra) -> EpochState MaryEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt (EpochState (PreviousEra MaryEra) -> EpochState MaryEra)
-> EpochState (PreviousEra MaryEra) -> EpochState MaryEra
forall a b. (a -> b) -> a -> b
$ NewEpochState AllegraEra -> EpochState AllegraEra
forall era. NewEpochState era -> EpochState era
nesEs NewEpochState AllegraEra
NewEpochState (PreviousEra MaryEra)
nes
        , nesRu :: StrictMaybe PulsingRewUpdate
nesRu = NewEpochState AllegraEra -> StrictMaybe PulsingRewUpdate
forall era. NewEpochState era -> StrictMaybe PulsingRewUpdate
nesRu NewEpochState AllegraEra
NewEpochState (PreviousEra MaryEra)
nes
        , nesPd :: PoolDistr
nesPd = NewEpochState AllegraEra -> PoolDistr
forall era. NewEpochState era -> PoolDistr
nesPd NewEpochState AllegraEra
NewEpochState (PreviousEra MaryEra)
nes
        , stashedAVVMAddresses :: StashedAVVMAddresses MaryEra
stashedAVVMAddresses = ()
        }

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

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

instance TranslateEra MaryEra PParams

instance TranslateEra MaryEra PParamsUpdate

instance TranslateEra MaryEra FuturePParams where
  translateEra :: TranslationContext MaryEra
-> FuturePParams (PreviousEra MaryEra)
-> Except
     (TranslationError MaryEra FuturePParams) (FuturePParams MaryEra)
translateEra TranslationContext MaryEra
ctxt = \case
    FuturePParams (PreviousEra MaryEra)
NoPParamsUpdate -> FuturePParams MaryEra
-> ExceptT Void Identity (FuturePParams MaryEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure FuturePParams MaryEra
forall era. FuturePParams era
NoPParamsUpdate
    DefinitePParamsUpdate PParams (PreviousEra MaryEra)
pp -> PParams MaryEra -> FuturePParams MaryEra
forall era. PParams era -> FuturePParams era
DefinitePParamsUpdate (PParams MaryEra -> FuturePParams MaryEra)
-> ExceptT Void Identity (PParams MaryEra)
-> ExceptT Void Identity (FuturePParams MaryEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TranslationContext MaryEra
-> PParams (PreviousEra MaryEra)
-> Except (TranslationError MaryEra PParams) (PParams MaryEra)
forall era (f :: * -> *).
TranslateEra era f =>
TranslationContext era
-> f (PreviousEra era) -> Except (TranslationError era f) (f era)
translateEra TranslationContext MaryEra
ctxt PParams (PreviousEra MaryEra)
pp
    PotentialPParamsUpdate Maybe (PParams (PreviousEra MaryEra))
mpp -> Maybe (PParams MaryEra) -> FuturePParams MaryEra
forall era. Maybe (PParams era) -> FuturePParams era
PotentialPParamsUpdate (Maybe (PParams MaryEra) -> FuturePParams MaryEra)
-> ExceptT Void Identity (Maybe (PParams MaryEra))
-> ExceptT Void Identity (FuturePParams MaryEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PParams AllegraEra -> ExceptT Void Identity (PParams MaryEra))
-> Maybe (PParams AllegraEra)
-> ExceptT Void Identity (Maybe (PParams MaryEra))
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 MaryEra
-> PParams (PreviousEra MaryEra)
-> Except (TranslationError MaryEra PParams) (PParams MaryEra)
forall era (f :: * -> *).
TranslateEra era f =>
TranslationContext era
-> f (PreviousEra era) -> Except (TranslationError era f) (f era)
translateEra TranslationContext MaryEra
ctxt) Maybe (PParams AllegraEra)
Maybe (PParams (PreviousEra MaryEra))
mpp

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

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

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

instance TranslateEra MaryEra PState where
  translateEra :: TranslationContext MaryEra
-> PState (PreviousEra MaryEra)
-> Except (TranslationError MaryEra PState) (PState MaryEra)
translateEra TranslationContext MaryEra
_ PState {Map (KeyHash 'StakePool) EpochNo
Map (KeyHash 'StakePool) Coin
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 MaryEra -> ExceptT Void Identity (PState MaryEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PState {Map (KeyHash 'StakePool) EpochNo
Map (KeyHash 'StakePool) Coin
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 MaryEra ShelleyCertState where
  translateEra :: TranslationContext MaryEra
-> ShelleyCertState (PreviousEra MaryEra)
-> Except
     (TranslationError MaryEra ShelleyCertState)
     (ShelleyCertState MaryEra)
translateEra TranslationContext MaryEra
ctxt ShelleyCertState (PreviousEra MaryEra)
ls =
    ShelleyCertState MaryEra
-> ExceptT Void Identity (ShelleyCertState MaryEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
      ShelleyCertState
        { shelleyCertDState :: DState MaryEra
shelleyCertDState = TranslationContext MaryEra
-> DState (PreviousEra MaryEra) -> DState MaryEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt (DState (PreviousEra MaryEra) -> DState MaryEra)
-> DState (PreviousEra MaryEra) -> DState MaryEra
forall a b. (a -> b) -> a -> b
$ ShelleyCertState AllegraEra -> DState AllegraEra
forall era. ShelleyCertState era -> DState era
shelleyCertDState ShelleyCertState AllegraEra
ShelleyCertState (PreviousEra MaryEra)
ls
        , shelleyCertPState :: PState MaryEra
shelleyCertPState = TranslationContext MaryEra
-> PState (PreviousEra MaryEra) -> PState MaryEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt (PState (PreviousEra MaryEra) -> PState MaryEra)
-> PState (PreviousEra MaryEra) -> PState MaryEra
forall a b. (a -> b) -> a -> b
$ ShelleyCertState AllegraEra -> PState AllegraEra
forall era. ShelleyCertState era -> PState era
shelleyCertPState ShelleyCertState AllegraEra
ShelleyCertState (PreviousEra MaryEra)
ls
        }

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

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

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

instance TranslateEra MaryEra UTxOState where
  translateEra :: TranslationContext MaryEra
-> UTxOState (PreviousEra MaryEra)
-> Except (TranslationError MaryEra UTxOState) (UTxOState MaryEra)
translateEra TranslationContext MaryEra
ctxt UTxOState (PreviousEra MaryEra)
us =
    UTxOState MaryEra -> ExceptT Void Identity (UTxOState MaryEra)
forall a. a -> ExceptT Void Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return
      UTxOState
        { utxosUtxo :: UTxO MaryEra
utxosUtxo = TranslationContext MaryEra
-> UTxO (PreviousEra MaryEra) -> UTxO MaryEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt (UTxO (PreviousEra MaryEra) -> UTxO MaryEra)
-> UTxO (PreviousEra MaryEra) -> UTxO MaryEra
forall a b. (a -> b) -> a -> b
$ UTxOState AllegraEra -> UTxO AllegraEra
forall era. UTxOState era -> UTxO era
utxosUtxo UTxOState AllegraEra
UTxOState (PreviousEra MaryEra)
us
        , utxosDeposited :: Coin
utxosDeposited = UTxOState AllegraEra -> Coin
forall era. UTxOState era -> Coin
utxosDeposited UTxOState AllegraEra
UTxOState (PreviousEra MaryEra)
us
        , utxosFees :: Coin
utxosFees = UTxOState AllegraEra -> Coin
forall era. UTxOState era -> Coin
utxosFees UTxOState AllegraEra
UTxOState (PreviousEra MaryEra)
us
        , utxosGovState :: GovState MaryEra
utxosGovState = TranslationContext MaryEra
-> ShelleyGovState (PreviousEra MaryEra) -> ShelleyGovState MaryEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt (ShelleyGovState (PreviousEra MaryEra) -> ShelleyGovState MaryEra)
-> ShelleyGovState (PreviousEra MaryEra) -> ShelleyGovState MaryEra
forall a b. (a -> b) -> a -> b
$ UTxOState AllegraEra -> GovState AllegraEra
forall era. UTxOState era -> GovState era
utxosGovState UTxOState AllegraEra
UTxOState (PreviousEra MaryEra)
us
        , utxosInstantStake :: InstantStake MaryEra
utxosInstantStake = TranslationContext MaryEra
-> ShelleyInstantStake (PreviousEra MaryEra)
-> ShelleyInstantStake MaryEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt (ShelleyInstantStake (PreviousEra MaryEra)
 -> ShelleyInstantStake MaryEra)
-> ShelleyInstantStake (PreviousEra MaryEra)
-> ShelleyInstantStake MaryEra
forall a b. (a -> b) -> a -> b
$ UTxOState AllegraEra -> InstantStake AllegraEra
forall era. UTxOState era -> InstantStake era
utxosInstantStake UTxOState AllegraEra
UTxOState (PreviousEra MaryEra)
us
        , utxosDonation :: Coin
utxosDonation = UTxOState AllegraEra -> Coin
forall era. UTxOState era -> Coin
utxosDonation UTxOState AllegraEra
UTxOState (PreviousEra MaryEra)
us
        }

instance TranslateEra MaryEra ShelleyInstantStake where
  translateEra :: TranslationContext MaryEra
-> ShelleyInstantStake (PreviousEra MaryEra)
-> Except
     (TranslationError MaryEra ShelleyInstantStake)
     (ShelleyInstantStake MaryEra)
translateEra TranslationContext MaryEra
_ = ShelleyInstantStake MaryEra
-> ExceptT Void Identity (ShelleyInstantStake MaryEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ShelleyInstantStake MaryEra
 -> ExceptT Void Identity (ShelleyInstantStake MaryEra))
-> (ShelleyInstantStake AllegraEra -> ShelleyInstantStake MaryEra)
-> ShelleyInstantStake AllegraEra
-> ExceptT Void Identity (ShelleyInstantStake MaryEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShelleyInstantStake AllegraEra -> ShelleyInstantStake MaryEra
forall a b. Coercible a b => a -> b
coerce

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

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

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

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

instance TranslateEra MaryEra Timelock where
  translateEra :: TranslationContext MaryEra
-> Timelock (PreviousEra MaryEra)
-> Except (TranslationError MaryEra Timelock) (Timelock MaryEra)
translateEra TranslationContext MaryEra
_ = Timelock MaryEra -> ExceptT Void Identity (Timelock MaryEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Timelock MaryEra -> ExceptT Void Identity (Timelock MaryEra))
-> (Timelock AllegraEra -> Timelock MaryEra)
-> Timelock AllegraEra
-> ExceptT Void Identity (Timelock MaryEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Timelock AllegraEra -> Timelock MaryEra
forall era1 era2.
(Era era1, Era era2) =>
Timelock era1 -> Timelock era2
translateTimelock

instance TranslateEra MaryEra AllegraTxAuxData where
  translateEra :: TranslationContext MaryEra
-> AllegraTxAuxData (PreviousEra MaryEra)
-> Except
     (TranslationError MaryEra AllegraTxAuxData)
     (AllegraTxAuxData MaryEra)
translateEra TranslationContext MaryEra
ctx (AllegraTxAuxData Map Word64 Metadatum
md StrictSeq (Timelock AllegraEra)
as) =
    AllegraTxAuxData MaryEra
-> Except
     (TranslationError MaryEra AllegraTxAuxData)
     (AllegraTxAuxData MaryEra)
forall a.
a -> ExceptT (TranslationError MaryEra AllegraTxAuxData) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AllegraTxAuxData MaryEra
 -> Except
      (TranslationError MaryEra AllegraTxAuxData)
      (AllegraTxAuxData MaryEra))
-> AllegraTxAuxData MaryEra
-> Except
     (TranslationError MaryEra AllegraTxAuxData)
     (AllegraTxAuxData MaryEra)
forall a b. (a -> b) -> a -> b
$ Map Word64 Metadatum
-> StrictSeq (Timelock MaryEra) -> AllegraTxAuxData MaryEra
forall era.
Era era =>
Map Word64 Metadatum
-> StrictSeq (Timelock era) -> AllegraTxAuxData era
AllegraTxAuxData Map Word64 Metadatum
md (StrictSeq (Timelock MaryEra) -> AllegraTxAuxData MaryEra)
-> StrictSeq (Timelock MaryEra) -> AllegraTxAuxData MaryEra
forall a b. (a -> b) -> a -> b
$ TranslationContext MaryEra
-> Timelock (PreviousEra MaryEra) -> Timelock MaryEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctx (Timelock AllegraEra -> Timelock MaryEra)
-> StrictSeq (Timelock AllegraEra) -> StrictSeq (Timelock MaryEra)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StrictSeq (Timelock AllegraEra)
as