{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE DisambiguateRecordFields #-}
{-# LANGUAGE EmptyCase #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}

module Cardano.Api.Internal.Tx.Output
  ( -- * Transaction outputs
    TxOut (..)

    -- ** Transaction output contexts
  , CtxTx
  , CtxUTxO
  , toCtxUTxOTxOut
  , fromCtxUTxOTxOut

    -- ** Ledger conversion functions for outputs
  , fromShelleyTxOut
  , toShelleyTxOut
  , toShelleyTxOutAny
  , convTxOuts
  , fromLedgerTxOuts
  , toByronTxOut
  --  ** An Output Value
  , TxOutValue (..)
  , lovelaceToTxOutValue
  , txOutValueToLovelace
  , txOutValueToValue

    -- ** Datum
  , TxOutDatum (..)
  , binaryDataToScriptData
  , scriptDataToInlineDatum

    -- ** Existential type over an era
  , TxOutInAnyEra (..)
  , txOutInAnyEra

    -- ** Utilities
  , validateTxOuts
  , parseHash
  , prettyRenderTxOut

    -- ** Error types
  , TxOutputError (..)
  )
where

import Cardano.Api.Internal.Address
import Cardano.Api.Internal.Eon.AlonzoEraOnwards
import Cardano.Api.Internal.Eon.BabbageEraOnwards
import Cardano.Api.Internal.Eon.Convert
import Cardano.Api.Internal.Eon.ShelleyBasedEra
import Cardano.Api.Internal.Eras.Case
import Cardano.Api.Internal.Eras.Core
import Cardano.Api.Internal.Error (Error (..), displayError)
import Cardano.Api.Internal.Hash
import Cardano.Api.Internal.Pretty
import Cardano.Api.Internal.ReexposeLedger qualified as Ledger
import Cardano.Api.Internal.Script
import Cardano.Api.Internal.ScriptData
import Cardano.Api.Internal.Serialise.Cbor
import Cardano.Api.Internal.SerialiseJSON
import Cardano.Api.Internal.SerialiseRaw
import Cardano.Api.Internal.Tx.Sign
import Cardano.Api.Internal.Utils
import Cardano.Api.Internal.Value
import Cardano.Api.Internal.ValueParser
import Cardano.Api.Ledger.Lens qualified as A

import Cardano.Chain.UTxO qualified as Byron
import Cardano.Ledger.Allegra.Core qualified as L
import Cardano.Ledger.Alonzo.Core qualified as L
import Cardano.Ledger.Api qualified as L
import Cardano.Ledger.BaseTypes (StrictMaybe (..))
import Cardano.Ledger.Coin qualified as L
import Cardano.Ledger.Core ()
import Cardano.Ledger.Core qualified as Core
import Cardano.Ledger.Core qualified as Ledger
import Cardano.Ledger.Plutus.Data qualified as Plutus

import Control.Applicative
import Data.Aeson (object, withObject, (.:), (.:?), (.=))
import Data.Aeson qualified as Aeson
import Data.Aeson.Key qualified as Aeson
import Data.Aeson.Types qualified as Aeson
import Data.Bifunctor (Bifunctor (..))
import Data.ByteString.Base16 qualified as Base16
import Data.ByteString.Char8 qualified as BSC
import Data.Map.Strict (Map)
import Data.Map.Strict qualified as Map
import Data.Scientific (toBoundedInteger)
import Data.Sequence.Strict qualified as Seq
import Data.String
import Data.Text (Text)
import Data.Text qualified as Text
import Data.Text.Encoding qualified as Text
import Data.Type.Equality
import Data.Word
import GHC.Exts (IsList (..))
import GHC.Stack
import Lens.Micro hiding (ix)
import Text.Parsec ((<?>))
import Text.Parsec qualified as Parsec
import Text.Parsec.String qualified as Parsec

-- ----------------------------------------------------------------------------
-- 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)

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 CardanoEra era -> CardanoEra era -> Maybe (era :~: era)
forall a b. CardanoEra a -> CardanoEra b -> Maybe (a :~: b)
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 TxOut CtxTx era -> TxOut CtxTx era -> Bool
forall a. Eq a => a -> a -> Bool
== TxOut CtxTx era
TxOut CtxTx era
out2
      Maybe (era :~: era)
Nothing -> Bool
False

deriving via (ShowOf TxOutInAnyEra) instance Pretty TxOutInAnyEra

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

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 -> TxOutDatum CtxUTxO era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
        TxOutDatumHash AlonzoEraOnwards era
s Hash ScriptData
h -> AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum CtxUTxO era
forall era ctx.
AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash AlonzoEraOnwards era
s Hash ScriptData
h
        TxOutSupplementalDatum AlonzoEraOnwards era
s HashableScriptData
datum -> AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum CtxUTxO era
forall era ctx.
AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash AlonzoEraOnwards era
s (Hash ScriptData -> TxOutDatum CtxUTxO era)
-> Hash ScriptData -> TxOutDatum CtxUTxO era
forall a b. (a -> b) -> a -> b
$ HashableScriptData -> Hash ScriptData
hashScriptDataBytes HashableScriptData
datum
        TxOutDatumInline BabbageEraOnwards era
s HashableScriptData
sd -> BabbageEraOnwards era
-> HashableScriptData -> TxOutDatum CtxUTxO era
forall era ctx.
BabbageEraOnwards era -> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline BabbageEraOnwards era
s HashableScriptData
sd
   in AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxUTxO era
-> ReferenceScript era
-> TxOut CtxUTxO era
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

fromCtxUTxOTxOut :: TxOut CtxUTxO era -> TxOut CtxTx era
fromCtxUTxOTxOut :: forall era. TxOut CtxUTxO era -> TxOut CtxTx era
fromCtxUTxOTxOut (TxOut AddressInEra era
addr TxOutValue era
val TxOutDatum CtxUTxO era
d ReferenceScript era
refS) =
  let dat :: TxOutDatum CtxTx era
dat = case TxOutDatum CtxUTxO era
d of
        TxOutDatum CtxUTxO era
TxOutDatumNone -> TxOutDatum CtxTx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
        TxOutDatumHash AlonzoEraOnwards era
s Hash ScriptData
h -> AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum CtxTx era
forall era ctx.
AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash AlonzoEraOnwards era
s Hash ScriptData
h
        TxOutDatumInline BabbageEraOnwards era
s HashableScriptData
sd -> BabbageEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
forall era ctx.
BabbageEraOnwards era -> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline BabbageEraOnwards era
s HashableScriptData
sd
   in AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxTx era
-> ReferenceScript era
-> TxOut CtxTx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut AddressInEra era
addr TxOutValue era
val TxOutDatum CtxTx era
dat ReferenceScript era
refS

convTxOuts
  :: forall ctx era ledgerera
   . HasCallStack
  => ShelleyLedgerEra era ~ ledgerera
  => ShelleyBasedEra era
  -> [TxOut ctx era]
  -> Seq.StrictSeq (Ledger.TxOut ledgerera)
convTxOuts :: forall ctx era ledgerera.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera) =>
ShelleyBasedEra era
-> [TxOut ctx era] -> StrictSeq (TxOut ledgerera)
convTxOuts ShelleyBasedEra era
sbe [TxOut ctx era]
txOuts = [Item (StrictSeq (TxOut ledgerera))] -> StrictSeq (TxOut ledgerera)
forall l. IsList l => [Item l] -> l
fromList ([Item (StrictSeq (TxOut ledgerera))]
 -> StrictSeq (TxOut ledgerera))
-> [Item (StrictSeq (TxOut ledgerera))]
-> StrictSeq (TxOut ledgerera)
forall a b. (a -> b) -> a -> b
$ (TxOut ctx era -> TxOut ledgerera)
-> [TxOut ctx era] -> [TxOut ledgerera]
forall a b. (a -> b) -> [a] -> [b]
map (ShelleyBasedEra era -> TxOut ctx era -> TxOut ledgerera
forall ctx era ledgerera.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera) =>
ShelleyBasedEra era -> TxOut ctx era -> TxOut ledgerera
toShelleyTxOutAny ShelleyBasedEra era
sbe) [TxOut ctx era]
txOuts

fromLedgerTxOuts
  :: forall era
   . ShelleyBasedEra era
  -> Ledger.TxBody (ShelleyLedgerEra era)
  -> TxBodyScriptData era
  -> [TxOut CtxTx era]
fromLedgerTxOuts :: forall era.
ShelleyBasedEra era
-> TxBody (ShelleyLedgerEra era)
-> TxBodyScriptData era
-> [TxOut CtxTx era]
fromLedgerTxOuts ShelleyBasedEra era
sbe TxBody (ShelleyLedgerEra era)
body TxBodyScriptData era
scriptdata =
  case ShelleyBasedEra era
sbe of
    ShelleyBasedEra era
ShelleyBasedEraShelley ->
      [ShelleyBasedEra era
-> TxOut (ShelleyLedgerEra era) -> TxOut CtxTx era
forall era ctx.
ShelleyBasedEra era
-> TxOut (ShelleyLedgerEra era) -> TxOut ctx era
fromShelleyTxOut ShelleyBasedEra era
sbe Item (StrictSeq (TxOut ShelleyEra))
TxOut (ShelleyLedgerEra era)
txout | Item (StrictSeq (TxOut ShelleyEra))
txout <- StrictSeq (TxOut ShelleyEra)
-> [Item (StrictSeq (TxOut ShelleyEra))]
forall l. IsList l => l -> [Item l]
toList (TxBody (ShelleyLedgerEra era)
ShelleyTxBody ShelleyEra
body ShelleyTxBody ShelleyEra
-> Getting
     (StrictSeq (TxOut ShelleyEra))
     (ShelleyTxBody ShelleyEra)
     (StrictSeq (TxOut ShelleyEra))
-> StrictSeq (TxOut ShelleyEra)
forall s a. s -> Getting a s a -> a
^. (StrictSeq (TxOut ShelleyEra)
 -> Const
      (StrictSeq (TxOut ShelleyEra)) (StrictSeq (TxOut ShelleyEra)))
-> TxBody ShelleyEra
-> Const (StrictSeq (TxOut ShelleyEra)) (TxBody ShelleyEra)
Getting
  (StrictSeq (TxOut ShelleyEra))
  (ShelleyTxBody ShelleyEra)
  (StrictSeq (TxOut ShelleyEra))
forall era.
EraTxBody era =>
Lens' (TxBody era) (StrictSeq (TxOut era))
Lens' (TxBody ShelleyEra) (StrictSeq (TxOut ShelleyEra))
L.outputsTxBodyL)]
    ShelleyBasedEra era
ShelleyBasedEraAllegra ->
      [ShelleyBasedEra era
-> TxOut (ShelleyLedgerEra era) -> TxOut CtxTx era
forall era ctx.
ShelleyBasedEra era
-> TxOut (ShelleyLedgerEra era) -> TxOut ctx era
fromShelleyTxOut ShelleyBasedEra era
sbe Item (StrictSeq (TxOut AllegraEra))
TxOut (ShelleyLedgerEra era)
txout | Item (StrictSeq (TxOut AllegraEra))
txout <- StrictSeq (TxOut AllegraEra)
-> [Item (StrictSeq (TxOut AllegraEra))]
forall l. IsList l => l -> [Item l]
toList (AllegraTxBody AllegraEra
TxBody (ShelleyLedgerEra era)
body AllegraTxBody AllegraEra
-> Getting
     (StrictSeq (TxOut AllegraEra))
     (AllegraTxBody AllegraEra)
     (StrictSeq (TxOut AllegraEra))
-> StrictSeq (TxOut AllegraEra)
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictSeq (TxOut AllegraEra))
  (AllegraTxBody AllegraEra)
  (StrictSeq (TxOut AllegraEra))
(StrictSeq (TxOut AllegraEra)
 -> Const
      (StrictSeq (TxOut AllegraEra)) (StrictSeq (TxOut AllegraEra)))
-> TxBody AllegraEra
-> Const (StrictSeq (TxOut AllegraEra)) (TxBody AllegraEra)
forall era.
EraTxBody era =>
Lens' (TxBody era) (StrictSeq (TxOut era))
Lens' (TxBody AllegraEra) (StrictSeq (TxOut AllegraEra))
L.outputsTxBodyL)]
    ShelleyBasedEra era
ShelleyBasedEraMary ->
      [ShelleyBasedEra era
-> TxOut (ShelleyLedgerEra era) -> TxOut CtxTx era
forall era ctx.
ShelleyBasedEra era
-> TxOut (ShelleyLedgerEra era) -> TxOut ctx era
fromShelleyTxOut ShelleyBasedEra era
sbe Item (StrictSeq (TxOut MaryEra))
TxOut (ShelleyLedgerEra era)
txout | Item (StrictSeq (TxOut MaryEra))
txout <- StrictSeq (TxOut MaryEra) -> [Item (StrictSeq (TxOut MaryEra))]
forall l. IsList l => l -> [Item l]
toList (TxBody (ShelleyLedgerEra era)
MaryTxBody MaryEra
body MaryTxBody MaryEra
-> Getting
     (StrictSeq (TxOut MaryEra))
     (MaryTxBody MaryEra)
     (StrictSeq (TxOut MaryEra))
-> StrictSeq (TxOut MaryEra)
forall s a. s -> Getting a s a -> a
^. (StrictSeq (TxOut MaryEra)
 -> Const (StrictSeq (TxOut MaryEra)) (StrictSeq (TxOut MaryEra)))
-> TxBody MaryEra
-> Const (StrictSeq (TxOut MaryEra)) (TxBody MaryEra)
Getting
  (StrictSeq (TxOut MaryEra))
  (MaryTxBody MaryEra)
  (StrictSeq (TxOut MaryEra))
forall era.
EraTxBody era =>
Lens' (TxBody era) (StrictSeq (TxOut era))
Lens' (TxBody MaryEra) (StrictSeq (TxOut MaryEra))
L.outputsTxBodyL)]
    ShelleyBasedEra era
ShelleyBasedEraAlonzo ->
      [ AlonzoEraOnwards era
-> Map DataHash (Data AlonzoEra)
-> TxOut (ShelleyLedgerEra era)
-> TxOut CtxTx era
forall era ledgerera.
AlonzoEraOnwards era
-> Map DataHash (Data ledgerera)
-> TxOut (ShelleyLedgerEra era)
-> TxOut CtxTx era
fromAlonzoTxOut
          AlonzoEraOnwards era
AlonzoEraOnwards AlonzoEra
AlonzoEraOnwardsAlonzo
          Map DataHash (Data AlonzoEra)
Map DataHash (Data (ShelleyLedgerEra era))
txdatums
          Item (StrictSeq (TxOut AlonzoEra))
TxOut (ShelleyLedgerEra era)
txout
      | let txdatums :: Map DataHash (Data (ShelleyLedgerEra era))
txdatums = TxBodyScriptData era -> Map DataHash (Data (ShelleyLedgerEra era))
forall era.
TxBodyScriptData era -> Map DataHash (Data (ShelleyLedgerEra era))
selectTxDatums TxBodyScriptData era
scriptdata
      , Item (StrictSeq (TxOut AlonzoEra))
txout <- StrictSeq (TxOut AlonzoEra) -> [Item (StrictSeq (TxOut AlonzoEra))]
forall l. IsList l => l -> [Item l]
toList (TxBody (ShelleyLedgerEra era)
AlonzoTxBody AlonzoEra
body AlonzoTxBody AlonzoEra
-> Getting
     (StrictSeq (TxOut AlonzoEra))
     (AlonzoTxBody AlonzoEra)
     (StrictSeq (TxOut AlonzoEra))
-> StrictSeq (TxOut AlonzoEra)
forall s a. s -> Getting a s a -> a
^. (StrictSeq (TxOut AlonzoEra)
 -> Const
      (StrictSeq (TxOut AlonzoEra)) (StrictSeq (TxOut AlonzoEra)))
-> TxBody AlonzoEra
-> Const (StrictSeq (TxOut AlonzoEra)) (TxBody AlonzoEra)
Getting
  (StrictSeq (TxOut AlonzoEra))
  (AlonzoTxBody AlonzoEra)
  (StrictSeq (TxOut AlonzoEra))
forall era.
EraTxBody era =>
Lens' (TxBody era) (StrictSeq (TxOut era))
Lens' (TxBody AlonzoEra) (StrictSeq (TxOut AlonzoEra))
L.outputsTxBodyL)
      ]
    ShelleyBasedEra era
ShelleyBasedEraBabbage ->
      [ BabbageEraOnwards era
-> Map DataHash (Data (ShelleyLedgerEra era))
-> TxOut (ShelleyLedgerEra era)
-> TxOut CtxTx era
forall era.
BabbageEraOnwards era
-> Map DataHash (Data (ShelleyLedgerEra era))
-> TxOut (ShelleyLedgerEra era)
-> TxOut CtxTx era
fromBabbageTxOut
          BabbageEraOnwards era
BabbageEraOnwards BabbageEra
BabbageEraOnwardsBabbage
          Map DataHash (Data (ShelleyLedgerEra era))
txdatums
          Item (StrictSeq (TxOut BabbageEra))
TxOut (ShelleyLedgerEra era)
txouts
      | let txdatums :: Map DataHash (Data (ShelleyLedgerEra era))
txdatums = TxBodyScriptData era -> Map DataHash (Data (ShelleyLedgerEra era))
forall era.
TxBodyScriptData era -> Map DataHash (Data (ShelleyLedgerEra era))
selectTxDatums TxBodyScriptData era
scriptdata
      , Item (StrictSeq (TxOut BabbageEra))
txouts <- StrictSeq (TxOut BabbageEra)
-> [Item (StrictSeq (TxOut BabbageEra))]
forall l. IsList l => l -> [Item l]
toList (TxBody (ShelleyLedgerEra era)
BabbageTxBody BabbageEra
body BabbageTxBody BabbageEra
-> Getting
     (StrictSeq (TxOut BabbageEra))
     (BabbageTxBody BabbageEra)
     (StrictSeq (TxOut BabbageEra))
-> StrictSeq (TxOut BabbageEra)
forall s a. s -> Getting a s a -> a
^. (StrictSeq (TxOut BabbageEra)
 -> Const
      (StrictSeq (TxOut BabbageEra)) (StrictSeq (TxOut BabbageEra)))
-> TxBody BabbageEra
-> Const (StrictSeq (TxOut BabbageEra)) (TxBody BabbageEra)
Getting
  (StrictSeq (TxOut BabbageEra))
  (BabbageTxBody BabbageEra)
  (StrictSeq (TxOut BabbageEra))
forall era.
EraTxBody era =>
Lens' (TxBody era) (StrictSeq (TxOut era))
Lens' (TxBody BabbageEra) (StrictSeq (TxOut BabbageEra))
L.outputsTxBodyL)
      ]
    ShelleyBasedEra era
