{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE DisambiguateRecordFields #-}
{-# LANGUAGE EmptyCase #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ViewPatterns #-}

{- HLINT ignore "Avoid lambda using `infix`" -}
{- HLINT ignore "Redundant flip" -}
{- HLINT ignore "Use section" -}

-- | Transaction bodies
--
module Cardano.Api.TxBody (
    parseTxId,
    -- * Transaction bodies
    TxBody(.., TxBody),
    makeTransactionBody,
    createTransactionBody,
    createAndValidateTransactionBody,
    TxBodyContent(..),
    TxBodyError(..),
    TxBodyScriptData(..),
    TxScriptValidity(..),
    TxScriptValiditySupportedInEra(..),

    ScriptValidity(..),
    scriptValidityToIsValid,
    isValidToScriptValidity,
    scriptValidityToTxScriptValidity,
    txScriptValidityToIsValid,
    txScriptValidityToScriptValidity,

    -- * Transaction Ids
    TxId(..),
    getTxId,
    getTxIdShelley,

    -- * Transaction inputs
    TxIn(..),
    TxIns,
    TxIx(..),
    genesisUTxOPseudoTxIn,

    -- * Transaction outputs
    CtxTx, CtxUTxO,
    TxOut(..),
    TxOutValue(..),
    TxOutDatum(TxOutDatumNone, TxOutDatumHash, TxOutDatumInTx, TxOutDatumInline),
    toCtxUTxOTxOut,
    lovelaceToTxOutValue,
    prettyRenderTxOut,
    txOutValueToLovelace,
    txOutValueToValue,
    parseHash,
    TxOutInAnyEra(..),
    txOutInAnyEra,

    -- * Other transaction body types
    TxInsCollateral(..),
    TxInsReference(..),
    TxReturnCollateral(..),
    TxTotalCollateral(..),
    TxFee(..),
    TxValidityLowerBound(..),
    TxValidityUpperBound(..),
    TxMetadataInEra(..),
    TxAuxScripts(..),
    TxExtraKeyWitnesses(..),
    TxWithdrawals(..),
    TxCertificates(..),
    TxUpdateProposal(..),
    TxMintValue(..),

    -- ** Building vs viewing transactions
    BuildTxWith(..),
    BuildTx,
    ViewTx,

    -- * Era-dependent transaction body features
    CollateralSupportedInEra(..),
    MultiAssetSupportedInEra(..),
    OnlyAdaSupportedInEra(..),
    TxFeesExplicitInEra(..),
    TxFeesImplicitInEra(..),
    ValidityUpperBoundSupportedInEra(..),
    ValidityNoUpperBoundSupportedInEra(..),
    ValidityLowerBoundSupportedInEra(..),
    TxMetadataSupportedInEra(..),
    AuxScriptsSupportedInEra(..),
    TxExtraKeyWitnessesSupportedInEra(..),
    ScriptDataSupportedInEra(..),
    WithdrawalsSupportedInEra(..),
    CertificatesSupportedInEra(..),
    UpdateProposalSupportedInEra(..),
    TxTotalAndReturnCollateralSupportedInEra(..),

    -- ** Feature availability functions
    collateralSupportedInEra,
    multiAssetSupportedInEra,
    txFeesExplicitInEra,
    validityUpperBoundSupportedInEra,
    validityNoUpperBoundSupportedInEra,
    validityLowerBoundSupportedInEra,
    txMetadataSupportedInEra,
    auxScriptsSupportedInEra,
    extraKeyWitnessesSupportedInEra,
    scriptDataSupportedInEra,
    withdrawalsSupportedInEra,
    certificatesSupportedInEra,
    updateProposalSupportedInEra,
    txScriptValiditySupportedInShelleyBasedEra,
    txScriptValiditySupportedInCardanoEra,
    totalAndReturnCollateralSupportedInEra,

    -- * Inspecting 'ScriptWitness'es
    AnyScriptWitness(..),
    ScriptWitnessIndex(..),
    renderScriptWitnessIndex,
    collectTxBodyScriptWitnesses,

    -- * Conversion to inline data
    scriptDataToInlineDatum,

    -- * Internal conversion functions & types
    toByronTxId,
    toShelleyTxId,
    toShelleyTxIn,
    toShelleyTxOut,
    toShelleyTxOutAny,
    fromShelleyTxId,
    fromShelleyTxIn,
    fromShelleyTxOut,
    toAlonzoRdmrPtr,
    fromAlonzoRdmrPtr,
    fromByronTxIn,
    fromLedgerTxOuts,
    renderTxIn,

    -- * Misc helpers
    calculateExecutionUnitsLovelace,
    orderStakeAddrs,
    orderTxIns,

    -- * Data family instances
    AsType(AsTxId, AsTxBody, AsByronTxBody, AsShelleyTxBody, AsMaryTxBody),
  ) where

import           Control.Applicative (some)
import           Control.Monad (guard)
import           Data.Aeson (object, withObject, (.:), (.:?), (.=))
import qualified Data.Aeson as Aeson
import qualified Data.Aeson.Key as Aeson
import qualified Data.Aeson.KeyMap as KeyMap
import qualified Data.Aeson.Types as Aeson
import           Data.Bifunctor (first)
import           Data.ByteString (ByteString)
import qualified Data.ByteString.Char8 as BSC
import qualified Data.ByteString.Lazy as LBS
import           Data.Foldable (for_, toList)
import           Data.Function (on)
import           Data.List (intercalate, sortBy)
import qualified Data.List as List
import qualified Data.List.NonEmpty as NonEmpty
import           Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import           Data.Maybe (catMaybes, fromMaybe, maybeToList)
import           Data.Scientific (toBoundedInteger)
import qualified Data.Sequence.Strict as Seq
import           Data.Set (Set)
import qualified Data.Set as Set
import           Data.String
import           Data.Text (Text)
import qualified Data.Text as Text
import           Data.Type.Equality (TestEquality (..), (:~:) (Refl))
import           Data.Word (Word16, Word32, Word64)
import           GHC.Generics
import           GHC.Records (HasField (..))
import           Lens.Micro hiding (ix)
import qualified Text.Parsec as Parsec
import           Text.Parsec ((<?>))
import qualified Text.Parsec.String as Parsec

import           Cardano.Binary (Annotated (..), reAnnotate, recoverBytes)
import qualified Cardano.Binary as CBOR
import qualified Cardano.Crypto.Hash.Class as Crypto
import qualified Cardano.Ledger.Serialization as CBOR (Sized, decodeNullMaybe, encodeNullMaybe,
                   mkSized, sizedValue)
import           Cardano.Slotting.Slot (SlotNo (..))

import qualified Cardano.Chain.Common as Byron
import qualified Cardano.Chain.UTxO as Byron
import qualified Cardano.Crypto.Hashing as Byron

import qualified Cardano.Ledger.Address as Shelley
import qualified Cardano.Ledger.AuxiliaryData as Ledger
import           Cardano.Ledger.Babbage.TxBody (BabbageEraTxBody (..),
                   BabbageTxBody (BabbageTxBody), BabbageTxOut (BabbageTxOut))
import           Cardano.Ledger.BaseTypes (StrictMaybe (..), maybeToStrictMaybe)
import qualified Cardano.Ledger.Block as Ledger
import qualified Cardano.Ledger.Coin as Ledger
import           Cardano.Ledger.Core (EraAuxiliaryData)
import qualified Cardano.Ledger.Core as Core
import qualified Cardano.Ledger.Core as Ledger
import qualified Cardano.Ledger.Credential as Shelley
import           Cardano.Ledger.Crypto (StandardCrypto)
import qualified Cardano.Ledger.Era as CC
import qualified Cardano.Ledger.Keys as Shelley
import qualified Cardano.Ledger.SafeHash as SafeHash
import qualified Cardano.Ledger.TxIn as Ledger
import           Cardano.Ledger.Val (isZero)

import           Cardano.Ledger.Shelley.API (ShelleyTxOut (ShelleyTxOut))
import qualified Cardano.Ledger.Shelley.API as Ledger hiding (TxBody, TxOut)
import qualified Cardano.Ledger.Shelley.Genesis as Shelley
import qualified Cardano.Ledger.Shelley.Metadata as Shelley
import qualified Cardano.Ledger.Shelley.Tx as Shelley
import qualified Cardano.Ledger.Shelley.TxBody as Shelley

import           Cardano.Ledger.Mary.Value (MaryValue)
import           Cardano.Ledger.ShelleyMA.AuxiliaryData (MAAuxiliaryData (..))
import qualified Cardano.Ledger.ShelleyMA.AuxiliaryData as Allegra
import           Cardano.Ledger.ShelleyMA.TxBody (MATxBody (..))
import qualified Cardano.Ledger.ShelleyMA.TxBody as Allegra
import qualified Cardano.Ledger.ShelleyMA.TxBody as Mary

import           Cardano.Ledger.Alonzo.Data (AlonzoAuxiliaryData (AlonzoAuxiliaryData))
import qualified Cardano.Ledger.Alonzo.Data as Alonzo
import qualified Cardano.Ledger.Alonzo.Language as Alonzo
import qualified Cardano.Ledger.Alonzo.PParams as Alonzo
import qualified Cardano.Ledger.Alonzo.Scripts as Alonzo
import qualified Cardano.Ledger.Alonzo.Tx as Alonzo
import           Cardano.Ledger.Alonzo.TxBody (AlonzoTxBody (AlonzoTxBody),
                   AlonzoTxOut (AlonzoTxOut))
import qualified Cardano.Ledger.Alonzo.TxBody as Alonzo
import qualified Cardano.Ledger.Alonzo.TxWitness as Alonzo

import qualified Cardano.Ledger.Babbage.PParams as Babbage
import qualified Cardano.Ledger.Babbage.TxBody as Babbage
import qualified Cardano.Ledger.Conway.TxBody as Conway
import           Ouroboros.Consensus.Shelley.Eras (StandardAllegra, StandardAlonzo, StandardBabbage,
                   StandardConway, StandardMary, StandardShelley)

import           Cardano.Api.Address
import           Cardano.Api.Certificate
import           Cardano.Api.Convenience.Constraints
import           Cardano.Api.EraCast
import           Cardano.Api.Eras
import           Cardano.Api.Error
import           Cardano.Api.Hash
import           Cardano.Api.HasTypeProxy
import           Cardano.Api.Keys.Byron
import           Cardano.Api.Keys.Shelley
import           Cardano.Api.NetworkId
import           Cardano.Api.ProtocolParameters
import           Cardano.Api.Script
import           Cardano.Api.ScriptData
import           Cardano.Api.SerialiseCBOR
import           Cardano.Api.SerialiseJSON
import           Cardano.Api.SerialiseRaw
import           Cardano.Api.SerialiseTextEnvelope
import           Cardano.Api.TxIn
import           Cardano.Api.TxMetadata
import           Cardano.Api.Utils
import           Cardano.Api.Value
import           Cardano.Api.ValueParser

-- | Indicates whether a script is expected to fail or pass validation.
data ScriptValidity
  = ScriptInvalid -- ^ Script is expected to fail validation.
                  -- Transactions marked as such can include scripts that fail validation.
                  -- Such transactions may be submitted to the chain, in which case the
                  -- collateral will be taken upon on chain script validation failure.

  | ScriptValid   -- ^ Script is expected to pass validation.
                  -- Transactions marked as such cannot include scripts that fail validation.

  deriving (ScriptValidity -> ScriptValidity -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScriptValidity -> ScriptValidity -> Bool
$c/= :: ScriptValidity -> ScriptValidity -> Bool
== :: ScriptValidity -> ScriptValidity -> Bool
$c== :: ScriptValidity -> ScriptValidity -> Bool
Eq, Int -> ScriptValidity -> ShowS
[ScriptValidity] -> ShowS
ScriptValidity -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScriptValidity] -> ShowS
$cshowList :: [ScriptValidity] -> ShowS
show :: ScriptValidity -> String
$cshow :: ScriptValidity -> String
showsPrec :: Int -> ScriptValidity -> ShowS
$cshowsPrec :: Int -> ScriptValidity -> ShowS
Show)

instance ToCBOR ScriptValidity where
  toCBOR :: ScriptValidity -> Encoding
toCBOR = forall a. ToCBOR a => a -> Encoding
toCBOR forall b c a. (b -> c) -> (a -> b) -> a -> c
. ScriptValidity -> IsValid
scriptValidityToIsValid

instance FromCBOR ScriptValidity where
  fromCBOR :: forall s. Decoder s ScriptValidity
fromCBOR = IsValid -> ScriptValidity
isValidToScriptValidity forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a s. FromCBOR a => Decoder s a
fromCBOR

scriptValidityToIsValid :: ScriptValidity -> Alonzo.IsValid
scriptValidityToIsValid :: ScriptValidity -> IsValid
scriptValidityToIsValid ScriptValidity
ScriptInvalid = Bool -> IsValid
Alonzo.IsValid Bool
False
scriptValidityToIsValid ScriptValidity
ScriptValid = Bool -> IsValid
Alonzo.IsValid Bool
True

isValidToScriptValidity :: Alonzo.IsValid -> ScriptValidity
isValidToScriptValidity :: IsValid -> ScriptValidity
isValidToScriptValidity (Alonzo.IsValid Bool
False) = ScriptValidity
ScriptInvalid
isValidToScriptValidity (Alonzo.IsValid Bool
True) = ScriptValidity
ScriptValid

-- | A representation of whether the era supports tx script validity.
--
-- The Alonzo and subsequent eras support script validity.
--
data TxScriptValidity era where
  TxScriptValidityNone :: TxScriptValidity era

  -- | Tx script validity is supported in transactions in the 'Alonzo' era onwards.
  TxScriptValidity
    :: TxScriptValiditySupportedInEra era
    -> ScriptValidity
    -> TxScriptValidity era

deriving instance Eq   (TxScriptValiditySupportedInEra era)
deriving instance Show (TxScriptValiditySupportedInEra era)

data TxScriptValiditySupportedInEra era where
  TxScriptValiditySupportedInAlonzoEra  :: TxScriptValiditySupportedInEra AlonzoEra
  TxScriptValiditySupportedInBabbageEra :: TxScriptValiditySupportedInEra BabbageEra
  TxScriptValiditySupportedInConwayEra  :: TxScriptValiditySupportedInEra ConwayEra

deriving instance Eq   (TxScriptValidity era)
deriving instance Show (TxScriptValidity era)

txScriptValiditySupportedInCardanoEra :: CardanoEra era -> Maybe (TxScriptValiditySupportedInEra era)
txScriptValiditySupportedInCardanoEra :: forall era.
CardanoEra era -> Maybe (TxScriptValiditySupportedInEra era)
txScriptValiditySupportedInCardanoEra CardanoEra era
ByronEra   = forall a. Maybe a
Nothing
txScriptValiditySupportedInCardanoEra CardanoEra era
ShelleyEra = forall a. Maybe a
Nothing
txScriptValiditySupportedInCardanoEra CardanoEra era
AllegraEra = forall a. Maybe a
Nothing
txScriptValiditySupportedInCardanoEra CardanoEra era
MaryEra    = forall a. Maybe a
Nothing
txScriptValiditySupportedInCardanoEra CardanoEra era
AlonzoEra  = forall a. a -> Maybe a
Just TxScriptValiditySupportedInEra AlonzoEra
TxScriptValiditySupportedInAlonzoEra
txScriptValiditySupportedInCardanoEra CardanoEra era
BabbageEra = forall a. a -> Maybe a
Just TxScriptValiditySupportedInEra BabbageEra
TxScriptValiditySupportedInBabbageEra
txScriptValiditySupportedInCardanoEra CardanoEra era
ConwayEra = forall a. a -> Maybe a
Just TxScriptValiditySupportedInEra ConwayEra
TxScriptValiditySupportedInConwayEra

txScriptValiditySupportedInShelleyBasedEra :: ShelleyBasedEra era -> Maybe (TxScriptValiditySupportedInEra era)
txScriptValiditySupportedInShelleyBasedEra :: forall era.
ShelleyBasedEra era -> Maybe (TxScriptValiditySupportedInEra era)
txScriptValiditySupportedInShelleyBasedEra ShelleyBasedEra era
ShelleyBasedEraShelley = forall a. Maybe a
Nothing
txScriptValiditySupportedInShelleyBasedEra ShelleyBasedEra era
ShelleyBasedEraAllegra = forall a. Maybe a
Nothing
txScriptValiditySupportedInShelleyBasedEra ShelleyBasedEra era
ShelleyBasedEraMary    = forall a. Maybe a
Nothing
txScriptValiditySupportedInShelleyBasedEra ShelleyBasedEra era
ShelleyBasedEraAlonzo  = forall a. a -> Maybe a
Just TxScriptValiditySupportedInEra AlonzoEra
TxScriptValiditySupportedInAlonzoEra
txScriptValiditySupportedInShelleyBasedEra ShelleyBasedEra era
ShelleyBasedEraBabbage = forall a. a -> Maybe a
Just TxScriptValiditySupportedInEra BabbageEra
TxScriptValiditySupportedInBabbageEra
txScriptValiditySupportedInShelleyBasedEra ShelleyBasedEra era
ShelleyBasedEraConway = forall a. a -> Maybe a
Just TxScriptValiditySupportedInEra ConwayEra
TxScriptValiditySupportedInConwayEra

txScriptValidityToScriptValidity :: TxScriptValidity era -> ScriptValidity
txScriptValidityToScriptValidity :: forall era. TxScriptValidity era -> ScriptValidity
txScriptValidityToScriptValidity TxScriptValidity era
TxScriptValidityNone = ScriptValidity
ScriptValid
txScriptValidityToScriptValidity (TxScriptValidity TxScriptValiditySupportedInEra era
_ ScriptValidity
scriptValidity) = ScriptValidity
scriptValidity

scriptValidityToTxScriptValidity :: ShelleyBasedEra era -> ScriptValidity -> TxScriptValidity era
scriptValidityToTxScriptValidity :: forall era.
ShelleyBasedEra era -> ScriptValidity -> TxScriptValidity era
scriptValidityToTxScriptValidity ShelleyBasedEra era
era ScriptValidity
scriptValidity = case forall era.
ShelleyBasedEra era -> Maybe (TxScriptValiditySupportedInEra era)
txScriptValiditySupportedInShelleyBasedEra ShelleyBasedEra era
era of
  Maybe (TxScriptValiditySupportedInEra era)
Nothing -> forall era. TxScriptValidity era
TxScriptValidityNone
  Just TxScriptValiditySupportedInEra era
witness -> forall era.
TxScriptValiditySupportedInEra era
-> ScriptValidity -> TxScriptValidity era
TxScriptValidity TxScriptValiditySupportedInEra era
witness ScriptValidity
scriptValidity

txScriptValidityToIsValid :: TxScriptValidity era -> Alonzo.IsValid
txScriptValidityToIsValid :: forall era. TxScriptValidity era -> IsValid
txScriptValidityToIsValid = ScriptValidity -> IsValid
scriptValidityToIsValid forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall era. TxScriptValidity era -> ScriptValidity
txScriptValidityToScriptValidity

-- ----------------------------------------------------------------------------
-- Transaction outputs
--

-- | The context is a transaction body
data CtxTx
-- | The context is the UTxO
data CtxUTxO

data TxOut ctx era = TxOut (AddressInEra    era)
                           (TxOutValue      era)
                           (TxOutDatum ctx  era)
                           (ReferenceScript era)

deriving instance Eq   (TxOut ctx era)
deriving instance Show (TxOut ctx era)

instance EraCast (TxOut ctx) where
  eraCast :: forall fromEra toEra.
(IsCardanoEra fromEra, IsCardanoEra toEra) =>
CardanoEra toEra
-> TxOut ctx fromEra -> Either EraCastError (TxOut ctx toEra)
eraCast CardanoEra toEra
toEra (TxOut AddressInEra fromEra
addressInEra TxOutValue fromEra
txOutValue TxOutDatum ctx fromEra
txOutDatum ReferenceScript fromEra
referenceScript) =
    forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) fromEra toEra.
