{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}

-- | Transactions in the context of a consensus mode, and other types used in
-- the transaction submission protocol.
--
module Cardano.Api.InMode (

    -- * Transaction in a consensus mode
    TxInMode(..),
    fromConsensusGenTx,
    toConsensusGenTx,

    -- * Transaction id in a consensus mode
    TxIdInMode(..),
    toConsensusTxId,

    -- * Transaction validation errors
    TxValidationError(..),
    TxValidationErrorInMode(..),
    fromConsensusApplyTxErr,
  ) where

import           Data.SOP.Strict (NS (S, Z))

import qualified Ouroboros.Consensus.Byron.Ledger as Consensus
import qualified Ouroboros.Consensus.Cardano.Block as Consensus
import qualified Ouroboros.Consensus.HardFork.Combinator as Consensus
import           Ouroboros.Consensus.HardFork.Combinator.AcrossEras (EraMismatch)
import qualified Ouroboros.Consensus.HardFork.Combinator.Degenerate as Consensus
import qualified Ouroboros.Consensus.Ledger.SupportsMempool as Consensus
import qualified Ouroboros.Consensus.Ledger.SupportsProtocol as Consensus
import qualified Ouroboros.Consensus.Protocol.TPraos as TPraos
import qualified Ouroboros.Consensus.Shelley.HFEras as Consensus
import qualified Ouroboros.Consensus.Shelley.Ledger as Consensus
import qualified Ouroboros.Consensus.TypeFamilyWrappers as Consensus

import           Cardano.Api.Eras
import           Cardano.Api.Modes
import           Cardano.Api.Tx
import           Cardano.Api.TxBody


-- ----------------------------------------------------------------------------
-- Transactions in the context of a consensus mode
--

-- | A 'Tx' in one of the eras supported by a given protocol mode.
--
-- For multi-era modes such as the 'CardanoMode' this type is a sum of the
-- different transaction types for all the eras. It is used in the
-- LocalTxSubmission protocol.
--
data TxInMode mode where

     -- | Everything we consider a normal transaction.
     --
     TxInMode :: Tx era -> EraInMode era mode -> TxInMode mode

     -- | Byron has various things we can post to the chain which are not
     -- actually transactions. This covers: update proposals, votes and
     -- delegation certs.
     --
     TxInByronSpecial :: Consensus.GenTx Consensus.ByronBlock
                      -> EraInMode ByronEra mode -> TxInMode mode

deriving instance Show (TxInMode mode)

fromConsensusGenTx
  :: ConsensusBlockForMode mode ~ block
  => ConsensusMode mode -> Consensus.GenTx block -> TxInMode mode