ShelleyBasedEraConway ->
      [ BabbageEraOnwards era
-> Map DataHash (Data (ShelleyLedgerEra era))
-> TxOut (ShelleyLedgerEra era)
-> TxOut CtxTx era
forall era.
BabbageEraOnwards era
-> Map DataHash (Data (ShelleyLedgerEra era))
-> TxOut (ShelleyLedgerEra era)
-> TxOut CtxTx era
fromBabbageTxOut
          BabbageEraOnwards era
BabbageEraOnwards ConwayEra
BabbageEraOnwardsConway
          Map DataHash (Data (ShelleyLedgerEra era))
txdatums
          Item (StrictSeq (TxOut ConwayEra))
TxOut (ShelleyLedgerEra era)
txouts
      | let txdatums :: Map DataHash (Data (ShelleyLedgerEra era))
txdatums = TxBodyScriptData era -> Map DataHash (Data (ShelleyLedgerEra era))
forall era.
TxBodyScriptData era -> Map DataHash (Data (ShelleyLedgerEra era))
selectTxDatums TxBodyScriptData era
scriptdata
      , Item (StrictSeq (TxOut ConwayEra))
txouts <- StrictSeq (TxOut ConwayEra) -> [Item (StrictSeq (TxOut ConwayEra))]
forall l. IsList l => l -> [Item l]
toList (TxBody (ShelleyLedgerEra era)
ConwayTxBody ConwayEra
body ConwayTxBody ConwayEra
-> Getting
     (StrictSeq (TxOut ConwayEra))
     (ConwayTxBody ConwayEra)
     (StrictSeq (TxOut ConwayEra))
-> StrictSeq (TxOut ConwayEra)
forall s a. s -> Getting a s a -> a
^. (StrictSeq (TxOut ConwayEra)
 -> Const
      (StrictSeq (TxOut ConwayEra)) (StrictSeq (TxOut ConwayEra)))
-> TxBody ConwayEra
-> Const (StrictSeq (TxOut ConwayEra)) (TxBody ConwayEra)
Getting
  (StrictSeq (TxOut ConwayEra))
  (ConwayTxBody ConwayEra)
  (StrictSeq (TxOut ConwayEra))
forall era.
EraTxBody era =>
Lens' (TxBody era) (StrictSeq (TxOut era))
Lens' (TxBody ConwayEra) (StrictSeq (TxOut ConwayEra))
L.outputsTxBodyL)
      ]

validateTxOuts :: ShelleyBasedEra era -> [TxOut CtxTx era] -> Either TxOutputError ()
validateTxOuts :: forall era.
ShelleyBasedEra era -> [TxOut CtxTx era] -> Either TxOutputError ()
validateTxOuts ShelleyBasedEra era
sbe [TxOut CtxTx era]
txOuts = do
  let era :: CardanoEra era
era = ShelleyBasedEra era -> CardanoEra era
forall era. ShelleyBasedEra era -> CardanoEra era
forall (eon :: * -> *) era.
ToCardanoEra eon =>
eon era -> CardanoEra era
toCardanoEra ShelleyBasedEra era
sbe
  CardanoEra era
-> (CardanoEraConstraints era => Either TxOutputError ())
-> Either TxOutputError ()
forall era a.
CardanoEra era -> (CardanoEraConstraints era => a) -> a
cardanoEraConstraints CardanoEra era
era ((CardanoEraConstraints era => Either TxOutputError ())
 -> Either TxOutputError ())
-> (CardanoEraConstraints era => Either TxOutputError ())
-> Either TxOutputError ()
forall a b. (a -> b) -> a -> b
$
    [Either TxOutputError ()] -> Either TxOutputError ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_
      [ do
          CardanoEra era
-> Value -> TxOut CtxTx era -> Either TxOutputError ()
forall era.
CardanoEra era
-> Value -> TxOut CtxTx era -> Either TxOutputError ()
positiveOutput CardanoEra era
era (TxOutValue era -> Value
forall era. TxOutValue era -> Value
txOutValueToValue TxOutValue era
v) TxOut CtxTx era
txout
          CardanoEra era
-> Value -> TxOut CtxTx era -> Either TxOutputError ()
forall era.
CardanoEra era
-> Value -> TxOut CtxTx era -> Either TxOutputError ()
outputDoesNotExceedMax CardanoEra era
era (TxOutValue era -> Value
forall era. TxOutValue era -> Value
txOutValueToValue TxOutValue era
v) TxOut CtxTx era
txout
      | txout :: TxOut CtxTx era
txout@(TxOut AddressInEra era
_ TxOutValue era
v TxOutDatum CtxTx era
_ ReferenceScript era
_) <- [TxOut CtxTx era]
txOuts
      ]

outputDoesNotExceedMax
  :: ()
  => CardanoEra era
  -> Value
  -> TxOut CtxTx era
  -> Either TxOutputError ()
outputDoesNotExceedMax :: forall era.
CardanoEra era
-> Value -> TxOut CtxTx era -> Either TxOutputError ()
outputDoesNotExceedMax CardanoEra era
era Value
v TxOut CtxTx era
txout =
  case [Quantity
q | (AssetId
_, Quantity
q) <- Value -> [Item Value]
forall l. IsList l => l -> [Item l]
toList Value
v, Quantity
q Quantity -> Quantity -> Bool
forall a. Ord a => a -> a -> Bool
> Quantity
maxTxOut] of
    [] -> () -> Either TxOutputError ()
forall a b. b -> Either a b
Right ()
    Quantity
q : [Quantity]
_ -> TxOutputError -> Either TxOutputError ()
forall a b. a -> Either a b
Left (Quantity -> TxOutInAnyEra -> TxOutputError
TxOutputOverflow Quantity
q (CardanoEra era -> TxOut CtxTx era -> TxOutInAnyEra
forall era. CardanoEra era -> TxOut CtxTx era -> TxOutInAnyEra
txOutInAnyEra CardanoEra era
era TxOut CtxTx era
txout))

positiveOutput
  :: ()
  => CardanoEra era
  -> Value
  -> TxOut CtxTx era
  -> Either TxOutputError ()
positiveOutput :: forall era.
CardanoEra era
-> Value -> TxOut CtxTx era -> Either TxOutputError ()
positiveOutput CardanoEra era
era Value
v TxOut CtxTx era
txout =
  case [Quantity
q | (AssetId
_, Quantity
q) <- Value -> [Item Value]
forall l. IsList l => l -> [Item l]
toList Value
v, Quantity
q Quantity -> Quantity -> Bool
forall a. Ord a => a -> a -> Bool
< Quantity
0] of
    [] -> () -> Either TxOutputError ()
forall a b. b -> Either a b
Right ()
    Quantity
q : [Quantity]
_ -> TxOutputError -> Either TxOutputError ()
forall a b. a -> Either a b
Left (Quantity -> TxOutInAnyEra -> TxOutputError
TxOutputNegative Quantity
q (CardanoEra era -> TxOut CtxTx era -> TxOutInAnyEra
forall era. CardanoEra era -> TxOut CtxTx era -> TxOutInAnyEra
txOutInAnyEra CardanoEra era
era TxOut CtxTx era
txout))

maxTxOut :: Quantity
maxTxOut :: Quantity
maxTxOut = Word64 -> Quantity
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64
forall a. Bounded a => a
maxBound :: Word64)

fromAlonzoTxOut
  :: forall era ledgerera
   . AlonzoEraOnwards era
  -> Map L.DataHash (L.Data ledgerera)
  -> L.TxOut (ShelleyLedgerEra era)
  -> TxOut CtxTx era
fromAlonzoTxOut :: forall era ledgerera.
AlonzoEraOnwards era
-> Map DataHash (Data ledgerera)
-> TxOut (ShelleyLedgerEra era)
-> TxOut CtxTx era
fromAlonzoTxOut AlonzoEraOnwards era
w Map DataHash (Data ledgerera)
txdatums TxOut (ShelleyLedgerEra era)
txOut =
  AlonzoEraOnwards era
-> (AlonzoEraOnwardsConstraints era => TxOut CtxTx era)
-> TxOut CtxTx era
forall era a.
AlonzoEraOnwards era -> (AlonzoEraOnwardsConstraints era => a) -> a
alonzoEraOnwardsConstraints AlonzoEraOnwards era
w ((AlonzoEraOnwardsConstraints era => TxOut CtxTx era)
 -> TxOut CtxTx era)
-> (AlonzoEraOnwardsConstraints era => TxOut CtxTx era)
-> TxOut CtxTx era
forall a b. (a -> b) -> a -> b
$
    AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxTx era
-> ReferenceScript era
-> TxOut CtxTx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
      (ShelleyBasedEra era -> Addr -> AddressInEra era
forall era. ShelleyBasedEra era -> Addr -> AddressInEra era
fromShelleyAddr ShelleyBasedEra era
forall era. IsShelleyBasedEra era => ShelleyBasedEra era
shelleyBasedEra (TxOut (ShelleyLedgerEra era)
txOut TxOut (ShelleyLedgerEra era)
-> Getting Addr (TxOut (ShelleyLedgerEra era)) Addr -> Addr
forall s a. s -> Getting a s a -> a
^. Getting Addr (TxOut (ShelleyLedgerEra era)) Addr
forall era. EraTxOut era => Lens' (TxOut era) Addr
Lens' (TxOut (ShelleyLedgerEra era)) Addr
L.addrTxOutL))
      (ShelleyBasedEra era
-> Value (ShelleyLedgerEra era) -> TxOutValue era
forall era.
(Eq (Value (ShelleyLedgerEra era)),
 Show (Value (ShelleyLedgerEra era))) =>
ShelleyBasedEra era
-> Value (ShelleyLedgerEra era) -> TxOutValue era
TxOutValueShelleyBased ShelleyBasedEra era
sbe (TxOut (ShelleyLedgerEra era)
txOut TxOut (ShelleyLedgerEra era)
-> Getting MaryValue (TxOut (ShelleyLedgerEra era)) MaryValue
-> MaryValue
forall s a. s -> Getting a s a -> a
^. (Value (ShelleyLedgerEra era)
 -> Const MaryValue (Value (ShelleyLedgerEra era)))
-> TxOut (ShelleyLedgerEra era)
-> Const MaryValue (TxOut (ShelleyLedgerEra era))
Getting MaryValue (TxOut (ShelleyLedgerEra era)) MaryValue
forall era. EraTxOut era => Lens' (TxOut era) (Value era)
Lens' (TxOut (ShelleyLedgerEra era)) (Value (ShelleyLedgerEra era))
L.valueTxOutL))
      (AlonzoEraOnwards era
-> Map DataHash (Data ledgerera)
-> StrictMaybe DataHash
-> TxOutDatum CtxTx era
forall era ledgerera.
AlonzoEraOnwards era
-> Map DataHash (Data ledgerera)
-> StrictMaybe DataHash
-> TxOutDatum CtxTx era
fromAlonzoTxOutDatum AlonzoEraOnwards era
w Map DataHash (Data ledgerera)
txdatums (TxOut (ShelleyLedgerEra era)
txOut TxOut (ShelleyLedgerEra era)
-> Getting
     (StrictMaybe DataHash)
     (TxOut (ShelleyLedgerEra era))
     (StrictMaybe DataHash)
-> StrictMaybe DataHash
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe DataHash)
  (TxOut (ShelleyLedgerEra era))
  (StrictMaybe DataHash)
forall era.
AlonzoEraTxOut era =>
Lens' (TxOut era) (StrictMaybe DataHash)
Lens' (TxOut (ShelleyLedgerEra era)) (StrictMaybe DataHash)
L.dataHashTxOutL))
      ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
 where
  ShelleyBasedEra era
sbe :: ShelleyBasedEra era = AlonzoEraOnwards era -> ShelleyBasedEra era
forall era. AlonzoEraOnwards era -> ShelleyBasedEra era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert AlonzoEraOnwards era
w

fromAlonzoTxOutDatum
  :: ()
  => AlonzoEraOnwards era
  -> Map L.DataHash (L.Data ledgerera)
  -> StrictMaybe L.DataHash
  -> TxOutDatum CtxTx era
fromAlonzoTxOutDatum :: forall era ledgerera.
AlonzoEraOnwards era
-> Map DataHash (Data ledgerera)
-> StrictMaybe DataHash
-> TxOutDatum CtxTx era
fromAlonzoTxOutDatum AlonzoEraOnwards era
w Map DataHash (Data ledgerera)
txdatums = \case
  StrictMaybe DataHash
SNothing -> TxOutDatum CtxTx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
  SJust DataHash
dh
    | Just Data ledgerera
d <- DataHash -> Map DataHash (Data ledgerera) -> Maybe (Data ledgerera)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup DataHash
dh Map DataHash (Data ledgerera)
txdatums ->
        AlonzoEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
forall era.
AlonzoEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
TxOutSupplementalDatum AlonzoEraOnwards era
w (Data ledgerera -> HashableScriptData
forall ledgerera. Data ledgerera -> HashableScriptData
fromAlonzoData Data ledgerera
d)
    | Bool
otherwise -> AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum CtxTx era
forall era ctx.
AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash AlonzoEraOnwards era
w (DataHash -> Hash ScriptData
ScriptDataHash DataHash
dh)

fromBabbageTxOut
  :: forall era
   . BabbageEraOnwards era
  -> Map L.DataHash (L.Data (ShelleyLedgerEra era))
  -> L.TxOut (ShelleyLedgerEra era)
  -> TxOut CtxTx era
fromBabbageTxOut :: forall era.
BabbageEraOnwards era
-> Map DataHash (Data (ShelleyLedgerEra era))
-> TxOut (ShelleyLedgerEra era)
-> TxOut CtxTx era
fromBabbageTxOut BabbageEraOnwards era
w Map DataHash (Data (ShelleyLedgerEra era))
txdatums TxOut (ShelleyLedgerEra era)
txout =
  BabbageEraOnwards era
-> (BabbageEraOnwardsConstraints era => TxOut CtxTx era)
-> TxOut CtxTx era
forall era a.
BabbageEraOnwards era
-> (BabbageEraOnwardsConstraints era => a) -> a
babbageEraOnwardsConstraints BabbageEraOnwards era
w ((BabbageEraOnwardsConstraints era => TxOut CtxTx era)
 -> TxOut CtxTx era)
-> (BabbageEraOnwardsConstraints era => TxOut CtxTx era)
-> TxOut CtxTx era
forall a b. (a -> b) -> a -> b
$
    AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxTx era
-> ReferenceScript era
-> TxOut CtxTx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
      (ShelleyBasedEra era -> Addr -> AddressInEra era
forall era. ShelleyBasedEra era -> Addr -> AddressInEra era
fromShelleyAddr ShelleyBasedEra era
forall era. IsShelleyBasedEra era => ShelleyBasedEra era
shelleyBasedEra (TxOut (ShelleyLedgerEra era)
BabbageTxOut (ShelleyLedgerEra era)
txout BabbageTxOut (ShelleyLedgerEra era)
-> Getting Addr (BabbageTxOut (ShelleyLedgerEra era)) Addr -> Addr
forall s a. s -> Getting a s a -> a
^. (Addr -> Const Addr Addr)
-> TxOut (ShelleyLedgerEra era)
-> Const Addr (TxOut (ShelleyLedgerEra era))
Getting Addr (BabbageTxOut (ShelleyLedgerEra era)) Addr
forall era. EraTxOut era => Lens' (TxOut era) Addr
Lens' (TxOut (ShelleyLedgerEra era)) Addr
L.addrTxOutL))
      (ShelleyBasedEra era
-> Value (ShelleyLedgerEra era) -> TxOutValue era
forall era.
(Eq (Value (ShelleyLedgerEra era)),
 Show (Value (ShelleyLedgerEra era))) =>
ShelleyBasedEra era
-> Value (ShelleyLedgerEra era) -> TxOutValue era
TxOutValueShelleyBased ShelleyBasedEra era
sbe (TxOut (ShelleyLedgerEra era)
BabbageTxOut (ShelleyLedgerEra era)
txout BabbageTxOut (ShelleyLedgerEra era)
-> Getting
     MaryValue (BabbageTxOut (ShelleyLedgerEra era)) MaryValue
-> MaryValue
forall s a. s -> Getting a s a -> a
^. (Value (ShelleyLedgerEra era)
 -> Const MaryValue (Value (ShelleyLedgerEra era)))
-> TxOut (ShelleyLedgerEra era)
-> Const MaryValue (TxOut (ShelleyLedgerEra era))
Getting MaryValue (BabbageTxOut (ShelleyLedgerEra era)) MaryValue
forall era. EraTxOut era => Lens' (TxOut era) (Value era)
Lens' (TxOut (ShelleyLedgerEra era)) (Value (ShelleyLedgerEra era))
L.valueTxOutL))
      TxOutDatum CtxTx era
