{-# 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.MempoolTx (MempoolTx)
import Cardano.Ledger.Shelley.LedgerState (
  EpochState (..),
  LedgerState (..),
  NewEpochState (..),
  UTxOState (..),
 )
import Cardano.Ledger.Shelley.PParams (ProposedPPUpdates (..), Update (..))
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
        , stashedAVVMAddresses :: StashedAVVMAddresses MaryEra
stashedAVVMAddresses = ()
        , nesLastTickSlotNo :: SlotNo
nesLastTickSlotNo = NewEpochState AllegraEra -> SlotNo
forall era. NewEpochState era -> SlotNo
nesLastTickSlotNo NewEpochState AllegraEra
NewEpochState (PreviousEra MaryEra)
nes
        }

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

--------------------------------------------------------------------------------
-- 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 SnapShots where
  translateEra :: TranslationContext MaryEra
-> SnapShots (PreviousEra MaryEra)
-> Except (TranslationError MaryEra SnapShots) (SnapShots MaryEra)
translateEra TranslationContext MaryEra
_ctxt _ss :: SnapShots (PreviousEra MaryEra)
_ss@SnapShots {GoSnapShot
MarkSnapShot
SetSnapShot
Coin
ssStakeMark :: MarkSnapShot
ssStakeSet :: SetSnapShot
ssStakeGo :: GoSnapShot
ssFee :: Coin
ssFee :: forall era. SnapShots era -> Coin
ssStakeGo :: forall era. SnapShots era -> GoSnapShot
ssStakeMark :: forall era. SnapShots era -> MarkSnapShot
ssStakeSet :: forall era. SnapShots era -> SetSnapShot
..} = SnapShots MaryEra -> ExceptT Void Identity (SnapShots MaryEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SnapShots {GoSnapShot
MarkSnapShot
SetSnapShot
Coin
ssStakeMark :: MarkSnapShot
ssStakeSet :: SetSnapShot
ssStakeGo :: GoSnapShot
ssFee :: Coin
ssFee :: Coin
ssStakeGo :: GoSnapShot
ssStakeMark :: MarkSnapShot
ssStakeSet :: SetSnapShot
..}

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 MaryEra
esSnapshots = TranslationContext MaryEra
-> SnapShots (PreviousEra MaryEra) -> SnapShots MaryEra
forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt (SnapShots (PreviousEra MaryEra) -> SnapShots MaryEra)
-> SnapShots (PreviousEra MaryEra) -> SnapShots MaryEra
forall a b. (a -> b) -> a -> b
$ EpochState AllegraEra -> SnapShots AllegraEra
forall era. EpochState era -> SnapShots era
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 ShelleyAccounts where
  translateEra :: TranslationContext MaryEra
-> ShelleyAccounts (PreviousEra MaryEra)
-> Except
     (TranslationError MaryEra ShelleyAccounts)
     (ShelleyAccounts MaryEra)
translateEra TranslationContext MaryEra
_ = ShelleyAccounts MaryEra
-> ExceptT Void Identity (ShelleyAccounts MaryEra)
forall a. a -> ExceptT Void Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ShelleyAccounts MaryEra
 -> ExceptT Void Identity (ShelleyAccounts MaryEra))
-> (ShelleyAccounts AllegraEra -> ShelleyAccounts MaryEra)
-> ShelleyAccounts AllegraEra
-> ExceptT Void Identity (ShelleyAccounts MaryEra)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShelleyAccounts AllegraEra -> ShelleyAccounts MaryEra
forall a b. Coercible a b => a -> b
coerce

instance TranslateEra MaryEra DState where
  translateEra :: TranslationContext MaryEra
-> DState (PreviousEra MaryEra)
-> Except (TranslationError MaryEra DState) (DState MaryEra)
translateEra TranslationContext MaryEra
ctx DState {dsAccounts :: forall era. DState era -> Accounts era
dsAccounts = Accounts (PreviousEra MaryEra)
accountsShelley, 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
..} = do
    dsAccounts <- TranslationContext MaryEra
-> ShelleyAccounts (PreviousEra MaryEra)
-> Except
     (TranslationError MaryEra ShelleyAccounts)
     (ShelleyAccounts MaryEra)