(EraCast f, IsCardanoEra fromEra, IsCardanoEra toEra) =>
CardanoEra toEra -> f fromEra -> Either EraCastError (f toEra)
eraCast CardanoEra toEra
toEra AddressInEra fromEra
addressInEra
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) fromEra toEra.
(EraCast f, IsCardanoEra fromEra, IsCardanoEra toEra) =>
CardanoEra toEra -> f fromEra -> Either EraCastError (f toEra)
eraCast CardanoEra toEra
toEra TxOutValue fromEra
txOutValue
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) fromEra toEra.
(EraCast f, IsCardanoEra fromEra, IsCardanoEra toEra) =>
CardanoEra toEra -> f fromEra -> Either EraCastError (f toEra)
eraCast CardanoEra toEra
toEra TxOutDatum ctx fromEra
txOutDatum
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) fromEra toEra.
(EraCast f, IsCardanoEra fromEra, IsCardanoEra toEra) =>
CardanoEra toEra -> f fromEra -> Either EraCastError (f toEra)
eraCast CardanoEra toEra
toEra ReferenceScript fromEra
referenceScript

data TxOutInAnyEra where
     TxOutInAnyEra :: CardanoEra era
                   -> TxOut CtxTx era
                   -> TxOutInAnyEra

deriving instance Show TxOutInAnyEra

instance Eq TxOutInAnyEra where
  TxOutInAnyEra CardanoEra era
era1 TxOut CtxTx era
out1 == :: TxOutInAnyEra -> TxOutInAnyEra -> Bool
== TxOutInAnyEra CardanoEra era
era2 TxOut CtxTx era
out2 =
    case forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality CardanoEra era
era1 CardanoEra era
era2 of
      Just era :~: era
Refl -> TxOut CtxTx era
out1 forall a. Eq a => a -> a -> Bool
== TxOut CtxTx era
out2
      Maybe (era :~: era)
Nothing   -> Bool
False

-- | Convenience constructor for 'TxOutInAnyEra'
txOutInAnyEra :: IsCardanoEra era => TxOut CtxTx era -> TxOutInAnyEra
txOutInAnyEra :: forall era. IsCardanoEra era => TxOut CtxTx era -> TxOutInAnyEra
txOutInAnyEra = forall witctx.
CardanoEra witctx -> TxOut CtxTx witctx -> TxOutInAnyEra
TxOutInAnyEra forall era. IsCardanoEra era => CardanoEra era
cardanoEra

toCtxUTxOTxOut :: TxOut CtxTx  era -> TxOut CtxUTxO era
toCtxUTxOTxOut :: forall era. TxOut CtxTx era -> TxOut CtxUTxO era
toCtxUTxOTxOut (TxOut AddressInEra era
addr TxOutValue era
val TxOutDatum CtxTx era
d ReferenceScript era
refS) =
  let dat :: TxOutDatum CtxUTxO era
dat = case TxOutDatum CtxTx era
d of
              TxOutDatum CtxTx era
TxOutDatumNone -> forall ctx era. TxOutDatum ctx era
TxOutDatumNone
              TxOutDatumHash ScriptDataSupportedInEra era
s Hash ScriptData
h -> forall era ctx.
ScriptDataSupportedInEra era
-> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash ScriptDataSupportedInEra era
s Hash ScriptData
h
              TxOutDatumInTx' ScriptDataSupportedInEra era
s Hash ScriptData
h HashableScriptData
_ -> forall era ctx.
ScriptDataSupportedInEra era
-> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash ScriptDataSupportedInEra era
s Hash ScriptData
h
              TxOutDatumInline ReferenceTxInsScriptsInlineDatumsSupportedInEra era
s HashableScriptData
sd -> forall era ctx.
ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline ReferenceTxInsScriptsInlineDatumsSupportedInEra era
s HashableScriptData
sd
  in forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut AddressInEra era
addr TxOutValue era
val TxOutDatum CtxUTxO era
dat ReferenceScript era
refS

instance IsCardanoEra era => ToJSON (TxOut ctx era) where
  toJSON :: TxOut ctx era -> Value
toJSON  = forall era ctx. CardanoEra era -> TxOut ctx era -> Value
txOutToJsonValue forall era. IsCardanoEra era => CardanoEra era
cardanoEra

txOutToJsonValue :: CardanoEra era -> TxOut ctx era -> Aeson.Value
txOutToJsonValue :: forall era ctx. CardanoEra era -> TxOut ctx era -> Value
txOutToJsonValue CardanoEra era
era (TxOut AddressInEra era
addr TxOutValue era
val TxOutDatum ctx era
dat ReferenceScript era
refScript) =
  case CardanoEra era
era of
    CardanoEra era
ByronEra -> [Pair] -> Value
object [Key
"address" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= AddressInEra era
addr, Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era
val]
    CardanoEra era
ShelleyEra -> [Pair] -> Value
object [Key
"address" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= AddressInEra era
addr, Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era
val]
    CardanoEra era
AllegraEra -> [Pair] -> Value
object [Key
"address" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= AddressInEra era
addr, Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era
val]
    CardanoEra era
MaryEra -> [Pair] -> Value
object [Key
"address" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= AddressInEra era
addr, Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era
val]
    CardanoEra era
AlonzoEra -> [Pair] -> Value
object
                   [ Key
"address" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= AddressInEra era
addr
                   , Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era
val
                   , forall ctx era. TxOutDatum ctx era -> Pair
datHashJsonVal TxOutDatum ctx era
dat
                   , Key
"datum" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall ctx era. TxOutDatum ctx era -> Value
datJsonVal TxOutDatum ctx era
dat
                   ]
    CardanoEra era
BabbageEra ->
      [Pair] -> Value
object
        [ Key
"address" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= AddressInEra era
addr
        , Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era
val
        , forall ctx era. TxOutDatum ctx era -> Pair
datHashJsonVal TxOutDatum ctx era
dat
        , Key
"datum" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall ctx era. TxOutDatum ctx era -> Value
datJsonVal TxOutDatum ctx era
dat
        , Key
"inlineDatum" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall ctx era. TxOutDatum ctx era -> Value
inlineDatumJsonVal TxOutDatum ctx era
dat
        , Key
"referenceScript" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall era. ReferenceScript era -> Value
refScriptJsonVal ReferenceScript era
refScript
        ]
    CardanoEra era
ConwayEra ->
      [Pair] -> Value
object
        [ Key
"address" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= AddressInEra era
addr
        , Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era
val
        , forall ctx era. TxOutDatum ctx era -> Pair
datHashJsonVal TxOutDatum ctx era
dat
        , Key
"datum" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall ctx era. TxOutDatum ctx era -> Value
datJsonVal TxOutDatum ctx era
dat
        , Key
"inlineDatum" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall ctx era. TxOutDatum ctx era -> Value
inlineDatumJsonVal TxOutDatum ctx era
dat
        , Key
"referenceScript" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall era. ReferenceScript era -> Value
refScriptJsonVal ReferenceScript era
refScript
        ]
 where
   datHashJsonVal :: TxOutDatum ctx era -> Aeson.Pair
   datHashJsonVal :: forall ctx era. TxOutDatum ctx era -> Pair
datHashJsonVal TxOutDatum ctx era
d =
     case TxOutDatum ctx era
d of
       TxOutDatum ctx era
TxOutDatumNone ->
         Key
"datumhash" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Value
Aeson.Null
       TxOutDatumHash ScriptDataSupportedInEra era
_ Hash ScriptData
h ->
         Key
"datumhash" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall a. ToJSON a => a -> Value
toJSON Hash ScriptData
h
       TxOutDatumInTx' ScriptDataSupportedInEra era
_ Hash ScriptData
h HashableScriptData
_ ->
         Key
"datumhash" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall a. ToJSON a => a -> Value
toJSON Hash ScriptData
h
       TxOutDatumInline ReferenceTxInsScriptsInlineDatumsSupportedInEra era
_ HashableScriptData
datum ->
         Key
"inlineDatumhash"  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall a. ToJSON a => a -> Value
toJSON (HashableScriptData -> Hash ScriptData
hashScriptDataBytes HashableScriptData
datum)

   datJsonVal :: TxOutDatum ctx era -> Aeson.Value
   datJsonVal :: forall ctx era. TxOutDatum ctx era -> Value
datJsonVal TxOutDatum ctx era
d =
     case TxOutDatum ctx era
d of
       TxOutDatum ctx era
TxOutDatumNone -> Value
Aeson.Null
       TxOutDatumHash ScriptDataSupportedInEra era
_ Hash ScriptData
_ -> Value
Aeson.Null
       TxOutDatumInTx' ScriptDataSupportedInEra era
_ Hash ScriptData
_ HashableScriptData
datum -> ScriptDataJsonSchema -> HashableScriptData -> Value
scriptDataToJson ScriptDataJsonSchema
ScriptDataJsonDetailedSchema HashableScriptData
datum
       TxOutDatumInline ReferenceTxInsScriptsInlineDatumsSupportedInEra era
_ HashableScriptData
_ -> Value
Aeson.Null

   inlineDatumJsonVal :: TxOutDatum ctx era -> Aeson.Value
   inlineDatumJsonVal :: forall ctx era. TxOutDatum ctx era -> Value
inlineDatumJsonVal TxOutDatum ctx era
d =
     case TxOutDatum ctx era
d of
       TxOutDatum ctx era
TxOutDatumNone -> Value
Aeson.Null
       TxOutDatumHash {} -> Value
Aeson.Null
       TxOutDatumInTx'{} -> Value
Aeson.Null
       TxOutDatumInline ReferenceTxInsScriptsInlineDatumsSupportedInEra era
_ HashableScriptData
datum -> ScriptDataJsonSchema -> HashableScriptData -> Value
scriptDataToJson ScriptDataJsonSchema
ScriptDataJsonDetailedSchema HashableScriptData
datum

   refScriptJsonVal :: ReferenceScript era -> Aeson.Value
   refScriptJsonVal :: forall era. ReferenceScript era -> Value
refScriptJsonVal ReferenceScript era
rScript =
     case ReferenceScript era
rScript of
       ReferenceScript ReferenceTxInsScriptsInlineDatumsSupportedInEra era
_ ScriptInAnyLang
s -> forall a. ToJSON a => a -> Value
toJSON ScriptInAnyLang
s
       ReferenceScript era
ReferenceScriptNone -> Value
Aeson.Null

instance IsShelleyBasedEra era => FromJSON (TxOut CtxTx era) where
      parseJSON :: Value -> Parser (TxOut CtxTx era)
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"TxOut" forall a b. (a -> b) -> a -> b
$ \Object
o -> do
        case forall era. IsShelleyBasedEra era => ShelleyBasedEra era
shelleyBasedEra :: ShelleyBasedEra era of
          ShelleyBasedEra era
ShelleyBasedEraShelley ->
            forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall ctx era. TxOutDatum ctx era
TxOutDatumNone
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall era. ReferenceScript era
ReferenceScriptNone
          ShelleyBasedEra era
ShelleyBasedEraMary ->
            forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall ctx era. TxOutDatum ctx era
TxOutDatumNone
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall era. ReferenceScript era
ReferenceScriptNone
          ShelleyBasedEra era
ShelleyBasedEraAllegra ->
            forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall ctx era. TxOutDatum ctx era
TxOutDatumNone
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall era. ReferenceScript era
ReferenceScriptNone
          ShelleyBasedEra era
ShelleyBasedEraAlonzo -> ScriptDataSupportedInEra era -> Object -> Parser (TxOut CtxTx era)
alonzoTxOutParser ScriptDataSupportedInEra AlonzoEra
ScriptDataInAlonzoEra Object
o

          ShelleyBasedEra era
ShelleyBasedEraBabbage -> do
            TxOut CtxTx era
alonzoTxOutInBabbage <- ScriptDataSupportedInEra era -> Object -> Parser (TxOut CtxTx era)
alonzoTxOutParser ScriptDataSupportedInEra BabbageEra
ScriptDataInBabbageEra Object
o

            -- We check for the existence of inline datums
            Maybe (Hash ScriptData)
inlineDatumHash <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inlineDatumhash"
            Maybe Value
inlineDatum <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inlineDatum"
            TxOutDatum CtxTx BabbageEra
mInlineDatum <-
              case (Maybe Value
inlineDatum, Maybe (Hash ScriptData)
inlineDatumHash) of
                (Just Value
dVal, Just Hash ScriptData
h) -> do
                  case ScriptDataJsonSchema
-> Value -> Either ScriptDataJsonBytesError HashableScriptData
scriptDataJsonToHashable ScriptDataJsonSchema
ScriptDataJsonDetailedSchema Value
dVal of
                    Left ScriptDataJsonBytesError
err ->
                      forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Error parsing TxOut JSON: " forall a. Semigroup a => a -> a -> a
<> forall e. Error e => e -> String
displayError ScriptDataJsonBytesError
err
                    Right HashableScriptData
hashableData -> do
                      if HashableScriptData -> Hash ScriptData
hashScriptDataBytes HashableScriptData
hashableData forall a. Eq a => a -> a -> Bool
/= Hash ScriptData
h
                      then forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Inline datum not equivalent to inline datum hash"
                      else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall era ctx.
ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline ReferenceTxInsScriptsInlineDatumsSupportedInEra BabbageEra
ReferenceTxInsScriptsInlineDatumsInBabbageEra HashableScriptData
hashableData
                (Maybe Value
Nothing, Maybe (Hash ScriptData)
Nothing) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall ctx era. TxOutDatum ctx era
TxOutDatumNone
                (Maybe Value
_,Maybe (Hash ScriptData)
_) -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Should not be possible to create a tx output with either an inline datum hash or an inline datum"

            Maybe ScriptInAnyLang
mReferenceScript <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"referenceScript"

            TxOut CtxTx BabbageEra
-> TxOutDatum CtxTx BabbageEra
-> Maybe ScriptInAnyLang
-> Parser (TxOut CtxTx BabbageEra)
reconcileBabbage TxOut CtxTx era
alonzoTxOutInBabbage TxOutDatum CtxTx BabbageEra
mInlineDatum Maybe ScriptInAnyLang
mReferenceScript

          ShelleyBasedEra era
ShelleyBasedEraConway -> do
            TxOut CtxTx era
alonzoTxOutInConway <- ScriptDataSupportedInEra era -> Object -> Parser (TxOut CtxTx era)
alonzoTxOutParser ScriptDataSupportedInEra ConwayEra
ScriptDataInConwayEra Object
o

            -- We check for the existence of inline datums
            Maybe (Hash ScriptData)
inlineDatumHash <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inlineDatumhash"
            Maybe Value
inlineDatum <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inlineDatum"
            TxOutDatum CtxTx ConwayEra
mInlineDatum <-
              case (Maybe Value
inlineDatum, Maybe (Hash ScriptData)
inlineDatumHash) of
                (Just Value
dVal, Just Hash ScriptData
h) ->
                  case ScriptDataJsonSchema
-> Value -> Either ScriptDataJsonError HashableScriptData
scriptDataFromJson ScriptDataJsonSchema
ScriptDataJsonDetailedSchema Value
dVal of
                    Left ScriptDataJsonError
err ->
                      forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Error parsing TxOut JSON: " forall a. Semigroup a => a -> a -> a
<> forall e. Error e => e -> String
displayError ScriptDataJsonError
err
                    Right HashableScriptData
sData ->
                      if HashableScriptData -> Hash ScriptData
hashScriptDataBytes HashableScriptData
sData forall a. Eq a => a -> a -> Bool
/= Hash ScriptData
h
                      then forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Inline datum not equivalent to inline datum hash"
                      else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall era ctx.
ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline ReferenceTxInsScriptsInlineDatumsSupportedInEra ConwayEra
ReferenceTxInsScriptsInlineDatumsInConwayEra HashableScriptData
sData
                (Maybe Value
Nothing, Maybe (Hash ScriptData)
Nothing) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall ctx era. TxOutDatum ctx era
TxOutDatumNone
                (Maybe Value
_,Maybe (Hash ScriptData)
_) -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Should not be possible to create a tx output with either an inline datum hash or an inline datum"

            Maybe ScriptInAnyLang
mReferenceScript <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"referenceScript"

            TxOut CtxTx ConwayEra
-> TxOutDatum CtxTx ConwayEra
-> Maybe ScriptInAnyLang
-> Parser (TxOut CtxTx ConwayEra)
reconcileConway TxOut CtxTx era
alonzoTxOutInConway TxOutDatum CtxTx ConwayEra
mInlineDatum Maybe ScriptInAnyLang
mReferenceScript
         where
           reconcileBabbage
             :: TxOut CtxTx BabbageEra -- ^ Alonzo era datum in Babbage era
             -> TxOutDatum CtxTx BabbageEra -- ^ Babbage inline datum
             -> Maybe ScriptInAnyLang
             -> Aeson.Parser (TxOut CtxTx BabbageEra)
           reconcileBabbage :: TxOut CtxTx BabbageEra
-> TxOutDatum CtxTx BabbageEra
-> Maybe ScriptInAnyLang
-> Parser (TxOut CtxTx BabbageEra)
reconcileBabbage top :: TxOut CtxTx BabbageEra
top@(TxOut AddressInEra BabbageEra
addr TxOutValue BabbageEra
v TxOutDatum CtxTx BabbageEra
dat ReferenceScript BabbageEra
r) TxOutDatum CtxTx BabbageEra
babbageDatum Maybe ScriptInAnyLang
mBabRefScript = do
             -- We check for conflicting datums
             TxOutDatum CtxTx BabbageEra
finalDat <- case (TxOutDatum CtxTx BabbageEra
dat, TxOutDatum CtxTx BabbageEra
babbageDatum) of
                           (TxOutDatum CtxTx BabbageEra
TxOutDatumNone, TxOutDatum CtxTx BabbageEra
bDatum) -> forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxTx BabbageEra
bDatum
                           (TxOutDatum CtxTx BabbageEra
anyDat, TxOutDatum CtxTx BabbageEra
TxOutDatumNone) -> forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxTx BabbageEra
anyDat
                           (TxOutDatum CtxTx BabbageEra
alonzoDat, TxOutDatum CtxTx BabbageEra
babbageDat) ->
                             forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Parsed an Alonzo era datum and a Babbage era datum " forall a. Semigroup a => a -> a -> a
<>
                                    String
"TxOut: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show TxOut CtxTx BabbageEra
top forall a. Semigroup a => a -> a -> a
<>
                                    String
"Alonzo datum: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show TxOutDatum CtxTx BabbageEra
alonzoDat forall a. Semigroup a => a -> a -> a
<>
                                    String
"Babbage dat: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show TxOutDatum CtxTx BabbageEra
babbageDat
             ReferenceScript BabbageEra
finalRefScript <- case Maybe ScriptInAnyLang
mBabRefScript of
                                 Maybe ScriptInAnyLang
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript BabbageEra
r
                                 Just ScriptInAnyLang