babbageTxOutDatum
      ( case TxOut (ShelleyLedgerEra era)
BabbageTxOut (ShelleyLedgerEra era)
txout BabbageTxOut (ShelleyLedgerEra era)
-> Getting
     (StrictMaybe (Script (ShelleyLedgerEra era)))
     (BabbageTxOut (ShelleyLedgerEra era))
     (StrictMaybe (Script (ShelleyLedgerEra era)))
-> StrictMaybe (Script (ShelleyLedgerEra era))
forall s a. s -> Getting a s a -> a
^. (StrictMaybe (Script (ShelleyLedgerEra era))
 -> Const
      (StrictMaybe (Script (ShelleyLedgerEra era)))
      (StrictMaybe (Script (ShelleyLedgerEra era))))
-> TxOut (ShelleyLedgerEra era)
-> Const
     (StrictMaybe (Script (ShelleyLedgerEra era)))
     (TxOut (ShelleyLedgerEra era))
Getting
  (StrictMaybe (Script (ShelleyLedgerEra era)))
  (BabbageTxOut (ShelleyLedgerEra era))
  (StrictMaybe (Script (ShelleyLedgerEra era)))
forall era.
BabbageEraTxOut era =>
Lens' (TxOut era) (StrictMaybe (Script era))
Lens'
  (TxOut (ShelleyLedgerEra era))
  (StrictMaybe (Script (ShelleyLedgerEra era)))
L.referenceScriptTxOutL of
          StrictMaybe (Script (ShelleyLedgerEra era))
SNothing -> ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
          SJust Script (ShelleyLedgerEra era)
rScript -> ShelleyBasedEra era
-> Script (ShelleyLedgerEra era) -> ReferenceScript era
forall era.
ShelleyBasedEra era
-> Script (ShelleyLedgerEra era) -> ReferenceScript era
fromShelleyScriptToReferenceScript ShelleyBasedEra era
forall era. IsShelleyBasedEra era => ShelleyBasedEra era
shelleyBasedEra Script (ShelleyLedgerEra era)
rScript
      )
 where
  ShelleyBasedEra era
sbe :: ShelleyBasedEra era = BabbageEraOnwards era -> ShelleyBasedEra era
forall era. BabbageEraOnwards era -> ShelleyBasedEra era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert BabbageEraOnwards era
w

  -- NOTE: This is different to 'fromBabbageTxOutDatum' as it may resolve
  -- 'DatumHash' values using the datums included in the transaction.
  babbageTxOutDatum :: TxOutDatum CtxTx era
  babbageTxOutDatum :: TxOutDatum CtxTx era
babbageTxOutDatum =
    BabbageEraOnwards era
-> (BabbageEraOnwardsConstraints era => TxOutDatum CtxTx era)
-> TxOutDatum CtxTx era
forall era a.
BabbageEraOnwards era
-> (BabbageEraOnwardsConstraints era => a) -> a
babbageEraOnwardsConstraints BabbageEraOnwards era
w ((BabbageEraOnwardsConstraints era => TxOutDatum CtxTx era)
 -> TxOutDatum CtxTx era)
-> (BabbageEraOnwardsConstraints era => TxOutDatum CtxTx era)
-> TxOutDatum CtxTx era
forall a b. (a -> b) -> a -> b
$
      case TxOut (ShelleyLedgerEra era)
BabbageTxOut (ShelleyLedgerEra era)
txout BabbageTxOut (ShelleyLedgerEra era)
-> Getting
     (Datum (ShelleyLedgerEra era))
     (BabbageTxOut (ShelleyLedgerEra era))
     (Datum (ShelleyLedgerEra era))
-> Datum (ShelleyLedgerEra era)
forall s a. s -> Getting a s a -> a
^. (Datum (ShelleyLedgerEra era)
 -> Const
      (Datum (ShelleyLedgerEra era)) (Datum (ShelleyLedgerEra era)))
-> TxOut (ShelleyLedgerEra era)
-> Const
     (Datum (ShelleyLedgerEra era)) (TxOut (ShelleyLedgerEra era))
Getting
  (Datum (ShelleyLedgerEra era))
  (BabbageTxOut (ShelleyLedgerEra era))
  (Datum (ShelleyLedgerEra era))
forall era. BabbageEraTxOut era => Lens' (TxOut era) (Datum era)
Lens' (TxOut (ShelleyLedgerEra era)) (Datum (ShelleyLedgerEra era))
L.datumTxOutL of
        Datum (ShelleyLedgerEra era)
L.NoDatum -> TxOutDatum CtxTx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
        L.DatumHash DataHash
dh -> DataHash -> TxOutDatum CtxTx era
resolveDatumInTx DataHash
dh
        L.Datum BinaryData (ShelleyLedgerEra era)
d -> BabbageEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
forall era ctx.
BabbageEraOnwards era -> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline BabbageEraOnwards era
w (HashableScriptData -> TxOutDatum CtxTx era)
-> HashableScriptData -> TxOutDatum CtxTx era
forall a b. (a -> b) -> a -> b
$ BabbageEraOnwards era
-> BinaryData (ShelleyLedgerEra era) -> HashableScriptData
forall ledgerera era.
Era ledgerera =>
BabbageEraOnwards era -> BinaryData ledgerera -> HashableScriptData
binaryDataToScriptData BabbageEraOnwards era
w BinaryData (ShelleyLedgerEra era)
d

  resolveDatumInTx :: L.DataHash -> TxOutDatum CtxTx era
  resolveDatumInTx :: DataHash -> TxOutDatum CtxTx era
resolveDatumInTx DataHash
dh
    | Just Data (ShelleyLedgerEra era)
d <- DataHash
-> Map DataHash (Data (ShelleyLedgerEra era))
-> Maybe (Data (ShelleyLedgerEra era))
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup DataHash
dh Map DataHash (Data (ShelleyLedgerEra era))
txdatums =
        AlonzoEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
forall era.
AlonzoEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
TxOutSupplementalDatum
          (BabbageEraOnwards era -> AlonzoEraOnwards era
forall era. BabbageEraOnwards era -> AlonzoEraOnwards era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert BabbageEraOnwards era
w)
          (Data (ShelleyLedgerEra era) -> HashableScriptData
forall ledgerera. Data ledgerera -> HashableScriptData
fromAlonzoData Data (ShelleyLedgerEra era)
d)
    | Bool
otherwise = AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum CtxTx era
forall era ctx.
AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash (BabbageEraOnwards era -> AlonzoEraOnwards era
forall era. BabbageEraOnwards era -> AlonzoEraOnwards era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert BabbageEraOnwards era
w) (DataHash -> Hash ScriptData
ScriptDataHash DataHash
dh)

instance IsCardanoEra era => ToJSON (TxOut ctx era) where
  toJSON :: TxOut ctx era -> Value
toJSON = CardanoEra era -> TxOut ctx era -> Value
forall era ctx. CardanoEra era -> TxOut ctx era -> Value
txOutToJsonValue CardanoEra era
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" Key -> AddressInEra era -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= AddressInEra era
addr, Key
"value" Key -> TxOutValue era -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era
val]
    CardanoEra era
ShelleyEra -> [Pair] -> Value
object [Key
"address" Key -> AddressInEra era -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= AddressInEra era
addr, Key
"value" Key -> TxOutValue era -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era
val]
    CardanoEra era
AllegraEra -> [Pair] -> Value
object [Key
"address" Key -> AddressInEra era -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= AddressInEra era
addr, Key
"value" Key -> TxOutValue era -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era
val]
    CardanoEra era
MaryEra -> [Pair] -> Value
object [Key
"address" Key -> AddressInEra era -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= AddressInEra era
addr, Key
"value" Key -> TxOutValue era -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era
val]
    CardanoEra era
AlonzoEra ->
      [Pair] -> Value
object
        [ Key
"address" Key -> AddressInEra era -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= AddressInEra era
addr
        , Key
"value" Key -> TxOutValue era -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era
val
        , TxOutDatum ctx era -> Pair
forall ctx era. TxOutDatum ctx era -> Pair
datHashJsonVal TxOutDatum ctx era
dat
        , Key
"datum" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutDatum ctx era -> Value
forall ctx era. TxOutDatum ctx era -> Value
datJsonVal TxOutDatum ctx era
dat
        ]
    CardanoEra era
BabbageEra ->
      [Pair] -> Value
object
        [ Key
"address" Key -> AddressInEra era -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= AddressInEra era
addr
        , Key
"value" Key -> TxOutValue era -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era
val
        , TxOutDatum ctx era -> Pair
forall ctx era. TxOutDatum ctx era -> Pair
datHashJsonVal TxOutDatum ctx era
dat
        , Key
"datum" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutDatum ctx era -> Value
forall ctx era. TxOutDatum ctx era -> Value
datJsonVal TxOutDatum ctx era
dat
        , Key
"inlineDatum" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutDatum ctx era -> Value
forall ctx era. TxOutDatum ctx era -> Value
inlineDatumJsonVal TxOutDatum ctx era
dat
        , Key
"inlineDatumRaw" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutDatum ctx era -> Value
forall ctx era. TxOutDatum ctx era -> Value
inlineDatumRawJsonCbor TxOutDatum ctx era
dat
        , Key
"referenceScript" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ReferenceScript era -> Value
forall era. ReferenceScript era -> Value
refScriptJsonVal ReferenceScript era
refScript
        ]
    CardanoEra era
ConwayEra ->
      [Pair] -> Value
