{-# 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 =
    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 MaryEra)
nes
        , nesBprev :: BlocksMade
nesBprev = forall era. NewEpochState era -> BlocksMade
nesBprev NewEpochState (PreviousEra MaryEra)
nes
        , nesBcur :: BlocksMade
nesBcur = forall era. NewEpochState era -> BlocksMade
nesBcur NewEpochState (PreviousEra MaryEra)
nes
        , nesEs :: EpochState MaryEra
nesEs = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b. (a -> b) -> a -> b
$ forall era. NewEpochState era -> EpochState era
nesEs NewEpochState (PreviousEra MaryEra)
nes
        , nesRu :: StrictMaybe PulsingRewUpdate
nesRu = forall era. NewEpochState era -> StrictMaybe PulsingRewUpdate
nesRu NewEpochState (PreviousEra MaryEra)
nes
        , nesPd :: PoolDistr
nesPd = forall era. NewEpochState era -> PoolDistr
nesPd 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 = 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 -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall era. FuturePParams era
NoPParamsUpdate
    DefinitePParamsUpdate PParams (PreviousEra MaryEra)
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 MaryEra
ctxt PParams (PreviousEra MaryEra)
pp
    PotentialPParamsUpdate Maybe (PParams (PreviousEra MaryEra))
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 MaryEra
ctxt) 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 =
    forall (m :: * -> *) a. Monad m => a -> m a