anyScript ->
                                   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall era.
ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> ScriptInAnyLang -> ReferenceScript era
ReferenceScript ReferenceTxInsScriptsInlineDatumsSupportedInEra BabbageEra
ReferenceTxInsScriptsInlineDatumsInBabbageEra ScriptInAnyLang
anyScript
             forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut AddressInEra BabbageEra
addr TxOutValue BabbageEra
v TxOutDatum CtxTx BabbageEra
finalDat ReferenceScript BabbageEra
finalRefScript

           reconcileConway
             :: TxOut CtxTx ConwayEra -- ^ Alonzo era datum in Conway era
             -> TxOutDatum CtxTx ConwayEra -- ^ Babbage inline datum
             -> Maybe ScriptInAnyLang
             -> Aeson.Parser (TxOut CtxTx ConwayEra)
           reconcileConway :: TxOut CtxTx ConwayEra
-> TxOutDatum CtxTx ConwayEra
-> Maybe ScriptInAnyLang
-> Parser (TxOut CtxTx ConwayEra)
reconcileConway top :: TxOut CtxTx ConwayEra
top@(TxOut AddressInEra ConwayEra
addr TxOutValue ConwayEra
v TxOutDatum CtxTx ConwayEra
dat ReferenceScript ConwayEra
r) TxOutDatum CtxTx ConwayEra
babbageDatum Maybe ScriptInAnyLang
mBabRefScript = do
             -- We check for conflicting datums
             TxOutDatum CtxTx ConwayEra
finalDat <- case (TxOutDatum CtxTx ConwayEra
dat, TxOutDatum CtxTx ConwayEra
babbageDatum) of
                           (TxOutDatum CtxTx ConwayEra
TxOutDatumNone, TxOutDatum CtxTx ConwayEra
bDatum) -> forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxTx ConwayEra
bDatum
                           (TxOutDatum CtxTx ConwayEra
anyDat, TxOutDatum CtxTx ConwayEra
TxOutDatumNone) -> forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxTx ConwayEra
anyDat
                           (TxOutDatum CtxTx ConwayEra
alonzoDat, TxOutDatum CtxTx ConwayEra
babbageDat) ->
                             forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Parsed an Alonzo era datum and a Conway era datum " forall a. Semigroup a => a -> a -> a
<>
                                    String
"TxOut: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show TxOut CtxTx ConwayEra
top forall a. Semigroup a => a -> a -> a
<>
                                    String
"Alonzo datum: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show TxOutDatum CtxTx ConwayEra
alonzoDat forall a. Semigroup a => a -> a -> a
<>
                                    String
"Conway dat: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show TxOutDatum CtxTx ConwayEra
babbageDat
             ReferenceScript ConwayEra
finalRefScript <- case Maybe ScriptInAnyLang
mBabRefScript of
                                 Maybe ScriptInAnyLang
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript ConwayEra
r
                                 Just ScriptInAnyLang
anyScript ->
                                   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall era.
ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> ScriptInAnyLang -> ReferenceScript era
ReferenceScript ReferenceTxInsScriptsInlineDatumsSupportedInEra ConwayEra
ReferenceTxInsScriptsInlineDatumsInConwayEra ScriptInAnyLang
anyScript
             forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut AddressInEra ConwayEra
addr TxOutValue ConwayEra
v TxOutDatum CtxTx ConwayEra
finalDat ReferenceScript ConwayEra
finalRefScript

           alonzoTxOutParser
             :: ScriptDataSupportedInEra era -> Aeson.Object -> Aeson.Parser (TxOut CtxTx era)
           alonzoTxOutParser :: ScriptDataSupportedInEra era -> Object -> Parser (TxOut CtxTx era)
alonzoTxOutParser ScriptDataSupportedInEra era
supp Object
o = do
            Maybe (Hash ScriptData)
mDatumHash <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"datumhash"
            Maybe Value
mDatumVal <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"datum"
            case (Maybe Value
mDatumVal, Maybe (Hash ScriptData)
mDatumHash) of
               (Maybe Value
Nothing,Maybe (Hash ScriptData)
Nothing) -> forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
                                          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
                                          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall ctx era. TxOutDatum ctx era
TxOutDatumNone
                                          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall era. ReferenceScript era
ReferenceScriptNone
               (Just Value
dVal, Just Hash ScriptData
dHash) -> do
                 case ScriptDataJsonSchema
-> Value -> Either ScriptDataJsonBytesError HashableScriptData
scriptDataJsonToHashable ScriptDataJsonSchema
ScriptDataJsonDetailedSchema Value
dVal of
                   Left ScriptDataJsonBytesError
e -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Error parsing ScriptData: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show ScriptDataJsonBytesError
e
                   Right HashableScriptData
hashableData ->
                      forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
                            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
                            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return (forall era.
ScriptDataSupportedInEra era
-> Hash ScriptData -> HashableScriptData -> TxOutDatum CtxTx era
TxOutDatumInTx' ScriptDataSupportedInEra era
supp Hash ScriptData
dHash HashableScriptData
hashableData)
                            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall era. ReferenceScript era
ReferenceScriptNone
               (Maybe Value
Nothing, Just Hash ScriptData
dHash) ->
                 forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
                       forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
                       forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return (forall era ctx.
ScriptDataSupportedInEra era
-> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash ScriptDataSupportedInEra era
supp Hash ScriptData
dHash)
                       forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall era. ReferenceScript era
ReferenceScriptNone
               (Just Value
_dVal, Maybe (Hash ScriptData)
Nothing) -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Only datum JSON was found, this should not be possible."

instance IsShelleyBasedEra era => FromJSON (TxOut CtxUTxO era) where
      parseJSON :: Value -> Parser (TxOut CtxUTxO era)
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"TxOut" forall a b. (a -> b) -> a -> b
$ \Object
o -> do
        case forall era. IsShelleyBasedEra era => ShelleyBasedEra era
shelleyBasedEra :: ShelleyBasedEra era of
          ShelleyBasedEra era
ShelleyBasedEraShelley ->
            forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall ctx era. TxOutDatum ctx era
TxOutDatumNone
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall era. ReferenceScript era
ReferenceScriptNone
          ShelleyBasedEra era
ShelleyBasedEraMary ->
            forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall ctx era. TxOutDatum ctx era
TxOutDatumNone
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall era. ReferenceScript era
ReferenceScriptNone
          ShelleyBasedEra era
ShelleyBasedEraAllegra ->
            forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall ctx era. TxOutDatum ctx era
TxOutDatumNone
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall era. ReferenceScript era
ReferenceScriptNone
          ShelleyBasedEra era
ShelleyBasedEraAlonzo -> ScriptDataSupportedInEra era
-> Object -> Parser (TxOut CtxUTxO era)
alonzoTxOutParser ScriptDataSupportedInEra AlonzoEra
ScriptDataInAlonzoEra Object
o

          ShelleyBasedEra era
ShelleyBasedEraBabbage -> do
            TxOut CtxUTxO era
alonzoTxOutInBabbage <- ScriptDataSupportedInEra era
-> Object -> Parser (TxOut CtxUTxO era)
alonzoTxOutParser ScriptDataSupportedInEra BabbageEra
ScriptDataInBabbageEra Object
o

            -- We check for the existence of inline datums
            Maybe (Hash ScriptData)
inlineDatumHash <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inlineDatumhash"
            Maybe Value
inlineDatum <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inlineDatum"
            TxOutDatum CtxUTxO BabbageEra
mInlineDatum <-
              case (Maybe Value
inlineDatum, Maybe (Hash ScriptData)
inlineDatumHash) of
                (Just Value
dVal, Just Hash ScriptData
h) -> do
                     case ScriptDataJsonSchema
-> Value -> Either ScriptDataJsonBytesError HashableScriptData
scriptDataJsonToHashable ScriptDataJsonSchema
ScriptDataJsonDetailedSchema Value
dVal of
                        Left ScriptDataJsonBytesError
err ->
                          forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Error parsing TxOut JSON: " forall a. Semigroup a => a -> a -> a
<> forall e. Error e => e -> String
displayError ScriptDataJsonBytesError
err
                        Right HashableScriptData
hashableData -> do
                          if HashableScriptData -> Hash ScriptData
hashScriptDataBytes HashableScriptData
hashableData forall a. Eq a => a -> a -> Bool
/= Hash ScriptData
h
                          then forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Inline datum not equivalent to inline datum hash"
                          else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall era ctx.
ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline ReferenceTxInsScriptsInlineDatumsSupportedInEra BabbageEra
ReferenceTxInsScriptsInlineDatumsInBabbageEra HashableScriptData
hashableData
                (Maybe Value
Nothing, Maybe (Hash ScriptData)
Nothing) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall ctx era. TxOutDatum ctx era
TxOutDatumNone
                (Maybe Value
_,Maybe (Hash ScriptData)
_) -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Should not be possible to create a tx output with either an inline datum hash or an inline datum"

            -- We check for a reference script
            Maybe ScriptInAnyLang
mReferenceScript <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"referenceScript"

            TxOut CtxUTxO BabbageEra
-> TxOutDatum CtxUTxO BabbageEra
-> Maybe ScriptInAnyLang
-> Parser (TxOut CtxUTxO BabbageEra)
reconcileBabbage TxOut CtxUTxO era
alonzoTxOutInBabbage TxOutDatum CtxUTxO BabbageEra
mInlineDatum Maybe ScriptInAnyLang
mReferenceScript

          ShelleyBasedEra era
ShelleyBasedEraConway -> do
            TxOut CtxUTxO era
alonzoTxOutInConway <- ScriptDataSupportedInEra era
-> Object -> Parser (TxOut CtxUTxO era)
alonzoTxOutParser ScriptDataSupportedInEra ConwayEra
ScriptDataInConwayEra Object
o

            -- We check for the existence of inline datums
            Maybe (Hash ScriptData)
inlineDatumHash <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inlineDatumhash"
            Maybe Value
inlineDatum <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inlineDatum"
            TxOutDatum CtxUTxO ConwayEra
mInlineDatum <-
              case (Maybe Value
inlineDatum, Maybe (Hash ScriptData)
inlineDatumHash) of
                (Just Value
dVal, Just Hash ScriptData
h) ->
                  case ScriptDataJsonSchema
-> Value -> Either ScriptDataJsonError HashableScriptData
scriptDataFromJson ScriptDataJsonSchema
ScriptDataJsonDetailedSchema Value
dVal of
                    Left ScriptDataJsonError
err ->
                      forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Error parsing TxOut JSON: " forall a. Semigroup a => a -> a -> a
<> forall e. Error e => e -> String
displayError ScriptDataJsonError
err
                    Right HashableScriptData
sData ->
                      if HashableScriptData -> Hash ScriptData
hashScriptDataBytes HashableScriptData
sData forall a. Eq a => a -> a -> Bool
/= Hash ScriptData
h
                      then forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Inline datum not equivalent to inline datum hash"
                      else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall era ctx.
ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline ReferenceTxInsScriptsInlineDatumsSupportedInEra ConwayEra
ReferenceTxInsScriptsInlineDatumsInConwayEra HashableScriptData
sData
                (Maybe Value
Nothing, Maybe (Hash ScriptData)
Nothing) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall ctx era. TxOutDatum ctx era
TxOutDatumNone
                (Maybe Value
_,Maybe (Hash ScriptData)
_) -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Should not be possible to create a tx output with either an inline datum hash or an inline datum"

            -- We check for a reference script
            Maybe ScriptInAnyLang
mReferenceScript <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"referenceScript"

            TxOut CtxUTxO ConwayEra
-> TxOutDatum CtxUTxO ConwayEra
-> Maybe ScriptInAnyLang
-> Parser (TxOut CtxUTxO ConwayEra)
reconcileConway TxOut CtxUTxO era
alonzoTxOutInConway TxOutDatum CtxUTxO ConwayEra
mInlineDatum Maybe ScriptInAnyLang
mReferenceScript
         where
           reconcileBabbage
             :: TxOut CtxUTxO BabbageEra -- ^ Alonzo era datum in Babbage era
             -> TxOutDatum CtxUTxO BabbageEra -- ^ Babbage inline datum
             -> Maybe ScriptInAnyLang
             -> Aeson.Parser (TxOut CtxUTxO BabbageEra)
           reconcileBabbage :: TxOut CtxUTxO BabbageEra
-> TxOutDatum CtxUTxO BabbageEra
-> Maybe ScriptInAnyLang
-> Parser (TxOut CtxUTxO BabbageEra)
reconcileBabbage (TxOut AddressInEra BabbageEra
addr TxOutValue BabbageEra
v TxOutDatum CtxUTxO BabbageEra
dat ReferenceScript BabbageEra
r) TxOutDatum CtxUTxO BabbageEra
babbageDatum Maybe ScriptInAnyLang
mBabRefScript = do
             -- We check for conflicting datums
             TxOutDatum CtxUTxO BabbageEra
finalDat <- case (TxOutDatum CtxUTxO BabbageEra
dat, TxOutDatum CtxUTxO BabbageEra
babbageDatum) of
                           (TxOutDatum CtxUTxO BabbageEra
TxOutDatumNone, TxOutDatum CtxUTxO BabbageEra
bDatum) -> forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxUTxO BabbageEra
bDatum
                           (TxOutDatum CtxUTxO BabbageEra
anyDat, TxOutDatum CtxUTxO BabbageEra
TxOutDatumNone) -> forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxUTxO BabbageEra
anyDat
                           (TxOutDatum CtxUTxO BabbageEra
_,TxOutDatum CtxUTxO BabbageEra
_) -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Parsed an Alonzo era datum and a Babbage era datum"
             ReferenceScript BabbageEra
finalRefScript <- case Maybe ScriptInAnyLang
mBabRefScript of
                                 Maybe ScriptInAnyLang
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript BabbageEra
r
                                 Just ScriptInAnyLang
anyScript ->
                                   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall era.
ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> ScriptInAnyLang -> ReferenceScript era
ReferenceScript ReferenceTxInsScriptsInlineDatumsSupportedInEra BabbageEra
ReferenceTxInsScriptsInlineDatumsInBabbageEra ScriptInAnyLang
anyScript

             forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut AddressInEra BabbageEra
addr TxOutValue BabbageEra
v TxOutDatum CtxUTxO BabbageEra
finalDat ReferenceScript BabbageEra
finalRefScript

           reconcileConway
             :: TxOut CtxUTxO ConwayEra -- ^ Alonzo era datum in Conway era
             -> TxOutDatum CtxUTxO ConwayEra -- ^ Babbage inline datum
             -> Maybe ScriptInAnyLang
             -> Aeson.Parser (TxOut CtxUTxO ConwayEra)
           reconcileConway :: TxOut CtxUTxO ConwayEra
-> TxOutDatum CtxUTxO ConwayEra
-> Maybe ScriptInAnyLang
-> Parser (TxOut CtxUTxO ConwayEra)
reconcileConway (TxOut AddressInEra ConwayEra
addr TxOutValue ConwayEra
v TxOutDatum CtxUTxO ConwayEra
dat ReferenceScript ConwayEra
r) TxOutDatum CtxUTxO ConwayEra
babbageDatum Maybe ScriptInAnyLang
mBabRefScript = do
             -- We check for conflicting datums
             TxOutDatum CtxUTxO ConwayEra
finalDat <- case (TxOutDatum CtxUTxO ConwayEra
dat, TxOutDatum CtxUTxO ConwayEra
babbageDatum) of
                           (TxOutDatum CtxUTxO ConwayEra
TxOutDatumNone, TxOutDatum CtxUTxO ConwayEra
bDatum) -> forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxUTxO ConwayEra
bDatum
                           (TxOutDatum CtxUTxO ConwayEra
anyDat, TxOutDatum CtxUTxO ConwayEra
TxOutDatumNone) -> forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxUTxO ConwayEra
anyDat
                           (TxOutDatum CtxUTxO ConwayEra
_,TxOutDatum CtxUTxO ConwayEra
_) -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Parsed an Alonzo era datum and a Conway era datum"
             ReferenceScript ConwayEra
finalRefScript <- case Maybe ScriptInAnyLang
mBabRefScript of
                                 Maybe ScriptInAnyLang
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript ConwayEra
r
                                 Just ScriptInAnyLang
anyScript ->
                                   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall era.
ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> ScriptInAnyLang -> ReferenceScript era
ReferenceScript ReferenceTxInsScriptsInlineDatumsSupportedInEra ConwayEra
ReferenceTxInsScriptsInlineDatumsInConwayEra ScriptInAnyLang
anyScript

             forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut AddressInEra ConwayEra
addr TxOutValue ConwayEra
v TxOutDatum CtxUTxO ConwayEra
finalDat ReferenceScript ConwayEra
finalRefScript

           alonzoTxOutParser :: ScriptDataSupportedInEra era -> Aeson.Object -> Aeson.Parser (TxOut CtxUTxO era)
           alonzoTxOutParser :: ScriptDataSupportedInEra era
-> Object -> Parser (TxOut CtxUTxO era)
alonzoTxOutParser ScriptDataSupportedInEra era
supp Object
o = do
            Maybe (Hash ScriptData)
mDatumHash <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"datumhash"
            case Maybe (Hash ScriptData)
mDatumHash of
               Maybe (Hash ScriptData)
Nothing -> forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
                                          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
                                          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall ctx era. TxOutDatum ctx era
TxOutDatumNone
                                          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall era. ReferenceScript era
ReferenceScriptNone
               Just Hash ScriptData
dHash ->
                 forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
                        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
                        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return (forall era ctx.
ScriptDataSupportedInEra era
-> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash ScriptDataSupportedInEra era
supp Hash ScriptData
dHash)
                        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall era. ReferenceScript era
ReferenceScriptNone

fromByronTxOut :: Byron.TxOut -> TxOut ctx ByronEra
fromByronTxOut :: forall ctx. TxOut -> TxOut ctx ByronEra
fromByronTxOut (Byron.TxOut Address
addr Lovelace
value) =
  forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
    (forall witctx era.
AddressTypeInEra witctx era -> Address witctx -> AddressInEra era
AddressInEra forall era. AddressTypeInEra ByronAddr era
ByronAddressInAnyEra (Address -> Address ByronAddr
ByronAddress Address
addr))
    (forall era. OnlyAdaSupportedInEra era -> Lovelace -> TxOutValue era
TxOutAdaOnly OnlyAdaSupportedInEra ByronEra
AdaOnlyInByronEra (Lovelace -> Lovelace
fromByronLovelace Lovelace
value))
     forall ctx era. TxOutDatum ctx era
TxOutDatumNone forall era. ReferenceScript era
ReferenceScriptNone


toByronTxOut :: TxOut ctx ByronEra -> Maybe Byron.TxOut
toByronTxOut :: forall ctx. TxOut ctx ByronEra -> Maybe TxOut
toByronTxOut (TxOut (AddressInEra AddressTypeInEra addrtype ByronEra
ByronAddressInAnyEra (ByronAddress Address
addr))
                    (TxOutAdaOnly OnlyAdaSupportedInEra ByronEra
AdaOnlyInByronEra Lovelace
value) TxOutDatum ctx ByronEra
_ ReferenceScript ByronEra
_) =
    Address -> Lovelace -> TxOut
Byron.TxOut Address
addr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lovelace -> Maybe Lovelace
toByronLovelace Lovelace
value

toByronTxOut (TxOut (AddressInEra AddressTypeInEra addrtype ByronEra
ByronAddressInAnyEra (ByronAddress Address
_))
                    (TxOutValue MultiAssetSupportedInEra ByronEra
era Value
_) TxOutDatum ctx ByronEra
_ ReferenceScript ByronEra
_) = case MultiAssetSupportedInEra ByronEra
era of {}