object
        [ Key
"address" Key -> AddressInEra era -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= AddressInEra era
addr
        , Key
"value" Key -> TxOutValue era -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutValue era
val
        , TxOutDatum ctx era -> Pair
forall ctx era. TxOutDatum ctx era -> Pair
datHashJsonVal TxOutDatum ctx era
dat
        , Key
"datum" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutDatum ctx era -> Value
forall ctx era. TxOutDatum ctx era -> Value
datJsonVal TxOutDatum ctx era
dat
        , Key
"inlineDatum" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutDatum ctx era -> Value
forall ctx era. TxOutDatum ctx era -> Value
inlineDatumJsonVal TxOutDatum ctx era
dat
        , Key
"inlineDatumRaw" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= TxOutDatum ctx era -> Value
forall ctx era. TxOutDatum ctx era -> Value
inlineDatumRawJsonCbor TxOutDatum ctx era
dat
        , Key
"referenceScript" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ReferenceScript era -> Value
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" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value
Aeson.Null
      TxOutDatumHash AlonzoEraOnwards era
_ Hash ScriptData
h ->
        Key
"datumhash" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Hash ScriptData -> Value
forall a. ToJSON a => a -> Value
toJSON Hash ScriptData
h
      TxOutSupplementalDatum AlonzoEraOnwards era
_ HashableScriptData
datum ->
        Key
"datumhash" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Hash ScriptData -> Value
forall a. ToJSON a => a -> Value
toJSON (HashableScriptData -> Hash ScriptData
hashScriptDataBytes HashableScriptData
datum)
      TxOutDatumInline BabbageEraOnwards era
_ HashableScriptData
datum ->
        Key
"inlineDatumhash" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Hash ScriptData -> Value
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 AlonzoEraOnwards era
_ Hash ScriptData
_ -> Value
Aeson.Null
      TxOutSupplementalDatum AlonzoEraOnwards era
_ HashableScriptData
datum -> ScriptDataJsonSchema -> HashableScriptData -> Value
scriptDataToJson ScriptDataJsonSchema
ScriptDataJsonDetailedSchema HashableScriptData
datum
      TxOutDatumInline BabbageEraOnwards 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
      TxOutSupplementalDatum{} -> Value
Aeson.Null
      TxOutDatumInline BabbageEraOnwards era
_ HashableScriptData
datum -> ScriptDataJsonSchema -> HashableScriptData -> Value
scriptDataToJson ScriptDataJsonSchema
ScriptDataJsonDetailedSchema HashableScriptData
datum

  inlineDatumRawJsonCbor :: TxOutDatum ctx era -> Aeson.Value
  inlineDatumRawJsonCbor :: forall ctx era. TxOutDatum ctx era -> Value
inlineDatumRawJsonCbor TxOutDatum ctx era
d =
    case TxOutDatum ctx era
d of
      TxOutDatum ctx era
TxOutDatumNone -> Value
Aeson.Null
      TxOutDatumHash{} -> Value
Aeson.Null
      TxOutSupplementalDatum{} -> Value
Aeson.Null
      TxOutDatumInline BabbageEraOnwards era
_ HashableScriptData
datum ->
        Text -> Value
Aeson.String
          (Text -> Value)
-> (HashableScriptData -> Text) -> HashableScriptData -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Text
Text.decodeUtf8
          (ByteString -> Text)
-> (HashableScriptData -> ByteString) -> HashableScriptData -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
Base16.encode
          (ByteString -> ByteString)
-> (HashableScriptData -> ByteString)
-> HashableScriptData
-> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashableScriptData -> ByteString
forall a. SerialiseAsCBOR a => a -> ByteString
serialiseToCBOR
          (HashableScriptData -> Value) -> HashableScriptData -> Value
forall a b. (a -> b) -> a -> b
$ HashableScriptData
datum

  refScriptJsonVal :: ReferenceScript era -> Aeson.Value
  refScriptJsonVal :: forall era. ReferenceScript era -> Value
refScriptJsonVal ReferenceScript era
rScript =
    case ReferenceScript era
rScript of
      ReferenceScript BabbageEraOnwards era
_ ScriptInAnyLang
s -> ScriptInAnyLang -> Value
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 = String
-> (Object -> Parser (TxOut CtxTx era))
-> Value
-> Parser (TxOut CtxTx era)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"TxOut" ((Object -> Parser (TxOut CtxTx era))
 -> Value -> Parser (TxOut CtxTx era))
-> (Object -> Parser (TxOut CtxTx era))
-> Value
-> Parser (TxOut CtxTx era)
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    case ShelleyBasedEra era
forall era. IsShelleyBasedEra era => ShelleyBasedEra era
shelleyBasedEra :: ShelleyBasedEra era of
      ShelleyBasedEra era
ShelleyBasedEraShelley ->
        AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxTx era
-> ReferenceScript era
-> TxOut CtxTx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
          (AddressInEra era
 -> TxOutValue era
 -> TxOutDatum CtxTx era
 -> ReferenceScript era
 -> TxOut CtxTx era)
-> Parser (AddressInEra era)
-> Parser
     (TxOutValue era
      -> TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (AddressInEra era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
          Parser
  (TxOutValue era
   -> TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
-> Parser (TxOutValue era)
-> Parser
     (TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (TxOutValue era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
          Parser
  (TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
-> Parser (TxOutDatum CtxTx era)
-> Parser (ReferenceScript era -> TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TxOutDatum CtxTx era -> Parser (TxOutDatum CtxTx era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxTx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
          Parser (ReferenceScript era -> TxOut CtxTx era)
-> Parser (ReferenceScript era) -> Parser (TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReferenceScript era -> Parser (ReferenceScript era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
      ShelleyBasedEra era
ShelleyBasedEraMary ->
        AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxTx era
-> ReferenceScript era
-> TxOut CtxTx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
          (AddressInEra era
 -> TxOutValue era
 -> TxOutDatum CtxTx era
 -> ReferenceScript era
 -> TxOut CtxTx era)
-> Parser (AddressInEra era)
-> Parser
     (TxOutValue era
      -> TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (AddressInEra era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
          Parser
  (TxOutValue era
   -> TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
-> Parser (TxOutValue era)
-> Parser
     (TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (TxOutValue era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
          Parser
  (TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
-> Parser (TxOutDatum CtxTx era)
-> Parser (ReferenceScript era -> TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TxOutDatum CtxTx era -> Parser (TxOutDatum CtxTx era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxTx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
          Parser (ReferenceScript era -> TxOut CtxTx era)
-> Parser (ReferenceScript era) -> Parser (TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReferenceScript era -> Parser (ReferenceScript era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
      ShelleyBasedEra era
ShelleyBasedEraAllegra ->
        AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxTx era
-> ReferenceScript era
-> TxOut CtxTx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
          (AddressInEra era
 -> TxOutValue era
 -> TxOutDatum CtxTx era
 -> ReferenceScript era
 -> TxOut CtxTx era)
-> Parser (AddressInEra era)
-> Parser
     (TxOutValue era
      -> TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (AddressInEra era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
          Parser
  (TxOutValue era
   -> TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
-> Parser (TxOutValue era)
-> Parser
     (TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (TxOutValue era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
          Parser
  (TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
-> Parser (TxOutDatum CtxTx era)
-> Parser (ReferenceScript era -> TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TxOutDatum CtxTx era -> Parser (TxOutDatum CtxTx era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxTx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
          Parser (ReferenceScript era -> TxOut CtxTx era)
-> Parser (ReferenceScript era) -> Parser (TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReferenceScript era -> Parser (ReferenceScript era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
      ShelleyBasedEra era
ShelleyBasedEraAlonzo -> AlonzoEraOnwards era -> Object -> Parser (TxOut CtxTx era)
alonzoTxOutParser AlonzoEraOnwards era
AlonzoEraOnwards AlonzoEra
AlonzoEraOnwardsAlonzo Object
o
      ShelleyBasedEra era
ShelleyBasedEraBabbage -> do
        TxOut CtxTx era
alonzoTxOutInBabbage <- AlonzoEraOnwards era -> Object -> Parser (TxOut CtxTx era)
alonzoTxOutParser AlonzoEraOnwards era
AlonzoEraOnwards BabbageEra
AlonzoEraOnwardsBabbage Object
o

        -- We check for the existence of inline datums
        Maybe (Hash ScriptData)
inlineDatumHash <- Object
o Object -> Key -> Parser (Maybe (Hash ScriptData))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inlineDatumhash"
        Maybe Value
inlineDatum <- Object
o Object -> Key -> Parser (Maybe Value)
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 ->
                  String -> Parser (TxOutDatum CtxTx BabbageEra)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser (TxOutDatum CtxTx BabbageEra))
-> String -> Parser (TxOutDatum CtxTx BabbageEra)
forall a b. (a -> b) -> a -> b
$ String
"Error parsing TxOut JSON: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> ScriptDataJsonBytesError -> String
forall a. Error a => a -> String
displayError ScriptDataJsonBytesError
err
                Right HashableScriptData
hashableData -> do
                  if HashableScriptData -> Hash ScriptData
hashScriptDataBytes HashableScriptData
hashableData Hash ScriptData -> Hash ScriptData -> Bool
forall a. Eq a => a -> a -> Bool
/= Hash ScriptData
h
                    then String -> Parser (TxOutDatum CtxTx BabbageEra)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Inline datum not equivalent to inline datum hash"
                    else TxOutDatum CtxTx BabbageEra -> Parser (TxOutDatum CtxTx BabbageEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (TxOutDatum CtxTx BabbageEra
 -> Parser (TxOutDatum CtxTx BabbageEra))
-> TxOutDatum CtxTx BabbageEra
-> Parser (TxOutDatum CtxTx BabbageEra)
forall a b. (a -> b) -> a -> b
$ BabbageEraOnwards BabbageEra
-> HashableScriptData -> TxOutDatum CtxTx BabbageEra
forall era ctx.
BabbageEraOnwards era -> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline BabbageEraOnwards BabbageEra
BabbageEraOnwardsBabbage HashableScriptData
hashableData
            (Maybe Value
Nothing, Maybe (Hash ScriptData)
Nothing) -> TxOutDatum CtxTx BabbageEra -> Parser (TxOutDatum CtxTx BabbageEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxTx BabbageEra
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
            (Maybe Value
_, Maybe (Hash ScriptData)
_) ->
              String -> Parser (TxOutDatum CtxTx BabbageEra)
forall a. String -> Parser a
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 Object -> Key -> Parser (Maybe ScriptInAnyLang)
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
TxOut CtxTx BabbageEra
alonzoTxOutInBabbage TxOutDatum CtxTx BabbageEra
mInlineDatum Maybe ScriptInAnyLang
mReferenceScript
      ShelleyBasedEra era
ShelleyBasedEraConway -> do
        TxOut CtxTx era
alonzoTxOutInConway <- AlonzoEraOnwards era -> Object -> Parser (TxOut CtxTx era)
alonzoTxOutParser AlonzoEraOnwards era
AlonzoEraOnwards ConwayEra
AlonzoEraOnwardsConway Object
o

        -- We check for the existence of inline datums
        Maybe (Hash ScriptData)
inlineDatumHash <- Object
o Object -> Key -> Parser (Maybe (Hash ScriptData))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inlineDatumhash"
        Maybe Value
inlineDatum <- Object
o Object -> Key -> Parser (Maybe Value)
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 ->
                  String -> Parser (TxOutDatum CtxTx ConwayEra)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser (TxOutDatum CtxTx ConwayEra))
-> String -> Parser (TxOutDatum CtxTx ConwayEra)
forall a b. (a -> b) -> a -> b
$ String
"Error parsing TxOut JSON: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> ScriptDataJsonError -> String
forall a. Error a => a -> String
displayError ScriptDataJsonError
err
                Right HashableScriptData
sData ->
                  if HashableScriptData -> Hash ScriptData
hashScriptDataBytes HashableScriptData
sData Hash ScriptData -> Hash ScriptData -> Bool
forall a. Eq a => a -> a -> Bool
/= Hash ScriptData
h
                    then String -> Parser (TxOutDatum CtxTx ConwayEra)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Inline datum not equivalent to inline datum hash"
                    else TxOutDatum CtxTx ConwayEra -> Parser (TxOutDatum CtxTx ConwayEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (TxOutDatum CtxTx ConwayEra -> Parser (TxOutDatum CtxTx ConwayEra))
-> TxOutDatum CtxTx ConwayEra
-> Parser (TxOutDatum CtxTx ConwayEra)
forall a b. (a -> b) -> a -> b
$ BabbageEraOnwards ConwayEra
-> HashableScriptData -> TxOutDatum CtxTx ConwayEra
forall era ctx.
BabbageEraOnwards era -> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline BabbageEraOnwards ConwayEra
BabbageEraOnwardsConway HashableScriptData
sData
            (Maybe Value
Nothing, Maybe (Hash ScriptData)
Nothing) -> TxOutDatum CtxTx ConwayEra -> Parser (TxOutDatum CtxTx ConwayEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxTx ConwayEra
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
            (Maybe Value
_, Maybe (Hash ScriptData)
_) ->
              String -> Parser (TxOutDatum CtxTx ConwayEra)
forall a. String -> Parser a
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 Object -> Key -> Parser (Maybe ScriptInAnyLang)
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
TxOut CtxTx ConwayEra
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) -> TxOutDatum CtxTx BabbageEra -> Parser (TxOutDatum CtxTx BabbageEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxTx BabbageEra
bDatum
        (TxOutDatum CtxTx BabbageEra
anyDat, TxOutDatum CtxTx BabbageEra
TxOutDatumNone) -> TxOutDatum CtxTx BabbageEra -> Parser (TxOutDatum CtxTx BabbageEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxTx BabbageEra
anyDat
        (TxOutDatum CtxTx BabbageEra
alonzoDat, TxOutDatum CtxTx BabbageEra
babbageDat) ->
          String -> Parser (TxOutDatum CtxTx BabbageEra)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser (TxOutDatum CtxTx BabbageEra))
-> String -> Parser (TxOutDatum CtxTx BabbageEra)
forall a b. (a -> b) -> a -> b
$
            String
"Parsed an Alonzo era datum and a Babbage era datum "
              String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"TxOut: "
              String -> ShowS
forall a. Semigroup a => a -> a -> a
<> TxOut CtxTx BabbageEra -> String
forall a. Show a => a -> String
show TxOut CtxTx BabbageEra
top
              String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"Alonzo datum: "
              String -> ShowS
forall a. Semigroup a => a -> a -> a
<> TxOutDatum CtxTx BabbageEra -> String
forall a. Show a => a -> String
show TxOutDatum CtxTx BabbageEra
alonzoDat
              String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"Babbage dat: "
              String -> ShowS
forall a. Semigroup a => a -> a -> a
<> TxOutDatum CtxTx BabbageEra -> String
forall a. Show a => a -> String
show TxOutDatum CtxTx BabbageEra
babbageDat
      ReferenceScript BabbageEra
finalRefScript <- case Maybe ScriptInAnyLang
mBabRefScript of
        Maybe ScriptInAnyLang
Nothing -> ReferenceScript BabbageEra -> Parser (ReferenceScript BabbageEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript BabbageEra
r
        Just ScriptInAnyLang
anyScript ->
          ReferenceScript BabbageEra -> Parser (ReferenceScript BabbageEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (ReferenceScript BabbageEra -> Parser (ReferenceScript BabbageEra))
-> ReferenceScript BabbageEra
-> Parser (ReferenceScript BabbageEra)
forall a b. (a -> b) -> a -> b
$ BabbageEraOnwards BabbageEra
-> ScriptInAnyLang -> ReferenceScript BabbageEra
forall era.
BabbageEraOnwards era -> ScriptInAnyLang -> ReferenceScript era
ReferenceScript BabbageEraOnwards BabbageEra
BabbageEraOnwardsBabbage ScriptInAnyLang
anyScript
      TxOut CtxTx BabbageEra -> Parser (TxOut CtxTx BabbageEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (TxOut CtxTx BabbageEra -> Parser (TxOut CtxTx BabbageEra))
-> TxOut CtxTx BabbageEra -> Parser (TxOut CtxTx BabbageEra)
forall a b. (a -> b) -> a -> b
$ AddressInEra BabbageEra
-> TxOutValue BabbageEra
-> TxOutDatum CtxTx BabbageEra
-> ReferenceScript BabbageEra
-> TxOut CtxTx BabbageEra
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) -> TxOutDatum CtxTx ConwayEra -> Parser (TxOutDatum CtxTx ConwayEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxTx ConwayEra
bDatum
        (TxOutDatum CtxTx ConwayEra
anyDat, TxOutDatum CtxTx ConwayEra
TxOutDatumNone) -> TxOutDatum CtxTx ConwayEra -> Parser (TxOutDatum CtxTx ConwayEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxTx ConwayEra
anyDat
        (TxOutDatum CtxTx ConwayEra
alonzoDat, TxOutDatum CtxTx ConwayEra
babbageDat) ->
          String -> Parser (TxOutDatum CtxTx ConwayEra)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser (TxOutDatum CtxTx ConwayEra))
-> String -> Parser (TxOutDatum CtxTx ConwayEra)
forall a b. (a -> b) -> a -> b
$
            String
"Parsed an Alonzo era datum and a Conway era datum "
              String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"TxOut: "
              String -> ShowS
forall a. Semigroup a => a -> a -> a
<> TxOut CtxTx ConwayEra -> String
forall a. Show a => a -> String
show TxOut CtxTx ConwayEra
top
              String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"Alonzo datum: "
              String -> ShowS
forall a. Semigroup a => a -> a -> a
<> TxOutDatum CtxTx ConwayEra -> String
forall a. Show a => a -> String
show TxOutDatum CtxTx ConwayEra
alonzoDat
              String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"Conway dat: "
              String -> ShowS
forall a. Semigroup a => a -> a -> a
<> TxOutDatum CtxTx ConwayEra -> String
forall a. Show a => a -> String
show TxOutDatum CtxTx ConwayEra
babbageDat
      ReferenceScript ConwayEra
finalRefScript <- case Maybe ScriptInAnyLang
mBabRefScript of
        Maybe ScriptInAnyLang
Nothing -> ReferenceScript ConwayEra -> Parser (ReferenceScript ConwayEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript ConwayEra
r
        Just ScriptInAnyLang
anyScript ->
          ReferenceScript ConwayEra -> Parser (ReferenceScript ConwayEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (ReferenceScript ConwayEra -> Parser (ReferenceScript ConwayEra))
-> ReferenceScript ConwayEra -> Parser (ReferenceScript ConwayEra)
forall a b. (a -> b) -> a -> b
$ BabbageEraOnwards ConwayEra
-> ScriptInAnyLang -> ReferenceScript ConwayEra
forall era.
BabbageEraOnwards era -> ScriptInAnyLang -> ReferenceScript era
ReferenceScript BabbageEraOnwards ConwayEra
BabbageEraOnwardsConway ScriptInAnyLang
anyScript
      TxOut CtxTx ConwayEra -> Parser (TxOut CtxTx ConwayEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (TxOut CtxTx ConwayEra -> Parser (TxOut CtxTx ConwayEra))
-> TxOut CtxTx ConwayEra -> Parser (TxOut CtxTx ConwayEra)
forall a b. (a -> b) -> a -> b
$ AddressInEra ConwayEra
-> TxOutValue ConwayEra
-> TxOutDatum CtxTx ConwayEra
-> ReferenceScript ConwayEra
-> TxOut CtxTx ConwayEra
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
      :: AlonzoEraOnwards era -> Aeson.Object -> Aeson.Parser (TxOut CtxTx era)
    alonzoTxOutParser :: AlonzoEraOnwards era -> Object -> Parser (TxOut CtxTx era)
alonzoTxOutParser AlonzoEraOnwards era
w Object
o = do
      Maybe (Hash ScriptData)
mDatumHash <- Object
o Object -> Key -> Parser (Maybe (Hash ScriptData))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"datumhash"
      Maybe Value
mDatumVal <- Object
o Object -> Key -> Parser (Maybe Value)
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) ->
          AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxTx era
-> ReferenceScript era
-> TxOut CtxTx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
            (AddressInEra era
 -> TxOutValue era
 -> TxOutDatum CtxTx era
 -> ReferenceScript era
 -> TxOut CtxTx era)
-> Parser (AddressInEra era)
-> Parser
     (TxOutValue era
      -> TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (AddressInEra era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
            Parser
  (TxOutValue era
   -> TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
-> Parser (TxOutValue era)
-> Parser
     (TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (TxOutValue era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
            Parser
  (TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
-> Parser (TxOutDatum CtxTx era)
-> Parser (ReferenceScript era -> TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TxOutDatum CtxTx era -> Parser (TxOutDatum CtxTx era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxTx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
            Parser (ReferenceScript era -> TxOut CtxTx era)
-> Parser (ReferenceScript era) -> Parser (TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReferenceScript era -> Parser (ReferenceScript era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
        (Just Value
dVal, Just{}) -> do
          case ScriptDataJsonSchema
-> Value -> Either ScriptDataJsonBytesError HashableScriptData
scriptDataJsonToHashable ScriptDataJsonSchema
ScriptDataJsonDetailedSchema Value
dVal of
            Left ScriptDataJsonBytesError
e -> String -> Parser (TxOut CtxTx era)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser (TxOut CtxTx era))
-> String -> Parser (TxOut CtxTx era)
forall a b. (a -> b) -> a -> b
$ String
"Error parsing ScriptData: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> ScriptDataJsonBytesError -> String
forall a. Show a => a -> String
show ScriptDataJsonBytesError
e
            Right HashableScriptData
hashableData ->
              AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxTx era
-> ReferenceScript era
-> TxOut CtxTx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
                (AddressInEra era
 -> TxOutValue era
 -> TxOutDatum CtxTx era
 -> ReferenceScript era
 -> TxOut CtxTx era)
-> Parser (AddressInEra era)
-> Parser
     (TxOutValue era
      -> TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (AddressInEra era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
                Parser
  (TxOutValue era
   -> TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
-> Parser (TxOutValue era)
-> Parser
     (TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (TxOutValue era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
                Parser
  (TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
-> Parser (TxOutDatum CtxTx era)
-> Parser (ReferenceScript era -> TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TxOutDatum CtxTx era -> Parser (TxOutDatum CtxTx era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (AlonzoEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
forall era.
AlonzoEraOnwards era -> HashableScriptData -> TxOutDatum CtxTx era
TxOutSupplementalDatum AlonzoEraOnwards era
w HashableScriptData
hashableData)
                Parser (ReferenceScript era -> TxOut CtxTx era)
-> Parser (ReferenceScript era) -> Parser (TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReferenceScript era -> Parser (ReferenceScript era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
        (Maybe Value
Nothing, Just Hash ScriptData
dHash) ->
          AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxTx era
-> ReferenceScript era
-> TxOut CtxTx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
            (AddressInEra era
 -> TxOutValue era
 -> TxOutDatum CtxTx era
 -> ReferenceScript era
 -> TxOut CtxTx era)
-> Parser (AddressInEra era)
-> Parser
     (TxOutValue era
      -> TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (AddressInEra era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
            Parser
  (TxOutValue era
   -> TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
-> Parser (TxOutValue era)
-> Parser
     (TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (TxOutValue era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
            Parser
  (TxOutDatum CtxTx era -> ReferenceScript era -> TxOut CtxTx era)
-> Parser (TxOutDatum CtxTx era)
-> Parser (ReferenceScript era -> TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TxOutDatum CtxTx era -> Parser (TxOutDatum CtxTx era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum CtxTx era
forall era ctx.
AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash AlonzoEraOnwards era
w Hash ScriptData
dHash)
            Parser (ReferenceScript era -> TxOut CtxTx era)
-> Parser (ReferenceScript era) -> Parser (TxOut CtxTx era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReferenceScript era -> Parser (ReferenceScript era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
        (Just Value
_dVal, Maybe (Hash ScriptData)
Nothing) -> String -> Parser (TxOut CtxTx era)
forall a. String -> Parser a
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 = String
-> (Object -> Parser (TxOut CtxUTxO era))
-> Value
-> Parser (TxOut CtxUTxO era)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"TxOut" ((Object -> Parser (TxOut CtxUTxO era))
 -> Value -> Parser (TxOut CtxUTxO era))
-> (Object -> Parser (TxOut CtxUTxO era))
-> Value
-> Parser (TxOut CtxUTxO era)
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    case ShelleyBasedEra era
forall era. IsShelleyBasedEra era => ShelleyBasedEra era
shelleyBasedEra :: ShelleyBasedEra era of
      ShelleyBasedEra era
ShelleyBasedEraShelley ->
        AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxUTxO era
-> ReferenceScript era
-> TxOut CtxUTxO era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
          (AddressInEra era
 -> TxOutValue era
 -> TxOutDatum CtxUTxO era
 -> ReferenceScript era
 -> TxOut CtxUTxO era)
-> Parser (AddressInEra era)
-> Parser
     (TxOutValue era
      -> TxOutDatum CtxUTxO era
      -> ReferenceScript era
      -> TxOut CtxUTxO era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (AddressInEra era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
          Parser
  (TxOutValue era
   -> TxOutDatum CtxUTxO era
   -> ReferenceScript era
   -> TxOut CtxUTxO era)
-> Parser (TxOutValue era)
-> Parser
     (TxOutDatum CtxUTxO era
      -> ReferenceScript era -> TxOut CtxUTxO era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (TxOutValue era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
          Parser
  (TxOutDatum CtxUTxO era
   -> ReferenceScript era -> TxOut CtxUTxO era)
-> Parser (TxOutDatum CtxUTxO era)
-> Parser (ReferenceScript era -> TxOut CtxUTxO era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TxOutDatum CtxUTxO era -> Parser (TxOutDatum CtxUTxO era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxUTxO era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
          Parser (ReferenceScript era -> TxOut CtxUTxO era)
-> Parser (ReferenceScript era) -> Parser (TxOut CtxUTxO era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReferenceScript era -> Parser (ReferenceScript era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
      ShelleyBasedEra era
ShelleyBasedEraMary ->
        AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxUTxO era
-> ReferenceScript era
-> TxOut CtxUTxO era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
          (AddressInEra era
 -> TxOutValue era
 -> TxOutDatum CtxUTxO era
 -> ReferenceScript era
 -> TxOut CtxUTxO era)
-> Parser (AddressInEra era)
-> Parser
     (TxOutValue era
      -> TxOutDatum CtxUTxO era
      -> ReferenceScript era
      -> TxOut CtxUTxO era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (AddressInEra era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
          Parser
  (TxOutValue era
   -> TxOutDatum CtxUTxO era
   -> ReferenceScript era
   -> TxOut CtxUTxO era)
-> Parser (TxOutValue era)
-> Parser
     (TxOutDatum CtxUTxO era
      -> ReferenceScript era -> TxOut CtxUTxO era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (TxOutValue era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
          Parser
  (TxOutDatum CtxUTxO era
   -> ReferenceScript era -> TxOut CtxUTxO era)
-> Parser (TxOutDatum CtxUTxO era)
-> Parser (ReferenceScript era -> TxOut CtxUTxO era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TxOutDatum CtxUTxO era -> Parser (TxOutDatum CtxUTxO era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxUTxO era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
          Parser (ReferenceScript era -> TxOut CtxUTxO era)
-> Parser (ReferenceScript era) -> Parser (TxOut CtxUTxO era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReferenceScript era -> Parser (ReferenceScript era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
      ShelleyBasedEra era
ShelleyBasedEraAllegra ->
        AddressInEra era
-> TxOutValue era
-> TxOutDatum CtxUTxO era
-> ReferenceScript era
-> TxOut CtxUTxO era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
          (AddressInEra era
 -> TxOutValue era
 -> TxOutDatum CtxUTxO era
 -> ReferenceScript era
 -> TxOut CtxUTxO era)
-> Parser (AddressInEra era)
-> Parser
     (TxOutValue era
      -> TxOutDatum CtxUTxO era
      -> ReferenceScript era
      -> TxOut CtxUTxO era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (AddressInEra era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
          Parser
  (TxOutValue era
   -> TxOutDatum CtxUTxO era
   -> ReferenceScript era
   -> TxOut CtxUTxO era)
-> Parser (TxOutValue era)
-> Parser
     (TxOutDatum CtxUTxO era
      -> ReferenceScript era -> TxOut CtxUTxO era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (TxOutValue era)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
          Parser
  (TxOutDatum CtxUTxO era
   -> ReferenceScript era -> TxOut CtxUTxO era)
-> Parser (TxOutDatum CtxUTxO era)
-> Parser (ReferenceScript era -> TxOut CtxUTxO era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TxOutDatum CtxUTxO era -> Parser (TxOutDatum CtxUTxO era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxUTxO era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
          Parser (ReferenceScript era -> TxOut CtxUTxO era)
-> Parser (ReferenceScript era) -> Parser (TxOut CtxUTxO era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReferenceScript era -> Parser (ReferenceScript era)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
      ShelleyBasedEra era
ShelleyBasedEraAlonzo -> AlonzoEraOnwards era -> Object -> Parser (TxOut CtxUTxO era)
alonzoTxOutParser AlonzoEraOnwards era
AlonzoEraOnwards AlonzoEra
AlonzoEraOnwardsAlonzo Object
o
      ShelleyBasedEra era
ShelleyBasedEraBabbage -> do
        TxOut CtxUTxO era
alonzoTxOutInBabbage <- AlonzoEraOnwards era -> Object -> Parser (TxOut CtxUTxO era)
alonzoTxOutParser AlonzoEraOnwards era
AlonzoEraOnwards BabbageEra
AlonzoEraOnwardsBabbage Object
o

        -- We check for the existence of inline datums
        Maybe (Hash ScriptData)
inlineDatumHash <- Object
o Object -> Key -> Parser (Maybe (Hash ScriptData))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inlineDatumhash"
        Maybe Value
inlineDatum <- Object
o Object -> Key -> Parser (Maybe Value)
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 ->
                  String -> Parser (TxOutDatum CtxUTxO BabbageEra)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser (TxOutDatum CtxUTxO BabbageEra))
-> String -> Parser (TxOutDatum CtxUTxO BabbageEra)
forall a b. (a -> b) -> a -> b
$ String
"Error parsing TxOut JSON: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> ScriptDataJsonBytesError -> String
forall a. Error a => a -> String
displayError ScriptDataJsonBytesError
err
                Right HashableScriptData
hashableData -> do
                  if HashableScriptData -> Hash ScriptData
hashScriptDataBytes HashableScriptData
hashableData Hash ScriptData -> Hash ScriptData -> Bool
forall a. Eq a => a -> a -> Bool
/= Hash ScriptData
h
                    then String -> Parser (TxOutDatum CtxUTxO BabbageEra)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Inline datum not equivalent to inline datum hash"
                    else TxOutDatum CtxUTxO BabbageEra
-> Parser (TxOutDatum CtxUTxO BabbageEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (TxOutDatum CtxUTxO BabbageEra
 -> Parser (TxOutDatum CtxUTxO BabbageEra))
-> TxOutDatum CtxUTxO BabbageEra
-> Parser (TxOutDatum CtxUTxO BabbageEra)
forall a b. (a -> b) -> a -> b
$ BabbageEraOnwards BabbageEra
-> HashableScriptData -> TxOutDatum CtxUTxO BabbageEra
forall era ctx.
BabbageEraOnwards era -> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline BabbageEraOnwards BabbageEra
BabbageEraOnwardsBabbage HashableScriptData
hashableData
            (Maybe Value
Nothing, Maybe (Hash ScriptData)
Nothing) -> TxOutDatum CtxUTxO BabbageEra
-> Parser (TxOutDatum CtxUTxO BabbageEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxUTxO BabbageEra
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
            (Maybe Value
_, Maybe (Hash ScriptData)
_) ->
              String -> Parser (TxOutDatum CtxUTxO BabbageEra)
forall a. String -> Parser a
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 Object -> Key -> Parser (Maybe ScriptInAnyLang)
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
TxOut CtxUTxO BabbageEra
alonzoTxOutInBabbage TxOutDatum CtxUTxO BabbageEra
mInlineDatum Maybe ScriptInAnyLang
mReferenceScript
      ShelleyBasedEra era
ShelleyBasedEraConway -> do
        TxOut CtxUTxO era
alonzoTxOutInConway <- AlonzoEraOnwards era -> Object -> Parser (TxOut CtxUTxO era)
alonzoTxOutParser AlonzoEraOnwards era
AlonzoEraOnwards ConwayEra
AlonzoEraOnwardsConway Object
o

        -- We check for the existence of inline datums
        Maybe (Hash ScriptData)
inlineDatumHash <- Object
o Object -> Key -> Parser (Maybe (Hash ScriptData))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inlineDatumhash"
        Maybe Value
inlineDatum <- Object
o Object -> Key -> Parser (Maybe Value)
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 ->
                  String -> Parser (TxOutDatum CtxUTxO ConwayEra)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser (TxOutDatum CtxUTxO ConwayEra))
-> String -> Parser (TxOutDatum CtxUTxO ConwayEra)
forall a b. (a -> b) -> a -> b
$ String
"Error parsing TxOut JSON: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> ScriptDataJsonError -> String
forall a. Error a => a -> String
displayError ScriptDataJsonError
err
                Right HashableScriptData
sData ->
                  if HashableScriptData -> Hash ScriptData
hashScriptDataBytes HashableScriptData
sData Hash ScriptData -> Hash ScriptData -> Bool
forall a. Eq a => a -> a -> Bool
/= Hash ScriptData
h
                    then String -> Parser (TxOutDatum CtxUTxO ConwayEra)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Inline datum not equivalent to inline datum hash"
                    else TxOutDatum CtxUTxO ConwayEra
-> Parser (TxOutDatum CtxUTxO ConwayEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (TxOutDatum CtxUTxO ConwayEra
 -> Parser (TxOutDatum CtxUTxO ConwayEra))
-> TxOutDatum CtxUTxO ConwayEra
-> Parser (TxOutDatum CtxUTxO ConwayEra)
forall a b. (a -> b) -> a -> b
$ BabbageEraOnwards ConwayEra
-> HashableScriptData -> TxOutDatum CtxUTxO ConwayEra
forall era ctx.
BabbageEraOnwards era -> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline BabbageEraOnwards ConwayEra
BabbageEraOnwardsConway HashableScriptData
sData
            (Maybe Value
Nothing, Maybe (Hash ScriptData)
Nothing) -> TxOutDatum CtxUTxO ConwayEra
-> Parser (TxOutDatum CtxUTxO ConwayEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxUTxO ConwayEra
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
            (Maybe Value
_, Maybe (Hash ScriptData)
_) ->
              String -> Parser (TxOutDatum CtxUTxO ConwayEra)
forall a. String -> Parser a
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 Object -> Key -> Parser (Maybe ScriptInAnyLang)
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
TxOut CtxUTxO ConwayEra
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) -> TxOutDatum CtxUTxO BabbageEra
-> Parser (TxOutDatum CtxUTxO BabbageEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxUTxO BabbageEra
bDatum
        (TxOutDatum CtxUTxO BabbageEra
anyDat, TxOutDatum CtxUTxO BabbageEra
TxOutDatumNone) -> TxOutDatum CtxUTxO BabbageEra
-> Parser (TxOutDatum CtxUTxO BabbageEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxUTxO BabbageEra
anyDat
        (TxOutDatum CtxUTxO BabbageEra
_, TxOutDatum CtxUTxO BabbageEra
_) -> String -> Parser (TxOutDatum CtxUTxO BabbageEra)
forall a. String -> Parser a
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 -> ReferenceScript BabbageEra -> Parser (ReferenceScript BabbageEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript BabbageEra
r
        Just ScriptInAnyLang
anyScript ->
          ReferenceScript BabbageEra -> Parser (ReferenceScript BabbageEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (ReferenceScript BabbageEra -> Parser (ReferenceScript BabbageEra))
-> ReferenceScript BabbageEra
-> Parser (ReferenceScript BabbageEra)
forall a b. (a -> b) -> a -> b
$ BabbageEraOnwards BabbageEra
-> ScriptInAnyLang -> ReferenceScript BabbageEra
forall era.
BabbageEraOnwards era -> ScriptInAnyLang -> ReferenceScript era
ReferenceScript BabbageEraOnwards BabbageEra
BabbageEraOnwardsBabbage ScriptInAnyLang
anyScript

      TxOut CtxUTxO BabbageEra -> Parser (TxOut CtxUTxO BabbageEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (TxOut CtxUTxO BabbageEra -> Parser (TxOut CtxUTxO BabbageEra))
-> TxOut CtxUTxO BabbageEra -> Parser (TxOut CtxUTxO BabbageEra)
forall a b. (a -> b) -> a -> b
$ AddressInEra BabbageEra
-> TxOutValue BabbageEra
-> TxOutDatum CtxUTxO BabbageEra
-> ReferenceScript BabbageEra
-> TxOut CtxUTxO BabbageEra
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) -> TxOutDatum CtxUTxO ConwayEra
-> Parser (TxOutDatum CtxUTxO ConwayEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxUTxO ConwayEra
bDatum
        (TxOutDatum CtxUTxO ConwayEra
anyDat, TxOutDatum CtxUTxO ConwayEra
TxOutDatumNone) -> TxOutDatum CtxUTxO ConwayEra
-> Parser (TxOutDatum CtxUTxO ConwayEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return TxOutDatum CtxUTxO ConwayEra
anyDat
        (TxOutDatum CtxUTxO ConwayEra
_, TxOutDatum CtxUTxO ConwayEra
_) -> String -> Parser (TxOutDatum CtxUTxO ConwayEra)
forall a. String -> Parser a
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 -> ReferenceScript ConwayEra -> Parser (ReferenceScript ConwayEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceScript ConwayEra
r
        Just ScriptInAnyLang
anyScript ->
          ReferenceScript ConwayEra -> Parser (ReferenceScript ConwayEra)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (ReferenceScript ConwayEra -> Parser (ReferenceScript ConwayEra))
-> ReferenceScript ConwayEra -> Parser (ReferenceScript ConwayEra)
forall a b. (a -> b) -> a -> b
$ BabbageEraOnwards ConwayEra
-> ScriptInAnyLang -> ReferenceScript ConwayEra
forall era.
BabbageEraOnwards era -> ScriptInAnyLang -> ReferenceScript era
ReferenceScript BabbageEraOnwards ConwayEra
BabbageEraOnwardsConway ScriptInAnyLang
anyScript

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

toByronTxOut :: TxOut CtxTx ByronEra -> Either TxOutputError Byron.TxOut
toByronTxOut :: TxOut CtxTx ByronEra -> Either TxOutputError TxOut
toByronTxOut = \case
  txout :: TxOut CtxTx ByronEra
txout@(TxOut (AddressInEra AddressTypeInEra addrtype ByronEra
ByronAddressInAnyEra (ByronAddress Address
addr)) (TxOutValueByron Coin
value) TxOutDatum CtxTx ByronEra
_ ReferenceScript ByronEra
_) ->
    Address -> Lovelace -> TxOut
Byron.TxOut Address
addr (Lovelace -> TxOut)
-> Either TxOutputError Lovelace -> Either TxOutputError TxOut
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Coin -> Maybe Lovelace
toByronLovelace Coin
value Maybe Lovelace -> TxOutputError -> Either TxOutputError Lovelace
forall a e. Maybe a -> e -> Either e a
?! TxOut CtxTx ByronEra -> Coin -> TxOutputError
classifyRangeError TxOut CtxTx ByronEra
txout Coin
value)
  TxOut (AddressInEra AddressTypeInEra addrtype ByronEra
ByronAddressInAnyEra (ByronAddress Address
_)) (TxOutValueShelleyBased ShelleyBasedEra ByronEra
w Value (ShelleyLedgerEra ByronEra)
_) TxOutDatum CtxTx ByronEra
_ ReferenceScript ByronEra
_ ->
    case ShelleyBasedEra ByronEra
w of {}
  TxOut (AddressInEra (ShelleyAddressInEra ShelleyBasedEra ByronEra
sbe) ShelleyAddress{}) TxOutValue ByronEra
_ TxOutDatum CtxTx ByronEra
_ ReferenceScript ByronEra
_ ->
    case ShelleyBasedEra ByronEra
sbe of {}
 where
  classifyRangeError :: TxOut CtxTx ByronEra -> L.Coin -> TxOutputError
  classifyRangeError :: TxOut CtxTx ByronEra -> Coin -> TxOutputError
classifyRangeError TxOut CtxTx ByronEra
txout Coin
value
    | Coin
value Coin -> Coin -> Bool
forall a. Ord a => a -> a -> Bool
< Coin
0 = Quantity -> TxOutInAnyEra -> TxOutputError
TxOutputNegative (Coin -> Quantity
lovelaceToQuantity Coin
value) (CardanoEra ByronEra -> TxOut CtxTx ByronEra -> TxOutInAnyEra
forall era. CardanoEra era -> TxOut CtxTx era -> TxOutInAnyEra
txOutInAnyEra CardanoEra ByronEra
ByronEra TxOut CtxTx ByronEra
txout)
    | Bool
otherwise = Quantity -> TxOutInAnyEra -> TxOutputError
TxOutputOverflow (Coin -> Quantity
lovelaceToQuantity Coin
value) (CardanoEra ByronEra -> TxOut CtxTx ByronEra -> TxOutInAnyEra
forall era. CardanoEra era -> TxOut CtxTx era -> TxOutInAnyEra
txOutInAnyEra CardanoEra ByronEra
ByronEra TxOut CtxTx ByronEra
txout)

toShelleyTxOut
  :: forall era ledgerera
   . HasCallStack
  => ShelleyLedgerEra era ~ ledgerera
  => ShelleyBasedEra era
  -> TxOut CtxUTxO era
  -> Ledger.TxOut ledgerera
toShelleyTxOut :: forall era ledgerera.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera) =>
ShelleyBasedEra era -> TxOut CtxUTxO era -> TxOut ledgerera
toShelleyTxOut ShelleyBasedEra era
sbe = ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era =>
    TxOut CtxUTxO era -> TxOut ledgerera)
-> TxOut CtxUTxO era
-> TxOut ledgerera
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
sbe ((ShelleyBasedEraConstraints era =>
  TxOut CtxUTxO era -> TxOut ledgerera)
 -> TxOut CtxUTxO era -> TxOut ledgerera)
-> (ShelleyBasedEraConstraints era =>
    TxOut CtxUTxO era -> TxOut ledgerera)
-> TxOut CtxUTxO era
-> TxOut ledgerera
forall a b. (a -> b) -> a -> b
$ \case
  TxOut AddressInEra era
addr (TxOutValueShelleyBased ShelleyBasedEra era
_ Value (ShelleyLedgerEra era)
value) TxOutDatum CtxUTxO era
txoutdata ReferenceScript era
refScript ->
    (ShelleyToMaryEraConstraints era =>
 ShelleyToMaryEra era -> TxOut ledgerera)
-> (AlonzoEraOnwardsConstraints era =>
    AlonzoEraOnwards era -> TxOut ledgerera)
-> ShelleyBasedEra era
-> TxOut ledgerera
forall era a.
(ShelleyToMaryEraConstraints era => ShelleyToMaryEra era -> a)
-> (AlonzoEraOnwardsConstraints era => AlonzoEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToMaryOrAlonzoEraOnwards
      (TxOut ledgerera -> ShelleyToMaryEra era -> TxOut ledgerera
forall a b. a -> b -> a
const (TxOut ledgerera -> ShelleyToMaryEra era -> TxOut ledgerera)
-> TxOut ledgerera -> ShelleyToMaryEra era -> TxOut ledgerera
forall a b. (a -> b) -> a -> b
$ Addr -> Value ledgerera -> TxOut ledgerera
forall era.
(EraTxOut era, HasCallStack) =>
Addr -> Value era -> TxOut era
L.mkBasicTxOut (AddressInEra era -> Addr
forall era. AddressInEra era -> Addr
toShelleyAddr AddressInEra era
addr) Value ledgerera
Value (ShelleyLedgerEra era)
value)
      ( \case
          AlonzoEraOnwards era
AlonzoEraOnwardsAlonzo ->
            Addr -> Value AlonzoEra -> TxOut AlonzoEra
forall era.
(EraTxOut era, HasCallStack) =>
Addr -> Value era -> TxOut era
L.mkBasicTxOut (AddressInEra era -> Addr
forall era. AddressInEra era -> Addr
toShelleyAddr AddressInEra era
addr) Value AlonzoEra
Value (ShelleyLedgerEra era)
value
              TxOut AlonzoEra
-> (TxOut AlonzoEra -> TxOut ledgerera) -> TxOut ledgerera
forall a b. a -> (a -> b) -> b
& (StrictMaybe DataHash -> Identity (StrictMaybe DataHash))
-> TxOut AlonzoEra -> Identity (TxOut ledgerera)
(StrictMaybe DataHash -> Identity (StrictMaybe DataHash))
-> TxOut AlonzoEra -> Identity (TxOut AlonzoEra)
forall era.
AlonzoEraTxOut era =>
Lens' (TxOut era) (StrictMaybe DataHash)
Lens' (TxOut AlonzoEra) (StrictMaybe DataHash)
L.dataHashTxOutL
                ((StrictMaybe DataHash -> Identity (StrictMaybe DataHash))
 -> TxOut AlonzoEra -> Identity (TxOut ledgerera))
-> StrictMaybe DataHash -> TxOut AlonzoEra -> TxOut ledgerera
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TxOutDatum CtxUTxO era -> StrictMaybe DataHash
forall era. TxOutDatum CtxUTxO era -> StrictMaybe DataHash
toAlonzoTxOutDatumHashUTxO TxOutDatum CtxUTxO era
txoutdata
          AlonzoEraOnwards era
AlonzoEraOnwardsBabbage ->
            Addr -> Value BabbageEra -> TxOut BabbageEra
forall era.
(EraTxOut era, HasCallStack) =>
Addr -> Value era -> TxOut era
L.mkBasicTxOut (AddressInEra era -> Addr
forall era. AddressInEra era -> Addr
toShelleyAddr AddressInEra era
addr) Value BabbageEra
Value (ShelleyLedgerEra era)
value
              TxOut BabbageEra
-> (TxOut BabbageEra -> TxOut BabbageEra) -> TxOut BabbageEra
forall a b. a -> (a -> b) -> b
& (Datum BabbageEra -> Identity (Datum BabbageEra))
-> TxOut BabbageEra -> Identity (TxOut BabbageEra)
forall era. BabbageEraTxOut era => Lens' (TxOut era) (Datum era)
Lens' (TxOut BabbageEra) (Datum BabbageEra)
L.datumTxOutL
                ((Datum BabbageEra -> Identity (Datum BabbageEra))
 -> TxOut BabbageEra -> Identity (TxOut BabbageEra))
-> Datum BabbageEra -> TxOut BabbageEra -> TxOut BabbageEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TxOutDatum CtxUTxO era -> Datum (ShelleyLedgerEra era)
forall era ctx.
Era (ShelleyLedgerEra era) =>
TxOutDatum ctx era -> Datum (ShelleyLedgerEra era)
toBabbageTxOutDatum TxOutDatum CtxUTxO era
txoutdata
              TxOut BabbageEra
-> (TxOut BabbageEra -> TxOut ledgerera) -> TxOut ledgerera
forall a b. a -> (a -> b) -> b
& (StrictMaybe (Script BabbageEra)
 -> Identity (StrictMaybe (Script BabbageEra)))
-> TxOut BabbageEra -> Identity (TxOut ledgerera)
(StrictMaybe (Script BabbageEra)
 -> Identity (StrictMaybe (Script BabbageEra)))
-> TxOut BabbageEra -> Identity (TxOut BabbageEra)
forall era.
BabbageEraTxOut era =>
Lens' (TxOut era) (StrictMaybe (Script era))
Lens' (TxOut BabbageEra) (StrictMaybe (Script BabbageEra))
L.referenceScriptTxOutL
                ((StrictMaybe (Script BabbageEra)
  -> Identity (StrictMaybe (Script BabbageEra)))
 -> TxOut BabbageEra -> Identity (TxOut ledgerera))
-> StrictMaybe (Script BabbageEra)
-> TxOut BabbageEra
-> TxOut ledgerera
forall s t a b. ASetter s t a b -> b -> s -> t
.~ ShelleyBasedEra era
-> ReferenceScript era
-> StrictMaybe (Script (ShelleyLedgerEra era))
forall era.
ShelleyBasedEra era
-> ReferenceScript era
-> StrictMaybe (Script (ShelleyLedgerEra era))
refScriptToShelleyScript ShelleyBasedEra era
sbe ReferenceScript era
refScript
          AlonzoEraOnwards era
AlonzoEraOnwardsConway ->
            Addr -> Value ConwayEra -> TxOut ConwayEra
forall era.
(EraTxOut era, HasCallStack) =>
Addr -> Value era -> TxOut era
L.mkBasicTxOut (AddressInEra era -> Addr
forall era. AddressInEra era -> Addr
toShelleyAddr AddressInEra era
addr) Value ConwayEra
Value (ShelleyLedgerEra era)
value
              TxOut ConwayEra
-> (TxOut ConwayEra -> TxOut ConwayEra) -> TxOut ConwayEra
forall a b. a -> (a -> b) -> b
& (Datum ConwayEra -> Identity (Datum ConwayEra))
-> TxOut ConwayEra -> Identity (TxOut ConwayEra)
forall era. BabbageEraTxOut era => Lens' (TxOut era) (Datum era)
Lens' (TxOut ConwayEra) (Datum ConwayEra)
L.datumTxOutL
                ((Datum ConwayEra -> Identity (Datum ConwayEra))
 -> TxOut ConwayEra -> Identity (TxOut ConwayEra))
-> Datum ConwayEra -> TxOut ConwayEra -> TxOut ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TxOutDatum CtxUTxO era -> Datum (ShelleyLedgerEra era)
forall era.
Era (ShelleyLedgerEra era) =>
TxOutDatum CtxUTxO era -> Datum (ShelleyLedgerEra era)
toBabbageTxOutDatumUTxO TxOutDatum CtxUTxO era
txoutdata
              TxOut ConwayEra
-> (TxOut ConwayEra -> TxOut ledgerera) -> TxOut ledgerera
forall a b. a -> (a -> b) -> b
& (StrictMaybe (Script ConwayEra)
 -> Identity (StrictMaybe (Script ConwayEra)))
-> TxOut ConwayEra -> Identity (TxOut ledgerera)
(StrictMaybe (Script ConwayEra)
 -> Identity (StrictMaybe (Script ConwayEra)))
-> TxOut ConwayEra -> Identity (TxOut ConwayEra)
forall era.
BabbageEraTxOut era =>
Lens' (TxOut era) (StrictMaybe (Script era))
Lens' (TxOut ConwayEra) (StrictMaybe (Script ConwayEra))
L.referenceScriptTxOutL
                ((StrictMaybe (Script ConwayEra)
  -> Identity (StrictMaybe (Script ConwayEra)))
 -> TxOut ConwayEra -> Identity (TxOut ledgerera))
-> StrictMaybe (Script ConwayEra)
-> TxOut ConwayEra
-> TxOut ledgerera
forall s t a b. ASetter s t a b -> b -> s -> t
.~ ShelleyBasedEra era
-> ReferenceScript era
-> StrictMaybe (Script (ShelleyLedgerEra era))
forall era.
ShelleyBasedEra era
-> ReferenceScript era
-> StrictMaybe (Script (ShelleyLedgerEra era))
refScriptToShelleyScript ShelleyBasedEra era
sbe ReferenceScript era
refScript
      )
      ShelleyBasedEra era
sbe

-- | A variant of 'toShelleyTxOutAny that is used only internally to this module
-- that works with a 'TxOut' in any context (including CtxTx) by ignoring
-- embedded datums (taking only their hash).
toShelleyTxOutAny
  :: forall ctx era ledgerera
   . HasCallStack
  => ShelleyLedgerEra era ~ ledgerera
  => ShelleyBasedEra era
  -> TxOut ctx era
  -> Ledger.TxOut ledgerera
toShelleyTxOutAny :: forall ctx era ledgerera.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera) =>
ShelleyBasedEra era -> TxOut ctx era -> TxOut ledgerera
toShelleyTxOutAny ShelleyBasedEra era
sbe = ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era =>
    TxOut ctx era -> TxOut ledgerera)
-> TxOut ctx era
-> TxOut ledgerera
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
sbe ((ShelleyBasedEraConstraints era =>
  TxOut ctx era -> TxOut ledgerera)
 -> TxOut ctx era -> TxOut ledgerera)
-> (ShelleyBasedEraConstraints era =>
    TxOut ctx era -> TxOut ledgerera)
-> TxOut ctx era
-> TxOut ledgerera
forall a b. (a -> b) -> a -> b
$ \case
  TxOut AddressInEra era
addr (TxOutValueShelleyBased ShelleyBasedEra era
_ Value (ShelleyLedgerEra era)
value) TxOutDatum ctx era
txoutdata ReferenceScript era
refScript ->
    (ShelleyToMaryEraConstraints era =>
 ShelleyToMaryEra era -> TxOut ledgerera)
-> (AlonzoEraOnwardsConstraints era =>
    AlonzoEraOnwards era -> TxOut ledgerera)
-> ShelleyBasedEra era
-> TxOut ledgerera
forall era a.
(ShelleyToMaryEraConstraints era => ShelleyToMaryEra era -> a)
-> (AlonzoEraOnwardsConstraints era => AlonzoEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToMaryOrAlonzoEraOnwards
      (TxOut ledgerera -> ShelleyToMaryEra era -> TxOut ledgerera
forall a b. a -> b -> a
const (TxOut ledgerera -> ShelleyToMaryEra era -> TxOut ledgerera)
-> TxOut ledgerera -> ShelleyToMaryEra era -> TxOut ledgerera
forall a b. (a -> b) -> a -> b
$ Addr -> Value ledgerera -> TxOut ledgerera
forall era.
(EraTxOut era, HasCallStack) =>
Addr -> Value era -> TxOut era
L.mkBasicTxOut (AddressInEra era -> Addr
forall era. AddressInEra era -> Addr
toShelleyAddr AddressInEra era
addr) Value ledgerera
Value (ShelleyLedgerEra era)
value)
      ( \case
          AlonzoEraOnwards era
AlonzoEraOnwardsAlonzo ->
            Addr -> Value AlonzoEra -> TxOut AlonzoEra
forall era.
(EraTxOut era, HasCallStack) =>
Addr -> Value era -> TxOut era
L.mkBasicTxOut (AddressInEra era -> Addr
forall era. AddressInEra era -> Addr
toShelleyAddr AddressInEra era
addr) Value AlonzoEra
Value (ShelleyLedgerEra era)
value
              TxOut AlonzoEra
-> (TxOut AlonzoEra -> TxOut ledgerera) -> TxOut ledgerera
forall a b. a -> (a -> b) -> b
& (StrictMaybe DataHash -> Identity (StrictMaybe DataHash))
-> TxOut AlonzoEra -> Identity (TxOut ledgerera)
(StrictMaybe DataHash -> Identity (StrictMaybe DataHash))
-> TxOut AlonzoEra -> Identity (TxOut AlonzoEra)
forall era.
AlonzoEraTxOut era =>
Lens' (TxOut era) (StrictMaybe DataHash)
Lens' (TxOut AlonzoEra) (StrictMaybe DataHash)
L.dataHashTxOutL
                ((StrictMaybe DataHash -> Identity (StrictMaybe DataHash))
 -> TxOut AlonzoEra -> Identity (TxOut ledgerera))
-> StrictMaybe DataHash -> TxOut AlonzoEra -> TxOut ledgerera
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TxOutDatum ctx era -> StrictMaybe DataHash
forall ctx era. TxOutDatum ctx era -> StrictMaybe DataHash
toAlonzoTxOutDatumHash TxOutDatum ctx era
txoutdata
          AlonzoEraOnwards era
AlonzoEraOnwardsBabbage ->
            Addr -> Value BabbageEra -> TxOut BabbageEra
forall era.
(EraTxOut era, HasCallStack) =>
Addr -> Value era -> TxOut era
L.mkBasicTxOut (AddressInEra era -> Addr
forall era. AddressInEra era -> Addr
toShelleyAddr AddressInEra era
addr) Value BabbageEra
Value (ShelleyLedgerEra era)
value
              TxOut BabbageEra
-> (TxOut BabbageEra -> TxOut BabbageEra) -> TxOut BabbageEra
forall a b. a -> (a -> b) -> b
& (Datum BabbageEra -> Identity (Datum BabbageEra))
-> TxOut BabbageEra -> Identity (TxOut BabbageEra)
forall era. BabbageEraTxOut era => Lens' (TxOut era) (Datum era)
Lens' (TxOut BabbageEra) (Datum BabbageEra)
L.datumTxOutL
                ((Datum BabbageEra -> Identity (Datum BabbageEra))
 -> TxOut BabbageEra -> Identity (TxOut BabbageEra))
-> Datum BabbageEra -> TxOut BabbageEra -> TxOut BabbageEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TxOutDatum ctx era -> Datum (ShelleyLedgerEra era)
forall era ctx.
Era (ShelleyLedgerEra era) =>
TxOutDatum ctx era -> Datum (ShelleyLedgerEra era)
toBabbageTxOutDatum TxOutDatum ctx era
txoutdata
              TxOut BabbageEra
-> (TxOut BabbageEra -> TxOut ledgerera) -> TxOut ledgerera
forall a b. a -> (a -> b) -> b
& (StrictMaybe (Script BabbageEra)
 -> Identity (StrictMaybe (Script BabbageEra)))
-> TxOut BabbageEra -> Identity (TxOut ledgerera)
(StrictMaybe (Script BabbageEra)
 -> Identity (StrictMaybe (Script BabbageEra)))
-> TxOut BabbageEra -> Identity (TxOut BabbageEra)
forall era.
BabbageEraTxOut era =>
Lens' (TxOut era) (StrictMaybe (Script era))
Lens' (TxOut BabbageEra) (StrictMaybe (Script BabbageEra))
L.referenceScriptTxOutL
                ((StrictMaybe (Script BabbageEra)
  -> Identity (StrictMaybe (Script BabbageEra)))
 -> TxOut BabbageEra -> Identity (TxOut ledgerera))
-> StrictMaybe (Script BabbageEra)
-> TxOut BabbageEra
-> TxOut ledgerera
forall s t a b. ASetter s t a b -> b -> s -> t
.~ ShelleyBasedEra era
-> ReferenceScript era
-> StrictMaybe (Script (ShelleyLedgerEra era))
forall era.
ShelleyBasedEra era
-> ReferenceScript era
-> StrictMaybe (Script (ShelleyLedgerEra era))
refScriptToShelleyScript ShelleyBasedEra era
sbe ReferenceScript era
refScript
          AlonzoEraOnwards era
AlonzoEraOnwardsConway ->
            Addr -> Value ConwayEra -> TxOut ConwayEra
forall era.
(EraTxOut era, HasCallStack) =>
Addr -> Value era -> TxOut era
L.mkBasicTxOut (AddressInEra era -> Addr
forall era. AddressInEra era -> Addr
toShelleyAddr AddressInEra era
addr) Value ConwayEra
Value (ShelleyLedgerEra era)
value
              TxOut ConwayEra
-> (TxOut ConwayEra -> TxOut ConwayEra) -> TxOut ConwayEra
forall a b. a -> (a -> b) -> b
& (Datum ConwayEra -> Identity (Datum ConwayEra))
-> TxOut ConwayEra -> Identity (TxOut ConwayEra)
forall era. BabbageEraTxOut era => Lens' (TxOut era) (Datum era)
Lens' (TxOut ConwayEra) (Datum ConwayEra)
L.datumTxOutL
                ((Datum ConwayEra -> Identity (Datum ConwayEra))
 -> TxOut ConwayEra -> Identity (TxOut ConwayEra))
-> Datum ConwayEra -> TxOut ConwayEra -> TxOut ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TxOutDatum ctx era -> Datum (ShelleyLedgerEra era)
forall era ctx.
Era (ShelleyLedgerEra era) =>
TxOutDatum ctx era -> Datum (ShelleyLedgerEra era)
toBabbageTxOutDatum TxOutDatum ctx era
txoutdata
              TxOut ConwayEra
-> (TxOut ConwayEra -> TxOut ledgerera) -> TxOut ledgerera
forall a b. a -> (a -> b) -> b
& (StrictMaybe (Script ConwayEra)
 -> Identity (StrictMaybe (Script ConwayEra)))
-> TxOut ConwayEra -> Identity (TxOut ledgerera)
(StrictMaybe (Script ConwayEra)
 -> Identity (StrictMaybe (Script ConwayEra)))
-> TxOut ConwayEra -> Identity (TxOut ConwayEra)
forall era.
BabbageEraTxOut era =>
Lens' (TxOut era) (StrictMaybe (Script era))
Lens' (TxOut ConwayEra) (StrictMaybe (Script ConwayEra))
L.referenceScriptTxOutL
                ((StrictMaybe (Script ConwayEra)
  -> Identity (StrictMaybe (Script ConwayEra)))
 -> TxOut ConwayEra -> Identity (TxOut ledgerera))
-> StrictMaybe (Script ConwayEra)
-> TxOut ConwayEra
-> TxOut ledgerera
forall s t a b. ASetter s t a b -> b -> s -> t
.~ ShelleyBasedEra era
-> ReferenceScript era
-> StrictMaybe (Script (ShelleyLedgerEra era))
forall era.
ShelleyBasedEra era
-> ReferenceScript era
-> StrictMaybe (Script (ShelleyLedgerEra era))
refScriptToShelleyScript ShelleyBasedEra era
sbe ReferenceScript era
refScript
      )
      ShelleyBasedEra era
sbe

fromShelleyTxOut
  :: forall era ctx
   . ()
  => ShelleyBasedEra era
  -> Core.TxOut (ShelleyLedgerEra era)
  -> TxOut ctx era
fromShelleyTxOut :: forall era ctx.
ShelleyBasedEra era
-> TxOut (ShelleyLedgerEra era) -> TxOut ctx era
fromShelleyTxOut ShelleyBasedEra era
sbe TxOut (ShelleyLedgerEra era)
ledgerTxOut = ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era => TxOut ctx era)
-> TxOut ctx era
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
sbe ((ShelleyBasedEraConstraints era => TxOut ctx era)
 -> TxOut ctx era)
-> (ShelleyBasedEraConstraints era => TxOut ctx era)
-> TxOut ctx era
forall a b. (a -> b) -> a -> b
$ do
  let txOutValue :: TxOutValue era
txOutValue = ShelleyBasedEra era
-> Value (ShelleyLedgerEra era) -> TxOutValue era
forall era.
(Eq (Value (ShelleyLedgerEra era)),
 Show (Value (ShelleyLedgerEra era))) =>
ShelleyBasedEra era
-> Value (ShelleyLedgerEra era) -> TxOutValue era
TxOutValueShelleyBased ShelleyBasedEra era
sbe (Value (ShelleyLedgerEra era) -> TxOutValue era)
-> Value (ShelleyLedgerEra era) -> TxOutValue era
forall a b. (a -> b) -> a -> b
$ TxOut (ShelleyLedgerEra era)
ledgerTxOut TxOut (ShelleyLedgerEra era)
-> Getting
     (Value (ShelleyLedgerEra era))
     (TxOut (ShelleyLedgerEra era))
     (Value (ShelleyLedgerEra era))
-> Value (ShelleyLedgerEra era)
forall s a. s -> Getting a s a -> a
^. ShelleyBasedEra era
-> Lens'
     (TxOut (ShelleyLedgerEra era)) (Value (ShelleyLedgerEra era))
forall era.
ShelleyBasedEra era
-> Lens'
     (TxOut (ShelleyLedgerEra era)) (Value (ShelleyLedgerEra era))
A.valueTxOutL ShelleyBasedEra era
sbe
  let addressInEra :: AddressInEra era
addressInEra = ShelleyBasedEra era -> Addr -> AddressInEra era
forall era. ShelleyBasedEra era -> Addr -> AddressInEra era
fromShelleyAddr ShelleyBasedEra era
sbe (Addr -> AddressInEra era) -> Addr -> AddressInEra era
forall a b. (a -> b) -> a -> b
$ TxOut (ShelleyLedgerEra era)
ledgerTxOut TxOut (ShelleyLedgerEra era)
-> Getting Addr (TxOut (ShelleyLedgerEra era)) Addr -> Addr
forall s a. s -> Getting a s a -> a
^. Getting Addr (TxOut (ShelleyLedgerEra era)) Addr
forall era. EraTxOut era => Lens' (TxOut era) Addr
Lens' (TxOut (ShelleyLedgerEra era)) Addr
L.addrTxOutL

  case ShelleyBasedEra era
sbe of
    ShelleyBasedEra era
ShelleyBasedEraShelley ->
      AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut AddressInEra era
addressInEra TxOutValue era
txOutValue TxOutDatum ctx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
    ShelleyBasedEra era
ShelleyBasedEraAllegra ->
      AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut AddressInEra era
addressInEra TxOutValue era
txOutValue TxOutDatum ctx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
    ShelleyBasedEra era
ShelleyBasedEraMary ->
      AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut AddressInEra era
addressInEra TxOutValue era
txOutValue TxOutDatum ctx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
    ShelleyBasedEra era
ShelleyBasedEraAlonzo ->
      AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
        AddressInEra era
addressInEra
        TxOutValue era
txOutValue
        (AlonzoEraOnwards era -> StrictMaybe DataHash -> TxOutDatum ctx era
forall era ctx.
AlonzoEraOnwards era -> StrictMaybe DataHash -> TxOutDatum ctx era
fromAlonzoTxOutDatumHash AlonzoEraOnwards era
AlonzoEraOnwards AlonzoEra
AlonzoEraOnwardsAlonzo StrictMaybe DataHash
mDatumHash)
        ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
     where
      mDatumHash :: StrictMaybe DataHash
mDatumHash = TxOut (ShelleyLedgerEra era)
AlonzoTxOut AlonzoEra
ledgerTxOut AlonzoTxOut AlonzoEra
-> Getting
     (StrictMaybe DataHash)
     (AlonzoTxOut AlonzoEra)
     (StrictMaybe DataHash)
-> StrictMaybe DataHash
forall s a. s -> Getting a s a -> a
^. (StrictMaybe DataHash
 -> Const (StrictMaybe DataHash) (StrictMaybe DataHash))
-> TxOut AlonzoEra
-> Const (StrictMaybe DataHash) (TxOut AlonzoEra)
Getting
  (StrictMaybe DataHash)
  (AlonzoTxOut AlonzoEra)
  (StrictMaybe DataHash)
forall era.
AlonzoEraTxOut era =>
Lens' (TxOut era) (StrictMaybe DataHash)
Lens' (TxOut AlonzoEra) (StrictMaybe DataHash)
L.dataHashTxOutL
    ShelleyBasedEra era
ShelleyBasedEraBabbage ->
      AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
        AddressInEra era
addressInEra
        TxOutValue era
txOutValue
        ( AlonzoEraOnwards era
-> BabbageEraOnwards era -> Datum BabbageEra -> TxOutDatum ctx era
forall ledgerera era ctx.
Era ledgerera =>
AlonzoEraOnwards era
-> BabbageEraOnwards era -> Datum ledgerera -> TxOutDatum ctx era
fromBabbageTxOutDatum
            AlonzoEraOnwards era
AlonzoEraOnwards BabbageEra
AlonzoEraOnwardsBabbage
            BabbageEraOnwards era
BabbageEraOnwards BabbageEra
BabbageEraOnwardsBabbage
            Datum BabbageEra
datum
        )
        ( case StrictMaybe (Script BabbageEra)
mRefScript of
            StrictMaybe (Script BabbageEra)
SNothing -> ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
            SJust Script BabbageEra
refScript ->
              ShelleyBasedEra era
-> Script (ShelleyLedgerEra era) -> ReferenceScript era
forall era.
ShelleyBasedEra era
-> Script (ShelleyLedgerEra era) -> ReferenceScript era
fromShelleyScriptToReferenceScript ShelleyBasedEra era
ShelleyBasedEra BabbageEra
ShelleyBasedEraBabbage Script BabbageEra
Script (ShelleyLedgerEra era)
refScript
        )
     where
      datum :: Datum BabbageEra
datum = TxOut (ShelleyLedgerEra era)
BabbageTxOut BabbageEra
ledgerTxOut BabbageTxOut BabbageEra
-> Getting
     (Datum BabbageEra) (BabbageTxOut BabbageEra) (Datum BabbageEra)
-> Datum BabbageEra
forall s a. s -> Getting a s a -> a
^. (Datum BabbageEra -> Const (Datum BabbageEra) (Datum BabbageEra))
-> TxOut BabbageEra -> Const (Datum BabbageEra) (TxOut BabbageEra)
Getting
  (Datum BabbageEra) (BabbageTxOut BabbageEra) (Datum BabbageEra)
forall era. BabbageEraTxOut era => Lens' (TxOut era) (Datum era)
Lens' (TxOut BabbageEra) (Datum BabbageEra)
L.datumTxOutL
      mRefScript :: StrictMaybe (Script BabbageEra)
mRefScript = TxOut (ShelleyLedgerEra era)
BabbageTxOut BabbageEra
ledgerTxOut BabbageTxOut BabbageEra
-> Getting
     (StrictMaybe (Script BabbageEra))
     (BabbageTxOut BabbageEra)
     (StrictMaybe (Script BabbageEra))
-> StrictMaybe (Script BabbageEra)
forall s a. s -> Getting a s a -> a
^. (StrictMaybe (Script BabbageEra)
 -> Const
      (StrictMaybe (Script BabbageEra))
      (StrictMaybe (Script BabbageEra)))
-> TxOut BabbageEra
-> Const (StrictMaybe (Script BabbageEra)) (TxOut BabbageEra)
Getting
  (StrictMaybe (Script BabbageEra))
  (BabbageTxOut BabbageEra)
  (StrictMaybe (Script BabbageEra))
forall era.
BabbageEraTxOut era =>
Lens' (TxOut era) (StrictMaybe (Script era))
Lens' (TxOut BabbageEra) (StrictMaybe (Script BabbageEra))
L.referenceScriptTxOutL
    ShelleyBasedEra era
ShelleyBasedEraConway ->
      AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut
        AddressInEra era
addressInEra
        TxOutValue era
txOutValue
        ( AlonzoEraOnwards era
-> BabbageEraOnwards era -> Datum ConwayEra -> TxOutDatum ctx era
forall ledgerera era ctx.
Era ledgerera =>
AlonzoEraOnwards era
-> BabbageEraOnwards era -> Datum ledgerera -> TxOutDatum ctx era
fromBabbageTxOutDatum
            AlonzoEraOnwards era
AlonzoEraOnwards ConwayEra
AlonzoEraOnwardsConway
            BabbageEraOnwards era
BabbageEraOnwards ConwayEra
BabbageEraOnwardsConway
            Datum ConwayEra
datum
        )
        ( case StrictMaybe (Script ConwayEra)
mRefScript of
            StrictMaybe (Script ConwayEra)
SNothing -> ReferenceScript era
forall era. ReferenceScript era
ReferenceScriptNone
            SJust Script ConwayEra
refScript ->
              ShelleyBasedEra era
-> Script (ShelleyLedgerEra era) -> ReferenceScript era
forall era.
ShelleyBasedEra era
-> Script (ShelleyLedgerEra era) -> ReferenceScript era
fromShelleyScriptToReferenceScript ShelleyBasedEra era
ShelleyBasedEra ConwayEra
ShelleyBasedEraConway Script ConwayEra
Script (ShelleyLedgerEra era)
refScript
        )
     where
      datum :: Datum ConwayEra
datum = TxOut (ShelleyLedgerEra era)
BabbageTxOut ConwayEra
ledgerTxOut BabbageTxOut ConwayEra
-> Getting
     (Datum ConwayEra) (BabbageTxOut ConwayEra) (Datum ConwayEra)
-> Datum ConwayEra
forall s a. s -> Getting a s a -> a
^. (Datum ConwayEra -> Const (Datum ConwayEra) (Datum ConwayEra))
-> TxOut ConwayEra -> Const (Datum ConwayEra) (TxOut ConwayEra)
Getting
  (Datum ConwayEra) (BabbageTxOut ConwayEra) (Datum ConwayEra)
forall era. BabbageEraTxOut era => Lens' (TxOut era) (Datum era)
Lens' (TxOut ConwayEra) (Datum ConwayEra)
L.datumTxOutL
      mRefScript :: StrictMaybe (Script ConwayEra)
mRefScript = TxOut (ShelleyLedgerEra era)
BabbageTxOut ConwayEra
ledgerTxOut BabbageTxOut ConwayEra
-> Getting
     (StrictMaybe (Script ConwayEra))
     (BabbageTxOut ConwayEra)
     (StrictMaybe (Script ConwayEra))
-> StrictMaybe (Script ConwayEra)
forall s a. s -> Getting a s a -> a
^. (StrictMaybe (Script ConwayEra)
 -> Const
      (StrictMaybe (Script ConwayEra)) (StrictMaybe (Script ConwayEra)))
-> TxOut ConwayEra
-> Const (StrictMaybe (Script ConwayEra)) (TxOut ConwayEra)
Getting
  (StrictMaybe (Script ConwayEra))
  (BabbageTxOut ConwayEra)
  (StrictMaybe (Script ConwayEra))
forall era.
BabbageEraTxOut era =>
Lens' (TxOut era) (StrictMaybe (Script era))
Lens' (TxOut ConwayEra) (StrictMaybe (Script ConwayEra))
L.referenceScriptTxOutL

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

data TxOutValue era where
  TxOutValueByron
    :: L.Coin
    -> TxOutValue ByronEra
  TxOutValueShelleyBased
    :: ( Eq (Ledger.Value (ShelleyLedgerEra era))
       , Show (Ledger.Value (ShelleyLedgerEra era))
       )
    => ShelleyBasedEra era
    -> L.Value (ShelleyLedgerEra era)
    -> TxOutValue era

deriving instance Eq (TxOutValue era)

deriving instance Show (TxOutValue era)

instance IsCardanoEra era => ToJSON (TxOutValue era) where
  toJSON :: TxOutValue era -> Value
toJSON = \case
    TxOutValueByron Coin
ll ->
      Coin -> Value
forall a. ToJSON a => a -> Value
toJSON Coin
ll
    TxOutValueShelleyBased ShelleyBasedEra era
sbe Value (ShelleyLedgerEra era)
val ->
      ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era => Value) -> Value
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
sbe ((ShelleyBasedEraConstraints era => Value) -> Value)
-> (ShelleyBasedEraConstraints era => Value) -> Value
forall a b. (a -> b) -> a -> b
$ Value -> Value
forall a. ToJSON a => a -> Value
toJSON (ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
forall era.
ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
fromLedgerValue ShelleyBasedEra era
sbe Value (ShelleyLedgerEra era)
val)

instance IsShelleyBasedEra era => FromJSON (TxOutValue era) where
  parseJSON :: Value -> Parser (TxOutValue era)
parseJSON = String
-> (Object -> Parser (TxOutValue era))
-> Value
-> Parser (TxOutValue era)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"TxOutValue" ((Object -> Parser (TxOutValue era))
 -> Value -> Parser (TxOutValue era))
-> (Object -> Parser (TxOutValue era))
-> Value
-> Parser (TxOutValue era)
forall a b. (a -> b) -> a -> b
$ \Object
o ->
    (ShelleyToAllegraEraConstraints era =>
 ShelleyToAllegraEra era -> Parser (TxOutValue era))
-> (MaryEraOnwardsConstraints era =>
    MaryEraOnwards era -> Parser (TxOutValue era))
-> ShelleyBasedEra era
-> Parser (TxOutValue era)
forall era a.
(ShelleyToAllegraEraConstraints era =>
 ShelleyToAllegraEra era -> a)
-> (MaryEraOnwardsConstraints era => MaryEraOnwards era -> a)
-> ShelleyBasedEra era
-> a
caseShelleyToAllegraOrMaryEraOnwards
      ( \ShelleyToAllegraEra era
shelleyToAlleg -> do
          Coin
ll <- Object
o Object -> Key -> Parser Coin
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"lovelace"
          let sbe :: ShelleyBasedEra era
sbe = ShelleyToAllegraEra era -> ShelleyBasedEra era
forall era. ShelleyToAllegraEra era -> ShelleyBasedEra era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert ShelleyToAllegraEra era
shelleyToAlleg
          TxOutValue era -> Parser (TxOutValue era)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TxOutValue era -> Parser (TxOutValue era))
-> TxOutValue era -> Parser (TxOutValue era)
forall a b. (a -> b) -> a -> b
$
            ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era => TxOutValue era)
-> TxOutValue era
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
sbe ((ShelleyBasedEraConstraints era => TxOutValue era)
 -> TxOutValue era)
-> (ShelleyBasedEraConstraints era => TxOutValue era)
-> TxOutValue era
forall a b. (a -> b) -> a -> b
$
              ShelleyBasedEra era
-> Value (ShelleyLedgerEra era) -> TxOutValue era
forall era.
(Eq (Value (ShelleyLedgerEra era)),
 Show (Value (ShelleyLedgerEra era))) =>
ShelleyBasedEra era
-> Value (ShelleyLedgerEra era) -> TxOutValue era
TxOutValueShelleyBased ShelleyBasedEra era
sbe (Value (ShelleyLedgerEra era) -> TxOutValue era)
-> Value (ShelleyLedgerEra era) -> TxOutValue era
forall a b. (a -> b) -> a -> b
$
                ShelleyBasedEra era -> Coin -> Value (ShelleyLedgerEra era)
forall era.
ShelleyBasedEra era -> Coin -> Value (ShelleyLedgerEra era)
A.mkAdaValue ShelleyBasedEra era
sbe Coin
ll
      )
      ( \MaryEraOnwards era
w -> do
          let l :: [Item Object]
l = Object -> [Item Object]
forall l. IsList l => l -> [Item l]
toList Object
o
              sbe :: ShelleyBasedEra era
sbe = MaryEraOnwards era -> ShelleyBasedEra era
forall era. MaryEraOnwards era -> ShelleyBasedEra era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert MaryEraOnwards era
w
          [Value]
vals <- (Pair -> Parser Value) -> [Pair] -> Parser [Value]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Pair -> Parser Value
decodeAssetId [Pair]
[Item Object]
l
          TxOutValue era -> Parser (TxOutValue era)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TxOutValue era -> Parser (TxOutValue era))
-> TxOutValue era -> Parser (TxOutValue era)
forall a b. (a -> b) -> a -> b
$
            ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era => TxOutValue era)
-> TxOutValue era
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
sbe ((ShelleyBasedEraConstraints era => TxOutValue era)
 -> TxOutValue era)
-> (ShelleyBasedEraConstraints era => TxOutValue era)
-> TxOutValue era
forall a b. (a -> b) -> a -> b
$
              ShelleyBasedEra era
-> Value (ShelleyLedgerEra era) -> TxOutValue era
forall era.
(Eq (Value (ShelleyLedgerEra era)),
 Show (Value (ShelleyLedgerEra era))) =>
ShelleyBasedEra era
-> Value (ShelleyLedgerEra era) -> TxOutValue era
TxOutValueShelleyBased ShelleyBasedEra era
sbe (Value (ShelleyLedgerEra era) -> TxOutValue era)
-> Value (ShelleyLedgerEra era) -> TxOutValue era
forall a b. (a -> b) -> a -> b
$
                MaryEraOnwards era -> Value -> Value (ShelleyLedgerEra era)
forall era.
MaryEraOnwards era -> Value -> Value (ShelleyLedgerEra era)
toLedgerValue MaryEraOnwards era
w (Value -> Value (ShelleyLedgerEra era))
-> Value -> Value (ShelleyLedgerEra era)
forall a b. (a -> b) -> a -> b
$
                  [Value] -> Value
forall a. Monoid a => [a] -> a
mconcat [Value]
vals
      )
      (forall era. IsShelleyBasedEra era => ShelleyBasedEra era
shelleyBasedEra @era)
   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 = String -> PolicyId
forall a. IsString a => String -> a
fromString (String -> PolicyId) -> (Text -> String) -> Text -> PolicyId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
Text.unpack (Text -> PolicyId) -> Text -> PolicyId
forall a b. (a -> b) -> a -> b
$ Key -> Text
Aeson.toText Key
polid
      [(AssetName, Quantity)]
aNameQuantity <- Object -> Parser [(AssetName, Quantity)]
decodeAssets Object
assetNameHm
      Value -> Parser Value
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value -> Parser Value)
-> ([(AssetId, Quantity)] -> Value)
-> [(AssetId, Quantity)]
-> Parser Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(AssetId, Quantity)] -> Value
[Item Value] -> Value
forall l. IsList l => [Item l] -> l
fromList ([(AssetId, Quantity)] -> Parser Value)
-> [(AssetId, Quantity)] -> Parser Value
forall a b. (a -> b) -> a -> b
$
        ((AssetName, Quantity) -> (AssetId, Quantity))
-> [(AssetName, Quantity)] -> [(AssetId, Quantity)]
forall a b. (a -> b) -> [a] -> [b]
map ((AssetName -> AssetId)
-> (AssetName, Quantity) -> (AssetId, Quantity)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first ((AssetName -> AssetId)
 -> (AssetName, Quantity) -> (AssetId, Quantity))
-> (AssetName -> AssetId)
-> (AssetName, Quantity)
-> (AssetId, Quantity)
forall a b. (a -> b) -> a -> b
$ PolicyId -> AssetName -> AssetId
AssetId PolicyId
polId) [(AssetName, Quantity)]
aNameQuantity
    decodeAssetId (Key
"lovelace", Aeson.Number Scientific
sci) =
      case Scientific -> Maybe Word64
forall i. (Integral i, Bounded i) => Scientific -> Maybe i
toBoundedInteger Scientific
sci of
        Just (Word64
ll :: Word64) ->
          Value -> Parser Value
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Value -> Parser Value) -> Value -> Parser Value
forall a b. (a -> b) -> a -> b
$ [Item Value] -> Value
forall l. IsList l => [Item l] -> l
fromList [(AssetId
AdaAssetId, Integer -> Quantity
Quantity (Integer -> Quantity) -> Integer -> Quantity
forall a b. (a -> b) -> a -> b
$ Word64 -> Integer
forall a. Integral a => a -> Integer
toInteger Word64
ll)]
        Maybe Word64
Nothing ->
          String -> Parser Value
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser Value) -> String -> Parser Value
forall a b. (a -> b) -> a -> b
$ String
"Expected a Bounded number but got: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Scientific -> String
forall a. Show a => a -> String
show Scientific
sci
    decodeAssetId Pair
wrong = String -> Parser Value
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser Value) -> String -> Parser Value
forall a b. (a -> b) -> a -> b
$ String
"Expected a policy id and a JSON object but got: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Pair -> String
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 :: [Item Object]
l = Object -> [Item Object]
forall l. IsList l => l -> [Item l]
toList Object
assetNameHm
       in (Pair -> Parser (AssetName, Quantity))
-> [Pair] -> Parser [(AssetName, Quantity)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (\(Key
aName, Value
q) -> (,) (AssetName -> Quantity -> (AssetName, Quantity))
-> Parser AssetName -> Parser (Quantity -> (AssetName, Quantity))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Key -> Parser AssetName
parseKeyAsAssetName Key
aName Parser (Quantity -> (AssetName, Quantity))
-> Parser Quantity -> Parser (AssetName, Quantity)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser Quantity
decodeQuantity Value
q) [Pair]
[Item Object]
l

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

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

lovelaceToTxOutValue
  :: ()
  => ShelleyBasedEra era
  -> L.Coin
  -> TxOutValue era
lovelaceToTxOutValue :: forall era. ShelleyBasedEra era -> Coin -> TxOutValue era
lovelaceToTxOutValue ShelleyBasedEra era
era Coin
ll =
  ShelleyBasedEra era
-> (ShelleyBasedEraConstraints era => TxOutValue era)
-> TxOutValue era
forall era a.
ShelleyBasedEra era -> (ShelleyBasedEraConstraints era => a) -> a
shelleyBasedEraConstraints ShelleyBasedEra era
era ((ShelleyBasedEraConstraints era => TxOutValue era)
 -> TxOutValue era)
-> (ShelleyBasedEraConstraints era => TxOutValue era)
-> TxOutValue era
forall a b. (a -> b) -> a -> b
$
    ShelleyBasedEra era
-> Value (ShelleyLedgerEra era) -> TxOutValue era
forall era.
(Eq (Value (ShelleyLedgerEra era)),
 Show (Value (ShelleyLedgerEra era))) =>
ShelleyBasedEra era
-> Value (ShelleyLedgerEra era) -> TxOutValue era
TxOutValueShelleyBased ShelleyBasedEra era
era (Value (ShelleyLedgerEra era) -> TxOutValue era)
-> Value (ShelleyLedgerEra era) -> TxOutValue era
forall a b. (a -> b) -> a -> b
$
      ShelleyBasedEra era -> Coin -> Value (ShelleyLedgerEra era)
forall era.
ShelleyBasedEra era -> Coin -> Value (ShelleyLedgerEra era)
A.mkAdaValue ShelleyBasedEra era
era Coin
ll

txOutValueToLovelace :: TxOutValue era -> L.Coin
txOutValueToLovelace :: forall era. TxOutValue era -> Coin
txOutValueToLovelace TxOutValue era
tv =
  case TxOutValue era
tv of
    TxOutValueByron Coin
l -> Coin
l
    TxOutValueShelleyBased ShelleyBasedEra era
sbe Value (ShelleyLedgerEra era)
v -> Value (ShelleyLedgerEra era)
v Value (ShelleyLedgerEra era)
-> Getting Coin (Value (ShelleyLedgerEra era)) Coin -> Coin
forall s a. s -> Getting a s a -> a
^. ShelleyBasedEra era -> Lens' (Value (ShelleyLedgerEra era)) Coin
forall era.
ShelleyBasedEra era -> Lens' (Value (ShelleyLedgerEra era)) Coin
A.adaAssetL ShelleyBasedEra era
sbe

txOutValueToValue :: TxOutValue era -> Value
txOutValueToValue :: forall era. TxOutValue era -> Value
txOutValueToValue TxOutValue era
tv =
  case TxOutValue era
tv of
    TxOutValueByron Coin
l -> Coin -> Value
lovelaceToValue Coin
l
    TxOutValueShelleyBased ShelleyBasedEra era
sbe Value (ShelleyLedgerEra era)
v -> ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
forall era.
ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
fromLedgerValue ShelleyBasedEra era
sbe Value (ShelleyLedgerEra era)
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
_)) =
  AddressAny -> Text
forall addr. SerialiseAddress addr => addr -> Text
serialiseAddress (Address addrtype -> AddressAny
forall addr. Address addr -> AddressAny
toAddressAny Address addrtype
addr)
    Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" + "
    Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Value -> Text
renderValue (TxOutValue era -> Value
forall era. TxOutValue era -> Value
txOutValueToValue TxOutValue era
txOutVal)

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

-- ----------------------------------------------------------------------------
-- 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
    :: AlonzoEraOnwards 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 (i.e this is a supplemental datum),
  -- and does not occur in the UTxO. The UTxO only contains the datum hash.
  TxOutSupplementalDatum
    :: AlonzoEraOnwards era
    -> 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
    :: BabbageEraOnwards era
    -> HashableScriptData
    -> TxOutDatum ctx era

deriving instance Eq (TxOutDatum ctx era)

deriving instance Show (TxOutDatum ctx era)

toAlonzoTxOutDatumHash
  :: TxOutDatum ctx era -> StrictMaybe Plutus.DataHash
toAlonzoTxOutDatumHash :: forall ctx era. TxOutDatum ctx era -> StrictMaybe DataHash
toAlonzoTxOutDatumHash TxOutDatum ctx era
TxOutDatumNone = StrictMaybe DataHash
forall a. StrictMaybe a
SNothing
toAlonzoTxOutDatumHash (TxOutDatumHash AlonzoEraOnwards era
_ (ScriptDataHash DataHash
dh)) = DataHash -> StrictMaybe DataHash
forall a. a -> StrictMaybe a
SJust DataHash
dh
toAlonzoTxOutDatumHash (TxOutDatumInline{}) = StrictMaybe DataHash
forall a. StrictMaybe a
SNothing
toAlonzoTxOutDatumHash (TxOutSupplementalDatum AlonzoEraOnwards era
_ HashableScriptData
d) =
  let ScriptDataHash DataHash
dh = HashableScriptData -> Hash ScriptData
hashScriptDataBytes HashableScriptData
d
   in DataHash -> StrictMaybe DataHash
forall a. a -> StrictMaybe a
SJust DataHash
dh

fromAlonzoTxOutDatumHash
  :: AlonzoEraOnwards era
  -> StrictMaybe Plutus.DataHash
  -> TxOutDatum ctx era
fromAlonzoTxOutDatumHash :: forall era ctx.
AlonzoEraOnwards era -> StrictMaybe DataHash -> TxOutDatum ctx era
fromAlonzoTxOutDatumHash AlonzoEraOnwards era
_ StrictMaybe DataHash
SNothing = TxOutDatum ctx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
fromAlonzoTxOutDatumHash AlonzoEraOnwards era
w (SJust DataHash
hash) = AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
forall era ctx.
AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash AlonzoEraOnwards era
w (Hash ScriptData -> TxOutDatum ctx era)
-> Hash ScriptData -> TxOutDatum ctx era
forall a b. (a -> b) -> a -> b
$ DataHash -> Hash ScriptData
ScriptDataHash DataHash
hash

toBabbageTxOutDatum
  :: L.Era (ShelleyLedgerEra era)
  => TxOutDatum ctx era
  -> Plutus.Datum (ShelleyLedgerEra era)
toBabbageTxOutDatum :: forall era ctx.
Era (ShelleyLedgerEra era) =>
TxOutDatum ctx era -> Datum (ShelleyLedgerEra era)
toBabbageTxOutDatum TxOutDatum ctx era
TxOutDatumNone = Datum (ShelleyLedgerEra era)
forall era. Datum era
Plutus.NoDatum
toBabbageTxOutDatum (TxOutDatumHash AlonzoEraOnwards era
_ (ScriptDataHash DataHash
dh)) = DataHash -> Datum (ShelleyLedgerEra era)
forall era. DataHash -> Datum era
Plutus.DatumHash DataHash
dh
toBabbageTxOutDatum (TxOutDatumInline BabbageEraOnwards era
_ HashableScriptData
sd) = HashableScriptData -> Datum (ShelleyLedgerEra era)
forall ledgerera.
Era ledgerera =>
HashableScriptData -> Datum ledgerera
scriptDataToInlineDatum HashableScriptData
sd
toBabbageTxOutDatum (TxOutSupplementalDatum AlonzoEraOnwards era
_ HashableScriptData
d) =
  let ScriptDataHash DataHash
dh = HashableScriptData -> Hash ScriptData
hashScriptDataBytes HashableScriptData
d
   in DataHash -> Datum (ShelleyLedgerEra era)
forall era. DataHash -> Datum era
Plutus.DatumHash DataHash
dh

fromBabbageTxOutDatum
  :: L.Era ledgerera
  => AlonzoEraOnwards era
  -> BabbageEraOnwards era
  -> Plutus.Datum ledgerera
  -> TxOutDatum ctx era
fromBabbageTxOutDatum :: forall ledgerera era ctx.
Era ledgerera =>
AlonzoEraOnwards era
-> BabbageEraOnwards era -> Datum ledgerera -> TxOutDatum ctx era
fromBabbageTxOutDatum AlonzoEraOnwards era
_ BabbageEraOnwards era
_ Datum ledgerera
Plutus.NoDatum = TxOutDatum ctx era
forall ctx era. TxOutDatum ctx era
TxOutDatumNone
fromBabbageTxOutDatum AlonzoEraOnwards era
w BabbageEraOnwards era
_ (Plutus.DatumHash DataHash
dh) =
  AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
forall era ctx.
AlonzoEraOnwards era -> Hash ScriptData -> TxOutDatum ctx era
TxOutDatumHash AlonzoEraOnwards era
w (Hash ScriptData -> TxOutDatum ctx era)
-> Hash ScriptData -> TxOutDatum ctx era
forall a b. (a -> b) -> a -> b
$ DataHash -> Hash ScriptData
ScriptDataHash DataHash
dh
fromBabbageTxOutDatum AlonzoEraOnwards era
_ BabbageEraOnwards era
w (Plutus.Datum BinaryData ledgerera
binData) =
  BabbageEraOnwards era -> HashableScriptData -> TxOutDatum ctx era
forall era ctx.
BabbageEraOnwards era -> HashableScriptData -> TxOutDatum ctx era
TxOutDatumInline BabbageEraOnwards era
w (HashableScriptData -> TxOutDatum ctx era)
-> HashableScriptData -> TxOutDatum ctx era
forall a b. (a -> b) -> a -> b
$ BabbageEraOnwards era -> BinaryData ledgerera -> HashableScriptData
forall ledgerera era.
Era ledgerera =>
BabbageEraOnwards era -> BinaryData ledgerera -> HashableScriptData
binaryDataToScriptData BabbageEraOnwards era
w BinaryData ledgerera
binData

toAlonzoTxOutDatumHashUTxO
  :: TxOutDatum CtxUTxO era -> StrictMaybe Plutus.DataHash
toAlonzoTxOutDatumHashUTxO :: forall era. TxOutDatum CtxUTxO era -> StrictMaybe DataHash
toAlonzoTxOutDatumHashUTxO TxOutDatum CtxUTxO era
TxOutDatumNone = StrictMaybe DataHash
forall a. StrictMaybe a
SNothing
toAlonzoTxOutDatumHashUTxO (TxOutDatumHash AlonzoEraOnwards era
_ (ScriptDataHash DataHash
dh)) = DataHash -> StrictMaybe DataHash
forall a. a -> StrictMaybe a
SJust DataHash
dh
toAlonzoTxOutDatumHashUTxO (TxOutDatumInline{}) = StrictMaybe DataHash
forall a. StrictMaybe a
SNothing

toBabbageTxOutDatumUTxO
  :: L.Era (ShelleyLedgerEra era)
  => TxOutDatum CtxUTxO era
  -> Plutus.Datum (ShelleyLedgerEra era)
toBabbageTxOutDatumUTxO :: forall era.
Era (ShelleyLedgerEra era) =>
TxOutDatum CtxUTxO era -> Datum (ShelleyLedgerEra era)
toBabbageTxOutDatumUTxO TxOutDatum CtxUTxO era
TxOutDatumNone = Datum (ShelleyLedgerEra era)
forall era. Datum era
Plutus.NoDatum
toBabbageTxOutDatumUTxO (TxOutDatumHash AlonzoEraOnwards era
_ (ScriptDataHash DataHash
dh)) = DataHash -> Datum (ShelleyLedgerEra era)
forall era. DataHash -> Datum era
Plutus.DatumHash DataHash
dh
toBabbageTxOutDatumUTxO (TxOutDatumInline BabbageEraOnwards era
_ HashableScriptData
sd) = HashableScriptData -> Datum (ShelleyLedgerEra era)
forall ledgerera.
Era ledgerera =>
HashableScriptData -> Datum ledgerera
scriptDataToInlineDatum HashableScriptData
sd

-- | Conversion of ScriptData to binary data which allows for the storage of data
-- onchain within a transaction output.
scriptDataToInlineDatum :: L.Era ledgerera => HashableScriptData -> L.Datum ledgerera
scriptDataToInlineDatum :: forall ledgerera.
Era ledgerera =>
HashableScriptData -> Datum ledgerera
scriptDataToInlineDatum HashableScriptData
d =
  BinaryData ledgerera -> Datum ledgerera
forall era. BinaryData era -> Datum era
L.Datum (BinaryData ledgerera -> Datum ledgerera)
-> (Data ledgerera -> BinaryData ledgerera)
-> Data ledgerera
-> Datum ledgerera
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Data ledgerera -> BinaryData ledgerera
forall era. Data era -> BinaryData era
L.dataToBinaryData (Data ledgerera -> Datum ledgerera)
-> Data ledgerera -> Datum ledgerera
forall a b. (a -> b) -> a -> b
$ HashableScriptData -> Data ledgerera
forall ledgerera.
Era ledgerera =>
HashableScriptData -> Data ledgerera
toAlonzoData HashableScriptData
d

binaryDataToScriptData
  :: L.Era ledgerera
  => BabbageEraOnwards era
  -> L.BinaryData ledgerera
  -> HashableScriptData
binaryDataToScriptData :: forall ledgerera era.
Era ledgerera =>
BabbageEraOnwards era -> BinaryData ledgerera -> HashableScriptData
binaryDataToScriptData BabbageEraOnwards era
BabbageEraOnwardsBabbage BinaryData ledgerera
d =
  Data ledgerera -> HashableScriptData
forall ledgerera. Data ledgerera -> HashableScriptData
fromAlonzoData (Data ledgerera -> HashableScriptData)
-> Data ledgerera -> HashableScriptData
forall a b. (a -> b) -> a -> b
$ BinaryData ledgerera -> Data ledgerera
forall era. Era era => BinaryData era -> Data era
L.binaryDataToData BinaryData ledgerera
d
binaryDataToScriptData BabbageEraOnwards era
BabbageEraOnwardsConway BinaryData ledgerera
d =
  Data ledgerera -> HashableScriptData
forall ledgerera. Data ledgerera -> HashableScriptData
fromAlonzoData (Data ledgerera -> HashableScriptData)
-> Data ledgerera -> HashableScriptData
forall a b. (a -> b) -> a -> b
$ BinaryData ledgerera -> Data ledgerera
forall era. Era era => BinaryData era -> Data era
L.binaryDataToData BinaryData ledgerera
d

data TxOutputError
  = TxOutputNegative !Quantity !TxOutInAnyEra
  | TxOutputOverflow !Quantity !TxOutInAnyEra
  deriving (TxOutputError -> TxOutputError -> Bool
(TxOutputError -> TxOutputError -> Bool)
-> (TxOutputError -> TxOutputError -> Bool) -> Eq TxOutputError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TxOutputError -> TxOutputError -> Bool
== :: TxOutputError -> TxOutputError -> Bool
$c/= :: TxOutputError -> TxOutputError -> Bool
/= :: TxOutputError -> TxOutputError -> Bool
Eq, Int -> TxOutputError -> ShowS
[TxOutputError] -> ShowS
TxOutputError -> String
(Int -> TxOutputError -> ShowS)
-> (TxOutputError -> String)
-> ([TxOutputError] -> ShowS)
-> Show TxOutputError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TxOutputError -> ShowS
showsPrec :: Int -> TxOutputError -> ShowS
$cshow :: TxOutputError -> String
show :: TxOutputError -> String
$cshowList :: [TxOutputError] -> ShowS
showList :: [TxOutputError] -> ShowS
Show)

instance Error TxOutputError where
  prettyError :: forall ann. TxOutputError -> Doc ann
prettyError = \case
    TxOutputNegative (Quantity Integer
q) TxOutInAnyEra
txout ->
      Doc ann
"Negative quantity ("
        Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Integer -> Doc ann
forall ann. Integer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Integer
q
        Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
") in transaction output: "
        Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> TxOutInAnyEra -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. TxOutInAnyEra -> Doc ann
pretty TxOutInAnyEra
txout
    TxOutputOverflow (Quantity Integer
q) TxOutInAnyEra
txout ->
      Doc ann
"Quantity too large ("
        Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Integer -> Doc ann
forall ann. Integer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Integer
q
        Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
" >= 2^64) in transaction output: "
        Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> TxOutInAnyEra -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. TxOutInAnyEra -> Doc ann
pretty TxOutInAnyEra
txout