return
      EpochState
        { esChainAccountState :: ChainAccountState
esChainAccountState = forall era. EpochState era -> ChainAccountState
esChainAccountState EpochState (PreviousEra MaryEra)
es
        , esSnapshots :: SnapShots
esSnapshots = forall era. EpochState era -> SnapShots
esSnapshots EpochState (PreviousEra MaryEra)
es
        , esLState :: LedgerState MaryEra
esLState = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b. (a -> b) -> a -> b
$ forall era. EpochState era -> LedgerState era
esLState EpochState (PreviousEra MaryEra)
es
        , esNonMyopic :: NonMyopic
esNonMyopic = forall era. EpochState era -> NonMyopic
esNonMyopic 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
UMap
GenDelegs
dsIRewards :: forall era. DState era -> InstantaneousRewards
dsGenDelegs :: forall era. DState era -> GenDelegs
dsFutureGenDelegs :: forall era. DState era -> Map FutureGenDeleg GenDelegPair
dsUnified :: forall era. DState era -> UMap
dsIRewards :: InstantaneousRewards
dsGenDelegs :: GenDelegs
dsFutureGenDelegs :: Map FutureGenDeleg GenDelegPair
dsUnified :: UMap
..} = forall (f :: * -> *) a. Applicative f => a -> f a
pure DState {Map FutureGenDeleg GenDelegPair
InstantaneousRewards
UMap
GenDelegs
dsIRewards :: InstantaneousRewards
dsGenDelegs :: GenDelegs
dsFutureGenDelegs :: Map FutureGenDeleg GenDelegPair
dsUnified :: UMap
dsIRewards :: InstantaneousRewards
dsGenDelegs :: GenDelegs
dsFutureGenDelegs :: Map FutureGenDeleg GenDelegPair
dsUnified :: UMap
..}

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 :: forall era.
CommitteeState era
-> Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
csCommitteeCreds :: Map (Credential 'ColdCommitteeRole) CommitteeAuthorization
..} = 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) PoolParams
Map (KeyHash 'StakePool) Coin
Map (KeyHash 'StakePool) EpochNo
psDeposits :: forall era. PState era -> Map (KeyHash 'StakePool) Coin
psRetiring :: forall era. PState era -> Map (KeyHash 'StakePool) EpochNo
psFutureStakePoolParams :: forall era. PState era -> Map (KeyHash 'StakePool) PoolParams
psStakePoolParams :: forall era. PState era -> Map (KeyHash 'StakePool) PoolParams
psDeposits :: Map (KeyHash 'StakePool) Coin
psRetiring :: Map (KeyHash 'StakePool) EpochNo
psFutureStakePoolParams :: Map (KeyHash 'StakePool) PoolParams
psStakePoolParams :: Map (KeyHash 'StakePool) PoolParams
..} = forall (f :: * -> *) a. Applicative f => a -> f a
pure PState {Map (KeyHash 'StakePool) PoolParams
Map (KeyHash 'StakePool) Coin
Map (KeyHash 'StakePool) EpochNo
psDeposits :: Map (KeyHash 'StakePool) Coin
psRetiring :: Map (KeyHash 'StakePool) EpochNo
psFutureStakePoolParams :: Map (KeyHash 'StakePool) PoolParams
psStakePoolParams :: Map (KeyHash 'StakePool) PoolParams
psDeposits :: Map (KeyHash 'StakePool) Coin
psRetiring :: Map (KeyHash 'StakePool) EpochNo
psFutureStakePoolParams :: Map (KeyHash 'StakePool) PoolParams
psStakePoolParams :: Map (KeyHash 'StakePool) PoolParams
..}

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 =
    forall (f :: * -> *) a. Applicative f => a -> f a
pure
      ShelleyCertState
        { shelleyCertDState :: DState MaryEra
shelleyCertDState = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b. (a -> b) -> a -> b
$ forall era. ShelleyCertState era -> DState era
shelleyCertDState ShelleyCertState (PreviousEra MaryEra)
ls
        , shelleyCertPState :: PState MaryEra
shelleyCertPState = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b. (a -> b) -> a -> b
$ forall era. ShelleyCertState era -> PState era
shelleyCertPState 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 =
    forall (m :: * -> *) a. Monad m => a -> m a
return
      LedgerState
        { lsUTxOState :: UTxOState MaryEra
lsUTxOState = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b. (a -> b) -> a -> b
$ forall era. LedgerState era -> UTxOState era
lsUTxOState LedgerState (PreviousEra MaryEra)
ls
        , lsCertState :: CertState MaryEra
lsCertState = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b. (a -> b) -> a -> b
$ forall era. LedgerState era -> CertState era
lsCertState 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) =
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall era.
Map (KeyHash 'Genesis) (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 MaryEra
ctxt) 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 =
    forall (m :: * -> *) a. Monad m => a -> m a
return
      ShelleyGovState
        { sgsCurProposals :: ProposedPPUpdates MaryEra
sgsCurProposals = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b. (a -> b) -> a -> b
$ forall era. ShelleyGovState era -> ProposedPPUpdates era
sgsCurProposals ShelleyGovState (PreviousEra MaryEra)
ps
        , sgsFutureProposals :: ProposedPPUpdates MaryEra
sgsFutureProposals = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b. (a -> b) -> a -> b
$ forall era. ShelleyGovState era -> ProposedPPUpdates era
sgsFutureProposals ShelleyGovState (PreviousEra MaryEra)
ps
        , sgsCurPParams :: PParams MaryEra
sgsCurPParams = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b. (a -> b) -> a -> b
$ forall era. ShelleyGovState era -> PParams era
sgsCurPParams ShelleyGovState (PreviousEra MaryEra)
ps
        , sgsPrevPParams :: PParams MaryEra
sgsPrevPParams = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b. (a -> b) -> a -> b
$ forall era. ShelleyGovState era -> PParams era
sgsPrevPParams ShelleyGovState (PreviousEra MaryEra)
ps
        , sgsFuturePParams :: FuturePParams MaryEra
sgsFuturePParams = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b. (a -> b) -> a -> b
$ forall era. ShelleyGovState era -> FuturePParams era
sgsFuturePParams 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 =
    forall (m :: * -> *) a. Monad m => a -> m a
return
      UTxOState
        { utxosUtxo :: UTxO MaryEra
utxosUtxo = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b. (a -> b) -> a -> b
$ forall era. UTxOState era -> UTxO era
utxosUtxo UTxOState (PreviousEra MaryEra)
us
        , utxosDeposited :: Coin
utxosDeposited = forall era. UTxOState era -> Coin
utxosDeposited UTxOState (PreviousEra MaryEra)
us
        , utxosFees :: Coin
utxosFees = forall era. UTxOState era -> Coin
utxosFees UTxOState (PreviousEra MaryEra)
us
        , utxosGovState :: GovState MaryEra
utxosGovState = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b. (a -> b) -> a -> b
$ forall era. UTxOState era -> GovState era
utxosGovState UTxOState (PreviousEra MaryEra)
us
        , utxosInstantStake :: InstantStake MaryEra
utxosInstantStake = forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b. (a -> b) -> a -> b
$ forall era. UTxOState era -> InstantStake era
utxosInstantStake UTxOState (PreviousEra MaryEra)
us
        , utxosDonation :: Coin
utxosDonation = forall era. UTxOState era -> Coin
utxosDonation UTxOState (PreviousEra MaryEra)
us
        }

instance TranslateEra MaryEra ShelleyInstantStake where
  translateEra :: TranslationContext MaryEra
-> ShelleyInstantStake (PreviousEra MaryEra)
-> Except
     (TranslationError MaryEra ShelleyInstantStake)
     (ShelleyInstantStake MaryEra)
translateEra TranslationContext MaryEra
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: 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 = 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 TranslateEra MaryEra UTxO where
  translateEra :: TranslationContext MaryEra
-> UTxO (PreviousEra MaryEra)
-> Except (TranslationError MaryEra UTxO) (UTxO MaryEra)
translateEra TranslationContext MaryEra
ctxt UTxO (PreviousEra MaryEra)
utxo =
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall era. Map TxIn (TxOut era) -> UTxO era
UTxO (forall era (f :: * -> *).
(TranslateEra era f, TranslationError era f ~ Void) =>
TranslationContext era -> f (PreviousEra era) -> f era
translateEra' TranslationContext MaryEra
ctxt forall a b k. (a -> b) -> Map k a -> Map k b
`Map.map` forall era. UTxO era -> Map TxIn (TxOut era)
unUTxO 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 = 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) = 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 MaryEra)
pp) EpochNo
en

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