toByronTxOut (TxOut (AddressInEra (ShelleyAddressInEra ShelleyBasedEra ByronEra
era) ShelleyAddress{})
                    TxOutValue ByronEra
_ TxOutDatum ctx ByronEra
_ ReferenceScript ByronEra
_) = case ShelleyBasedEra ByronEra
era of {}


toShelleyTxOut :: forall era ledgerera.
                  ShelleyLedgerEra era ~ ledgerera
               => ShelleyBasedEra era
               -> TxOut CtxUTxO era
               -> Ledger.TxOut ledgerera
toShelleyTxOut :: forall era ledgerera.
(ShelleyLedgerEra era ~ ledgerera) =>
ShelleyBasedEra era -> TxOut CtxUTxO era -> TxOut ledgerera
toShelleyTxOut ShelleyBasedEra era
era (TxOut AddressInEra era
_ (TxOutAdaOnly OnlyAdaSupportedInEra era
AdaOnlyInByronEra Lovelace
_) TxOutDatum CtxUTxO era
_ ReferenceScript era
_) =
    case ShelleyBasedEra era
era of {}

toShelleyTxOut ShelleyBasedEra era
_ (TxOut AddressInEra era
addr (TxOutAdaOnly OnlyAdaSupportedInEra era
AdaOnlyInShelleyEra Lovelace
value) TxOutDatum CtxUTxO era
_ ReferenceScript era
_) =
    forall era.
(HasCallStack, EraTxOut era) =>
Addr (Crypto era) -> Value era -> TxOut era
ShelleyTxOut (forall era. AddressInEra era -> Addr StandardCrypto
toShelleyAddr AddressInEra era
addr) (Lovelace -> Coin
toShelleyLovelace Lovelace
value)

toShelleyTxOut ShelleyBasedEra era
_ (TxOut AddressInEra era
addr (TxOutAdaOnly OnlyAdaSupportedInEra era
AdaOnlyInAllegraEra Lovelace
value) TxOutDatum CtxUTxO era
_ ReferenceScript era
_) =
    forall era.
(HasCallStack, EraTxOut era) =>
Addr (Crypto era) -> Value era -> TxOut era
ShelleyTxOut (forall era. AddressInEra era -> Addr StandardCrypto
toShelleyAddr AddressInEra era
addr) (Lovelace -> Coin
toShelleyLovelace Lovelace
value)

toShelleyTxOut ShelleyBasedEra era
_ (TxOut AddressInEra era
addr (TxOutValue MultiAssetSupportedInEra era
MultiAssetInMaryEra Value
value) TxOutDatum CtxUTxO era
_ ReferenceScript era
_) =
    forall era.
(HasCallStack, EraTxOut era) =>
Addr (Crypto era) -> Value era -> TxOut era
ShelleyTxOut (forall era. AddressInEra era -> Addr StandardCrypto
toShelleyAddr AddressInEra era
addr) (Value -> MaryValue StandardCrypto
toMaryValue Value
value)

toShelleyTxOut ShelleyBasedEra era
_ (TxOut AddressInEra era
addr (TxOutValue MultiAssetSupportedInEra era
MultiAssetInAlonzoEra Value
value) TxOutDatum CtxUTxO era
txoutdata ReferenceScript era
_) =
    forall era.
(Era era, Val (Value era), HasCallStack) =>
Addr (Crypto era)
-> Value era
-> StrictMaybe (DataHash (Crypto era))
-> AlonzoTxOut era
AlonzoTxOut (forall era. AddressInEra era -> Addr StandardCrypto
toShelleyAddr AddressInEra era
addr) (Value -> MaryValue StandardCrypto
toMaryValue Value
value)
                 (TxOutDatum CtxUTxO AlonzoEra
-> StrictMaybe (DataHash StandardCrypto)
toAlonzoTxOutDataHash TxOutDatum CtxUTxO era
txoutdata)

toShelleyTxOut ShelleyBasedEra era
era (TxOut AddressInEra era
addr (TxOutValue MultiAssetSupportedInEra era
MultiAssetInBabbageEra Value
value) TxOutDatum CtxUTxO era
txoutdata ReferenceScript era
refScript) =
    let cEra :: CardanoEra era
cEra = forall era. ShelleyBasedEra era -> CardanoEra era
shelleyBasedToCardanoEra ShelleyBasedEra era
era
    in forall era.
(Era era, Val (Value era), HasCallStack) =>
Addr (Crypto era)
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
BabbageTxOut (forall era. AddressInEra era -> Addr StandardCrypto
toShelleyAddr AddressInEra era
addr) (Value -> MaryValue StandardCrypto
toMaryValue Value
value)
                    (forall era.
(Crypto (ShelleyLedgerEra era) ~ StandardCrypto) =>
TxOutDatum CtxUTxO era -> Datum (ShelleyLedgerEra era)
toBabbageTxOutDatum TxOutDatum CtxUTxO era
txoutdata)
                    (forall era.
CardanoEra era
-> ReferenceScript era
-> StrictMaybe (Script (ShelleyLedgerEra era))
refScriptToShelleyScript CardanoEra era
cEra ReferenceScript era
refScript)

toShelleyTxOut ShelleyBasedEra era
era (TxOut AddressInEra era
addr (TxOutValue MultiAssetSupportedInEra era
MultiAssetInConwayEra Value
value) TxOutDatum CtxUTxO era
txoutdata ReferenceScript era
refScript) =
    let cEra :: CardanoEra era
cEra = forall era. ShelleyBasedEra era -> CardanoEra era
shelleyBasedToCardanoEra ShelleyBasedEra era
era
    in forall era.
(Era era, Val (Value era), HasCallStack) =>
Addr (Crypto era)
-> Value era
-> Datum era
-> StrictMaybe (Script era)
-> BabbageTxOut era
BabbageTxOut (forall era. AddressInEra era -> Addr StandardCrypto
toShelleyAddr AddressInEra era
addr) (Value -> MaryValue StandardCrypto
toMaryValue Value
value)
                     (forall era.
(Crypto (ShelleyLedgerEra era) ~ StandardCrypto) =>
TxOutDatum CtxUTxO era -> Datum (ShelleyLedgerEra era)
toBabbageTxOutDatum TxOutDatum CtxUTxO era
txoutdata) (forall era.
CardanoEra era
-> ReferenceScript era
-> StrictMaybe (Script (ShelleyLedgerEra era))
refScriptToShelleyScript CardanoEra era
cEra ReferenceScript era
refScript)

fromShelleyTxOut :: ShelleyLedgerEra era ~ ledgerera
                 => ShelleyBasedEra era
                 -> Core.TxOut ledgerera
                 -> TxOut ctx era
fromShelleyTxOut :: forall era ledgerera ctx.
(ShelleyLedgerEra era ~ ledgerera) =>
ShelleyBasedEra era -> TxOut ledgerera -> TxOut ctx era
fromShelleyTxOut ShelleyBasedEra era
era TxOut ledgerera
ledgerTxOut =
  case ShelleyBasedEra era
era of
    ShelleyBasedEra era
ShelleyBasedEraShelley ->
        forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut (forall era.
ShelleyBasedEra era -> Addr StandardCrypto -> AddressInEra era
fromShelleyAddr ShelleyBasedEra era
era Addr (Crypto (ShelleyEra StandardCrypto))
addr)
              (forall era. OnlyAdaSupportedInEra era -> Lovelace -> TxOutValue era
TxOutAdaOnly OnlyAdaSupportedInEra ShelleyEra
AdaOnlyInShelleyEra
                            (Coin -> Lovelace
fromShelleyLovelace Value (ShelleyEra StandardCrypto)
value))
               forall ctx era. TxOutDatum ctx era
TxOutDatumNone forall era. ReferenceScript era
ReferenceScriptNone
      where
        ShelleyTxOut Addr (Crypto (ShelleyEra StandardCrypto))
addr Value (ShelleyEra StandardCrypto)
value = TxOut ledgerera
ledgerTxOut

    ShelleyBasedEra era