forall era (f :: * -> *).
TranslateEra era f =>
TranslationContext era
-> f (PreviousEra era) -> Except (TranslationError era f) (f era)
translateEra TranslationContext MaryEra
ctx Accounts (PreviousEra MaryEra)
ShelleyAccounts (PreviousEra MaryEra)
accountsShelley
    pure DState {..}

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 (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
Map (KeyHash StakePool) (StakePoolParams (PreviousEra MaryEra))
Map (KeyHash StakePool) StakePoolState
Map (KeyHash StakePool) EpochNo
Set BlsVerKeyHash
psVRFKeyHashes :: Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
psStakePools :: Map (KeyHash StakePool) StakePoolState
psFutureStakePoolParams :: Map (KeyHash StakePool) (StakePoolParams (PreviousEra MaryEra))
psRetiring :: Map (KeyHash StakePool) EpochNo
psBlsKeyHashes :: Set BlsVerKeyHash
psBlsKeyHashes :: forall era. PState era -> Set BlsVerKeyHash
psFutureStakePoolParams :: forall era.
PState era -> Map (KeyHash StakePool) (StakePoolParams era)
psRetiring :: forall era. PState era -> Map (KeyHash StakePool) EpochNo
psStakePools :: forall era. PState era -> Map (KeyHash StakePool) StakePoolState
psVRFKeyHashes :: forall era.
PState era -> Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
..} = PState MaryEra
-> Except (TranslationError MaryEra PState) (PState MaryEra)
forall a. a -> ExceptT (TranslationError MaryEra PState) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PState MaryEra
 -> Except (TranslationError MaryEra PState) (PState MaryEra))
-> PState MaryEra
-> Except (TranslationError MaryEra PState) (PState MaryEra)
forall a b. (a -> b) -> a -> b
$ PState AllegraEra -> PState MaryEra
forall a b. Coercible a b => a -> b
coerce PState {Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
Map (KeyHash StakePool) (StakePoolParams AllegraEra)
Map (KeyHash StakePool) (StakePoolParams (PreviousEra MaryEra))
Map (KeyHash StakePool) StakePoolState
Map (KeyHash StakePool) EpochNo
Set BlsVerKeyHash
psVRFKeyHashes :: Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
psStakePools :: Map (KeyHash StakePool) StakePoolState
psFutureStakePoolParams :: Map (KeyHash StakePool) (StakePoolParams (PreviousEra MaryEra))
psRetiring :: Map (KeyHash StakePool) EpochNo
psBlsKeyHashes :: Set BlsVerKeyHash
psBlsKeyHashes :: Set BlsVerKeyHash
psFutureStakePoolParams :: Map (KeyHash StakePool) (StakePoolParams AllegraEra)
psRetiring :: Map (KeyHash StakePool) EpochNo
psStakePools :: Map (KeyHash StakePool) StakePoolState
psVRFKeyHashes :: Map (VRFVerKeyHash StakePoolVRF) (NonZero Word64)
..}

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
        , lsLastEbAnnouncement :: StrictMaybe EbAnnouncement
lsLastEbAnnouncement = LedgerState AllegraEra -> StrictMaybe EbAnnouncement
forall era. LedgerState era -> StrictMaybe EbAnnouncement
lsLastEbAnnouncement 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 GenesisRole) (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 GenesisRole) (PParamsUpdate MaryEra)
-> ProposedPPUpdates MaryEra
forall era.
Map (KeyHash GenesisRole) (PParamsUpdate era)
-> ProposedPPUpdates era
ProposedPPUpdates (Map (KeyHash GenesisRole) (PParamsUpdate MaryEra)
 -> ProposedPPUpdates MaryEra)
-> Map (KeyHash GenesisRole) (PParamsUpdate MaryEra)
-> ProposedPPUpdates MaryEra
forall a b. (a -> b) -> a -> b
$ (PParamsUpdate AllegraEra -> PParamsUpdate MaryEra)
-> Map (KeyHash GenesisRole) (PParamsUpdate AllegraEra)
-> Map (KeyHash GenesisRole) (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 GenesisRole) (PParamsUpdate AllegraEra)
Map (KeyHash GenesisRole) (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 = Text
-> ShelleyTxWits (PreviousEra MaryEra)
-> Except DecoderError (ShelleyTxWits MaryEra)
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 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 (NativeScript 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 (NativeScript MaryEra) -> AllegraTxAuxData MaryEra
forall era.
(Era era, EncCBOR (NativeScript era)) =>
Map Word64 Metadatum
-> StrictSeq (NativeScript era) -> AllegraTxAuxData era
AllegraTxAuxData Map Word64 Metadatum
md (StrictSeq (NativeScript MaryEra) -> AllegraTxAuxData MaryEra)
-> StrictSeq (NativeScript 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)
StrictSeq (NativeScript AllegraEra)
as