fromConsensusGenTx :: forall mode block.
(ConsensusBlockForMode mode ~ block) =>
ConsensusMode mode -> GenTx block -> TxInMode mode
fromConsensusGenTx ConsensusMode mode
ByronMode (Consensus.HardForkGenTx (Consensus.OneEraGenTx (Z GenTx x
tx'))) =
  forall mode.
GenTx ByronBlock -> EraInMode ByronEra mode -> TxInMode mode
TxInByronSpecial GenTx x
tx' EraInMode ByronEra ByronMode
ByronEraInByronMode

fromConsensusGenTx ConsensusMode mode
ShelleyMode (Consensus.HardForkGenTx (Consensus.OneEraGenTx (Z GenTx x
tx'))) =
  let Consensus.ShelleyTx TxId (EraCrypto StandardShelley)
_txid Tx StandardShelley
shelleyEraTx = GenTx x
tx'
  in forall era mode. Tx era -> EraInMode era mode -> TxInMode mode
TxInMode (forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra ShelleyEra
ShelleyBasedEraShelley Tx StandardShelley
shelleyEraTx) EraInMode ShelleyEra ShelleyMode
ShelleyEraInShelleyMode

fromConsensusGenTx ConsensusMode mode
CardanoMode (Consensus.HardForkGenTx (Consensus.OneEraGenTx (Z GenTx x
tx'))) =
  forall mode.
GenTx ByronBlock -> EraInMode ByronEra mode -> TxInMode mode
TxInByronSpecial GenTx x
tx' EraInMode ByronEra CardanoMode
ByronEraInCardanoMode

fromConsensusGenTx ConsensusMode mode
CardanoMode (Consensus.HardForkGenTx (Consensus.OneEraGenTx (S (Z GenTx x
tx')))) =
  let Consensus.ShelleyTx TxId (EraCrypto StandardShelley)
_txid Tx StandardShelley
shelleyEraTx = GenTx x
tx'
  in forall era mode. Tx era -> EraInMode era mode -> TxInMode mode
TxInMode (forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra ShelleyEra
ShelleyBasedEraShelley Tx StandardShelley
shelleyEraTx) EraInMode ShelleyEra CardanoMode
ShelleyEraInCardanoMode

fromConsensusGenTx ConsensusMode mode
CardanoMode (Consensus.HardForkGenTx (Consensus.OneEraGenTx (S (S (Z GenTx x
tx'))))) =
  let Consensus.ShelleyTx TxId (EraCrypto (AllegraEra StandardCrypto))
_txid Tx (AllegraEra StandardCrypto)
shelleyEraTx = GenTx x
tx'
  in forall era mode. Tx era -> EraInMode era mode -> TxInMode mode
TxInMode (forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra AllegraEra
ShelleyBasedEraAllegra Tx (AllegraEra StandardCrypto)
shelleyEraTx) EraInMode AllegraEra CardanoMode
AllegraEraInCardanoMode

fromConsensusGenTx ConsensusMode mode
CardanoMode (Consensus.HardForkGenTx (Consensus.OneEraGenTx (S (S (S (Z GenTx x
tx')))))) =
  let Consensus.ShelleyTx TxId (EraCrypto (MaryEra StandardCrypto))
_txid Tx (MaryEra StandardCrypto)
shelleyEraTx = GenTx x
tx'
  in forall era mode. Tx era -> EraInMode era mode -> TxInMode mode
TxInMode (forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra MaryEra
ShelleyBasedEraMary Tx (MaryEra StandardCrypto)
shelleyEraTx) EraInMode MaryEra CardanoMode
MaryEraInCardanoMode

fromConsensusGenTx ConsensusMode mode
CardanoMode (Consensus.HardForkGenTx (Consensus.OneEraGenTx (S (S (S (S (Z GenTx x
tx'))))))) =
  let Consensus.ShelleyTx TxId (EraCrypto (AlonzoEra StandardCrypto))
_txid Tx (AlonzoEra StandardCrypto)
shelleyEraTx = GenTx x
tx'
  in forall era mode. Tx era -> EraInMode era mode -> TxInMode mode
TxInMode (forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra AlonzoEra
ShelleyBasedEraAlonzo Tx (AlonzoEra StandardCrypto)
shelleyEraTx) EraInMode AlonzoEra CardanoMode
AlonzoEraInCardanoMode

fromConsensusGenTx ConsensusMode mode
CardanoMode (Consensus.HardForkGenTx (Consensus.OneEraGenTx (S (S (S (S (S (Z GenTx x
tx')))))))) =
  let Consensus.ShelleyTx TxId (EraCrypto (BabbageEra StandardCrypto))
_txid Tx (BabbageEra StandardCrypto)
shelleyEraTx = GenTx x
tx'
  in forall era mode. Tx era -> EraInMode era mode -> TxInMode mode
TxInMode (forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra BabbageEra
ShelleyBasedEraBabbage Tx (BabbageEra StandardCrypto)
shelleyEraTx) EraInMode BabbageEra CardanoMode
BabbageEraInCardanoMode

fromConsensusGenTx ConsensusMode mode
CardanoMode (Consensus.HardForkGenTx (Consensus.OneEraGenTx (S (S (S (S (S (S (Z GenTx x
tx'))))))))) =
  let Consensus.ShelleyTx TxId (EraCrypto (ConwayEra StandardCrypto))
_txid Tx (ConwayEra StandardCrypto)
shelleyEraTx = GenTx x
tx'
  in forall era mode. Tx era -> EraInMode era mode -> TxInMode mode
TxInMode (forall era.
ShelleyBasedEra era -> Tx (ShelleyLedgerEra era) -> Tx era
ShelleyTx ShelleyBasedEra ConwayEra
ShelleyBasedEraConway Tx (ConwayEra StandardCrypto)
shelleyEraTx) EraInMode ConwayEra CardanoMode
ConwayEraInCardanoMode

toConsensusGenTx :: ConsensusBlockForMode mode ~ block
                 => TxInMode mode
                 -> Consensus.GenTx block
toConsensusGenTx :: forall mode block.
(ConsensusBlockForMode mode ~ block) =>
TxInMode mode -> GenTx block
toConsensusGenTx (TxInMode (ByronTx ATxAux ByteString
tx) EraInMode era mode
ByronEraInByronMode) =
    forall (xs :: [*]). OneEraGenTx xs -> GenTx (HardForkBlock xs)
Consensus.HardForkGenTx (forall (xs :: [*]). NS GenTx xs -> OneEraGenTx xs
Consensus.OneEraGenTx (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z GenTx ByronBlock
tx'))
  where
    tx' :: GenTx ByronBlock
tx' = TxId -> ATxAux ByteString -> GenTx ByronBlock
Consensus.ByronTx (ATxAux ByteString -> TxId
Consensus.byronIdTx ATxAux ByteString
tx) ATxAux ByteString
tx

toConsensusGenTx (TxInMode (ByronTx ATxAux ByteString
tx) EraInMode era mode
ByronEraInCardanoMode) =
    forall (xs :: [*]). OneEraGenTx xs -> GenTx (HardForkBlock xs)
Consensus.HardForkGenTx (forall (xs :: [*]). NS GenTx xs -> OneEraGenTx xs
Consensus.OneEraGenTx (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z GenTx ByronBlock
tx'))
  where
    tx' :: GenTx ByronBlock
tx' = TxId -> ATxAux ByteString -> GenTx ByronBlock
Consensus.ByronTx (ATxAux ByteString -> TxId
Consensus.byronIdTx ATxAux ByteString
tx) ATxAux ByteString
tx
    --TODO: add the above as mkByronTx to the consensus code,
    -- matching mkShelleyTx below

toConsensusGenTx (TxInByronSpecial GenTx ByronBlock
gtx EraInMode ByronEra mode
ByronEraInByronMode) =
    forall (xs :: [*]). OneEraGenTx xs -> GenTx (HardForkBlock xs)
Consensus.HardForkGenTx (forall (xs :: [*]). NS GenTx xs -> OneEraGenTx xs
Consensus.OneEraGenTx (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z GenTx ByronBlock
gtx))

toConsensusGenTx (TxInByronSpecial GenTx ByronBlock
gtx EraInMode ByronEra mode
ByronEraInCardanoMode) =
    forall (xs :: [*]). OneEraGenTx xs -> GenTx (HardForkBlock xs)
Consensus.HardForkGenTx (forall (xs :: [*]). NS GenTx xs -> OneEraGenTx xs
Consensus.OneEraGenTx (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z GenTx ByronBlock
gtx))

toConsensusGenTx (TxInMode (ShelleyTx ShelleyBasedEra era
_ Tx (ShelleyLedgerEra era)
tx) EraInMode era mode
ShelleyEraInShelleyMode) =
    forall (xs :: [*]). OneEraGenTx xs -> GenTx (HardForkBlock xs)
Consensus.HardForkGenTx (forall (xs :: [*]). NS GenTx xs -> OneEraGenTx xs
Consensus.OneEraGenTx (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z GenTx (ShelleyBlock (TPraos StandardCrypto) StandardShelley)
tx'))
  where
    tx' :: GenTx (ShelleyBlock (TPraos StandardCrypto) StandardShelley)
tx' = forall era proto.
ShelleyBasedEra era =>
Tx era -> GenTx (ShelleyBlock proto era)
Consensus.mkShelleyTx Tx (ShelleyLedgerEra era)
tx

toConsensusGenTx (TxInMode (ShelleyTx ShelleyBasedEra era
_ Tx (ShelleyLedgerEra era)
tx) EraInMode era mode
ShelleyEraInCardanoMode) =
    forall (xs :: [*]). OneEraGenTx xs -> GenTx (HardForkBlock xs)
Consensus.HardForkGenTx (forall (xs :: [*]). NS GenTx xs -> OneEraGenTx xs
Consensus.OneEraGenTx (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z GenTx (ShelleyBlock (TPraos StandardCrypto) StandardShelley)
tx')))
  where
    tx' :: GenTx (ShelleyBlock (TPraos StandardCrypto) StandardShelley)
tx' = forall era proto.
ShelleyBasedEra era =>
Tx era -> GenTx (ShelleyBlock proto era)
Consensus.mkShelleyTx Tx (ShelleyLedgerEra era)
tx

toConsensusGenTx (TxInMode (ShelleyTx ShelleyBasedEra era
_ Tx (ShelleyLedgerEra era)
tx) EraInMode era mode
AllegraEraInCardanoMode) =
    forall (xs :: [*]). OneEraGenTx xs -> GenTx (HardForkBlock xs)
Consensus.HardForkGenTx (forall (xs :: [*]). NS GenTx xs -> OneEraGenTx xs
Consensus.OneEraGenTx (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z GenTx
  (ShelleyBlock (TPraos StandardCrypto) (AllegraEra StandardCrypto))
tx'))))
  where
    tx' :: GenTx
  (ShelleyBlock (TPraos StandardCrypto) (AllegraEra StandardCrypto))
tx' = forall era proto.
ShelleyBasedEra era =>
Tx era -> GenTx (ShelleyBlock proto era)
Consensus.mkShelleyTx Tx (ShelleyLedgerEra era)
tx

toConsensusGenTx (TxInMode (ShelleyTx ShelleyBasedEra era
_ Tx (ShelleyLedgerEra era)
tx) EraInMode era mode
MaryEraInCardanoMode) =
    forall (xs :: [*]). OneEraGenTx xs -> GenTx (HardForkBlock xs)
Consensus.HardForkGenTx (forall (xs :: [*]). NS GenTx xs -> OneEraGenTx xs
Consensus.OneEraGenTx (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z GenTx
  (ShelleyBlock (TPraos StandardCrypto) (MaryEra StandardCrypto))
tx')))))
  where
    tx' :: GenTx
  (ShelleyBlock (TPraos StandardCrypto) (MaryEra StandardCrypto))
tx' = forall era proto.
ShelleyBasedEra era =>
Tx era -> GenTx (ShelleyBlock proto era)
Consensus.mkShelleyTx Tx (ShelleyLedgerEra era)
tx

toConsensusGenTx (TxInMode (ShelleyTx ShelleyBasedEra era
_ Tx (ShelleyLedgerEra era)
tx) EraInMode era mode
AlonzoEraInCardanoMode) =
    forall (xs :: [*]). OneEraGenTx xs -> GenTx (HardForkBlock xs)
Consensus.HardForkGenTx (forall (xs :: [*]). NS GenTx xs -> OneEraGenTx xs
Consensus.OneEraGenTx (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z GenTx
  (ShelleyBlock (TPraos StandardCrypto) (AlonzoEra StandardCrypto))
tx'))))))
  where
    tx' :: GenTx
  (ShelleyBlock (TPraos StandardCrypto) (AlonzoEra StandardCrypto))
tx' = forall era proto.
ShelleyBasedEra era =>
Tx era -> GenTx (ShelleyBlock proto era)
Consensus.mkShelleyTx Tx (ShelleyLedgerEra era)
tx

toConsensusGenTx (TxInMode (ShelleyTx ShelleyBasedEra era
_ Tx (ShelleyLedgerEra era)
tx) EraInMode era mode
BabbageEraInCardanoMode) =
    forall (xs :: [*]). OneEraGenTx xs -> GenTx (HardForkBlock xs)
Consensus.HardForkGenTx (forall (xs :: [*]). NS GenTx xs -> OneEraGenTx xs
Consensus.OneEraGenTx (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z GenTx
  (ShelleyBlock (Praos StandardCrypto) (BabbageEra StandardCrypto))
tx')))))))
  where
    tx' :: GenTx
  (ShelleyBlock (Praos StandardCrypto) (BabbageEra StandardCrypto))
tx' = forall era proto.
ShelleyBasedEra era =>
Tx era -> GenTx (ShelleyBlock proto era)
Consensus.mkShelleyTx Tx (ShelleyLedgerEra era)
tx

toConsensusGenTx (TxInMode (ShelleyTx ShelleyBasedEra era
_ Tx (ShelleyLedgerEra era)
tx) EraInMode era mode
ConwayEraInCardanoMode) =
    forall (xs :: [*]). OneEraGenTx xs -> GenTx (HardForkBlock xs)
Consensus.HardForkGenTx (forall (xs :: [*]). NS GenTx xs -> OneEraGenTx xs
Consensus.OneEraGenTx (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z GenTx
  (ShelleyBlock (Praos StandardCrypto) (ConwayEra StandardCrypto))
tx'))))))))
  where
    tx' :: GenTx
  (ShelleyBlock (Praos StandardCrypto) (ConwayEra StandardCrypto))
tx' = forall era proto.
ShelleyBasedEra era =>
Tx era -> GenTx (ShelleyBlock proto era)
Consensus.mkShelleyTx Tx (ShelleyLedgerEra era)
tx

toConsensusGenTx (TxInMode (ShelleyTx ShelleyBasedEra era
_ Tx (ShelleyLedgerEra era)
_) EraInMode era mode
ByronEraInByronMode) =
  forall a. HasCallStack => String -> a
error String
"Cardano.Api.InMode.toConsensusGenTx: ShelleyTx In Byron era"
toConsensusGenTx (TxInMode (ShelleyTx ShelleyBasedEra era
_ Tx (ShelleyLedgerEra era)
_) EraInMode era mode
ByronEraInCardanoMode) =
  forall a. HasCallStack => String -> a
error String
"Cardano.Api.InMode.toConsensusGenTx: ShelleyTx In Byron era"

-- ----------------------------------------------------------------------------
-- Transaction ids in the context of a consensus mode
--

-- | A 'TxId' in one of the eras supported by a given protocol mode.
--
-- For multi-era modes such as the 'CardanoMode' this type is a sum of the
-- different transaction types for all the eras. It is used in the
-- LocalTxMonitoring protocol.
--

data TxIdInMode mode where
  TxIdInMode :: TxId -> EraInMode era mode -> TxIdInMode mode

toConsensusTxId
  :: ConsensusBlockForMode mode ~ block
  => TxIdInMode mode -> Consensus.TxId  (Consensus.GenTx block)
toConsensusTxId :: forall mode block.
(ConsensusBlockForMode mode ~ block) =>
TxIdInMode mode -> TxId (GenTx block)
toConsensusTxId (TxIdInMode TxId
txid EraInMode era mode
ByronEraInByronMode) =
  forall (xs :: [*]).
OneEraGenTxId xs -> TxId (GenTx (HardForkBlock xs))
Consensus.HardForkGenTxId forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (xs :: [*]). NS WrapGenTxId xs -> OneEraGenTxId xs
Consensus.OneEraGenTxId forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z forall a b. (a -> b) -> a -> b
$ forall blk. GenTxId blk -> WrapGenTxId blk
Consensus.WrapGenTxId TxId (GenTx ByronBlock)
txid'
 where
  txid' :: Consensus.TxId (Consensus.GenTx Consensus.ByronBlock)
  txid' :: TxId (GenTx ByronBlock)
txid' = TxId -> TxId (GenTx ByronBlock)
Consensus.ByronTxId forall a b. (a -> b) -> a -> b
$ TxId -> TxId
toByronTxId TxId
txid

toConsensusTxId (TxIdInMode TxId
t EraInMode era mode
ShelleyEraInShelleyMode) =
    forall (xs :: [*]).
OneEraGenTxId xs -> TxId (GenTx (HardForkBlock xs))
Consensus.HardForkGenTxId forall a b. (a -> b) -> a -> b
$ forall (xs :: [*]). NS WrapGenTxId xs -> OneEraGenTxId xs
Consensus.OneEraGenTxId  forall a b. (a -> b) -> a -> b
$ forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z  (forall blk. GenTxId blk -> WrapGenTxId blk
Consensus.WrapGenTxId TxId (GenTx (ShelleyBlock (TPraos StandardCrypto) StandardShelley))
txid')
 where
  txid' :: Consensus.TxId (Consensus.GenTx Consensus.StandardShelleyBlock)
  txid' :: TxId (GenTx (ShelleyBlock (TPraos StandardCrypto) StandardShelley))
txid' = forall proto era.
TxId (EraCrypto era) -> TxId (GenTx (ShelleyBlock proto era))
Consensus.ShelleyTxId forall a b. (a -> b) -> a -> b
$ TxId -> TxId StandardCrypto
toShelleyTxId TxId
t

toConsensusTxId (TxIdInMode TxId
txid EraInMode era mode
ByronEraInCardanoMode) =
  forall (xs :: [*]).
OneEraGenTxId xs -> TxId (GenTx (HardForkBlock xs))
Consensus.HardForkGenTxId forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (xs :: [*]). NS WrapGenTxId xs -> OneEraGenTxId xs
Consensus.OneEraGenTxId forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z forall a b. (a -> b) -> a -> b
$ forall blk. GenTxId blk -> WrapGenTxId blk
Consensus.WrapGenTxId TxId (GenTx ByronBlock)
txid'
 where
  txid' :: Consensus.TxId (Consensus.GenTx Consensus.ByronBlock)
  txid' :: TxId (GenTx ByronBlock)
txid' = TxId -> TxId (GenTx ByronBlock)
Consensus.ByronTxId forall a b. (a -> b) -> a -> b
$ TxId -> TxId
toByronTxId TxId
txid

toConsensusTxId (TxIdInMode TxId
txid EraInMode era mode
ShelleyEraInCardanoMode) =
  forall (xs :: [*]).
OneEraGenTxId xs -> TxId (GenTx (HardForkBlock xs))
Consensus.HardForkGenTxId (forall (xs :: [*]). NS WrapGenTxId xs -> OneEraGenTxId xs
Consensus.OneEraGenTxId (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z (forall blk. GenTxId blk -> WrapGenTxId blk
Consensus.WrapGenTxId TxId (GenTx (ShelleyBlock (TPraos StandardCrypto) StandardShelley))
txid'))))
 where
  txid' :: Consensus.TxId (Consensus.GenTx Consensus.StandardShelleyBlock)
  txid' :: TxId (GenTx (ShelleyBlock (TPraos StandardCrypto) StandardShelley))
txid' = forall proto era.
TxId (EraCrypto era) -> TxId (GenTx (ShelleyBlock proto era))
Consensus.ShelleyTxId forall a b. (a -> b) -> a -> b
$ TxId -> TxId StandardCrypto
toShelleyTxId TxId
txid

toConsensusTxId (TxIdInMode TxId
txid EraInMode era mode
AllegraEraInCardanoMode) =
  forall (xs :: [*]).
OneEraGenTxId xs -> TxId (GenTx (HardForkBlock xs))
Consensus.HardForkGenTxId (forall (xs :: [*]). NS WrapGenTxId xs -> OneEraGenTxId xs
Consensus.OneEraGenTxId (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z (forall blk. GenTxId blk -> WrapGenTxId blk
Consensus.WrapGenTxId TxId
  (GenTx
     (ShelleyBlock (TPraos StandardCrypto) (AllegraEra StandardCrypto)))
txid')))))
 where
  txid' :: Consensus.TxId (Consensus.GenTx Consensus.StandardAllegraBlock)
  txid' :: TxId
  (GenTx
     (ShelleyBlock (TPraos StandardCrypto) (AllegraEra StandardCrypto)))
txid' = forall proto era.
TxId (EraCrypto era) -> TxId (GenTx (ShelleyBlock proto era))
Consensus.ShelleyTxId forall a b. (a -> b) -> a -> b
$ TxId -> TxId StandardCrypto
toShelleyTxId TxId
txid

toConsensusTxId (TxIdInMode TxId
txid EraInMode era mode
MaryEraInCardanoMode) =
  forall (xs :: [*]).
OneEraGenTxId xs -> TxId (GenTx (HardForkBlock xs))
Consensus.HardForkGenTxId (forall (xs :: [*]). NS WrapGenTxId xs -> OneEraGenTxId xs
Consensus.OneEraGenTxId (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z (forall blk. GenTxId blk -> WrapGenTxId blk
Consensus.WrapGenTxId TxId
  (GenTx
     (ShelleyBlock (TPraos StandardCrypto) (MaryEra StandardCrypto)))
txid'))))))
 where
  txid' :: Consensus.TxId (Consensus.GenTx Consensus.StandardMaryBlock)
  txid' :: TxId
  (GenTx
     (ShelleyBlock (TPraos StandardCrypto) (MaryEra StandardCrypto)))
txid' = forall proto era.
TxId (EraCrypto era) -> TxId (GenTx (ShelleyBlock proto era))
Consensus.ShelleyTxId forall a b. (a -> b) -> a -> b
$ TxId -> TxId StandardCrypto
toShelleyTxId TxId
txid

toConsensusTxId (TxIdInMode TxId
txid EraInMode era mode
AlonzoEraInCardanoMode) =
  forall (xs :: [*]).
OneEraGenTxId xs -> TxId (GenTx (HardForkBlock xs))
Consensus.HardForkGenTxId (forall (xs :: [*]). NS WrapGenTxId xs -> OneEraGenTxId xs
Consensus.OneEraGenTxId (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z (forall blk. GenTxId blk -> WrapGenTxId blk
Consensus.WrapGenTxId TxId
  (GenTx
     (ShelleyBlock (TPraos StandardCrypto) (AlonzoEra StandardCrypto)))
txid')))))))
 where
  txid' :: Consensus.TxId (Consensus.GenTx Consensus.StandardAlonzoBlock)
  txid' :: TxId
  (GenTx
     (ShelleyBlock (TPraos StandardCrypto) (AlonzoEra StandardCrypto)))
txid' = forall proto era.
TxId (EraCrypto era) -> TxId (GenTx (ShelleyBlock proto era))
Consensus.ShelleyTxId forall a b. (a -> b) -> a -> b
$ TxId -> TxId StandardCrypto
toShelleyTxId TxId
txid

toConsensusTxId (TxIdInMode TxId
txid EraInMode era mode
BabbageEraInCardanoMode) =
  forall (xs :: [*]).
OneEraGenTxId xs -> TxId (GenTx (HardForkBlock xs))
Consensus.HardForkGenTxId (forall (xs :: [*]). NS WrapGenTxId xs -> OneEraGenTxId xs
Consensus.OneEraGenTxId (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z (forall blk. GenTxId blk -> WrapGenTxId blk
Consensus.WrapGenTxId TxId
  (GenTx
     (ShelleyBlock (Praos StandardCrypto) (BabbageEra StandardCrypto)))
txid'))))))))
 where
  txid' :: Consensus.TxId (Consensus.GenTx Consensus.StandardBabbageBlock)
  txid' :: TxId
  (GenTx
     (ShelleyBlock (Praos StandardCrypto) (BabbageEra StandardCrypto)))
txid' = forall proto era.
TxId (EraCrypto era) -> TxId (GenTx (ShelleyBlock proto era))
Consensus.ShelleyTxId forall a b. (a -> b) -> a -> b
$ TxId -> TxId StandardCrypto
toShelleyTxId TxId
txid

toConsensusTxId (TxIdInMode TxId
txid EraInMode era mode
ConwayEraInCardanoMode) =
  forall (xs :: [*]).
OneEraGenTxId xs -> TxId (GenTx (HardForkBlock xs))
Consensus.HardForkGenTxId (forall (xs :: [*]). NS WrapGenTxId xs -> OneEraGenTxId xs
Consensus.OneEraGenTxId (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z (forall blk. GenTxId blk -> WrapGenTxId blk
Consensus.WrapGenTxId TxId
  (GenTx
     (ShelleyBlock (Praos StandardCrypto) (ConwayEra StandardCrypto)))
txid')))))))))
 where
  txid' :: Consensus.TxId (Consensus.GenTx Consensus.StandardConwayBlock)
  txid' :: TxId
  (GenTx
     (ShelleyBlock (Praos StandardCrypto) (ConwayEra StandardCrypto)))
txid' = forall proto era.
TxId (EraCrypto era) -> TxId (GenTx (ShelleyBlock proto era))
Consensus.ShelleyTxId forall a b. (a -> b) -> a -> b
$ TxId -> TxId StandardCrypto
toShelleyTxId TxId
txid

-- ----------------------------------------------------------------------------
-- Transaction validation errors in the context of eras and consensus modes
--

-- | The transaction validations errors that can occur from trying to submit a
-- transaction to a local node. The errors are specific to an era.
--
data TxValidationError era where

     ByronTxValidationError
       :: Consensus.ApplyTxErr Consensus.ByronBlock
       -> TxValidationError ByronEra

     ShelleyTxValidationError
       :: ShelleyBasedEra era
       -> Consensus.ApplyTxErr (Consensus.ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
       -> TxValidationError era

-- The GADT in the ShelleyTxValidationError case requires a custom instance
instance Show (TxValidationError era) where
    showsPrec :: Int -> TxValidationError era -> ShowS
showsPrec Int
p (ByronTxValidationError ApplyTxErr ByronBlock
err) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11)
        ( String -> ShowS
showString String
"ByronTxValidationError "
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 ApplyTxErr ByronBlock
err
        )

    showsPrec Int
p (ShelleyTxValidationError ShelleyBasedEra era
ShelleyBasedEraShelley ApplyTxErr
  (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
err) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11)
        ( String -> ShowS
showString String
"ShelleyTxValidationError ShelleyBasedEraShelley "
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 ApplyTxErr
  (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
err
        )

    showsPrec Int
p (ShelleyTxValidationError ShelleyBasedEra era
ShelleyBasedEraAllegra ApplyTxErr
  (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
err) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11)
        ( String -> ShowS
showString String
"ShelleyTxValidationError ShelleyBasedEraAllegra "
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 ApplyTxErr
  (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
err
        )

    showsPrec Int
p (ShelleyTxValidationError ShelleyBasedEra era
ShelleyBasedEraMary ApplyTxErr
  (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
err) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11)
        ( String -> ShowS
showString String
"ShelleyTxValidationError ShelleyBasedEraMary "
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 ApplyTxErr
  (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
err
        )

    showsPrec Int
p (ShelleyTxValidationError ShelleyBasedEra era
ShelleyBasedEraAlonzo ApplyTxErr
  (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
err) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11)
        ( String -> ShowS
showString String
"ShelleyTxValidationError ShelleyBasedEraAlonzo "
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 ApplyTxErr
  (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
err
        )

    showsPrec Int
p (ShelleyTxValidationError ShelleyBasedEra era
ShelleyBasedEraBabbage ApplyTxErr
  (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
err) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11)
        ( String -> ShowS
showString String
"ShelleyTxValidationError ShelleyBasedEraBabbage "
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 ApplyTxErr
  (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
err
        )

    showsPrec Int
p (ShelleyTxValidationError ShelleyBasedEra era
ShelleyBasedEraConway ApplyTxErr
  (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
err) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11)
        ( String -> ShowS
showString String
"ShelleyTxValidationError ShelleyBasedEraConway "
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 ApplyTxErr
  (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
err
        )

-- | A 'TxValidationError' in one of the eras supported by a given protocol
-- mode.
--
-- This is used in the LocalStateQuery protocol.
--
data TxValidationErrorInMode mode where
     TxValidationErrorInMode :: TxValidationError era
                             -> EraInMode era mode
                             -> TxValidationErrorInMode mode

     TxValidationEraMismatch :: EraMismatch
                             -> TxValidationErrorInMode mode

deriving instance Show (TxValidationErrorInMode mode)


fromConsensusApplyTxErr :: ConsensusBlockForMode mode ~ block
                        => Consensus.LedgerSupportsProtocol
                             (Consensus.ShelleyBlock
                             (TPraos.TPraos Consensus.StandardCrypto)
                             (Consensus.ShelleyEra Consensus.StandardCrypto))
                        => ConsensusMode mode
                        -> Consensus.ApplyTxErr block
                        -> TxValidationErrorInMode mode
fromConsensusApplyTxErr :: forall mode block.
(ConsensusBlockForMode mode ~ block,
 LedgerSupportsProtocol
   (ShelleyBlock (TPraos StandardCrypto) StandardShelley)) =>
ConsensusMode mode
-> ApplyTxErr block -> TxValidationErrorInMode mode
fromConsensusApplyTxErr ConsensusMode mode
ByronMode (Consensus.DegenApplyTxErr ApplyTxErr ByronBlock
err) =
    forall era mode.
TxValidationError era
-> EraInMode era mode -> TxValidationErrorInMode mode
TxValidationErrorInMode
      (ApplyTxErr ByronBlock -> TxValidationError ByronEra
ByronTxValidationError ApplyTxErr ByronBlock
err)
      EraInMode ByronEra ByronMode
ByronEraInByronMode

fromConsensusApplyTxErr ConsensusMode mode
ShelleyMode (Consensus.DegenApplyTxErr ApplyTxErr (ShelleyBlock (TPraos StandardCrypto) StandardShelley)
err) =
    forall era mode.
TxValidationError era
-> EraInMode era mode -> TxValidationErrorInMode mode
TxValidationErrorInMode
      (forall era.
ShelleyBasedEra era
-> ApplyTxErr
     (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
-> TxValidationError era
ShelleyTxValidationError ShelleyBasedEra ShelleyEra
ShelleyBasedEraShelley ApplyTxErr (ShelleyBlock (TPraos StandardCrypto) StandardShelley)
err)
      EraInMode ShelleyEra ShelleyMode
ShelleyEraInShelleyMode

fromConsensusApplyTxErr ConsensusMode mode
CardanoMode (Consensus.ApplyTxErrByron ApplyTxErr ByronBlock
err) =
    forall era mode.
TxValidationError era
-> EraInMode era mode -> TxValidationErrorInMode mode
TxValidationErrorInMode
      (ApplyTxErr ByronBlock -> TxValidationError ByronEra
ByronTxValidationError ApplyTxErr ByronBlock
err)
      EraInMode ByronEra CardanoMode
ByronEraInCardanoMode

fromConsensusApplyTxErr ConsensusMode mode
CardanoMode (Consensus.ApplyTxErrShelley ApplyTxErr (ShelleyBlock (TPraos StandardCrypto) StandardShelley)
err) =
    forall era mode.
TxValidationError era
-> EraInMode era mode -> TxValidationErrorInMode mode
TxValidationErrorInMode
      (forall era.
ShelleyBasedEra era
-> ApplyTxErr
     (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
-> TxValidationError era
ShelleyTxValidationError ShelleyBasedEra ShelleyEra
ShelleyBasedEraShelley ApplyTxErr (ShelleyBlock (TPraos StandardCrypto) StandardShelley)
err)
      EraInMode ShelleyEra CardanoMode
ShelleyEraInCardanoMode

fromConsensusApplyTxErr ConsensusMode mode
CardanoMode (Consensus.ApplyTxErrAllegra ApplyTxErr
  (ShelleyBlock (TPraos StandardCrypto) (AllegraEra StandardCrypto))
err) =
    forall era mode.
TxValidationError era
-> EraInMode era mode -> TxValidationErrorInMode mode
TxValidationErrorInMode
      (forall era.
ShelleyBasedEra era
-> ApplyTxErr
     (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
-> TxValidationError era
ShelleyTxValidationError ShelleyBasedEra AllegraEra
ShelleyBasedEraAllegra ApplyTxErr
  (ShelleyBlock (TPraos StandardCrypto) (AllegraEra StandardCrypto))
err)
      EraInMode AllegraEra CardanoMode
AllegraEraInCardanoMode

fromConsensusApplyTxErr ConsensusMode mode
CardanoMode (Consensus.ApplyTxErrMary ApplyTxErr
  (ShelleyBlock (TPraos StandardCrypto) (MaryEra StandardCrypto))
err) =
    forall era mode.
TxValidationError era
-> EraInMode era mode -> TxValidationErrorInMode mode
TxValidationErrorInMode
      (forall era.
ShelleyBasedEra era
-> ApplyTxErr
     (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
-> TxValidationError era
ShelleyTxValidationError ShelleyBasedEra MaryEra
ShelleyBasedEraMary ApplyTxErr
  (ShelleyBlock (TPraos StandardCrypto) (MaryEra StandardCrypto))
err)
      EraInMode MaryEra CardanoMode
MaryEraInCardanoMode

fromConsensusApplyTxErr ConsensusMode mode
CardanoMode (Consensus.ApplyTxErrAlonzo ApplyTxErr
  (ShelleyBlock (TPraos StandardCrypto) (AlonzoEra StandardCrypto))
err) =
    forall era mode.
TxValidationError era
-> EraInMode era mode -> TxValidationErrorInMode mode
TxValidationErrorInMode
      (forall era.
ShelleyBasedEra era
-> ApplyTxErr
     (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
-> TxValidationError era
ShelleyTxValidationError ShelleyBasedEra AlonzoEra
ShelleyBasedEraAlonzo ApplyTxErr
  (ShelleyBlock (TPraos StandardCrypto) (AlonzoEra StandardCrypto))
err)
      EraInMode AlonzoEra CardanoMode
AlonzoEraInCardanoMode

fromConsensusApplyTxErr ConsensusMode mode
CardanoMode (Consensus.ApplyTxErrBabbage ApplyTxErr
  (ShelleyBlock (Praos StandardCrypto) (BabbageEra StandardCrypto))
err) =
    forall era mode.
TxValidationError era
-> EraInMode era mode -> TxValidationErrorInMode mode
TxValidationErrorInMode
      (forall era.
ShelleyBasedEra era
-> ApplyTxErr
     (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
-> TxValidationError era
ShelleyTxValidationError ShelleyBasedEra BabbageEra
ShelleyBasedEraBabbage ApplyTxErr
  (ShelleyBlock (Praos StandardCrypto) (BabbageEra StandardCrypto))
err)
      EraInMode BabbageEra CardanoMode
BabbageEraInCardanoMode

fromConsensusApplyTxErr ConsensusMode mode
CardanoMode (Consensus.ApplyTxErrConway ApplyTxErr
  (ShelleyBlock (Praos StandardCrypto) (ConwayEra StandardCrypto))
err) =
    forall era mode.
TxValidationError era
-> EraInMode era mode -> TxValidationErrorInMode mode
TxValidationErrorInMode
      (forall era.
ShelleyBasedEra era
-> ApplyTxErr
     (ShelleyBlock (ConsensusProtocol era) (ShelleyLedgerEra era))
-> TxValidationError era
ShelleyTxValidationError ShelleyBasedEra ConwayEra
ShelleyBasedEraConway ApplyTxErr
  (ShelleyBlock (Praos StandardCrypto) (ConwayEra StandardCrypto))
err)
      EraInMode ConwayEra CardanoMode
ConwayEraInCardanoMode

fromConsensusApplyTxErr ConsensusMode mode
CardanoMode (Consensus.ApplyTxErrWrongEra EraMismatch
err) =
    forall mode. EraMismatch -> TxValidationErrorInMode mode
TxValidationEraMismatch EraMismatch
err