ShelleyBasedEraAllegra ->
        forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut (forall era.
ShelleyBasedEra era -> Addr StandardCrypto -> AddressInEra era
fromShelleyAddr ShelleyBasedEra era
era Addr (Crypto (ShelleyMAEra 'Allegra StandardCrypto))
addr)
              (forall era. OnlyAdaSupportedInEra era -> Lovelace -> TxOutValue era
TxOutAdaOnly OnlyAdaSupportedInEra AllegraEra
AdaOnlyInAllegraEra
                            (Coin -> Lovelace
fromShelleyLovelace Value (ShelleyMAEra 'Allegra StandardCrypto)
value))
               forall ctx era. TxOutDatum ctx era
TxOutDatumNone forall era. ReferenceScript era
ReferenceScriptNone
      where
        ShelleyTxOut Addr (Crypto (ShelleyMAEra 'Allegra StandardCrypto))
addr Value (ShelleyMAEra 'Allegra StandardCrypto)
value = TxOut ledgerera
ledgerTxOut

    ShelleyBasedEra era
ShelleyBasedEraMary ->
        forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut (forall era.
ShelleyBasedEra era -> Addr StandardCrypto -> AddressInEra era
fromShelleyAddr ShelleyBasedEra era
era Addr (Crypto (ShelleyMAEra 'Mary StandardCrypto))
addr)
              (forall era. MultiAssetSupportedInEra era -> Value -> TxOutValue era
TxOutValue MultiAssetSupportedInEra MaryEra
MultiAssetInMaryEra
                          (MaryValue StandardCrypto -> Value
fromMaryValue Value (ShelleyMAEra 'Mary StandardCrypto)
value))
               forall ctx era. TxOutDatum ctx era
TxOutDatumNone forall era. ReferenceScript era
ReferenceScriptNone
      where
        ShelleyTxOut Addr (Crypto (ShelleyMAEra 'Mary StandardCrypto))
addr Value (ShelleyMAEra 'Mary StandardCrypto)
value = TxOut ledgerera
ledgerTxOut

    ShelleyBasedEra era
ShelleyBasedEraAlonzo ->
       forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut (forall era.
ShelleyBasedEra era -> Addr StandardCrypto -> AddressInEra era
fromShelleyAddr ShelleyBasedEra era
era Addr (Crypto (AlonzoEra StandardCrypto))
addr)
             (forall era. MultiAssetSupportedInEra era -> Value -> TxOutValue era
TxOutValue MultiAssetSupportedInEra AlonzoEra
MultiAssetInAlonzoEra
                         (MaryValue StandardCrypto -> Value
fromMaryValue Value (AlonzoEra StandardCrypto)
value))
             (forall era ctx.
ScriptDataSupportedInEra era
-> StrictMaybe (DataHash StandardCrypto) -> TxOutDatum ctx era
fromAlonzoTxOutDataHash ScriptDataSupportedInEra AlonzoEra
ScriptDataInAlonzoEra StrictMaybe (DataHash (Crypto (AlonzoEra StandardCrypto)))
datahash)
             forall era. ReferenceScript era
ReferenceScriptNone
      where
        AlonzoTxOut Addr (Crypto (AlonzoEra StandardCrypto))
addr Value (AlonzoEra StandardCrypto)
value StrictMaybe (DataHash (Crypto (AlonzoEra StandardCrypto)))
datahash = TxOut ledgerera
ledgerTxOut

    ShelleyBasedEra era
ShelleyBasedEraBabbage ->
       forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut (forall era.
ShelleyBasedEra era -> Addr StandardCrypto -> AddressInEra era
fromShelleyAddr ShelleyBasedEra era
era Addr (Crypto (BabbageEra StandardCrypto))
addr)
             (forall era. MultiAssetSupportedInEra era -> Value -> TxOutValue era
TxOutValue MultiAssetSupportedInEra BabbageEra
MultiAssetInBabbageEra
                         (MaryValue StandardCrypto -> Value
fromMaryValue Value (BabbageEra StandardCrypto)
value))
             (forall ledgerera era ctx.
(Crypto ledgerera ~ StandardCrypto) =>
ScriptDataSupportedInEra era
-> ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> Datum ledgerera
-> TxOutDatum ctx era
fromBabbageTxOutDatum
               ScriptDataSupportedInEra BabbageEra
ScriptDataInBabbageEra
               ReferenceTxInsScriptsInlineDatumsSupportedInEra BabbageEra
ReferenceTxInsScriptsInlineDatumsInBabbageEra
               Datum (BabbageEra StandardCrypto)
datum)
             (case StrictMaybe (Script (BabbageEra StandardCrypto))
mRefScript of
                StrictMaybe (Script (BabbageEra StandardCrypto))
SNothing -> forall era. ReferenceScript era
ReferenceScriptNone
                SJust Script (BabbageEra StandardCrypto)
refScript ->
                  forall era.
ShelleyBasedEra era
-> Script (ShelleyLedgerEra era) -> ReferenceScript era
fromShelleyScriptToReferenceScript ShelleyBasedEra BabbageEra
ShelleyBasedEraBabbage Script (BabbageEra StandardCrypto)
refScript)
      where
        BabbageTxOut Addr (Crypto (BabbageEra StandardCrypto))
addr Value (BabbageEra StandardCrypto)
value Datum (BabbageEra StandardCrypto)
datum StrictMaybe (Script (BabbageEra StandardCrypto))
mRefScript = TxOut ledgerera
ledgerTxOut

    ShelleyBasedEra era
ShelleyBasedEraConway ->
       forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut (forall era.
ShelleyBasedEra era -> Addr StandardCrypto -> AddressInEra era
fromShelleyAddr ShelleyBasedEra era
era Addr (Crypto (ConwayEra StandardCrypto))
addr)
             (forall era. MultiAssetSupportedInEra era -> Value -> TxOutValue era
TxOutValue MultiAssetSupportedInEra ConwayEra
MultiAssetInConwayEra
                         (MaryValue StandardCrypto -> Value
fromMaryValue Value (ConwayEra StandardCrypto)
value))
             (forall ledgerera era ctx.
(Crypto ledgerera ~ StandardCrypto) =>
ScriptDataSupportedInEra era
-> ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> Datum ledgerera
-> TxOutDatum ctx era
fromBabbageTxOutDatum
               ScriptDataSupportedInEra ConwayEra
ScriptDataInConwayEra
               ReferenceTxInsScriptsInlineDatumsSupportedInEra ConwayEra
ReferenceTxInsScriptsInlineDatumsInConwayEra
               Datum (ConwayEra StandardCrypto)
datum)
             (case StrictMaybe (Script (ConwayEra StandardCrypto))
mRefScript of
                StrictMaybe (Script (ConwayEra StandardCrypto))
SNothing -> forall era. ReferenceScript era
ReferenceScriptNone
                SJust Script (ConwayEra StandardCrypto)
refScript ->
                  forall era.
ShelleyBasedEra era
-> Script (ShelleyLedgerEra era) -> ReferenceScript era
fromShelleyScriptToReferenceScript ShelleyBasedEra ConwayEra
ShelleyBasedEraConway Script (ConwayEra StandardCrypto)
refScript)
      where
        BabbageTxOut Addr (Crypto (ConwayEra StandardCrypto))
addr Value (ConwayEra StandardCrypto)
value Datum (ConwayEra StandardCrypto)
datum StrictMaybe (Script (ConwayEra StandardCrypto))
mRefScript = TxOut ledgerera
ledgerTxOut


-- TODO: If ledger creates an open type family for datums
-- we can consolidate this function with the Babbage version
toAlonzoTxOutDataHash
  :: TxOutDatum CtxUTxO AlonzoEra
  -> StrictMaybe (Alonzo.DataHash StandardCrypto)
toAlonzoTxOutDataHash :: TxOutDatum CtxUTxO AlonzoEra
-> StrictMaybe (DataHash StandardCrypto)
toAlonzoTxOutDataHash  TxOutDatum CtxUTxO AlonzoEra
TxOutDatumNone                        = forall a. StrictMaybe a
SNothing
toAlonzoTxOutDataHash (TxOutDatumHash ScriptDataSupportedInEra AlonzoEra
_ (ScriptDataHash DataHash StandardCrypto
dh)) = forall a. a -> StrictMaybe a
SJust DataHash StandardCrypto
dh
toAlonzoTxOutDataHash (TxOutDatumInline ReferenceTxInsScriptsInlineDatumsSupportedInEra AlonzoEra
inlineDatumSupp HashableScriptData
_sd) =
  case ReferenceTxInsScriptsInlineDatumsSupportedInEra AlonzoEra
inlineDatumSupp :: ReferenceTxInsScriptsInlineDatumsSupportedInEra AlonzoEra of {}

fromAlonzoTxOutDataHash :: ScriptDataSupportedInEra era
                        -> StrictMaybe (Alonzo.DataHash StandardCrypto)
                        -> TxOutDatum ctx era
fromAlonzoTxOutDataHash :: forall era ctx.
ScriptDataSupportedInEra era
-> StrictMaybe (DataHash StandardCrypto) -> TxOutDatum ctx era
fromAlonzoTxOutDataHash ScriptDataSupportedInEra era
_    StrictMaybe (DataHash StandardCrypto)
SNothing  = forall ctx era. TxOutDatum ctx era
TxOutDatumNone
fromAlonzoTxOutDataHash ScriptDataSupportedInEra era
s (SJust DataHash StandardCrypto
dh)   = forall era ctx.
ScriptDataSupportedInEra era
-> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash ScriptDataSupportedInEra era
s (DataHash StandardCrypto -> Hash ScriptData
ScriptDataHash DataHash StandardCrypto
dh)

-- TODO: If ledger creates an open type family for datums
-- we can consolidate this function with the Alonzo version
toBabbageTxOutDatum
  :: Ledger.Crypto (ShelleyLedgerEra era) ~ StandardCrypto
  => TxOutDatum CtxUTxO era -> Babbage.Datum (ShelleyLedgerEra era)
toBabbageTxOutDatum :: forall era.
(Crypto (ShelleyLedgerEra era) ~ StandardCrypto) =>
TxOutDatum CtxUTxO era -> Datum (ShelleyLedgerEra era)
toBabbageTxOutDatum  TxOutDatum CtxUTxO era
TxOutDatumNone = forall era. Datum era
Babbage.NoDatum
toBabbageTxOutDatum (TxOutDatumHash ScriptDataSupportedInEra era
_ (ScriptDataHash DataHash StandardCrypto
dh)) = forall era. DataHash (Crypto era) -> Datum era
Babbage.DatumHash DataHash StandardCrypto
dh
toBabbageTxOutDatum (TxOutDatumInline ReferenceTxInsScriptsInlineDatumsSupportedInEra era
_ HashableScriptData
sd) = forall ledgerera. HashableScriptData -> Datum ledgerera
scriptDataToInlineDatum HashableScriptData
sd

fromBabbageTxOutDatum
  :: Ledger.Crypto ledgerera ~ StandardCrypto
  => ScriptDataSupportedInEra era
  -> ReferenceTxInsScriptsInlineDatumsSupportedInEra era
  -> Babbage.Datum ledgerera
  -> TxOutDatum ctx era
fromBabbageTxOutDatum :: forall ledgerera era ctx.
(Crypto ledgerera ~ StandardCrypto) =>
ScriptDataSupportedInEra era
-> ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> Datum ledgerera
-> TxOutDatum ctx era
fromBabbageTxOutDatum ScriptDataSupportedInEra era
_ ReferenceTxInsScriptsInlineDatumsSupportedInEra era
_ Datum ledgerera
Babbage.NoDatum = forall ctx era. TxOutDatum ctx era
TxOutDatumNone
fromBabbageTxOutDatum ScriptDataSupportedInEra era
supp ReferenceTxInsScriptsInlineDatumsSupportedInEra era
_ (Babbage.DatumHash DataHash (Crypto ledgerera)
dh) =
  forall era ctx.
ScriptDataSupportedInEra era
-> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash ScriptDataSupportedInEra era
supp forall a b. (a -> b) -> a -> b
$ DataHash StandardCrypto -> Hash ScriptData
ScriptDataHash DataHash (Crypto ledgerera)
dh
fromBabbageTxOutDatum ScriptDataSupportedInEra era
_ ReferenceTxInsScriptsInlineDatumsSupportedInEra era
supp (Babbage.Datum BinaryData ledgerera
binData) =
  forall era ctx.
ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline ReferenceTxInsScriptsInlineDatumsSupportedInEra era
supp forall a b. (a -> b) -> a -> b
$ forall era ledgerera.
ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> BinaryData ledgerera -> HashableScriptData
binaryDataToScriptData ReferenceTxInsScriptsInlineDatumsSupportedInEra era
supp BinaryData ledgerera
binData



-- ----------------------------------------------------------------------------
-- Era-dependent transaction body features
--

-- | A representation of whether the era supports transactions with inputs used
-- only for collateral for script fees.
--
-- The Alonzo and subsequent eras support collateral inputs.
--
data CollateralSupportedInEra era where

     CollateralInAlonzoEra  :: CollateralSupportedInEra AlonzoEra
     CollateralInBabbageEra :: CollateralSupportedInEra BabbageEra
     CollateralInConwayEra  :: CollateralSupportedInEra ConwayEra

deriving instance Eq   (CollateralSupportedInEra era)
deriving instance Show (CollateralSupportedInEra era)

collateralSupportedInEra :: CardanoEra era
                         -> Maybe (CollateralSupportedInEra era)
collateralSupportedInEra :: forall era. CardanoEra era -> Maybe (CollateralSupportedInEra era)
collateralSupportedInEra CardanoEra era
ByronEra   = forall a. Maybe a
Nothing
collateralSupportedInEra CardanoEra era
ShelleyEra = forall a. Maybe a
Nothing
collateralSupportedInEra CardanoEra era
AllegraEra = forall a. Maybe a
Nothing
collateralSupportedInEra CardanoEra era
MaryEra    = forall a. Maybe a
Nothing
collateralSupportedInEra CardanoEra era
AlonzoEra  = forall a. a -> Maybe a
Just CollateralSupportedInEra AlonzoEra
CollateralInAlonzoEra
collateralSupportedInEra CardanoEra era
BabbageEra = forall a. a -> Maybe a
Just CollateralSupportedInEra BabbageEra
CollateralInBabbageEra
collateralSupportedInEra CardanoEra era
ConwayEra = forall a. a -> Maybe a
Just CollateralSupportedInEra ConwayEra
CollateralInConwayEra


-- | A representation of whether the era supports multi-asset transactions.
--
-- The Mary and subsequent eras support multi-asset transactions.
--
-- The negation of this is 'OnlyAdaSupportedInEra'.
--
data MultiAssetSupportedInEra era where

     -- | Multi-asset transactions are supported in the 'Mary' era.
     MultiAssetInMaryEra :: MultiAssetSupportedInEra MaryEra

     -- | Multi-asset transactions are supported in the 'Alonzo' era.
     MultiAssetInAlonzoEra :: MultiAssetSupportedInEra AlonzoEra

     -- | Multi-asset transactions are supported in the 'Babbage' era.
     MultiAssetInBabbageEra :: MultiAssetSupportedInEra BabbageEra

     -- | Multi-asset transactions are supported in the 'Conway' era.
     MultiAssetInConwayEra :: MultiAssetSupportedInEra ConwayEra

deriving instance Eq   (MultiAssetSupportedInEra era)
deriving instance Show (MultiAssetSupportedInEra era)

instance ToJSON (MultiAssetSupportedInEra era) where
  toJSON :: MultiAssetSupportedInEra era -> Value
toJSON = Text -> Value
Aeson.String forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
Text.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show

-- | A representation of whether the era supports only ada transactions.
--
-- Prior to the Mary era only ada transactions are supported. Multi-assets are
-- supported from the Mary era onwards.
--
-- This is the negation of 'MultiAssetSupportedInEra'. It exists since we need
-- evidence to be positive.
--
data OnlyAdaSupportedInEra era where

     AdaOnlyInByronEra   :: OnlyAdaSupportedInEra ByronEra
     AdaOnlyInShelleyEra :: OnlyAdaSupportedInEra ShelleyEra
     AdaOnlyInAllegraEra :: OnlyAdaSupportedInEra AllegraEra

deriving instance Eq   (OnlyAdaSupportedInEra era)
deriving instance Show (OnlyAdaSupportedInEra era)

multiAssetSupportedInEra :: CardanoEra era
                         -> Either (OnlyAdaSupportedInEra era)
                                   (MultiAssetSupportedInEra era)
multiAssetSupportedInEra :: forall era.
CardanoEra era
-> Either
     (OnlyAdaSupportedInEra era) (MultiAssetSupportedInEra era)
multiAssetSupportedInEra CardanoEra era
ByronEra   = forall a b. a -> Either a b
Left OnlyAdaSupportedInEra ByronEra
AdaOnlyInByronEra
multiAssetSupportedInEra CardanoEra era
ShelleyEra = forall a b. a -> Either a b
Left OnlyAdaSupportedInEra ShelleyEra
AdaOnlyInShelleyEra
multiAssetSupportedInEra CardanoEra era
AllegraEra = forall a b. a -> Either a b
Left OnlyAdaSupportedInEra AllegraEra
AdaOnlyInAllegraEra
multiAssetSupportedInEra CardanoEra era
MaryEra    = forall a b. b -> Either a b
Right MultiAssetSupportedInEra MaryEra
MultiAssetInMaryEra
multiAssetSupportedInEra CardanoEra era
AlonzoEra  = forall a b. b -> Either a b
Right MultiAssetSupportedInEra AlonzoEra
MultiAssetInAlonzoEra
multiAssetSupportedInEra CardanoEra era
BabbageEra = forall a b. b -> Either a b
Right MultiAssetSupportedInEra BabbageEra
MultiAssetInBabbageEra
multiAssetSupportedInEra CardanoEra era
ConwayEra = forall a b. b -> Either a b
Right MultiAssetSupportedInEra ConwayEra
MultiAssetInConwayEra


-- | A representation of whether the era requires explicitly specified fees in
-- transactions.
--
-- The Byron era tx fees are implicit (as the difference bettween the sum of
-- outputs and sum of inputs), but all later eras the fees are specified in the
-- transaction explicitly.
--
data TxFeesExplicitInEra era where

     TxFeesExplicitInShelleyEra :: TxFeesExplicitInEra ShelleyEra
     TxFeesExplicitInAllegraEra :: TxFeesExplicitInEra AllegraEra
     TxFeesExplicitInMaryEra    :: TxFeesExplicitInEra MaryEra
     TxFeesExplicitInAlonzoEra  :: TxFeesExplicitInEra AlonzoEra
     TxFeesExplicitInBabbageEra :: TxFeesExplicitInEra BabbageEra
     TxFeesExplicitInConwayEra  :: TxFeesExplicitInEra ConwayEra

deriving instance Eq   (TxFeesExplicitInEra era)
deriving instance Show (TxFeesExplicitInEra era)

-- | A representation of whether the era requires implicitly specified fees in
-- transactions.
--
-- This is the negation of 'TxFeesExplicitInEra'.
--
data TxFeesImplicitInEra era where
     TxFeesImplicitInByronEra :: TxFeesImplicitInEra ByronEra

deriving instance Eq   (TxFeesImplicitInEra era)
deriving instance Show (TxFeesImplicitInEra era)

txFeesExplicitInEra :: CardanoEra era
                    -> Either (TxFeesImplicitInEra era)
                              (TxFeesExplicitInEra era)
txFeesExplicitInEra :: forall era.
CardanoEra era
-> Either (TxFeesImplicitInEra era) (TxFeesExplicitInEra era)
txFeesExplicitInEra CardanoEra era
ByronEra   = forall a b. a -> Either a b
Left  TxFeesImplicitInEra ByronEra
TxFeesImplicitInByronEra
txFeesExplicitInEra CardanoEra era
ShelleyEra = forall a b. b -> Either a b
Right TxFeesExplicitInEra ShelleyEra
TxFeesExplicitInShelleyEra
txFeesExplicitInEra CardanoEra era
AllegraEra = forall a b. b -> Either a b
Right TxFeesExplicitInEra AllegraEra
TxFeesExplicitInAllegraEra
txFeesExplicitInEra CardanoEra era
MaryEra    = forall a b. b -> Either a b
Right TxFeesExplicitInEra MaryEra
TxFeesExplicitInMaryEra
txFeesExplicitInEra CardanoEra era
AlonzoEra  = forall a b. b -> Either a b
Right TxFeesExplicitInEra AlonzoEra
TxFeesExplicitInAlonzoEra
txFeesExplicitInEra CardanoEra era
BabbageEra = forall a b. b -> Either a b
Right TxFeesExplicitInEra BabbageEra
TxFeesExplicitInBabbageEra
txFeesExplicitInEra CardanoEra era
ConwayEra = forall a b. b -> Either a b
Right TxFeesExplicitInEra ConwayEra
TxFeesExplicitInConwayEra


-- | A representation of whether the era supports transactions with an upper
-- bound on the range of slots in which they are valid.
--
-- The Shelley and subsequent eras support an upper bound on the validity
-- range. In the Shelley era specifically it is actually required. It is
-- optional in later eras.
--
data ValidityUpperBoundSupportedInEra era where

     ValidityUpperBoundInShelleyEra :: ValidityUpperBoundSupportedInEra ShelleyEra
     ValidityUpperBoundInAllegraEra :: ValidityUpperBoundSupportedInEra AllegraEra
     ValidityUpperBoundInMaryEra    :: ValidityUpperBoundSupportedInEra MaryEra
     ValidityUpperBoundInAlonzoEra  :: ValidityUpperBoundSupportedInEra AlonzoEra
     ValidityUpperBoundInBabbageEra :: ValidityUpperBoundSupportedInEra BabbageEra
     ValidityUpperBoundInConwayEra :: ValidityUpperBoundSupportedInEra ConwayEra

deriving instance Eq   (ValidityUpperBoundSupportedInEra era)
deriving instance Show (ValidityUpperBoundSupportedInEra era)

validityUpperBoundSupportedInEra :: CardanoEra era
                                 -> Maybe (ValidityUpperBoundSupportedInEra era)
validityUpperBoundSupportedInEra :: forall era.
CardanoEra era -> Maybe (ValidityUpperBoundSupportedInEra era)
validityUpperBoundSupportedInEra CardanoEra era
ByronEra   = forall a. Maybe a
Nothing
validityUpperBoundSupportedInEra CardanoEra era
ShelleyEra = forall a. a -> Maybe a
Just ValidityUpperBoundSupportedInEra ShelleyEra
ValidityUpperBoundInShelleyEra
validityUpperBoundSupportedInEra CardanoEra era
AllegraEra = forall a. a -> Maybe a
Just ValidityUpperBoundSupportedInEra AllegraEra
ValidityUpperBoundInAllegraEra
validityUpperBoundSupportedInEra CardanoEra era
MaryEra    = forall a. a -> Maybe a
Just ValidityUpperBoundSupportedInEra MaryEra
ValidityUpperBoundInMaryEra
validityUpperBoundSupportedInEra CardanoEra era
AlonzoEra  = forall a. a -> Maybe a
Just ValidityUpperBoundSupportedInEra AlonzoEra
ValidityUpperBoundInAlonzoEra
validityUpperBoundSupportedInEra CardanoEra era
BabbageEra = forall a. a -> Maybe a
Just ValidityUpperBoundSupportedInEra BabbageEra
ValidityUpperBoundInBabbageEra
validityUpperBoundSupportedInEra CardanoEra era
ConwayEra = forall a. a -> Maybe a
Just ValidityUpperBoundSupportedInEra ConwayEra
ValidityUpperBoundInConwayEra


-- | A representation of whether the era supports transactions having /no/
-- upper bound on the range of slots in which they are valid.
--
-- Note that the 'ShelleyEra' /does not support/ omitting a validity upper
-- bound. It was introduced as a /required/ field in Shelley and then made
-- optional in Allegra and subsequent eras.
--
-- The Byron era supports this by virtue of the fact that it does not support
-- validity ranges at all.
--
data ValidityNoUpperBoundSupportedInEra era where

     ValidityNoUpperBoundInByronEra   :: ValidityNoUpperBoundSupportedInEra ByronEra
     ValidityNoUpperBoundInAllegraEra :: ValidityNoUpperBoundSupportedInEra AllegraEra
     ValidityNoUpperBoundInMaryEra    :: ValidityNoUpperBoundSupportedInEra MaryEra
     ValidityNoUpperBoundInAlonzoEra  :: ValidityNoUpperBoundSupportedInEra AlonzoEra
     ValidityNoUpperBoundInBabbageEra :: ValidityNoUpperBoundSupportedInEra BabbageEra
     ValidityNoUpperBoundInConwayEra  :: ValidityNoUpperBoundSupportedInEra ConwayEra

deriving instance Eq   (ValidityNoUpperBoundSupportedInEra era)
deriving instance Show (ValidityNoUpperBoundSupportedInEra era)

validityNoUpperBoundSupportedInEra :: CardanoEra era
                                   -> Maybe (ValidityNoUpperBoundSupportedInEra era)
validityNoUpperBoundSupportedInEra :: forall era.
CardanoEra era -> Maybe (ValidityNoUpperBoundSupportedInEra era)
validityNoUpperBoundSupportedInEra CardanoEra era
ByronEra   = forall a. a -> Maybe a
Just ValidityNoUpperBoundSupportedInEra ByronEra
ValidityNoUpperBoundInByronEra
validityNoUpperBoundSupportedInEra CardanoEra era
ShelleyEra = forall a. Maybe a
Nothing
validityNoUpperBoundSupportedInEra CardanoEra era
AllegraEra = forall a. a -> Maybe a
Just ValidityNoUpperBoundSupportedInEra AllegraEra
ValidityNoUpperBoundInAllegraEra
validityNoUpperBoundSupportedInEra CardanoEra era
MaryEra    = forall a. a -> Maybe a
Just ValidityNoUpperBoundSupportedInEra MaryEra
ValidityNoUpperBoundInMaryEra
validityNoUpperBoundSupportedInEra CardanoEra era
AlonzoEra  = forall a. a -> Maybe a
Just ValidityNoUpperBoundSupportedInEra AlonzoEra
ValidityNoUpperBoundInAlonzoEra
validityNoUpperBoundSupportedInEra CardanoEra era
BabbageEra = forall a. a -> Maybe a
Just ValidityNoUpperBoundSupportedInEra BabbageEra
ValidityNoUpperBoundInBabbageEra
validityNoUpperBoundSupportedInEra CardanoEra era
ConwayEra = forall a. a -> Maybe a
Just ValidityNoUpperBoundSupportedInEra ConwayEra
ValidityNoUpperBoundInConwayEra


-- | A representation of whether the era supports transactions with a lower
-- bound on the range of slots in which they are valid.
--
-- The Allegra and subsequent eras support an optional lower bound on the
-- validity range. No equivalent of 'ValidityNoUpperBoundSupportedInEra' is
-- needed since all eras support having no lower bound.
--
data ValidityLowerBoundSupportedInEra era where

     ValidityLowerBoundInAllegraEra :: ValidityLowerBoundSupportedInEra AllegraEra
     ValidityLowerBoundInMaryEra    :: ValidityLowerBoundSupportedInEra MaryEra
     ValidityLowerBoundInAlonzoEra  :: ValidityLowerBoundSupportedInEra AlonzoEra
     ValidityLowerBoundInBabbageEra :: ValidityLowerBoundSupportedInEra BabbageEra
     ValidityLowerBoundInConwayEra  :: ValidityLowerBoundSupportedInEra ConwayEra

deriving instance Eq   (ValidityLowerBoundSupportedInEra era)
deriving instance Show (ValidityLowerBoundSupportedInEra era)

validityLowerBoundSupportedInEra :: CardanoEra era
                                 -> Maybe (ValidityLowerBoundSupportedInEra era)
validityLowerBoundSupportedInEra :: forall era.
CardanoEra era -> Maybe (ValidityLowerBoundSupportedInEra era)
validityLowerBoundSupportedInEra CardanoEra era
ByronEra   = forall a. Maybe a
Nothing
validityLowerBoundSupportedInEra CardanoEra era
ShelleyEra = forall a. Maybe a
Nothing
validityLowerBoundSupportedInEra CardanoEra era
AllegraEra = forall a. a -> Maybe a
Just ValidityLowerBoundSupportedInEra AllegraEra
ValidityLowerBoundInAllegraEra
validityLowerBoundSupportedInEra CardanoEra era
MaryEra    = forall a. a -> Maybe a
Just ValidityLowerBoundSupportedInEra MaryEra
ValidityLowerBoundInMaryEra
validityLowerBoundSupportedInEra CardanoEra era
AlonzoEra  = forall a. a -> Maybe a
Just ValidityLowerBoundSupportedInEra AlonzoEra
ValidityLowerBoundInAlonzoEra
validityLowerBoundSupportedInEra CardanoEra era
BabbageEra = forall a. a -> Maybe a
Just ValidityLowerBoundSupportedInEra BabbageEra
ValidityLowerBoundInBabbageEra
validityLowerBoundSupportedInEra CardanoEra era
ConwayEra  = forall a. a -> Maybe a
Just ValidityLowerBoundSupportedInEra ConwayEra
ValidityLowerBoundInConwayEra

-- | A representation of whether the era supports transaction metadata.
--
-- Transaction metadata is supported from the Shelley era onwards.
--
data TxMetadataSupportedInEra era where

     TxMetadataInShelleyEra :: TxMetadataSupportedInEra ShelleyEra
     TxMetadataInAllegraEra :: TxMetadataSupportedInEra AllegraEra
     TxMetadataInMaryEra    :: TxMetadataSupportedInEra MaryEra
     TxMetadataInAlonzoEra  :: TxMetadataSupportedInEra AlonzoEra
     TxMetadataInBabbageEra :: TxMetadataSupportedInEra BabbageEra
     TxMetadataInConwayEra  :: TxMetadataSupportedInEra ConwayEra

deriving instance Eq   (TxMetadataSupportedInEra era)
deriving instance Show (TxMetadataSupportedInEra era)

txMetadataSupportedInEra :: CardanoEra era
                         -> Maybe (TxMetadataSupportedInEra era)
txMetadataSupportedInEra :: forall era. CardanoEra era -> Maybe (TxMetadataSupportedInEra era)
txMetadataSupportedInEra CardanoEra era
ByronEra   = forall a. Maybe a
Nothing
txMetadataSupportedInEra CardanoEra era
ShelleyEra = forall a. a -> Maybe a
Just TxMetadataSupportedInEra ShelleyEra
TxMetadataInShelleyEra
txMetadataSupportedInEra CardanoEra era
AllegraEra = forall a. a -> Maybe a
Just TxMetadataSupportedInEra AllegraEra
TxMetadataInAllegraEra
txMetadataSupportedInEra CardanoEra era
MaryEra    = forall a. a -> Maybe a
Just TxMetadataSupportedInEra MaryEra
TxMetadataInMaryEra
txMetadataSupportedInEra CardanoEra era
AlonzoEra  = forall a. a -> Maybe a
Just TxMetadataSupportedInEra AlonzoEra
TxMetadataInAlonzoEra
txMetadataSupportedInEra CardanoEra era
BabbageEra = forall a. a -> Maybe a
Just TxMetadataSupportedInEra BabbageEra
TxMetadataInBabbageEra
txMetadataSupportedInEra CardanoEra era
ConwayEra  = forall a. a -> Maybe a
Just TxMetadataSupportedInEra ConwayEra
TxMetadataInConwayEra


-- | A representation of whether the era supports auxiliary scripts in
-- transactions.
--
-- Auxiliary scripts are supported from the Allegra era onwards.
--
data AuxScriptsSupportedInEra era where

     AuxScriptsInAllegraEra :: AuxScriptsSupportedInEra AllegraEra
     AuxScriptsInMaryEra    :: AuxScriptsSupportedInEra MaryEra
     AuxScriptsInAlonzoEra  :: AuxScriptsSupportedInEra AlonzoEra
     AuxScriptsInBabbageEra :: AuxScriptsSupportedInEra BabbageEra
     AuxScriptsInConwayEra  :: AuxScriptsSupportedInEra ConwayEra

deriving instance Eq   (AuxScriptsSupportedInEra era)
deriving instance Show (AuxScriptsSupportedInEra era)

auxScriptsSupportedInEra :: CardanoEra era
                         -> Maybe (AuxScriptsSupportedInEra era)
auxScriptsSupportedInEra :: forall era. CardanoEra era -> Maybe (AuxScriptsSupportedInEra era)
auxScriptsSupportedInEra CardanoEra era
ByronEra   = forall a. Maybe a
Nothing
auxScriptsSupportedInEra CardanoEra era
ShelleyEra = forall a. Maybe a
Nothing
auxScriptsSupportedInEra CardanoEra era
AllegraEra = forall a. a -> Maybe a
Just AuxScriptsSupportedInEra AllegraEra
AuxScriptsInAllegraEra
auxScriptsSupportedInEra CardanoEra era
MaryEra    = forall a. a -> Maybe a
Just AuxScriptsSupportedInEra MaryEra
AuxScriptsInMaryEra
auxScriptsSupportedInEra CardanoEra era
AlonzoEra  = forall a. a -> Maybe a
Just AuxScriptsSupportedInEra AlonzoEra
AuxScriptsInAlonzoEra
auxScriptsSupportedInEra CardanoEra era
BabbageEra = forall a. a -> Maybe a
Just AuxScriptsSupportedInEra BabbageEra
AuxScriptsInBabbageEra
auxScriptsSupportedInEra CardanoEra era
ConwayEra  = forall a. a -> Maybe a
Just AuxScriptsSupportedInEra ConwayEra
AuxScriptsInConwayEra


-- | A representation of whether the era supports transactions that specify
-- in the body that they need extra key witnesses, and where this fact is
-- visible to scripts.
--
-- Extra key witnesses visible to scripts are supported from the Alonzo era
-- onwards.
--
data TxExtraKeyWitnessesSupportedInEra era where

     ExtraKeyWitnessesInAlonzoEra  :: TxExtraKeyWitnessesSupportedInEra AlonzoEra
     ExtraKeyWitnessesInBabbageEra :: TxExtraKeyWitnessesSupportedInEra BabbageEra
     ExtraKeyWitnessesInConwayEra  :: TxExtraKeyWitnessesSupportedInEra ConwayEra

deriving instance Eq   (TxExtraKeyWitnessesSupportedInEra era)
deriving instance Show (TxExtraKeyWitnessesSupportedInEra era)

extraKeyWitnessesSupportedInEra :: CardanoEra era
                                -> Maybe (TxExtraKeyWitnessesSupportedInEra era)
extraKeyWitnessesSupportedInEra :: forall era.
CardanoEra era -> Maybe (TxExtraKeyWitnessesSupportedInEra era)
extraKeyWitnessesSupportedInEra CardanoEra era
ByronEra   = forall a. Maybe a
Nothing
extraKeyWitnessesSupportedInEra CardanoEra era
ShelleyEra = forall a. Maybe a
Nothing
extraKeyWitnessesSupportedInEra CardanoEra era
AllegraEra = forall a. Maybe a
Nothing
extraKeyWitnessesSupportedInEra CardanoEra era
MaryEra    = forall a. Maybe a
Nothing
extraKeyWitnessesSupportedInEra CardanoEra era
AlonzoEra  = forall a. a -> Maybe a
Just TxExtraKeyWitnessesSupportedInEra AlonzoEra
ExtraKeyWitnessesInAlonzoEra
extraKeyWitnessesSupportedInEra CardanoEra era
BabbageEra = forall a. a -> Maybe a
Just TxExtraKeyWitnessesSupportedInEra BabbageEra
ExtraKeyWitnessesInBabbageEra
extraKeyWitnessesSupportedInEra CardanoEra era
ConwayEra  = forall a. a -> Maybe a
Just TxExtraKeyWitnessesSupportedInEra ConwayEra
ExtraKeyWitnessesInConwayEra


-- | A representation of whether the era supports script data in transactions.
data ScriptDataSupportedInEra era where

     -- | Script data is supported in transactions in the 'Alonzo' era.
     ScriptDataInAlonzoEra  :: ScriptDataSupportedInEra AlonzoEra
     ScriptDataInBabbageEra :: ScriptDataSupportedInEra BabbageEra
     ScriptDataInConwayEra :: ScriptDataSupportedInEra ConwayEra

deriving instance Eq   (ScriptDataSupportedInEra era)
deriving instance Show (ScriptDataSupportedInEra era)

scriptDataSupportedInEra :: CardanoEra era
                         -> Maybe (ScriptDataSupportedInEra era)
scriptDataSupportedInEra :: forall era. CardanoEra era -> Maybe (ScriptDataSupportedInEra era)
scriptDataSupportedInEra CardanoEra era
ByronEra   = forall a. Maybe a
Nothing
scriptDataSupportedInEra CardanoEra era
ShelleyEra = forall a. Maybe a
Nothing
scriptDataSupportedInEra CardanoEra era
AllegraEra = forall a. Maybe a
Nothing
scriptDataSupportedInEra CardanoEra era
MaryEra    = forall a. Maybe a
Nothing
scriptDataSupportedInEra CardanoEra era
AlonzoEra  = forall a. a -> Maybe a
Just ScriptDataSupportedInEra AlonzoEra
ScriptDataInAlonzoEra
scriptDataSupportedInEra CardanoEra era
BabbageEra = forall a. a -> Maybe a
Just ScriptDataSupportedInEra BabbageEra
ScriptDataInBabbageEra
scriptDataSupportedInEra CardanoEra era
ConwayEra  = forall a. a -> Maybe a
Just ScriptDataSupportedInEra ConwayEra
ScriptDataInConwayEra


-- | A representation of whether the era supports withdrawals from reward
-- accounts.
--
-- The Shelley and subsequent eras support stake addresses, their associated
-- reward accounts and support for withdrawals from them.
--
data WithdrawalsSupportedInEra era where

     WithdrawalsInShelleyEra :: WithdrawalsSupportedInEra ShelleyEra
     WithdrawalsInAllegraEra :: WithdrawalsSupportedInEra AllegraEra
     WithdrawalsInMaryEra    :: WithdrawalsSupportedInEra MaryEra
     WithdrawalsInAlonzoEra  :: WithdrawalsSupportedInEra AlonzoEra
     WithdrawalsInBabbageEra :: WithdrawalsSupportedInEra BabbageEra
     WithdrawalsInConwayEra :: WithdrawalsSupportedInEra ConwayEra

deriving instance Eq   (WithdrawalsSupportedInEra era)
deriving instance Show (WithdrawalsSupportedInEra era)

withdrawalsSupportedInEra :: CardanoEra era
                          -> Maybe (WithdrawalsSupportedInEra era)
withdrawalsSupportedInEra :: forall era. CardanoEra era -> Maybe (WithdrawalsSupportedInEra era)
withdrawalsSupportedInEra CardanoEra era
ByronEra   = forall a. Maybe a
Nothing
withdrawalsSupportedInEra CardanoEra era
ShelleyEra = forall a. a -> Maybe a
Just WithdrawalsSupportedInEra ShelleyEra
WithdrawalsInShelleyEra
withdrawalsSupportedInEra CardanoEra era
AllegraEra = forall a. a -> Maybe a
Just WithdrawalsSupportedInEra AllegraEra
WithdrawalsInAllegraEra
withdrawalsSupportedInEra CardanoEra era
MaryEra    = forall a. a -> Maybe a
Just WithdrawalsSupportedInEra MaryEra
WithdrawalsInMaryEra
withdrawalsSupportedInEra CardanoEra era
AlonzoEra  = forall a. a -> Maybe a
Just WithdrawalsSupportedInEra AlonzoEra
WithdrawalsInAlonzoEra
withdrawalsSupportedInEra CardanoEra era
BabbageEra = forall a. a -> Maybe a
Just WithdrawalsSupportedInEra BabbageEra
WithdrawalsInBabbageEra
withdrawalsSupportedInEra CardanoEra era
ConwayEra  = forall a. a -> Maybe a
Just WithdrawalsSupportedInEra ConwayEra
WithdrawalsInConwayEra


-- | A representation of whether the era supports 'Certificate's embedded in
-- transactions.
--
-- The Shelley and subsequent eras support such certificates.
--
data CertificatesSupportedInEra era where

     CertificatesInShelleyEra :: CertificatesSupportedInEra ShelleyEra
     CertificatesInAllegraEra :: CertificatesSupportedInEra AllegraEra
     CertificatesInMaryEra    :: CertificatesSupportedInEra MaryEra
     CertificatesInAlonzoEra  :: CertificatesSupportedInEra AlonzoEra
     CertificatesInBabbageEra :: CertificatesSupportedInEra BabbageEra
     CertificatesInConwayEra  :: CertificatesSupportedInEra ConwayEra

deriving instance Eq   (CertificatesSupportedInEra era)
deriving instance Show (CertificatesSupportedInEra era)

certificatesSupportedInEra :: CardanoEra era
                           -> Maybe (CertificatesSupportedInEra era)
certificatesSupportedInEra :: forall era.
CardanoEra era -> Maybe (CertificatesSupportedInEra era)
certificatesSupportedInEra CardanoEra era
ByronEra   = forall a. Maybe a
Nothing
certificatesSupportedInEra CardanoEra era
ShelleyEra = forall a. a -> Maybe a
Just CertificatesSupportedInEra ShelleyEra
CertificatesInShelleyEra
certificatesSupportedInEra CardanoEra era
AllegraEra = forall a. a -> Maybe a
Just CertificatesSupportedInEra AllegraEra
CertificatesInAllegraEra
certificatesSupportedInEra CardanoEra era
MaryEra    = forall a. a -> Maybe a
Just CertificatesSupportedInEra MaryEra
CertificatesInMaryEra
certificatesSupportedInEra CardanoEra era
AlonzoEra  = forall a. a -> Maybe a
Just CertificatesSupportedInEra AlonzoEra
CertificatesInAlonzoEra
certificatesSupportedInEra CardanoEra era
BabbageEra = forall a. a -> Maybe a
Just CertificatesSupportedInEra BabbageEra
CertificatesInBabbageEra
certificatesSupportedInEra CardanoEra era
ConwayEra  = forall a. a -> Maybe a
Just CertificatesSupportedInEra ConwayEra
CertificatesInConwayEra


-- | A representation of whether the era supports 'UpdateProposal's embedded in
-- transactions.
--
-- The Shelley and subsequent eras support such update proposals. They Byron
-- era has a notion of an update proposal, but it is a standalone chain object
-- and not embedded in a transaction.
--
data UpdateProposalSupportedInEra era where

     UpdateProposalInShelleyEra :: UpdateProposalSupportedInEra ShelleyEra
     UpdateProposalInAllegraEra :: UpdateProposalSupportedInEra AllegraEra
     UpdateProposalInMaryEra    :: UpdateProposalSupportedInEra MaryEra
     UpdateProposalInAlonzoEra  :: UpdateProposalSupportedInEra AlonzoEra
     UpdateProposalInBabbageEra :: UpdateProposalSupportedInEra BabbageEra
     UpdateProposalInConwayEra  :: UpdateProposalSupportedInEra ConwayEra

deriving instance Eq   (UpdateProposalSupportedInEra era)
deriving instance Show (UpdateProposalSupportedInEra era)

updateProposalSupportedInEra :: CardanoEra era
                             -> Maybe (UpdateProposalSupportedInEra era)
updateProposalSupportedInEra :: forall era.
CardanoEra era -> Maybe (UpdateProposalSupportedInEra era)
updateProposalSupportedInEra CardanoEra era
ByronEra   = forall a. Maybe a
Nothing
updateProposalSupportedInEra CardanoEra era
ShelleyEra = forall a. a -> Maybe a
Just UpdateProposalSupportedInEra ShelleyEra
UpdateProposalInShelleyEra
updateProposalSupportedInEra CardanoEra era
AllegraEra = forall a. a -> Maybe a
Just UpdateProposalSupportedInEra AllegraEra
UpdateProposalInAllegraEra
updateProposalSupportedInEra CardanoEra era
MaryEra    = forall a. a -> Maybe a
Just UpdateProposalSupportedInEra MaryEra
UpdateProposalInMaryEra
updateProposalSupportedInEra CardanoEra era
AlonzoEra  = forall a. a -> Maybe a
Just UpdateProposalSupportedInEra AlonzoEra
UpdateProposalInAlonzoEra
updateProposalSupportedInEra CardanoEra era
BabbageEra = forall a. a -> Maybe a
Just UpdateProposalSupportedInEra BabbageEra
UpdateProposalInBabbageEra
updateProposalSupportedInEra CardanoEra era
ConwayEra  = forall a. a -> Maybe a
Just UpdateProposalSupportedInEra ConwayEra
UpdateProposalInConwayEra

-- ----------------------------------------------------------------------------
-- Building vs viewing transactions
--

data BuildTx
data ViewTx

data BuildTxWith build a where

     ViewTx      ::      BuildTxWith ViewTx  a
     BuildTxWith :: a -> BuildTxWith BuildTx a

deriving instance Eq   a => Eq   (BuildTxWith build a)
deriving instance Show a => Show (BuildTxWith build a)

-- ----------------------------------------------------------------------------
-- Transaction input values (era-dependent)
--

type TxIns build era = [(TxIn, BuildTxWith build (Witness WitCtxTxIn era))]

data TxInsCollateral era where

     TxInsCollateralNone :: TxInsCollateral era

     TxInsCollateral     :: CollateralSupportedInEra era
                         -> [TxIn] -- Only key witnesses, no scripts.
                         -> TxInsCollateral era

deriving instance Eq   (TxInsCollateral era)
deriving instance Show (TxInsCollateral era)

data TxInsReference build era where

     TxInsReferenceNone :: TxInsReference build era

     TxInsReference     :: ReferenceTxInsScriptsInlineDatumsSupportedInEra era
                        -> [TxIn]
                        -> TxInsReference build era

deriving instance Eq   (TxInsReference build era)
deriving instance Show (TxInsReference build era)

-- ----------------------------------------------------------------------------
-- Transaction output values (era-dependent)
--

data TxOutValue era where

     TxOutAdaOnly :: OnlyAdaSupportedInEra era -> Lovelace -> TxOutValue era

     TxOutValue   :: MultiAssetSupportedInEra era -> Value -> TxOutValue era

instance EraCast TxOutValue where
  eraCast :: forall fromEra toEra.
(IsCardanoEra fromEra, IsCardanoEra toEra) =>
CardanoEra toEra
-> TxOutValue fromEra -> Either EraCastError (TxOutValue toEra)
eraCast CardanoEra toEra
toEra TxOutValue fromEra
v = case TxOutValue fromEra
v of
    TxOutAdaOnly OnlyAdaSupportedInEra fromEra
_previousEra Lovelace
lovelace ->
      case forall era.
CardanoEra era
-> Either
     (OnlyAdaSupportedInEra era) (MultiAssetSupportedInEra era)
multiAssetSupportedInEra CardanoEra toEra
toEra of
        Left OnlyAdaSupportedInEra toEra
adaOnly -> forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ forall era. OnlyAdaSupportedInEra era -> Lovelace -> TxOutValue era
TxOutAdaOnly OnlyAdaSupportedInEra toEra
adaOnly Lovelace
lovelace
        Right MultiAssetSupportedInEra toEra
multiAssetSupp -> forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ forall era. MultiAssetSupportedInEra era -> Value -> TxOutValue era
TxOutValue MultiAssetSupportedInEra toEra
multiAssetSupp forall a b. (a -> b) -> a -> b
$ Lovelace -> Value
lovelaceToValue Lovelace
lovelace
    TxOutValue  (MultiAssetSupportedInEra fromEra
_ :: MultiAssetSupportedInEra fromEra) Value
value  ->
      case forall era.
CardanoEra era
-> Either
     (OnlyAdaSupportedInEra era) (MultiAssetSupportedInEra era)
multiAssetSupportedInEra CardanoEra toEra
toEra of
        Left OnlyAdaSupportedInEra toEra
_adaOnly -> forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ forall fromEra toEra value.
(IsCardanoEra fromEra, IsCardanoEra toEra, Show value) =>
value -> CardanoEra fromEra -> CardanoEra toEra -> EraCastError
EraCastError TxOutValue fromEra
v (forall era. IsCardanoEra era => CardanoEra era
cardanoEra @fromEra) CardanoEra toEra
toEra
        Right MultiAssetSupportedInEra toEra
multiAssetSupp -> forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ forall era. MultiAssetSupportedInEra era -> Value -> TxOutValue era
TxOutValue MultiAssetSupportedInEra toEra
multiAssetSupp Value
value


deriving instance Eq   (TxOutValue era)
deriving instance Show (TxOutValue era)
deriving instance Generic (TxOutValue era)

instance ToJSON (TxOutValue era) where
  toJSON :: TxOutValue era -> Value
toJSON (TxOutAdaOnly OnlyAdaSupportedInEra era
_ Lovelace
ll) = forall a. ToJSON a => a -> Value
toJSON Lovelace
ll
  toJSON (TxOutValue MultiAssetSupportedInEra era
_ Value
val) = forall a. ToJSON a => a -> Value
toJSON Value
val

instance IsCardanoEra era => FromJSON (TxOutValue era) where
  parseJSON :: Value -> Parser (TxOutValue era)
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"TxOutValue" forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    case forall era.
CardanoEra era
-> Either
     (OnlyAdaSupportedInEra era) (MultiAssetSupportedInEra era)
multiAssetSupportedInEra forall era. IsCardanoEra era => CardanoEra era
cardanoEra of
      Left OnlyAdaSupportedInEra era
onlyAda -> do
        Value
ll <- Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"lovelace"
        forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall era. OnlyAdaSupportedInEra era -> Lovelace -> TxOutValue era
TxOutAdaOnly OnlyAdaSupportedInEra era
onlyAda forall a b. (a -> b) -> a -> b
$ Value -> Lovelace
selectLovelace Value
ll
      Right MultiAssetSupportedInEra era
maSupported -> do
        let l :: [Pair]
l = forall v. KeyMap v -> [(Key, v)]
KeyMap.toList Object
o
        [Value]
vals <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Pair -> Parser Value
decodeAssetId [Pair]
l
        forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall era. MultiAssetSupportedInEra era -> Value -> TxOutValue era
TxOutValue MultiAssetSupportedInEra era
maSupported forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat [Value]
vals
    where
     decodeAssetId :: (Aeson.Key, Aeson.Value) -> Aeson.Parser Value
     decodeAssetId :: Pair -> Parser Value
decodeAssetId (Key
polid, Aeson.Object Object
assetNameHm) = do
       let polId :: PolicyId
polId = forall a. IsString a => String -> a
fromString forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
Text.unpack forall a b. (a -> b) -> a -> b
$ Key -> Text
Aeson.toText Key
polid
       [(AssetName, Quantity)]
aNameQuantity <- Object -> Parser [(AssetName, Quantity)]
decodeAssets Object
assetNameHm
       forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(AssetId, Quantity)] -> Value
valueFromList
         forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first forall a b. (a -> b) -> a -> b
$ PolicyId -> AssetName -> AssetId
AssetId PolicyId
polId) [(AssetName, Quantity)]
aNameQuantity

     decodeAssetId (Key
"lovelace", Aeson.Number Scientific
sci) =
       case forall i. (Integral i, Bounded i) => Scientific -> Maybe i
toBoundedInteger Scientific
sci of
         Just (Word64
ll :: Word64) ->
           forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ [(AssetId, Quantity)] -> Value
valueFromList [(AssetId
AdaAssetId, Integer -> Quantity
Quantity forall a b. (a -> b) -> a -> b
$ forall a. Integral a => a -> Integer
toInteger Word64
ll)]
         Maybe Word64
Nothing ->
           forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Expected a Bounded number but got: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show Scientific
sci
     decodeAssetId Pair
wrong = forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Expected a policy id and a JSON object but got: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show Pair
wrong

     decodeAssets :: Aeson.Object -> Aeson.Parser [(AssetName, Quantity)]
     decodeAssets :: Object -> Parser [(AssetName, Quantity)]
decodeAssets Object
assetNameHm =
       let l :: [Pair]
l = forall v. KeyMap v -> [(Key, v)]
KeyMap.toList Object
assetNameHm
       in forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (\(Key
aName, Value
q) -> (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Key -> Parser AssetName
parseAssetName Key
aName forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser Quantity
decodeQuantity Value
q) [Pair]
l

     parseAssetName :: Aeson.Key -> Aeson.Parser AssetName
     parseAssetName :: Key -> Parser AssetName
parseAssetName Key
aName = forall a. Parser a -> Text -> Parser a
runParsecParser Parser AssetName
assetName (Key -> Text
Aeson.toText Key
aName)

     decodeQuantity :: Aeson.Value -> Aeson.Parser Quantity
     decodeQuantity :: Value -> Parser Quantity
decodeQuantity (Aeson.Number Scientific
sci) =
       case forall i. (Integral i, Bounded i) => Scientific -> Maybe i
toBoundedInteger Scientific
sci of
         Just (Word64
ll :: Word64) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Quantity
Quantity forall a b. (a -> b) -> a -> b
$ forall a. Integral a => a -> Integer
toInteger Word64
ll
         Maybe Word64
Nothing -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Expected a Bounded number but got: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show Scientific
sci
     decodeQuantity Value
wrong = forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Expected aeson Number but got: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show Value
wrong

lovelaceToTxOutValue :: IsCardanoEra era => Lovelace -> TxOutValue era
lovelaceToTxOutValue :: forall era. IsCardanoEra era => Lovelace -> TxOutValue era
lovelaceToTxOutValue Lovelace
l =
    case forall era.
CardanoEra era
-> Either
     (OnlyAdaSupportedInEra era) (MultiAssetSupportedInEra era)
multiAssetSupportedInEra forall era. IsCardanoEra era => CardanoEra era
cardanoEra of
      Left OnlyAdaSupportedInEra era
adaOnly     -> forall era. OnlyAdaSupportedInEra era -> Lovelace -> TxOutValue era
TxOutAdaOnly OnlyAdaSupportedInEra era
adaOnly  Lovelace
l
      Right MultiAssetSupportedInEra era
multiAsset -> forall era. MultiAssetSupportedInEra era -> Value -> TxOutValue era
TxOutValue MultiAssetSupportedInEra era
multiAsset (Lovelace -> Value
lovelaceToValue Lovelace
l)

txOutValueToLovelace :: TxOutValue era -> Lovelace
txOutValueToLovelace :: forall era. TxOutValue era -> Lovelace
txOutValueToLovelace TxOutValue era
tv =
  case TxOutValue era
tv of
    TxOutAdaOnly OnlyAdaSupportedInEra era
_ Lovelace
l -> Lovelace
l
    TxOutValue MultiAssetSupportedInEra era
_ Value
v -> Value -> Lovelace
selectLovelace Value
v

txOutValueToValue :: TxOutValue era -> Value
txOutValueToValue :: forall era. TxOutValue era -> Value
txOutValueToValue TxOutValue era
tv =
  case TxOutValue era
tv of
    TxOutAdaOnly OnlyAdaSupportedInEra era
_ Lovelace
l -> Lovelace -> Value
lovelaceToValue Lovelace
l
    TxOutValue MultiAssetSupportedInEra era
_ Value
v -> Value
v

prettyRenderTxOut :: TxOutInAnyEra -> Text
prettyRenderTxOut :: TxOutInAnyEra -> Text
prettyRenderTxOut (TxOutInAnyEra CardanoEra era
_ (TxOut (AddressInEra AddressTypeInEra addrtype era
_ Address addrtype
addr) TxOutValue era
txOutVal TxOutDatum CtxTx era
_ ReferenceScript era
_)) =
     forall addr. SerialiseAddress addr => addr -> Text
serialiseAddress (forall addr. Address addr -> AddressAny
toAddressAny Address addrtype
addr) forall a. Semigroup a => a -> a -> a
<> Text
" + "
  forall a. Semigroup a => a -> a -> a
<> Value -> Text
renderValue (forall era. TxOutValue era -> Value
txOutValueToValue TxOutValue era
txOutVal)

data TxReturnCollateral ctx era where

     TxReturnCollateralNone :: TxReturnCollateral ctx era

     TxReturnCollateral     :: TxTotalAndReturnCollateralSupportedInEra era
                            -> TxOut ctx era
                            -> TxReturnCollateral ctx era

deriving instance Eq   (TxReturnCollateral ctx era)
deriving instance Show (TxReturnCollateral ctx era)

data TxTotalCollateral era where

     TxTotalCollateralNone :: TxTotalCollateral era

     TxTotalCollateral     :: TxTotalAndReturnCollateralSupportedInEra era
                           -> Lovelace
                           -> TxTotalCollateral era

deriving instance Eq   (TxTotalCollateral era)
deriving instance Show (TxTotalCollateral era)

data TxTotalAndReturnCollateralSupportedInEra era where

     TxTotalAndReturnCollateralInBabbageEra :: TxTotalAndReturnCollateralSupportedInEra BabbageEra
     TxTotalAndReturnCollateralInConwayEra :: TxTotalAndReturnCollateralSupportedInEra ConwayEra

deriving instance Eq   (TxTotalAndReturnCollateralSupportedInEra era)
deriving instance Show (TxTotalAndReturnCollateralSupportedInEra era)

totalAndReturnCollateralSupportedInEra
  :: CardanoEra era -> Maybe (TxTotalAndReturnCollateralSupportedInEra era)
totalAndReturnCollateralSupportedInEra :: forall era.
CardanoEra era
-> Maybe (TxTotalAndReturnCollateralSupportedInEra era)
totalAndReturnCollateralSupportedInEra CardanoEra era
ByronEra = forall a. Maybe a
Nothing
totalAndReturnCollateralSupportedInEra CardanoEra era
ShelleyEra = forall a. Maybe a
Nothing
totalAndReturnCollateralSupportedInEra CardanoEra era
AllegraEra = forall a. Maybe a
Nothing
totalAndReturnCollateralSupportedInEra CardanoEra era
MaryEra = forall a. Maybe a
Nothing
totalAndReturnCollateralSupportedInEra CardanoEra era
AlonzoEra = forall a. Maybe a
Nothing
totalAndReturnCollateralSupportedInEra CardanoEra era
BabbageEra = forall a. a -> Maybe a
Just TxTotalAndReturnCollateralSupportedInEra BabbageEra
TxTotalAndReturnCollateralInBabbageEra
totalAndReturnCollateralSupportedInEra CardanoEra era
ConwayEra = forall a. a -> Maybe a
Just TxTotalAndReturnCollateralSupportedInEra ConwayEra
TxTotalAndReturnCollateralInConwayEra

-- ----------------------------------------------------------------------------
-- Transaction output datum (era-dependent)
--

data TxOutDatum ctx era where

     TxOutDatumNone   :: TxOutDatum ctx era

     -- | A transaction output that only specifies the hash of the datum, but
     -- not the full datum value.
     --
     TxOutDatumHash   :: ScriptDataSupportedInEra era
                      -> Hash ScriptData
                      -> TxOutDatum ctx era

     -- | A transaction output that specifies the whole datum value. This can
     -- only be used in the context of the transaction body, and does not occur
     -- in the UTxO. The UTxO only contains the datum hash.
     --
     TxOutDatumInTx'  :: ScriptDataSupportedInEra era
                      -> Hash ScriptData
                      -> HashableScriptData
                      -> TxOutDatum CtxTx era

     -- | A transaction output that specifies the whole datum instead of the
     -- datum hash. Note that the datum map will not be updated with this datum,
     -- it only exists at the transaction output.
     --
     TxOutDatumInline :: ReferenceTxInsScriptsInlineDatumsSupportedInEra era
                      -> HashableScriptData
                      -> TxOutDatum ctx era

deriving instance Eq   (TxOutDatum ctx era)
deriving instance Show (TxOutDatum ctx era)

instance EraCast (TxOutDatum ctx)  where
  eraCast :: forall fromEra toEra.
(IsCardanoEra fromEra, IsCardanoEra toEra) =>
CardanoEra toEra
-> TxOutDatum ctx fromEra
-> Either EraCastError (TxOutDatum ctx toEra)
eraCast CardanoEra toEra
toEra TxOutDatum ctx fromEra
v = case TxOutDatum ctx fromEra
v of
    TxOutDatum ctx fromEra
TxOutDatumNone -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall ctx era. TxOutDatum ctx era
TxOutDatumNone
    TxOutDatumHash (ScriptDataSupportedInEra fromEra
_ :: ScriptDataSupportedInEra fromEra) Hash ScriptData
hash ->
      case forall era. CardanoEra era -> Maybe (ScriptDataSupportedInEra era)
scriptDataSupportedInEra CardanoEra toEra
toEra of
        Maybe (ScriptDataSupportedInEra toEra)
Nothing -> forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ forall fromEra toEra value.
(IsCardanoEra fromEra, IsCardanoEra toEra, Show value) =>
value -> CardanoEra fromEra -> CardanoEra toEra -> EraCastError
EraCastError TxOutDatum ctx fromEra
v (forall era. IsCardanoEra era => CardanoEra era
cardanoEra @fromEra) CardanoEra toEra
toEra
        Just ScriptDataSupportedInEra toEra
sDatumsSupported ->
          forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ forall era ctx.
ScriptDataSupportedInEra era
-> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash ScriptDataSupportedInEra toEra
sDatumsSupported Hash ScriptData
hash
    TxOutDatumInTx' (ScriptDataSupportedInEra fromEra
_ :: ScriptDataSupportedInEra fromEra) Hash ScriptData
scriptData HashableScriptData
hash ->
      case forall era. CardanoEra era -> Maybe (ScriptDataSupportedInEra era)
scriptDataSupportedInEra CardanoEra toEra
toEra of
        Maybe (ScriptDataSupportedInEra toEra)
Nothing -> forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ forall fromEra toEra value.
(IsCardanoEra fromEra, IsCardanoEra toEra, Show value) =>
value -> CardanoEra fromEra -> CardanoEra toEra -> EraCastError
EraCastError TxOutDatum ctx fromEra
v (forall era. IsCardanoEra era => CardanoEra era
cardanoEra @fromEra) CardanoEra toEra
toEra
        Just ScriptDataSupportedInEra toEra
sDatumsSupported ->
          forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ forall era.
ScriptDataSupportedInEra era
-> Hash ScriptData -> HashableScriptData -> TxOutDatum CtxTx era
TxOutDatumInTx' ScriptDataSupportedInEra toEra
sDatumsSupported Hash ScriptData
scriptData HashableScriptData
hash
    TxOutDatumInline (ReferenceTxInsScriptsInlineDatumsSupportedInEra fromEra
_ :: ReferenceTxInsScriptsInlineDatumsSupportedInEra fromEra) HashableScriptData
scriptData ->
      case forall era.
CardanoEra era
-> Maybe (ReferenceTxInsScriptsInlineDatumsSupportedInEra era)
refInsScriptsAndInlineDatsSupportedInEra CardanoEra toEra
toEra of
        Maybe (ReferenceTxInsScriptsInlineDatumsSupportedInEra toEra)
Nothing -> forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ forall fromEra toEra value.
(IsCardanoEra fromEra, IsCardanoEra toEra, Show value) =>
value -> CardanoEra fromEra -> CardanoEra toEra -> EraCastError
EraCastError TxOutDatum ctx fromEra
v (forall era. IsCardanoEra era => CardanoEra era
cardanoEra @fromEra) CardanoEra toEra
toEra
        Just ReferenceTxInsScriptsInlineDatumsSupportedInEra toEra
refInsAndInlineSupported ->
          forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ forall era ctx.
ReferenceTxInsScriptsInlineDatumsSupportedInEra era
-> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline ReferenceTxInsScriptsInlineDatumsSupportedInEra toEra
refInsAndInlineSupported HashableScriptData
scriptData

pattern TxOutDatumInTx
  :: ScriptDataSupportedInEra era
  -> HashableScriptData
  -> TxOutDatum CtxTx era
pattern $bTxOutDatumInTx :: forall era.
ScriptDataSupportedInEra era
-> HashableScriptData -> TxOutDatum CtxTx era
$mTxOutDatumInTx :: forall {r} {era}.
TxOutDatum CtxTx era
-> (ScriptDataSupportedInEra era -> HashableScriptData -> r)
-> ((# #) -> r)
-> r
TxOutDatumInTx s d <- TxOutDatumInTx' s _ d
  where
    TxOutDatumInTx ScriptDataSupportedInEra era
s HashableScriptData
d = forall era.
ScriptDataSupportedInEra era
-> Hash ScriptData -> HashableScriptData -> TxOutDatum CtxTx era
TxOutDatumInTx' ScriptDataSupportedInEra era
s (HashableScriptData -> Hash ScriptData
hashScriptDataBytes HashableScriptData
d) HashableScriptData
d

{-# COMPLETE TxOutDatumNone, TxOutDatumHash, TxOutDatumInTx', TxOutDatumInline #-}
{-# COMPLETE TxOutDatumNone, TxOutDatumHash, TxOutDatumInTx , TxOutDatumInline #-}

parseHash :: SerialiseAsRawBytes (Hash a) => AsType (Hash a) -> Parsec.Parser (Hash a)
parseHash :: forall a.
SerialiseAsRawBytes (Hash a) =>
AsType (Hash a) -> Parser (Hash a)
parseHash AsType (Hash a)
asType = do
  String
str <- forall (f :: * -> *) a. Alternative f => f a -> f [a]
some forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
Parsec.hexDigit forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"hash"
  forall (m :: * -> *) e a.
MonadFail m =>
(e -> String) -> Either e a -> m a
failEitherWith (\RawBytesHexError
e -> String
"Failed to parse hash: " forall a. [a] -> [a] -> [a]
++ forall e. Error e => e -> String
displayError RawBytesHexError
e) forall a b. (a -> b) -> a -> b
$
    forall a.
SerialiseAsRawBytes a =>
AsType a -> ByteString -> Either RawBytesHexError a
deserialiseFromRawBytesHex AsType (Hash a)
asType (String -> ByteString
BSC.pack String
str)

-- ----------------------------------------------------------------------------
-- Transaction fees
--

data TxFee era where

     TxFeeImplicit :: TxFeesImplicitInEra era -> TxFee era

     TxFeeExplicit :: TxFeesExplicitInEra era -> Lovelace -> TxFee era

deriving instance Eq   (TxFee era)
deriving instance Show (TxFee era)


-- ----------------------------------------------------------------------------
-- Transaction validity range
--

-- | This was formerly known as the TTL.
--
data TxValidityUpperBound era where

     TxValidityNoUpperBound :: ValidityNoUpperBoundSupportedInEra era
                            -> TxValidityUpperBound era

     TxValidityUpperBound   :: ValidityUpperBoundSupportedInEra era
                            -> SlotNo
                            -> TxValidityUpperBound era

deriving instance Eq   (TxValidityUpperBound era)
deriving instance Show (TxValidityUpperBound era)


data TxValidityLowerBound era where

     TxValidityNoLowerBound :: TxValidityLowerBound era

     TxValidityLowerBound   :: ValidityLowerBoundSupportedInEra era
                            -> SlotNo
                            -> TxValidityLowerBound era

deriving instance Eq   (TxValidityLowerBound era)
deriving instance Show (TxValidityLowerBound era)


-- ----------------------------------------------------------------------------
-- Transaction metadata (era-dependent)
--

data TxMetadataInEra era where

     TxMetadataNone  :: TxMetadataInEra era

     TxMetadataInEra :: TxMetadataSupportedInEra era
                     -> TxMetadata
                     -> TxMetadataInEra era

deriving instance Eq   (TxMetadataInEra era)
deriving instance Show (TxMetadataInEra era)


-- ----------------------------------------------------------------------------
-- Auxiliary scripts (era-dependent)
--

data TxAuxScripts era where

     TxAuxScriptsNone :: TxAuxScripts era

     TxAuxScripts     :: AuxScriptsSupportedInEra era
                      -> [ScriptInEra era]
                      -> TxAuxScripts era

deriving instance Eq   (TxAuxScripts era)
deriving instance Show (TxAuxScripts era)

-- ----------------------------------------------------------------------------
-- Optionally required signatures (era-dependent)
--

data TxExtraKeyWitnesses era where

  TxExtraKeyWitnessesNone :: TxExtraKeyWitnesses era

  TxExtraKeyWitnesses     :: TxExtraKeyWitnessesSupportedInEra era
                          -> [Hash PaymentKey]
                          -> TxExtraKeyWitnesses era

deriving instance Eq   (TxExtraKeyWitnesses era)
deriving instance Show (TxExtraKeyWitnesses era)

-- ----------------------------------------------------------------------------
-- Withdrawals within transactions (era-dependent)
--

data TxWithdrawals build era where

     TxWithdrawalsNone :: TxWithdrawals build era

     TxWithdrawals     :: WithdrawalsSupportedInEra era
                       -> [(StakeAddress, Lovelace,
                            BuildTxWith build (Witness WitCtxStake era))]
                       -> TxWithdrawals build era

deriving instance Eq   (TxWithdrawals build era)
deriving instance Show (TxWithdrawals build era)


-- ----------------------------------------------------------------------------
-- Certificates within transactions (era-dependent)
--

data TxCertificates build era where

     TxCertificatesNone :: TxCertificates build era

     TxCertificates     :: CertificatesSupportedInEra era
                        -> [Certificate]
                        -> BuildTxWith build
                             (Map StakeCredential (Witness WitCtxStake era))
                        -> TxCertificates build era

deriving instance Eq   (TxCertificates build era)
deriving instance Show (TxCertificates build era)


-- ----------------------------------------------------------------------------
-- Transaction update proposal (era-dependent)
--

data TxUpdateProposal era where

     TxUpdateProposalNone :: TxUpdateProposal era

     TxUpdateProposal     :: UpdateProposalSupportedInEra era
                          -> UpdateProposal
                          -> TxUpdateProposal era

deriving instance Eq   (TxUpdateProposal era)
deriving instance Show (TxUpdateProposal era)


-- ----------------------------------------------------------------------------
-- Value minting within transactions (era-dependent)
--

data TxMintValue build era where

     TxMintNone  :: TxMintValue build era

     TxMintValue :: MultiAssetSupportedInEra era
                 -> Value
                 -> BuildTxWith build
                      (Map PolicyId (ScriptWitness WitCtxMint era))
                 -> TxMintValue build era

deriving instance Eq   (TxMintValue build era)
deriving instance Show (TxMintValue build era)


-- ----------------------------------------------------------------------------
-- Transaction body content
--

data TxBodyContent build era =
     TxBodyContent {
       forall build era. TxBodyContent build era -> TxIns build era
txIns              :: TxIns build era,
       forall build era. TxBodyContent build era -> TxInsCollateral era
txInsCollateral    :: TxInsCollateral era,
       forall build era.
TxBodyContent build era -> TxInsReference build era
txInsReference     :: TxInsReference build era,
       forall build era. TxBodyContent build era -> [TxOut CtxTx era]
txOuts             :: [TxOut CtxTx era],
       forall build era. TxBodyContent build era -> TxTotalCollateral era
txTotalCollateral  :: TxTotalCollateral era,
       forall build era.
TxBodyContent build era -> TxReturnCollateral CtxTx era
txReturnCollateral :: TxReturnCollateral CtxTx era,
       forall build era. TxBodyContent build era -> TxFee era
txFee              :: TxFee era,
       forall build era.
TxBodyContent build era
-> (TxValidityLowerBound era, TxValidityUpperBound era)
txValidityRange    :: (TxValidityLowerBound era,
                              TxValidityUpperBound era),
       forall build era. TxBodyContent build era -> TxMetadataInEra era
txMetadata         :: TxMetadataInEra era,
       forall build era. TxBodyContent build era -> TxAuxScripts era
txAuxScripts       :: TxAuxScripts era,
       forall build era.
TxBodyContent build era -> TxExtraKeyWitnesses era
txExtraKeyWits     :: TxExtraKeyWitnesses era,
       forall build era.
TxBodyContent build era
-> BuildTxWith build (Maybe ProtocolParameters)
txProtocolParams   :: BuildTxWith build (Maybe ProtocolParameters),
       forall build era.
TxBodyContent build era -> TxWithdrawals build era
txWithdrawals      :: TxWithdrawals  build era,
       forall build era.
TxBodyContent build era -> TxCertificates build era
txCertificates     :: TxCertificates build era,
       forall build era. TxBodyContent build era -> TxUpdateProposal era
txUpdateProposal   :: TxUpdateProposal era,
       forall build era. TxBodyContent build era -> TxMintValue build era
txMintValue        :: TxMintValue    build era,
       forall build era. TxBodyContent build era -> TxScriptValidity era
txScriptValidity   :: TxScriptValidity era
     }
     deriving (TxBodyContent build era -> TxBodyContent build era -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall build era.
TxBodyContent build era -> TxBodyContent build era -> Bool
/= :: TxBodyContent build era -> TxBodyContent build era -> Bool
$c/= :: forall build era.
TxBodyContent build era -> TxBodyContent build era -> Bool
== :: TxBodyContent build era -> TxBodyContent build era -> Bool
$c== :: forall build era.
TxBodyContent build era -> TxBodyContent build era -> Bool
Eq, Int -> TxBodyContent build era -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall build era. Int -> TxBodyContent build era -> ShowS
forall build era. [TxBodyContent build era] -> ShowS
forall build era. TxBodyContent build era -> String
showList :: [TxBodyContent build era] -> ShowS
$cshowList :: forall build era. [TxBodyContent build era] -> ShowS
show :: TxBodyContent build era -> String
$cshow :: forall build era. TxBodyContent build era -> String
showsPrec :: Int -> TxBodyContent build era -> ShowS
$cshowsPrec :: forall build era. Int -> TxBodyContent build era -> ShowS
Show)


-- ----------------------------------------------------------------------------
-- Transaction bodies
--

data TxBody era where

     ByronTxBody
       :: Annotated Byron.Tx ByteString
       -> TxBody ByronEra

     ShelleyTxBody
       :: ShelleyBasedEra era
       -> Ledger.TxBody (ShelleyLedgerEra era)

          -- We include the scripts along with the tx body, rather than the
          -- witnesses set, since they need to be known when building the body.
       -> [Ledger.Script (ShelleyLedgerEra era)]

          -- The info for each use of each script: the script input data, both
          -- the UTxO input data (called the "datum") and the supplied input
          -- data (called the "redeemer") and the execution units.
       -> TxBodyScriptData era

          -- The 'Ledger.AuxiliaryData' consists of one or several things,
          -- depending on era:
          -- + transaction metadata  (in Shelley and later)
          -- + auxiliary scripts     (in Allegra and later)
          -- Note that there is no auxiliary script data as such, because the
          -- extra script data has to be passed to scripts and hence is needed
          -- for validation. It is thus part of the witness data, not the
          -- auxiliary data.
       -> Maybe (Ledger.AuxiliaryData (ShelleyLedgerEra era))

       -> TxScriptValidity era -- ^ Mark script as expected to pass or fail validation

       -> TxBody era
     -- The 'ShelleyBasedEra' GADT tells us what era we are in.
     -- The 'ShelleyLedgerEra' type family maps that to the era type from the
     -- ledger lib. The 'Ledger.TxBody' type family maps that to a specific
     -- tx body type, which is different for each Shelley-based era.


data TxBodyScriptData era where
     TxBodyNoScriptData :: TxBodyScriptData era
     TxBodyScriptData   :: ScriptDataSupportedInEra era
                        -> Alonzo.TxDats (ShelleyLedgerEra era)
                        -> Alonzo.Redeemers (ShelleyLedgerEra era)
                        -> TxBodyScriptData era

deriving instance Eq   (TxBodyScriptData era)
deriving instance Show (TxBodyScriptData era)


-- The GADT in the ShelleyTxBody case requires a custom instance
instance Eq (TxBody era) where
    == :: TxBody era -> TxBody era -> Bool
(==) (ByronTxBody Annotated Tx ByteString
txbodyA)
         (ByronTxBody Annotated Tx ByteString
txbodyB) = Annotated Tx ByteString
txbodyA forall a. Eq a => a -> a -> Bool
== Annotated Tx ByteString
txbodyB

    (==) (ShelleyTxBody ShelleyBasedEra era
era TxBody (ShelleyLedgerEra era)
txbodyA [Script (ShelleyLedgerEra era)]
txscriptsA TxBodyScriptData era
redeemersA Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadataA TxScriptValidity era
scriptValidityA)
         (ShelleyTxBody ShelleyBasedEra era
_   TxBody (ShelleyLedgerEra era)
txbodyB [Script (ShelleyLedgerEra era)]
txscriptsB TxBodyScriptData era
redeemersB Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadataB TxScriptValidity era
scriptValidityB) =
         case ShelleyBasedEra era
era of
           ShelleyBasedEra era
ShelleyBasedEraShelley -> TxBody (ShelleyLedgerEra era)
txbodyA     forall a. Eq a => a -> a -> Bool
== TxBody (ShelleyLedgerEra era)
txbodyB
                                  Bool -> Bool -> Bool
&& [Script (ShelleyLedgerEra era)]
txscriptsA  forall a. Eq a => a -> a -> Bool
== [Script (ShelleyLedgerEra era)]
txscriptsB
                                  Bool -> Bool -> Bool
&& Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadataA forall a. Eq a => a -> a -> Bool
== Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadataB

           ShelleyBasedEra era
ShelleyBasedEraAllegra -> TxBody (ShelleyLedgerEra era)
txbodyA     forall a. Eq a => a -> a -> Bool
== TxBody (ShelleyLedgerEra era)
txbodyB
                                  Bool -> Bool -> Bool
&& [Script (ShelleyLedgerEra era)]
txscriptsA  forall a. Eq a => a -> a -> Bool
== [Script (ShelleyLedgerEra era)]
txscriptsB
                                  Bool -> Bool -> Bool
&& Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadataA forall a. Eq a => a -> a -> Bool
== Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadataB

           ShelleyBasedEra era
ShelleyBasedEraMary    -> TxBody (ShelleyLedgerEra era)
txbodyA     forall a. Eq a => a -> a -> Bool
== TxBody (ShelleyLedgerEra era)
txbodyB
                                  Bool -> Bool -> Bool
&& [Script (ShelleyLedgerEra era)]
txscriptsA  forall a. Eq a => a -> a -> Bool
== [Script (ShelleyLedgerEra era)]
txscriptsB
                                  Bool -> Bool -> Bool
&& Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadataA forall a. Eq a => a -> a -> Bool
== Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadataB

           ShelleyBasedEra era
ShelleyBasedEraAlonzo  -> TxBody (ShelleyLedgerEra era)
txbodyA         forall a. Eq a => a -> a -> Bool
== TxBody (ShelleyLedgerEra era)
txbodyB
                                  Bool -> Bool -> Bool
&& [Script (ShelleyLedgerEra era)]
txscriptsA      forall a. Eq a => a -> a -> Bool
== [Script (ShelleyLedgerEra era)]
txscriptsB
                                  Bool -> Bool -> Bool
&& TxBodyScriptData era
redeemersA      forall a. Eq a => a -> a -> Bool
== TxBodyScriptData era
redeemersB
                                  Bool -> Bool -> Bool
&& Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadataA     forall a. Eq a => a -> a -> Bool
== Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadataB
                                  Bool -> Bool -> Bool
&& TxScriptValidity era
scriptValidityA forall a. Eq a => a -> a -> Bool
== TxScriptValidity era
scriptValidityB

           ShelleyBasedEra era
ShelleyBasedEraBabbage -> TxBody (ShelleyLedgerEra era)
txbodyA         forall a. Eq a => a -> a -> Bool
== TxBody (ShelleyLedgerEra era)
txbodyB
                                  Bool -> Bool -> Bool
&& [Script (ShelleyLedgerEra era)]
txscriptsA      forall a. Eq a => a -> a -> Bool
== [Script (ShelleyLedgerEra era)]
txscriptsB
                                  Bool -> Bool -> Bool
&& TxBodyScriptData era
redeemersA      forall a. Eq a => a -> a -> Bool
== TxBodyScriptData era
redeemersB
                                  Bool -> Bool -> Bool
&& Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadataA     forall a. Eq a => a -> a -> Bool
== Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadataB
                                  Bool -> Bool -> Bool
&& TxScriptValidity era
scriptValidityA forall a. Eq a => a -> a -> Bool
== TxScriptValidity era
scriptValidityB

           ShelleyBasedEra era
ShelleyBasedEraConway  -> TxBody (ShelleyLedgerEra era)
txbodyA         forall a. Eq a => a -> a -> Bool
== TxBody (ShelleyLedgerEra era)
txbodyB
                                  Bool -> Bool -> Bool
&& [Script (ShelleyLedgerEra era)]
txscriptsA      forall a. Eq a => a -> a -> Bool
== [Script (ShelleyLedgerEra era)]
txscriptsB
                                  Bool -> Bool -> Bool
&& TxBodyScriptData era
redeemersA      forall a. Eq a => a -> a -> Bool
== TxBodyScriptData era
redeemersB
                                  Bool -> Bool -> Bool
&& Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadataA     forall a. Eq a => a -> a -> Bool
== Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadataB
                                  Bool -> Bool -> Bool
&& TxScriptValidity era
scriptValidityA forall a. Eq a => a -> a -> Bool
== TxScriptValidity era
scriptValidityB

    (==) ByronTxBody{} (ShelleyTxBody ShelleyBasedEra era
era TxBody (ShelleyLedgerEra era)
_ [Script (ShelleyLedgerEra era)]
_ TxBodyScriptData era
_ Maybe (AuxiliaryData (ShelleyLedgerEra era))
_ TxScriptValidity era
_) = case ShelleyBasedEra era
era of {}
    (==) (ShelleyTxBody ShelleyBasedEra era
era TxBody (ShelleyLedgerEra era)
_ [Script (ShelleyLedgerEra era)]
_ TxBodyScriptData era
_ Maybe (AuxiliaryData (ShelleyLedgerEra era))
_ TxScriptValidity era
_) ByronTxBody{} = case ShelleyBasedEra era
era of {}


-- The GADT in the ShelleyTxBody case requires a custom instance
instance Show (TxBody era) where
    showsPrec :: Int -> TxBody era -> ShowS
showsPrec Int
p (ByronTxBody Annotated Tx ByteString
txbody) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11)
        ( String -> ShowS
showString String
"ByronTxBody "
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Annotated Tx ByteString
txbody
        )

    showsPrec Int
p (ShelleyTxBody ShelleyBasedEra era
ShelleyBasedEraShelley
                               TxBody (ShelleyLedgerEra era)
txbody [Script (ShelleyLedgerEra era)]
txscripts TxBodyScriptData era
redeemers Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata TxScriptValidity era
scriptValidity) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11)
        ( String -> ShowS
showString String
"ShelleyTxBody ShelleyBasedEraShelley "
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxBody (ShelleyLedgerEra era)
txbody
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 [Script (ShelleyLedgerEra era)]
txscripts
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxBodyScriptData era
redeemers
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxScriptValidity era
scriptValidity
        )

    showsPrec Int
p (ShelleyTxBody ShelleyBasedEra era
ShelleyBasedEraAllegra
                               TxBody (ShelleyLedgerEra era)
txbody [Script (ShelleyLedgerEra era)]
txscripts TxBodyScriptData era
redeemers Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata TxScriptValidity era
scriptValidity) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11)
        ( String -> ShowS
showString String
"ShelleyTxBody ShelleyBasedEraAllegra "
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxBody (ShelleyLedgerEra era)
txbody
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 [Script (ShelleyLedgerEra era)]
txscripts
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxBodyScriptData era
redeemers
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxScriptValidity era
scriptValidity
        )

    showsPrec Int
p (ShelleyTxBody ShelleyBasedEra era
ShelleyBasedEraMary
                               TxBody (ShelleyLedgerEra era)
txbody [Script (ShelleyLedgerEra era)]
txscripts TxBodyScriptData era
redeemers Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata TxScriptValidity era
scriptValidity) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11)
        ( String -> ShowS
showString String
"ShelleyTxBody ShelleyBasedEraMary "
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxBody (ShelleyLedgerEra era)
txbody
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 [Script (ShelleyLedgerEra era)]
txscripts
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxBodyScriptData era
redeemers
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxScriptValidity era
scriptValidity
        )

    showsPrec Int
p (ShelleyTxBody ShelleyBasedEra era
ShelleyBasedEraAlonzo
                               TxBody (ShelleyLedgerEra era)
txbody [Script (ShelleyLedgerEra era)]
txscripts TxBodyScriptData era
redeemers Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata TxScriptValidity era
scriptValidity) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11)
        ( String -> ShowS
showString String
"ShelleyTxBody ShelleyBasedEraAlonzo "
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxBody (ShelleyLedgerEra era)
txbody
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 [Script (ShelleyLedgerEra era)]
txscripts
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxBodyScriptData era
redeemers
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxScriptValidity era
scriptValidity
        )

    showsPrec Int
p (ShelleyTxBody ShelleyBasedEra era
ShelleyBasedEraBabbage
                               TxBody (ShelleyLedgerEra era)
txbody [Script (ShelleyLedgerEra era)]
txscripts TxBodyScriptData era
redeemers Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata TxScriptValidity era
scriptValidity) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11)
        ( String -> ShowS
showString String
"ShelleyTxBody ShelleyBasedEraBabbage "
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxBody (ShelleyLedgerEra era)
txbody
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 [Script (ShelleyLedgerEra era)]
txscripts
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxBodyScriptData era
redeemers
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxScriptValidity era
scriptValidity
        )

    showsPrec Int
p (ShelleyTxBody ShelleyBasedEra era
ShelleyBasedEraConway
                               TxBody (ShelleyLedgerEra era)
txbody [Script (ShelleyLedgerEra era)]
txscripts TxBodyScriptData era
redeemers Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata TxScriptValidity era
scriptValidity) =
      Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
11)
        ( String -> ShowS
showString String
"ShelleyTxBody ShelleyBasedEraConway "
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxBody (ShelleyLedgerEra era)
txbody
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 [Script (ShelleyLedgerEra era)]
txscripts
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxBodyScriptData era
redeemers
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' '
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 TxScriptValidity era
scriptValidity
        )


instance HasTypeProxy era => HasTypeProxy (TxBody era) where
    data AsType (TxBody era) = AsTxBody (AsType era)
    proxyToAsType :: Proxy (TxBody era) -> AsType (TxBody era)
proxyToAsType Proxy (TxBody era)
_ = forall era. AsType era -> AsType (TxBody era)
AsTxBody (forall t. HasTypeProxy t => Proxy t -> AsType t
proxyToAsType (forall {k} (t :: k). Proxy t
Proxy :: Proxy era))

pattern AsByronTxBody :: AsType (TxBody ByronEra)
pattern $bAsByronTxBody :: AsType (TxBody ByronEra)
$mAsByronTxBody :: forall {r}.
AsType (TxBody ByronEra) -> ((# #) -> r) -> ((# #) -> r) -> r
AsByronTxBody   = AsTxBody AsByronEra
{-# COMPLETE AsByronTxBody #-}

pattern AsShelleyTxBody :: AsType (TxBody ShelleyEra)
pattern $bAsShelleyTxBody :: AsType (TxBody ShelleyEra)
$mAsShelleyTxBody :: forall {r}.
AsType (TxBody ShelleyEra) -> ((# #) -> r) -> ((# #) -> r) -> r
AsShelleyTxBody = AsTxBody AsShelleyEra
{-# COMPLETE AsShelleyTxBody #-}

pattern AsMaryTxBody :: AsType (TxBody MaryEra)
pattern $bAsMaryTxBody :: AsType (TxBody MaryEra)
$mAsMaryTxBody :: forall {r}.
AsType (TxBody MaryEra) -> ((# #) -> r) -> ((# #) -> r) -> r
AsMaryTxBody = AsTxBody AsMaryEra
{-# COMPLETE AsMaryTxBody #-}

instance IsCardanoEra era => SerialiseAsCBOR (TxBody era) where

    serialiseToCBOR :: TxBody era -> ByteString
serialiseToCBOR (ByronTxBody Annotated Tx ByteString
txbody) =
      forall t. Decoded t => t -> ByteString
recoverBytes Annotated Tx ByteString
txbody

    serialiseToCBOR (ShelleyTxBody ShelleyBasedEra era
era TxBody (ShelleyLedgerEra era)
txbody [Script (ShelleyLedgerEra era)]
txscripts TxBodyScriptData era
redeemers Maybe (AuxiliaryData (ShelleyLedgerEra era))
txmetadata TxScriptValidity era
scriptValidity) =
      case ShelleyBasedEra era
era of
        -- Use the same serialisation impl, but at different types:
        ShelleyBasedEra era
ShelleyBasedEraShelley -> forall era ledgerera.
(ShelleyLedgerEra era ~ ledgerera, ToCBOR (TxBody ledgerera),
 ToCBOR (Script ledgerera), ToCBOR (TxDats ledgerera),
 ToCBOR (Redeemers ledgerera), ToCBOR (AuxiliaryData ledgerera)) =>
Shel