{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}

module Cardano.Api.Experimental.Tx.Internal.BodyContent
  ( TxCertificates (..)
  , TxReturnCollateral (..)
  , TxTotalCollateral (..)
  , TxExtraKeyWitnesses (..)
  , TxInsReference (..)
  , TxMintValue (..)
  , TxOut (..)
  , TxProposalProcedures (..)
  , TxValidityLowerBound (..)
  , TxVotingProcedures (..)
  , TxWithdrawals (..)

    -- * Transaction body content at either level
  , BodyContent (TxBodyContent, SubTxBodyContent)
  , TxBodyContent
  , SubTxBodyContent
  , defaultTxBodyContent
  , defaultSubTxBodyContent

    -- ** Fields of a top-level body
  , txIns
  , txInsCollateral
  , txInsReference
  , txOuts
  , txTotalCollateral
  , txReturnCollateral
  , txFee
  , txValidityLowerBound
  , txValidityUpperBound
  , txMetadata
  , txAuxScripts
  , txExtraKeyWits
  , txProtocolParams
  , txWithdrawals
  , txCertificates
  , txMintValue
  , txScriptValidity
  , txProposalProcedures
  , txVotingProcedures
  , txCurrentTreasuryValue
  , txTreasuryDonation
  , txSupplementalDatums
  , txGuards
  , txSubTransactions
  , txRequiredTopLevelGuards
  , txDirectDeposits
  , txAccountBalanceIntervals
  , txStartingAccountBalanceIntervals

    -- ** Fields of a sub-transaction body
  , subTxIns
  , subTxInsReference
  , subTxOuts
  , subTxValidityLowerBound
  , subTxValidityUpperBound
  , subTxMetadata
  , subTxAuxScripts
  , subTxProtocolParams
  , subTxWithdrawals
  , subTxCertificates
  , subTxMintValue
  , subTxProposalProcedures
  , subTxVotingProcedures
  , subTxCurrentTreasuryValue
  , subTxTreasuryDonation
  , subTxSupplementalDatums
  , subTxGuards
  , subTxRequiredTopLevelGuards
  , subTxDirectDeposits
  , subTxAccountBalanceIntervals
  , Datum (..)
  , MakeUnsignedTxError (..)
  , extractDatumsAndHashes
  , getDatums
  , collectTxBodyScriptWitnessRequirements
  , makeUnsignedTx
  , extractAllIndexedPlutusScriptWitnesses
  , txMintValueToValue
  , mkTxCertificates
  , mkTxVotingProcedures
  , mkTxProposalProcedures

    -- * Getters and Setters

    -- ** Shared by both levels
  , modTxOuts
  , setTxAuxScripts
  , setTxCertificates
  , setTxCurrentTreasuryValue
  , setTxIns
  , setTxInsReference
  , setTxMetadata
  , setTxMintValue
  , setTxOuts
  , setTxProposalProcedures
  , setTxProtocolParams
  , setTxSupplementalDatums
  , setTxTreasuryDonation
  , setTxValidityLowerBound
  , setTxValidityUpperBound
  , setTxVotingProcedures
  , setTxWithdrawals
  , setTxGuards
  , setTxRequiredTopLevelGuards
  , setTxDirectDeposits
  , setTxAccountBalanceIntervals

    -- ** Top-level bodies only
  , setTxReturnCollateral
  , setTxTotalCollateral
  , setTxExtraKeyWits
  , setTxFee
  , setTxInsCollateral
  , setTxScriptValidity
  , setTxSubTransactions
  , setTxStartingAccountBalanceIntervals

    -- * Internal conversions
  , convTxIns
  , convReferenceInputs
  , convWithdrawals
  , convCertificates
  , convMintValue
  , convProposalProcedures
  , convVotingProcedures
  , convPParamsToScriptIntegrityHash
  , toAuxiliaryData
  , extractWitnessableTxIns
  , extractWitnessableMints
  , extractWitnessableCertificates
  , extractWitnessableWithdrawals
  , extractWitnessableVotes
  , extractWitnessableProposals
  )
where

import Cardano.Api.Address
import Cardano.Api.Era.Internal.Eon.ShelleyBasedEra (ShelleyBasedEra (..), ShelleyLedgerEra)
import Cardano.Api.Error
import Cardano.Api.Experimental.AnyScriptWitness
import Cardano.Api.Experimental.Certificate qualified as Exp
import Cardano.Api.Experimental.Era
import Cardano.Api.Experimental.Plutus
  ( AnyIndexedPlutusScriptWitness (..)
  , Witnessable (..)
  , WitnessableItem (..)
  , createIndexedPlutusScriptWitnesses
  )
import Cardano.Api.Experimental.Simple.Script
import Cardano.Api.Experimental.Tx.Internal.AnyWitness
  ( AnyWitness (..)
  , anyScriptWitnessToAnyWitness
  )
import Cardano.Api.Experimental.Tx.Internal.Certificate.Compatible (getTxCertWitness)
import Cardano.Api.Experimental.Tx.Internal.TxScriptWitnessRequirements
  ( TxScriptWitnessRequirements (..)
  , getTxScriptWitnessesRequirements
  )
import Cardano.Api.Experimental.Tx.Internal.Type
import Cardano.Api.Governance.Internal.Action.VotingProcedure
  ( VotingError (..)
  , mergeVotingProcedures
  )
import Cardano.Api.Key.Internal
import Cardano.Api.Ledger.Internal.Reexport (StrictMaybe (..))
import Cardano.Api.Ledger.Internal.Reexport qualified as L
import Cardano.Api.Monad.Error (failEitherWith, liftMaybe)
import Cardano.Api.Plutus.Internal.Script
  ( PlutusScript (..)
  , PlutusScriptVersion (..)
  , ScriptInAnyLang (..)
  , ScriptLanguage (..)
  , fromAllegraTimelock
  , toAllegraTimelock
  )
import Cardano.Api.Plutus.Internal.Script qualified as OldScript
import Cardano.Api.Plutus.Internal.ScriptData qualified as Api
import Cardano.Api.Pretty
import Cardano.Api.Serialise.Cbor (serialiseToCBOR)
import Cardano.Api.Tx.Internal.Body
  ( CtxTx
  , TxIn
  , asGuard
  , toShelleyTxIn
  , toShelleyWithdrawal
  )
import Cardano.Api.Tx.Internal.Sign
import Cardano.Api.Tx.Internal.TxMetadata
import Cardano.Api.Value.Internal
  ( PolicyAssets
  , PolicyId
  , Value
  , fromLedgerValue
  , policyAssetsToValue
  , toMaryValue
  )

import Cardano.Binary qualified as CBOR
import Cardano.Ledger.Allegra.Scripts (Timelock)
import Cardano.Ledger.Alonzo.Scripts qualified as L
import Cardano.Ledger.Alonzo.Tx qualified as L
import Cardano.Ledger.Alonzo.TxBody qualified as L
import Cardano.Ledger.Alonzo.TxWits qualified as L
import Cardano.Ledger.Api qualified as L
import Cardano.Ledger.Core qualified as L (TxLevel (..))
import Cardano.Ledger.Core qualified as Ledger
import Cardano.Ledger.Dijkstra.TxBody qualified as L
  ( DijkstraEraTxBody
      ( accountBalanceIntervalsTxBodyL
      , requiredTopLevelGuardsL
      , startingAccountBalanceIntervalsTxBodyL
      , subTransactionsTxBodyL
      )
  )
import Cardano.Ledger.Plutus.Language (PlutusBinary (..), plutusLanguage)
import Cardano.Ledger.Plutus.Language qualified as Plutus

import Control.Monad
import Data.Aeson (FromJSON (..), ToJSON (..), (.:), (.:?), (.=))
import Data.Aeson qualified as Aeson
import Data.Aeson.Types (Pair, Parser)
import Data.ByteString.Base16 qualified as Base16
import Data.ByteString.Short qualified as SBS
import Data.Functor
import Data.List qualified as List
import Data.List.NonEmpty (NonEmpty)
import Data.List.NonEmpty qualified as NonEmpty
import Data.Map.Ordered.Strict (OMap)
import Data.Map.Ordered.Strict qualified as OMap
import Data.Map.Strict (Map)
import Data.Map.Strict qualified as Map
import Data.Maybe
import Data.OMap.Strict qualified as LOMap
import Data.OSet.Strict (OSet)
import Data.OSet.Strict qualified as OSet
import Data.Sequence.Strict qualified as Seq
import Data.Set (Set)
import Data.Set qualified as Set
import Data.Text qualified as Text
import Data.Text.Encoding qualified as Text
import GHC.Exts (IsList (..))
import Lens.Micro

-- | Error that can occur when constructing an unsigned transaction.
data MakeUnsignedTxError
  = -- | Plutus scripts are present in the transaction but no protocol
    -- parameters were provided. Protocol parameters are required to
    -- compute the script integrity hash (script_data_hash).
    MakeUnsignedTxMissingProtocolParams
  | -- | Fields were set on the body content that the ledger body of the
    -- target era has no slot for. The body content record is shared by all
    -- eras, so this is only detected when the body is built.
    -- The field names are those of the 'TxBodyContent' record.
    MakeUnsignedTxFieldsNotSupportedInEra (Some Era) (NonEmpty Text)
  deriving (MakeUnsignedTxError -> MakeUnsignedTxError -> Bool
(MakeUnsignedTxError -> MakeUnsignedTxError -> Bool)
-> (MakeUnsignedTxError -> MakeUnsignedTxError -> Bool)
-> Eq MakeUnsignedTxError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MakeUnsignedTxError -> MakeUnsignedTxError -> Bool
== :: MakeUnsignedTxError -> MakeUnsignedTxError -> Bool
$c/= :: MakeUnsignedTxError -> MakeUnsignedTxError -> Bool
/= :: MakeUnsignedTxError -> MakeUnsignedTxError -> Bool
Eq, Int -> MakeUnsignedTxError -> ShowS
[MakeUnsignedTxError] -> ShowS
MakeUnsignedTxError -> String
(Int -> MakeUnsignedTxError -> ShowS)
-> (MakeUnsignedTxError -> String)
-> ([MakeUnsignedTxError] -> ShowS)
-> Show MakeUnsignedTxError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MakeUnsignedTxError -> ShowS
showsPrec :: Int -> MakeUnsignedTxError -> ShowS
$cshow :: MakeUnsignedTxError -> String
show :: MakeUnsignedTxError -> String
$cshowList :: [MakeUnsignedTxError] -> ShowS
showList :: [MakeUnsignedTxError] -> ShowS
Show)

instance Error MakeUnsignedTxError where
  prettyError :: forall ann. MakeUnsignedTxError -> Doc ann
prettyError MakeUnsignedTxError
MakeUnsignedTxMissingProtocolParams =
    [Doc ann] -> Doc ann
forall a. Monoid a => [a] -> a
mconcat
      [ Doc ann
"Transaction uses Plutus scripts but no protocol parameters were provided. "
      , Doc ann
"Protocol parameters are required to compute the script integrity hash "
      , Doc ann
"(script_data_hash) from the cost models."
      ]
  prettyError (MakeUnsignedTxFieldsNotSupportedInEra (Some Era a
era) NonEmpty Text
fields) =
    [Doc ann] -> Doc ann
forall a. Monoid a => [a] -> a
mconcat
      [ Doc ann
"Transaction body content sets fields that do not exist in the "
      , Era a -> Doc ann
forall a ann. Show a => a -> Doc ann
pshow Era a
era
      , Doc ann
" era: "
      , Text -> Doc ann
forall ann. Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Text -> Doc ann) -> ([Text] -> Text) -> [Text] -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Text] -> Text
Text.intercalate Text
", " ([Text] -> Doc ann) -> [Text] -> Doc ann
forall a b. (a -> b) -> a -> b
$ NonEmpty Text -> [Text]
forall a. NonEmpty a -> [a]
NonEmpty.toList NonEmpty Text
fields
      ]

makeUnsignedTx
  :: forall era
   . Era era
  -> TxBodyContent (LedgerEra era)
  -> Either MakeUnsignedTxError (UnsignedTx (LedgerEra era))
makeUnsignedTx :: forall era.
Era era
-> TxBodyContent (LedgerEra era)
-> Either MakeUnsignedTxError (UnsignedTx (LedgerEra era))
makeUnsignedTx Era era
era TxBodyContent (LedgerEra era)
bc = Era era
-> (EraCommonConstraints era =>
    Either MakeUnsignedTxError (UnsignedTx (LedgerEra era)))
-> Either MakeUnsignedTxError (UnsignedTx (LedgerEra era))
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints Era era
era ((EraCommonConstraints era =>
  Either MakeUnsignedTxError (UnsignedTx (LedgerEra era)))
 -> Either MakeUnsignedTxError (UnsignedTx (LedgerEra era)))
-> (EraCommonConstraints era =>
    Either MakeUnsignedTxError (UnsignedTx (LedgerEra era)))
-> Either MakeUnsignedTxError (UnsignedTx (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ do
  let TxScriptWitnessRequirements Set Language
languages [Script (LedgerEra era)]
scripts TxDats (LedgerEra era)
datums Redeemers (LedgerEra era)
redeemers = TxBodyContent (LedgerEra era)
-> TxScriptWitnessRequirements (LedgerEra era)
forall (l :: TxLevel) era.
IsEra era =>
BodyContent l (LedgerEra era)
-> TxScriptWitnessRequirements (LedgerEra era)
collectTxBodyScriptWitnessRequirements TxBodyContent (LedgerEra era)
bc

  -- cardano-api types
  let apiMintValue :: TxMintValue (LedgerEra era)
apiMintValue = TxBodyContent (LedgerEra era) -> TxMintValue (LedgerEra era)
forall era. TxBodyContent era -> TxMintValue era
txMintValue TxBodyContent (LedgerEra era)
bc
      apiReferenceInputs :: TxInsReference (LedgerEra era)
apiReferenceInputs = TxBodyContent (LedgerEra era) -> TxInsReference (LedgerEra era)
forall era. TxBodyContent era -> TxInsReference era
txInsReference TxBodyContent (LedgerEra era)
bc

      -- Ledger types
      txins :: Set TxIn
txins = [(TxIn, AnyWitness (LedgerEra era))] -> Set TxIn
forall era. [(TxIn, AnyWitness era)] -> Set TxIn
convTxIns ([(TxIn, AnyWitness (LedgerEra era))] -> Set TxIn)
-> [(TxIn, AnyWitness (LedgerEra era))] -> Set TxIn
forall a b. (a -> b) -> a -> b
$ TxBodyContent (LedgerEra era)
-> [(TxIn, AnyWitness (LedgerEra era))]
forall era. TxBodyContent era -> [(TxIn, AnyWitness era)]
txIns TxBodyContent (LedgerEra era)
bc
      collTxIns :: Set TxIn
collTxIns = TxBodyContent (LedgerEra era) -> Set TxIn
forall era. TxBodyContent (LedgerEra era) -> Set TxIn
convCollateralTxIns TxBodyContent (LedgerEra era)
bc
      refTxIns :: Set TxIn
refTxIns = TxInsReference (LedgerEra era) -> Set TxIn
forall era. TxInsReference era -> Set TxIn
convReferenceInputs TxInsReference (LedgerEra era)
apiReferenceInputs
      outs :: StrictSeq (TxOut (LedgerEra era))
outs = [Item (StrictSeq (TxOut (LedgerEra era)))]
-> StrictSeq (TxOut (LedgerEra era))
forall l. IsList l => [Item l] -> l
fromList [Item (StrictSeq (TxOut (LedgerEra era)))
TxOut (LedgerEra era)
o | TxOut TxOut (LedgerEra era)
o <- TxBodyContent (LedgerEra era) -> [TxOut (LedgerEra era)]
forall era. TxBodyContent era -> [TxOut era]
txOuts TxBodyContent (LedgerEra era)
bc]
      protocolParameters :: Maybe (PParams (LedgerEra era))
protocolParameters = TxBodyContent (LedgerEra era) -> Maybe (PParams (LedgerEra era))
forall era. TxBodyContent era -> Maybe (PParams era)
txProtocolParams TxBodyContent (LedgerEra era)
bc
      fee :: Coin
fee = TxBodyContent (LedgerEra era) -> Coin
forall era. TxBodyContent era -> Coin
txFee TxBodyContent (LedgerEra era)
bc
      withdrawals :: Withdrawals
withdrawals = TxWithdrawals (LedgerEra era) -> Withdrawals
forall era. TxWithdrawals era -> Withdrawals
convWithdrawals (TxWithdrawals (LedgerEra era) -> Withdrawals)
-> TxWithdrawals (LedgerEra era) -> Withdrawals
forall a b. (a -> b) -> a -> b
$ TxBodyContent (LedgerEra era) -> TxWithdrawals (LedgerEra era)
forall era. TxBodyContent era -> TxWithdrawals era
txWithdrawals TxBodyContent (LedgerEra era)
bc
      certs :: StrictSeq (TxCert (LedgerEra era))
certs = TxCertificates (LedgerEra era)
-> StrictSeq (TxCert (LedgerEra era))
forall era.
TxCertificates (LedgerEra era)
-> StrictSeq (TxCert (LedgerEra era))
convCertificates (TxCertificates (LedgerEra era)
 -> StrictSeq (TxCert (LedgerEra era)))
-> TxCertificates (LedgerEra era)
-> StrictSeq (TxCert (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ TxBodyContent (LedgerEra era) -> TxCertificates (LedgerEra era)
forall era. TxBodyContent era -> TxCertificates era
txCertificates TxBodyContent (LedgerEra era)
bc
      retCollateral :: Maybe (TxOut (LedgerEra era))
retCollateral = TxReturnCollateral (LedgerEra era) -> TxOut (LedgerEra era)
forall era. TxReturnCollateral era -> TxOut era
unTxReturnCollateral (TxReturnCollateral (LedgerEra era) -> TxOut (LedgerEra era))
-> Maybe (TxReturnCollateral (LedgerEra era))
-> Maybe (TxOut (LedgerEra era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TxBodyContent (LedgerEra era)
-> Maybe (TxReturnCollateral (LedgerEra era))
forall era. TxBodyContent era -> Maybe (TxReturnCollateral era)
txReturnCollateral TxBodyContent (LedgerEra era)
bc
      totCollateral :: Maybe Coin
totCollateral = TxTotalCollateral -> Coin
unTxTotalCollateral (TxTotalCollateral -> Coin)
-> Maybe TxTotalCollateral -> Maybe Coin
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TxBodyContent (LedgerEra era) -> Maybe TxTotalCollateral
forall era. TxBodyContent era -> Maybe TxTotalCollateral
txTotalCollateral TxBodyContent (LedgerEra era)
bc
      txAuxData :: Maybe (TxAuxData (LedgerEra era))
txAuxData = TxMetadata
-> [SimpleScript (LedgerEra era)]
-> Maybe (TxAuxData (LedgerEra era))
forall era.
IsEra era =>
TxMetadata
-> [SimpleScript (LedgerEra era)]
-> Maybe (TxAuxData (LedgerEra era))
toAuxiliaryData (TxBodyContent (LedgerEra era) -> TxMetadata
forall era. TxBodyContent era -> TxMetadata
txMetadata TxBodyContent (LedgerEra era)
bc) (TxBodyContent (LedgerEra era) -> [SimpleScript (LedgerEra era)]
forall era. TxBodyContent era -> [SimpleScript era]
txAuxScripts TxBodyContent (LedgerEra era)
bc)
      scriptValidity :: IsPhase2Valid
scriptValidity = ScriptValidity -> IsPhase2Valid
scriptValidityToIsValid (ScriptValidity -> IsPhase2Valid)
-> ScriptValidity -> IsPhase2Valid
forall a b. (a -> b) -> a -> b
$ TxBodyContent (LedgerEra era) -> ScriptValidity
forall era. TxBodyContent era -> ScriptValidity
txScriptValidity TxBodyContent (LedgerEra era)
bc

  scriptIntegrityHash <-
    Maybe (PParams (LedgerEra era))
-> Redeemers (LedgerEra era)
-> TxDats (LedgerEra era)
-> Set Language
-> Either MakeUnsignedTxError (StrictMaybe ScriptIntegrityHash)
forall era.
IsEra era =>
Maybe (PParams (LedgerEra era))
-> Redeemers (LedgerEra era)
-> TxDats (LedgerEra era)
-> Set Language
-> Either MakeUnsignedTxError (StrictMaybe ScriptIntegrityHash)
convPParamsToScriptIntegrityHash
      Maybe (PParams (LedgerEra era))
protocolParameters
      Redeemers (LedgerEra era)
redeemers
      TxDats (LedgerEra era)
datums
      Set Language
languages

  let setMint = TxMintValue (LedgerEra era) -> MultiAsset
forall era. TxMintValue era -> MultiAsset
convMintValue TxMintValue (LedgerEra era)
apiMintValue
      -- Fields common to all supported eras. Era-specific fields are set in
      -- 'eraSpecificLedgerTxBody'.
      commonLedgerTxBody =
        TxBody TopTx (LedgerEra era)
forall era (l :: TxLevel).
(EraTxBody era, Typeable l) =>
TxBody l era
forall (l :: TxLevel). Typeable l => TxBody l (LedgerEra era)
L.mkBasicTxBody
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (Set TxIn -> Identity (Set TxIn))
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era (l :: TxLevel).
EraTxBody era =>
Lens' (TxBody l era) (Set TxIn)
forall (l :: TxLevel). Lens' (TxBody l (LedgerEra era)) (Set TxIn)
L.inputsTxBodyL ((Set TxIn -> Identity (Set TxIn))
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> Set TxIn
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Set TxIn
txins
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (Set TxIn -> Identity (Set TxIn))
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era.
AlonzoEraTxBody era =>
Lens' (TxBody TopTx era) (Set TxIn)
Lens' (TxBody TopTx (LedgerEra era)) (Set TxIn)
L.collateralInputsTxBodyL ((Set TxIn -> Identity (Set TxIn))
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> Set TxIn
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Set TxIn
collTxIns
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (Set TxIn -> Identity (Set TxIn))
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era (l :: TxLevel).
BabbageEraTxBody era =>
Lens' (TxBody l era) (Set TxIn)
forall (l :: TxLevel). Lens' (TxBody l (LedgerEra era)) (Set TxIn)
L.referenceInputsTxBodyL ((Set TxIn -> Identity (Set TxIn))
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> Set TxIn
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Set TxIn
refTxIns
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (StrictSeq (TxOut (LedgerEra era))
 -> Identity (StrictSeq (TxOut (LedgerEra era))))
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era (l :: TxLevel).
EraTxBody era =>
Lens' (TxBody l era) (StrictSeq (TxOut era))
forall (l :: TxLevel).
Lens'
  (TxBody l (LedgerEra era)) (StrictSeq (TxOut (LedgerEra era)))
L.outputsTxBodyL ((StrictSeq (TxOut (LedgerEra era))
  -> Identity (StrictSeq (TxOut (LedgerEra era))))
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> StrictSeq (TxOut (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ StrictSeq (TxOut (LedgerEra era))
outs
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (StrictMaybe Coin -> Identity (StrictMaybe Coin))
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era.
BabbageEraTxBody era =>
Lens' (TxBody TopTx era) (StrictMaybe Coin)
Lens' (TxBody TopTx (LedgerEra era)) (StrictMaybe Coin)
L.totalCollateralTxBodyL ((StrictMaybe Coin -> Identity (StrictMaybe Coin))
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> StrictMaybe Coin
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe Coin -> StrictMaybe Coin
forall a. Maybe a -> StrictMaybe a
L.maybeToStrictMaybe Maybe Coin
totCollateral
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (StrictMaybe (TxOut (LedgerEra era))
 -> Identity (StrictMaybe (TxOut (LedgerEra era))))
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era.
BabbageEraTxBody era =>
Lens' (TxBody TopTx era) (StrictMaybe (TxOut era))
Lens'
  (TxBody TopTx (LedgerEra era))
  (StrictMaybe (TxOut (LedgerEra era)))
L.collateralReturnTxBodyL ((StrictMaybe (TxOut (LedgerEra era))
  -> Identity (StrictMaybe (TxOut (LedgerEra era))))
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> StrictMaybe (TxOut (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe (TxOut (LedgerEra era))
-> StrictMaybe (TxOut (LedgerEra era))
forall a. Maybe a -> StrictMaybe a
L.maybeToStrictMaybe Maybe (TxOut (LedgerEra era))
retCollateral
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (Coin -> Identity Coin)
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era. EraTxBody era => Lens' (TxBody TopTx era) Coin
Lens' (TxBody TopTx (LedgerEra era)) Coin
L.feeTxBodyL ((Coin -> Identity Coin)
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> Coin
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Coin
fee
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (ValidityInterval -> Identity ValidityInterval)
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era (l :: TxLevel).
AllegraEraTxBody era =>
Lens' (TxBody l era) ValidityInterval
forall (l :: TxLevel).
Lens' (TxBody l (LedgerEra era)) ValidityInterval
L.vldtTxBodyL ((ValidityInterval -> Identity ValidityInterval)
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> ((StrictMaybe SlotNo -> Identity (StrictMaybe SlotNo))
    -> ValidityInterval -> Identity ValidityInterval)
-> (StrictMaybe SlotNo -> Identity (StrictMaybe SlotNo))
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StrictMaybe SlotNo -> Identity (StrictMaybe SlotNo))
-> ValidityInterval -> Identity ValidityInterval
Lens' ValidityInterval (StrictMaybe SlotNo)
L.invalidBeforeL ((StrictMaybe SlotNo -> Identity (StrictMaybe SlotNo))
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> StrictMaybe SlotNo
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe SlotNo -> StrictMaybe SlotNo
forall a. Maybe a -> StrictMaybe a
L.maybeToStrictMaybe (TxBodyContent (LedgerEra era) -> Maybe SlotNo
forall era. TxBodyContent era -> Maybe SlotNo
txValidityLowerBound TxBodyContent (LedgerEra era)
bc)
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (ValidityInterval -> Identity ValidityInterval)
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era (l :: TxLevel).
AllegraEraTxBody era =>
Lens' (TxBody l era) ValidityInterval
forall (l :: TxLevel).
Lens' (TxBody l (LedgerEra era)) ValidityInterval
L.vldtTxBodyL ((ValidityInterval -> Identity ValidityInterval)
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> ((StrictMaybe SlotNo -> Identity (StrictMaybe SlotNo))
    -> ValidityInterval -> Identity ValidityInterval)
-> (StrictMaybe SlotNo -> Identity (StrictMaybe SlotNo))
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StrictMaybe SlotNo -> Identity (StrictMaybe SlotNo))
-> ValidityInterval -> Identity ValidityInterval
Lens' ValidityInterval (StrictMaybe SlotNo)
L.invalidHereAfterL ((StrictMaybe SlotNo -> Identity (StrictMaybe SlotNo))
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> StrictMaybe SlotNo
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe SlotNo -> StrictMaybe SlotNo
forall a. Maybe a -> StrictMaybe a
L.maybeToStrictMaybe (TxBodyContent (LedgerEra era) -> Maybe SlotNo
forall era. TxBodyContent era -> Maybe SlotNo
txValidityUpperBound TxBodyContent (LedgerEra era)
bc)
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (StrictMaybe ScriptIntegrityHash
 -> Identity (StrictMaybe ScriptIntegrityHash))
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era (l :: TxLevel).
AlonzoEraTxBody era =>
Lens' (TxBody l era) (StrictMaybe ScriptIntegrityHash)
forall (l :: TxLevel).
Lens' (TxBody l (LedgerEra era)) (StrictMaybe ScriptIntegrityHash)
L.scriptIntegrityHashTxBodyL ((StrictMaybe ScriptIntegrityHash
  -> Identity (StrictMaybe ScriptIntegrityHash))
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> StrictMaybe ScriptIntegrityHash
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ StrictMaybe ScriptIntegrityHash
scriptIntegrityHash
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (Withdrawals -> Identity Withdrawals)
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era (l :: TxLevel).
EraTxBody era =>
Lens' (TxBody l era) Withdrawals
forall (l :: TxLevel). Lens' (TxBody l (LedgerEra era)) Withdrawals
L.withdrawalsTxBodyL ((Withdrawals -> Identity Withdrawals)
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> Withdrawals
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Withdrawals
withdrawals
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (StrictSeq (TxCert (LedgerEra era))
 -> Identity (StrictSeq (TxCert (LedgerEra era))))
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era (l :: TxLevel).
EraTxBody era =>
Lens' (TxBody l era) (StrictSeq (TxCert era))
forall (l :: TxLevel).
Lens'
  (TxBody l (LedgerEra era)) (StrictSeq (TxCert (LedgerEra era)))
L.certsTxBodyL ((StrictSeq (TxCert (LedgerEra era))
  -> Identity (StrictSeq (TxCert (LedgerEra era))))
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> StrictSeq (TxCert (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ StrictSeq (TxCert (LedgerEra era))
certs
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (MultiAsset -> Identity MultiAsset)
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era (l :: TxLevel).
MaryEraTxBody era =>
Lens' (TxBody l era) MultiAsset
forall (l :: TxLevel). Lens' (TxBody l (LedgerEra era)) MultiAsset
L.mintTxBodyL ((MultiAsset -> Identity MultiAsset)
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> MultiAsset
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ MultiAsset
setMint
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (StrictMaybe TxAuxDataHash -> Identity (StrictMaybe TxAuxDataHash))
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era (l :: TxLevel).
EraTxBody era =>
Lens' (TxBody l era) (StrictMaybe TxAuxDataHash)
forall (l :: TxLevel).
Lens' (TxBody l (LedgerEra era)) (StrictMaybe TxAuxDataHash)
L.auxDataHashTxBodyL ((StrictMaybe TxAuxDataHash
  -> Identity (StrictMaybe TxAuxDataHash))
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> StrictMaybe TxAuxDataHash
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe TxAuxDataHash -> StrictMaybe TxAuxDataHash
forall a. Maybe a -> StrictMaybe a
L.maybeToStrictMaybe (TxAuxData (LedgerEra era) -> TxAuxDataHash
forall era. EraTxAuxData era => TxAuxData era -> TxAuxDataHash
Ledger.hashTxAuxData (TxAuxData (LedgerEra era) -> TxAuxDataHash)
-> Maybe (TxAuxData (LedgerEra era)) -> Maybe TxAuxDataHash
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (TxAuxData (LedgerEra era))
txAuxData)
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (OSet (ProposalProcedure (LedgerEra era))
 -> Identity (OSet (ProposalProcedure (LedgerEra era))))
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era (l :: TxLevel).
ConwayEraTxBody era =>
Lens' (TxBody l era) (OSet (ProposalProcedure era))
forall (l :: TxLevel).
Lens'
  (TxBody l (LedgerEra era))
  (OSet (ProposalProcedure (LedgerEra era)))
L.proposalProceduresTxBodyL ((OSet (ProposalProcedure (LedgerEra era))
  -> Identity (OSet (ProposalProcedure (LedgerEra era))))
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> OSet (ProposalProcedure (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe (TxProposalProcedures (LedgerEra era))
-> OSet (ProposalProcedure (LedgerEra era))
forall era.
IsEra era =>
Maybe (TxProposalProcedures (LedgerEra era))
-> OSet (ProposalProcedure (LedgerEra era))
convProposalProcedures (TxBodyContent (LedgerEra era)
-> Maybe (TxProposalProcedures (LedgerEra era))
forall era. TxBodyContent era -> Maybe (TxProposalProcedures era)
txProposalProcedures TxBodyContent (LedgerEra era)
bc)
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (VotingProcedures (LedgerEra era)
 -> Identity (VotingProcedures (LedgerEra era)))
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era (l :: TxLevel).
ConwayEraTxBody era =>
Lens' (TxBody l era) (VotingProcedures era)
forall (l :: TxLevel).
Lens' (TxBody l (LedgerEra era)) (VotingProcedures (LedgerEra era))
L.votingProceduresTxBodyL ((VotingProcedures (LedgerEra era)
  -> Identity (VotingProcedures (LedgerEra era)))
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> VotingProcedures (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe (TxVotingProcedures (LedgerEra era))
-> VotingProcedures (LedgerEra era)
forall era.
Maybe (TxVotingProcedures (LedgerEra era))
-> VotingProcedures (LedgerEra era)
convVotingProcedures (TxBodyContent (LedgerEra era)
-> Maybe (TxVotingProcedures (LedgerEra era))
forall era. TxBodyContent era -> Maybe (TxVotingProcedures era)
txVotingProcedures TxBodyContent (LedgerEra era)
bc)
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (Coin -> Identity Coin)
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era (l :: TxLevel).
ConwayEraTxBody era =>
Lens' (TxBody l era) Coin
forall (l :: TxLevel). Lens' (TxBody l (LedgerEra era)) Coin
L.treasuryDonationTxBodyL ((Coin -> Identity Coin)
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> Coin
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Coin -> Maybe Coin -> Coin
forall a. a -> Maybe a -> a
fromMaybe (Integer -> Coin
L.Coin Integer
0) (TxBodyContent (LedgerEra era) -> Maybe Coin
forall era. TxBodyContent era -> Maybe Coin
txTreasuryDonation TxBodyContent (LedgerEra era)
bc)
          TxBody TopTx (LedgerEra era)
-> (TxBody TopTx (LedgerEra era) -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (StrictMaybe Coin -> Identity (StrictMaybe Coin))
-> TxBody TopTx (LedgerEra era)
-> Identity (TxBody TopTx (LedgerEra era))
forall era (l :: TxLevel).
ConwayEraTxBody era =>
Lens' (TxBody l era) (StrictMaybe Coin)
forall (l :: TxLevel).
Lens' (TxBody l (LedgerEra era)) (StrictMaybe Coin)
L.currentTreasuryValueTxBodyL ((StrictMaybe Coin -> Identity (StrictMaybe Coin))
 -> TxBody TopTx (LedgerEra era)
 -> Identity (TxBody TopTx (LedgerEra era)))
-> StrictMaybe Coin
-> TxBody TopTx (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe Coin -> StrictMaybe Coin
forall a. Maybe a -> StrictMaybe a
L.maybeToStrictMaybe (TxBodyContent (LedgerEra era) -> Maybe Coin
forall era. TxBodyContent era -> Maybe Coin
txCurrentTreasuryValue TxBodyContent (LedgerEra era)
bc)

      scriptWitnesses =
        TxWits (LedgerEra era)
forall era. EraTxWits era => TxWits era
L.mkBasicTxWits
          TxWits (LedgerEra era)
-> (TxWits (LedgerEra era) -> TxWits (LedgerEra era))
-> TxWits (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (Map ScriptHash (Script (LedgerEra era))
 -> Identity (Map ScriptHash (Script (LedgerEra era))))
-> TxWits (LedgerEra era) -> Identity (TxWits (LedgerEra era))
forall era.
EraTxWits era =>
Lens' (TxWits era) (Map ScriptHash (Script era))
Lens'
  (TxWits (LedgerEra era)) (Map ScriptHash (Script (LedgerEra era)))
L.scriptTxWitsL
            ((Map ScriptHash (Script (LedgerEra era))
  -> Identity (Map ScriptHash (Script (LedgerEra era))))
 -> TxWits (LedgerEra era) -> Identity (TxWits (LedgerEra era)))
-> Map ScriptHash (Script (LedgerEra era))
-> TxWits (LedgerEra era)
-> TxWits (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ [Item (Map ScriptHash (Script (LedgerEra era)))]
-> Map ScriptHash (Script (LedgerEra era))
forall l. IsList l => [Item l] -> l
fromList
              [ (Script (LedgerEra era) -> ScriptHash
forall era. EraScript era => Script era -> ScriptHash
L.hashScript Script (LedgerEra era)
sw, Script (LedgerEra era)
sw)
              | Script (LedgerEra era)
sw <- [Script (LedgerEra era)]
scripts
              ]
          TxWits (LedgerEra era)
-> (TxWits (LedgerEra era) -> TxWits (LedgerEra era))
-> TxWits (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (TxDats (LedgerEra era) -> Identity (TxDats (LedgerEra era)))
-> TxWits (LedgerEra era) -> Identity (TxWits (LedgerEra era))
forall era. AlonzoEraTxWits era => Lens' (TxWits era) (TxDats era)
Lens' (TxWits (LedgerEra era)) (TxDats (LedgerEra era))
L.datsTxWitsL ((TxDats (LedgerEra era) -> Identity (TxDats (LedgerEra era)))
 -> TxWits (LedgerEra era) -> Identity (TxWits (LedgerEra era)))
-> TxDats (LedgerEra era)
-> TxWits (LedgerEra era)
-> TxWits (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TxDats (LedgerEra era)
datums
          TxWits (LedgerEra era)
-> (TxWits (LedgerEra era) -> TxWits (LedgerEra era))
-> TxWits (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (Redeemers (LedgerEra era) -> Identity (Redeemers (LedgerEra era)))
-> TxWits (LedgerEra era) -> Identity (TxWits (LedgerEra era))
forall era.
AlonzoEraTxWits era =>
Lens' (TxWits era) (Redeemers era)
Lens' (TxWits (LedgerEra era)) (Redeemers (LedgerEra era))
L.rdmrsTxWitsL ((Redeemers (LedgerEra era)
  -> Identity (Redeemers (LedgerEra era)))
 -> TxWits (LedgerEra era) -> Identity (TxWits (LedgerEra era)))
-> Redeemers (LedgerEra era)
-> TxWits (LedgerEra era)
-> TxWits (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Redeemers (LedgerEra era)
redeemers

  eraSpecificTxBody <- eraSpecificLedgerTxBody era commonLedgerTxBody bc
  Right $
    UnsignedTx $
      L.mkBasicTx eraSpecificTxBody
        & L.witsTxL .~ scriptWitnesses
        & L.auxDataTxL .~ L.maybeToStrictMaybe (toAuxiliaryData (txMetadata bc) (txAuxScripts bc))
        & L.isPhase2ValidTxL .~ scriptValidity

convTxIns :: [(TxIn, AnyWitness era)] -> Set L.TxIn
convTxIns :: forall era. [(TxIn, AnyWitness era)] -> Set TxIn
convTxIns [(TxIn, AnyWitness era)]
inputs =
  [TxIn] -> Set TxIn
forall a. Ord a => [a] -> Set a
Set.fromList [TxIn -> TxIn
toShelleyTxIn TxIn
txin | (TxIn
txin, AnyWitness era
_) <- [(TxIn, AnyWitness era)]
inputs]

convCollateralTxIns :: TxBodyContent (LedgerEra era) -> Set L.TxIn
convCollateralTxIns :: forall era. TxBodyContent (LedgerEra era) -> Set TxIn
convCollateralTxIns TxBodyContent (LedgerEra era)
b =
  [Item (Set TxIn)] -> Set TxIn
forall l. IsList l => [Item l] -> l
fromList ((TxIn -> Item (Set TxIn)) -> [TxIn] -> [Item (Set TxIn)]
forall a b. (a -> b) -> [a] -> [b]
map TxIn -> Item (Set TxIn)
TxIn -> TxIn
toShelleyTxIn ([TxIn] -> [Item (Set TxIn)]) -> [TxIn] -> [Item (Set TxIn)]
forall a b. (a -> b) -> a -> b
$ TxBodyContent (LedgerEra era) -> [TxIn]
forall era. TxBodyContent era -> [TxIn]
txInsCollateral TxBodyContent (LedgerEra era)
b)

convReferenceInputs :: TxInsReference era -> Set L.TxIn
convReferenceInputs :: forall era. TxInsReference era -> Set TxIn
convReferenceInputs (TxInsReference [TxIn]
ins Set (Datum CtxTx era)
_) =
  [Item (Set TxIn)] -> Set TxIn
forall l. IsList l => [Item l] -> l
fromList ([Item (Set TxIn)] -> Set TxIn) -> [Item (Set TxIn)] -> Set TxIn
forall a b. (a -> b) -> a -> b
$ (TxIn -> Item (Set TxIn)) -> [TxIn] -> [Item (Set TxIn)]
forall a b. (a -> b) -> [a] -> [b]
map TxIn -> Item (Set TxIn)
TxIn -> TxIn
toShelleyTxIn [TxIn]
ins

convWithdrawals :: TxWithdrawals era -> L.Withdrawals
convWithdrawals :: forall era. TxWithdrawals era -> Withdrawals
convWithdrawals (TxWithdrawals [(StakeAddress, Coin, AnyWitness era)]
ws) =
  [(StakeAddress, Coin, AnyWitness era)] -> Withdrawals
forall a. [(StakeAddress, Coin, a)] -> Withdrawals
toShelleyWithdrawal [(StakeAddress, Coin, AnyWitness era)]
ws

convMintValue :: TxMintValue era -> L.MultiAsset
convMintValue :: forall era. TxMintValue era -> MultiAsset
convMintValue TxMintValue era
v = do
  let L.MaryValue Coin
_coin MultiAsset
multiAsset = Value -> MaryValue
toMaryValue (Value -> MaryValue) -> Value -> MaryValue
forall a b. (a -> b) -> a -> b
$ TxMintValue era -> Value
forall era. TxMintValue era -> Value
txMintValueToValue TxMintValue era
v
  MultiAsset
multiAsset

convExtraKeyWitnesses
  :: TxExtraKeyWitnesses -> Set (L.KeyHash L.Guard)
convExtraKeyWitnesses :: TxExtraKeyWitnesses -> Set (KeyHash Guard)
convExtraKeyWitnesses (TxExtraKeyWitnesses [Hash PaymentKey]
khs) =
  [Item (Set (KeyHash Guard))] -> Set (KeyHash Guard)
forall l. IsList l => [Item l] -> l
fromList
    [ KeyHash Payment -> KeyHash Guard
forall (a :: KeyRole -> *) (r :: KeyRole).
HasKeyRole a =>
a r -> a Guard
asGuard KeyHash Payment
kh
    | PaymentKeyHash KeyHash Payment
kh <- [Hash PaymentKey]
khs
    ]

convCertificates
  :: TxCertificates (LedgerEra era)
  -> Seq.StrictSeq (L.TxCert (LedgerEra era))
convCertificates :: forall era.
TxCertificates (LedgerEra era)
-> StrictSeq (TxCert (LedgerEra era))
convCertificates (TxCertificates OMap
  (Certificate (LedgerEra era)) (Maybe (AnyWitness (LedgerEra era)))
cs) =
  [Item (StrictSeq (TxCert (LedgerEra era)))]
-> StrictSeq (TxCert (LedgerEra era))
forall l. IsList l => [Item l] -> l
fromList ([Item (StrictSeq (TxCert (LedgerEra era)))]
 -> StrictSeq (TxCert (LedgerEra era)))
-> ([(Certificate (LedgerEra era),
      Maybe (AnyWitness (LedgerEra era)))]
    -> [Item (StrictSeq (TxCert (LedgerEra era)))])
-> [(Certificate (LedgerEra era),
     Maybe (AnyWitness (LedgerEra era)))]
-> StrictSeq (TxCert (LedgerEra era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Certificate (LedgerEra era), Maybe (AnyWitness (LedgerEra era)))
 -> Item (StrictSeq (TxCert (LedgerEra era))))
-> [(Certificate (LedgerEra era),
     Maybe (AnyWitness (LedgerEra era)))]
-> [Item (StrictSeq (TxCert (LedgerEra era)))]
forall a b. (a -> b) -> [a] -> [b]
map (\(Exp.Certificate TxCert (LedgerEra era)
c, Maybe (AnyWitness (LedgerEra era))
_) -> Item (StrictSeq (TxCert (LedgerEra era)))
TxCert (LedgerEra era)
c) ([(Certificate (LedgerEra era),
   Maybe (AnyWitness (LedgerEra era)))]
 -> StrictSeq (TxCert (LedgerEra era)))
-> [(Certificate (LedgerEra era),
     Maybe (AnyWitness (LedgerEra era)))]
-> StrictSeq (TxCert (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ OMap
  (Certificate (LedgerEra era)) (Maybe (AnyWitness (LedgerEra era)))
-> [Item
      (OMap
         (Certificate (LedgerEra era))
         (Maybe (AnyWitness (LedgerEra era))))]
forall l. IsList l => l -> [Item l]
toList OMap
  (Certificate (LedgerEra era)) (Maybe (AnyWitness (LedgerEra era)))
cs

convPParamsToScriptIntegrityHash
  :: forall era
   . IsEra era
  => Maybe (Ledger.PParams (LedgerEra era))
  -> L.Redeemers (LedgerEra era)
  -> L.TxDats (LedgerEra era)
  -> Set Plutus.Language
  -> Either MakeUnsignedTxError (StrictMaybe L.ScriptIntegrityHash)
convPParamsToScriptIntegrityHash :: forall era.
IsEra era =>
Maybe (PParams (LedgerEra era))
-> Redeemers (LedgerEra era)
-> TxDats (LedgerEra era)
-> Set Language
-> Either MakeUnsignedTxError (StrictMaybe ScriptIntegrityHash)
convPParamsToScriptIntegrityHash Maybe (PParams (LedgerEra era))
mTxProtocolParams Redeemers (LedgerEra era)
redeemers TxDats (LedgerEra era)
datums Set Language
languages = Era era
-> (EraCommonConstraints era =>
    Either MakeUnsignedTxError (StrictMaybe ScriptIntegrityHash))
-> Either MakeUnsignedTxError (StrictMaybe ScriptIntegrityHash)
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era =>
  Either MakeUnsignedTxError (StrictMaybe ScriptIntegrityHash))
 -> Either MakeUnsignedTxError (StrictMaybe ScriptIntegrityHash))
-> (EraCommonConstraints era =>
    Either MakeUnsignedTxError (StrictMaybe ScriptIntegrityHash))
-> Either MakeUnsignedTxError (StrictMaybe ScriptIntegrityHash)
forall a b. (a -> b) -> a -> b
$ do
  -- This logic is copied from ledger, because their code is not reusable
  -- c.f. https://github.com/IntersectMBO/cardano-ledger/commit/5a975d9af507c9ee835a86d3bb77f3e2670ad228#diff-8236dfec9688f22550b91fc9a87af9915523ab9c5bd817218ecceec8ca7a789bR282
  let shouldCalculateHash :: Bool
shouldCalculateHash =
        Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$
          Map
  (PlutusPurpose AsIx (LedgerEra era))
  (Data (LedgerEra era), ExUnits)
-> Bool
forall a. Map (PlutusPurpose AsIx (LedgerEra era)) a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Redeemers (LedgerEra era)
redeemers Redeemers (LedgerEra era)
-> Getting
     (Map
        (PlutusPurpose AsIx (LedgerEra era))
        (Data (LedgerEra era), ExUnits))
     (Redeemers (LedgerEra era))
     (Map
        (PlutusPurpose AsIx (LedgerEra era))
        (Data (LedgerEra era), ExUnits))
-> Map
     (PlutusPurpose AsIx (LedgerEra era))
     (Data (LedgerEra era), ExUnits)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map
     (PlutusPurpose AsIx (LedgerEra era))
     (Data (LedgerEra era), ExUnits))
  (Redeemers (LedgerEra era))
  (Map
     (PlutusPurpose AsIx (LedgerEra era))
     (Data (LedgerEra era), ExUnits))
forall era.
AlonzoEraScript era =>
Lens'
  (Redeemers era) (Map (PlutusPurpose AsIx era) (Data era, ExUnits))
Lens'
  (Redeemers (LedgerEra era))
  (Map
     (PlutusPurpose AsIx (LedgerEra era))
     (Data (LedgerEra era), ExUnits))
L.unRedeemersL)
            Bool -> Bool -> Bool
&& Map (SafeHash EraIndependentData) (Data (LedgerEra era)) -> Bool
forall a. Map (SafeHash EraIndependentData) a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (TxDats (LedgerEra era)
datums TxDats (LedgerEra era)
-> Getting
     (Map (SafeHash EraIndependentData) (Data (LedgerEra era)))
     (TxDats (LedgerEra era))
     (Map (SafeHash EraIndependentData) (Data (LedgerEra era)))
-> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
forall s a. s -> Getting a s a -> a
^. Getting
  (Map (SafeHash EraIndependentData) (Data (LedgerEra era)))
  (TxDats (LedgerEra era))
  (Map (SafeHash EraIndependentData) (Data (LedgerEra era)))
forall era.
Era era =>
Lens' (TxDats era) (Map (SafeHash EraIndependentData) (Data era))
Lens'
  (TxDats (LedgerEra era))
  (Map (SafeHash EraIndependentData) (Data (LedgerEra era)))
L.unTxDatsL)
            Bool -> Bool -> Bool
&& Set Language -> Bool
forall a. Set a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Set Language
languages
  if Bool
shouldCalculateHash
    then do
      pp <- MakeUnsignedTxError
-> Maybe (PParams (LedgerEra era))
-> Either MakeUnsignedTxError (PParams (LedgerEra era))
forall e (m :: * -> *) a. MonadError e m => e -> Maybe a -> m a
liftMaybe MakeUnsignedTxError
MakeUnsignedTxMissingProtocolParams Maybe (PParams (LedgerEra era))
mTxProtocolParams
      pure $
        SJust $
          L.hashScriptIntegrity $
            L.ScriptIntegrity redeemers datums (Set.map (L.getLanguageView pp) languages)
    else StrictMaybe ScriptIntegrityHash
-> Either MakeUnsignedTxError (StrictMaybe ScriptIntegrityHash)
forall a. a -> Either MakeUnsignedTxError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure StrictMaybe ScriptIntegrityHash
forall a. StrictMaybe a
SNothing

convProposalProcedures
  :: forall era
   . IsEra era
  => Maybe (TxProposalProcedures (LedgerEra era)) -> OSet (L.ProposalProcedure (LedgerEra era))
convProposalProcedures :: forall era.
IsEra era =>
Maybe (TxProposalProcedures (LedgerEra era))
-> OSet (ProposalProcedure (LedgerEra era))
convProposalProcedures Maybe (TxProposalProcedures (LedgerEra era))
Nothing = OSet (ProposalProcedure (LedgerEra era))
forall a. OSet a
OSet.empty
convProposalProcedures (Just (TxProposalProcedures OMap
  (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era))
proposals)) =
  Era era
-> (EraCommonConstraints era =>
    OSet (ProposalProcedure (LedgerEra era)))
-> OSet (ProposalProcedure (LedgerEra era))
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era =>
  OSet (ProposalProcedure (LedgerEra era)))
 -> OSet (ProposalProcedure (LedgerEra era)))
-> (EraCommonConstraints era =>
    OSet (ProposalProcedure (LedgerEra era)))
-> OSet (ProposalProcedure (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ [Item (OSet (ProposalProcedure (LedgerEra era)))]
-> OSet (ProposalProcedure (LedgerEra era))
forall l. IsList l => [Item l] -> l
fromList ([Item (OSet (ProposalProcedure (LedgerEra era)))]
 -> OSet (ProposalProcedure (LedgerEra era)))
-> [Item (OSet (ProposalProcedure (LedgerEra era)))]
-> OSet (ProposalProcedure (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ (ProposalProcedure (LedgerEra era), AnyWitness (LedgerEra era))
-> Item (OSet (ProposalProcedure (LedgerEra era)))
(ProposalProcedure (LedgerEra era), AnyWitness (LedgerEra era))
-> ProposalProcedure (LedgerEra era)
forall a b. (a, b) -> a
fst ((ProposalProcedure (LedgerEra era), AnyWitness (LedgerEra era))
 -> Item (OSet (ProposalProcedure (LedgerEra era))))
-> [(ProposalProcedure (LedgerEra era),
     AnyWitness (LedgerEra era))]
-> [Item (OSet (ProposalProcedure (LedgerEra era)))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> OMap
  (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era))
-> [Item
      (OMap
         (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era)))]
forall l. IsList l => l -> [Item l]
toList OMap
  (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era))
proposals

convVotingProcedures
  :: Maybe (TxVotingProcedures (LedgerEra era)) -> L.VotingProcedures (LedgerEra era)
convVotingProcedures :: forall era.
Maybe (TxVotingProcedures (LedgerEra era))
-> VotingProcedures (LedgerEra era)
convVotingProcedures (Just (TxVotingProcedures VotingProcedures (LedgerEra era)
vps Map Voter (AnyWitness (LedgerEra era))
_)) = VotingProcedures (LedgerEra era)
vps
convVotingProcedures Maybe (TxVotingProcedures (LedgerEra era))
Nothing = Map Voter (Map GovActionId (VotingProcedure (LedgerEra era)))
-> VotingProcedures (LedgerEra era)
forall era.
Map Voter (Map GovActionId (VotingProcedure era))
-> VotingProcedures era
L.VotingProcedures Map Voter (Map GovActionId (VotingProcedure (LedgerEra era)))
forall a. Monoid a => a
mempty

-- | Auxiliary data consists of the tx metadata
-- and the auxiliary scripts, and the auxiliary script data.
toAuxiliaryData
  :: forall era
   . IsEra era
  => TxMetadata
  -> [SimpleScript (LedgerEra era)]
  -> Maybe (L.TxAuxData (LedgerEra era))
toAuxiliaryData :: forall era.
IsEra era =>
TxMetadata
-> [SimpleScript (LedgerEra era)]
-> Maybe (TxAuxData (LedgerEra era))
toAuxiliaryData TxMetadata
txMData [SimpleScript (LedgerEra era)]
ss' =
  let ms :: Map Word64 Metadatum
ms = Map Word64 TxMetadataValue -> Map Word64 Metadatum
toShelleyMetadata (Map Word64 TxMetadataValue -> Map Word64 Metadatum)
-> Map Word64 TxMetadataValue -> Map Word64 Metadatum
forall a b. (a -> b) -> a -> b
$ TxMetadata -> Map Word64 TxMetadataValue
unTxMetadata TxMetadata
txMData
   in case forall era. IsEra era => Era era
useEra @era of
        Era era
ConwayEra ->
          let ss :: [AlonzoScript ConwayEra]
ss = [NativeScript ConwayEra -> AlonzoScript ConwayEra
forall era. NativeScript era -> AlonzoScript era
L.NativeScript NativeScript ConwayEra
s | SimpleScript NativeScript ConwayEra
s <- [SimpleScript ConwayEra]
[SimpleScript (LedgerEra era)]
ss']
           in Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Bool
not (Map Word64 Metadatum -> Bool
forall k a. Map k a -> Bool
Map.null Map Word64 Metadatum
ms Bool -> Bool -> Bool
&& [AlonzoScript ConwayEra] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [AlonzoScript ConwayEra]
ss)) Maybe ()
-> AlonzoTxAuxData ConwayEra -> Maybe (AlonzoTxAuxData ConwayEra)
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Map Word64 Metadatum
-> [AlonzoScript ConwayEra] -> AlonzoTxAuxData ConwayEra
forall (f :: * -> *) era.
(Foldable f, AlonzoEraScript era) =>
Map Word64 Metadatum -> f (AlonzoScript era) -> AlonzoTxAuxData era
L.mkAlonzoTxAuxData Map Word64 Metadatum
ms [AlonzoScript ConwayEra]
ss
        Era era
DijkstraEra ->
          let ss :: [AlonzoScript DijkstraEra]
ss = [NativeScript DijkstraEra -> AlonzoScript DijkstraEra
forall era. NativeScript era -> AlonzoScript era
L.NativeScript NativeScript DijkstraEra
s | SimpleScript NativeScript DijkstraEra
s <- [SimpleScript DijkstraEra]
[SimpleScript (LedgerEra era)]
ss']
           in Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Bool
not (Map Word64 Metadatum -> Bool
forall k a. Map k a -> Bool
Map.null Map Word64 Metadatum
ms Bool -> Bool -> Bool
&& [AlonzoScript DijkstraEra] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [AlonzoScript DijkstraEra]
ss)) Maybe ()
-> AlonzoTxAuxData DijkstraEra
-> Maybe (AlonzoTxAuxData DijkstraEra)
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Map Word64 Metadatum
-> [AlonzoScript DijkstraEra] -> AlonzoTxAuxData DijkstraEra
forall (f :: * -> *) era.
(Foldable f, AlonzoEraScript era) =>
Map Word64 Metadatum -> f (AlonzoScript era) -> AlonzoTxAuxData era
L.mkAlonzoTxAuxData Map Word64 Metadatum
ms [AlonzoScript DijkstraEra]
ss

-- | Set the fields that differ between eras on the body built in 'makeUnsignedTx'.
eraSpecificLedgerTxBody
  :: Era era
  -> L.TxBody L.TopTx (LedgerEra era)
  -> TxBodyContent (LedgerEra era)
  -> Either MakeUnsignedTxError (L.TxBody L.TopTx (LedgerEra era))
eraSpecificLedgerTxBody :: forall era.
Era era
-> TxBody TopTx (LedgerEra era)
-> TxBodyContent (LedgerEra era)
-> Either MakeUnsignedTxError (TxBody TopTx (LedgerEra era))
eraSpecificLedgerTxBody Era era
era TxBody TopTx (LedgerEra era)
ledgerbody TxBodyContent (LedgerEra era)
bc =
  case Era era
era of
    Era era
ConwayEra ->
      case [Text] -> Maybe (NonEmpty Text)
forall a. [a] -> Maybe (NonEmpty a)
NonEmpty.nonEmpty [Text]
dijkstraOnlyFieldsSet of
        Just NonEmpty Text
fields -> MakeUnsignedTxError
-> Either MakeUnsignedTxError (TxBody TopTx (LedgerEra era))
forall a b. a -> Either a b
Left (MakeUnsignedTxError
 -> Either MakeUnsignedTxError (TxBody TopTx (LedgerEra era)))
-> MakeUnsignedTxError
-> Either MakeUnsignedTxError (TxBody TopTx (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ Some Era -> NonEmpty Text -> MakeUnsignedTxError
MakeUnsignedTxFieldsNotSupportedInEra (Era era -> Some Era
forall {k} (f :: k -> *) (a :: k).
(Typeable a, Typeable (f a)) =>
f a -> Some f
Some Era era
era) NonEmpty Text
fields
        Maybe (NonEmpty Text)
Nothing ->
          TxBody TopTx (LedgerEra era)
-> Either MakeUnsignedTxError (TxBody TopTx (LedgerEra era))
forall a b. b -> Either a b
Right (TxBody TopTx (LedgerEra era)
 -> Either MakeUnsignedTxError (TxBody TopTx (LedgerEra era)))
-> TxBody TopTx (LedgerEra era)
-> Either MakeUnsignedTxError (TxBody TopTx (LedgerEra era))
forall a b. (a -> b) -> a -> b
$
            TxBody TopTx ConwayEra
TxBody TopTx (LedgerEra era)
ledgerbody
              TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (Set (KeyHash Guard) -> Identity (Set (KeyHash Guard)))
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era (l :: TxLevel).
(AlonzoEraTxBody era, AtMostEra "Conway" era) =>
Lens' (TxBody l era) (Set (KeyHash Guard))
forall (l :: TxLevel).
AtMostEra "Conway" ConwayEra =>
Lens' (TxBody l ConwayEra) (Set (KeyHash Guard))
Lens' (TxBody TopTx ConwayEra) (Set (KeyHash Guard))
L.reqSignerHashesTxBodyL ((Set (KeyHash Guard) -> Identity (Set (KeyHash Guard)))
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> Set (KeyHash Guard)
-> TxBody TopTx ConwayEra
-> TxBody TopTx ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Set (KeyHash Guard)
reqSignerHashes
    Era era
DijkstraEra ->
      -- Dijkstra replaced required signer hashes with guards, so extra key
      -- witnesses become key-hash guards.
      TxBody TopTx (LedgerEra era)
-> Either MakeUnsignedTxError (TxBody TopTx (LedgerEra era))
forall a b. b -> Either a b
Right (TxBody TopTx (LedgerEra era)
 -> Either MakeUnsignedTxError (TxBody TopTx (LedgerEra era)))
-> TxBody TopTx (LedgerEra era)
-> Either MakeUnsignedTxError (TxBody TopTx (LedgerEra era))
forall a b. (a -> b) -> a -> b
$
        TxBody TopTx DijkstraEra
TxBody TopTx (LedgerEra era)
ledgerbody
          TxBody TopTx DijkstraEra
-> (TxBody TopTx DijkstraEra -> TxBody TopTx DijkstraEra)
-> TxBody TopTx DijkstraEra
forall a b. a -> (a -> b) -> b
& (OSet (Credential Guard) -> Identity (OSet (Credential Guard)))
-> TxBody TopTx DijkstraEra -> Identity (TxBody TopTx DijkstraEra)
forall era (l :: TxLevel).
DijkstraEraTxBody era =>
Lens' (TxBody l era) (OSet (Credential Guard))
forall (l :: TxLevel).
Lens' (TxBody l DijkstraEra) (OSet (Credential Guard))
L.guardsTxBodyL
            ((OSet (Credential Guard) -> Identity (OSet (Credential Guard)))
 -> TxBody TopTx DijkstraEra -> Identity (TxBody TopTx DijkstraEra))
-> OSet (Credential Guard)
-> TxBody TopTx DijkstraEra
-> TxBody TopTx DijkstraEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ (TxBodyContent DijkstraEra -> OSet (Credential Guard)
forall era. TxBodyContent era -> OSet (Credential Guard)
txGuards TxBodyContent DijkstraEra
TxBodyContent (LedgerEra era)
bc OSet (Credential Guard)
-> OSet (Credential Guard) -> OSet (Credential Guard)
forall a. Semigroup a => a -> a -> a
<> Set (Credential Guard) -> OSet (Credential Guard)
forall a. Set a -> OSet a
OSet.fromSet ((KeyHash Guard -> Credential Guard)
-> Set (KeyHash Guard) -> Set (Credential Guard)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map KeyHash Guard -> Credential Guard
forall (kr :: KeyRole). KeyHash kr -> Credential kr
L.KeyHashObj Set (KeyHash Guard)
reqSignerHashes))
          TxBody TopTx DijkstraEra
-> (TxBody TopTx DijkstraEra -> TxBody TopTx DijkstraEra)
-> TxBody TopTx DijkstraEra
forall a b. a -> (a -> b) -> b
& (OMap TxId (Tx SubTx DijkstraEra)
 -> Identity (OMap TxId (Tx SubTx DijkstraEra)))
-> TxBody TopTx DijkstraEra -> Identity (TxBody TopTx DijkstraEra)
forall era.
DijkstraEraTxBody era =>
Lens' (TxBody TopTx era) (OMap TxId (Tx SubTx era))
Lens' (TxBody TopTx DijkstraEra) (OMap TxId (Tx SubTx DijkstraEra))
L.subTransactionsTxBodyL ((OMap TxId (Tx SubTx DijkstraEra)
  -> Identity (OMap TxId (Tx SubTx DijkstraEra)))
 -> TxBody TopTx DijkstraEra -> Identity (TxBody TopTx DijkstraEra))
-> OMap TxId (Tx SubTx DijkstraEra)
-> TxBody TopTx DijkstraEra
-> TxBody TopTx DijkstraEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TxBodyContent DijkstraEra -> OMap TxId (Tx SubTx DijkstraEra)
forall era. TxBodyContent era -> OMap TxId (Tx SubTx era)
txSubTransactions TxBodyContent DijkstraEra
TxBodyContent (LedgerEra era)
bc
          TxBody TopTx DijkstraEra
-> (TxBody TopTx DijkstraEra -> TxBody TopTx DijkstraEra)
-> TxBody TopTx DijkstraEra
forall a b. a -> (a -> b) -> b
& (Map (Credential Guard) (StrictMaybe (Data DijkstraEra))
 -> Identity
      (Map (Credential Guard) (StrictMaybe (Data DijkstraEra))))
-> TxBody TopTx DijkstraEra -> Identity (TxBody TopTx DijkstraEra)
forall era (l :: TxLevel).
DijkstraEraTxBody era =>
Lens'
  (TxBody l era) (Map (Credential Guard) (StrictMaybe (Data era)))
forall (l :: TxLevel).
Lens'
  (TxBody l DijkstraEra)
  (Map (Credential Guard) (StrictMaybe (Data DijkstraEra)))
L.requiredTopLevelGuardsL ((Map (Credential Guard) (StrictMaybe (Data DijkstraEra))
  -> Identity
       (Map (Credential Guard) (StrictMaybe (Data DijkstraEra))))
 -> TxBody TopTx DijkstraEra -> Identity (TxBody TopTx DijkstraEra))
-> Map (Credential Guard) (StrictMaybe (Data DijkstraEra))
-> TxBody TopTx DijkstraEra
-> TxBody TopTx DijkstraEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TxBodyContent DijkstraEra
-> Map (Credential Guard) (StrictMaybe (Data DijkstraEra))
forall era.
TxBodyContent era
-> Map (Credential Guard) (StrictMaybe (Data era))
txRequiredTopLevelGuards TxBodyContent DijkstraEra
TxBodyContent (LedgerEra era)
bc
          TxBody TopTx DijkstraEra
-> (TxBody TopTx DijkstraEra -> TxBody TopTx DijkstraEra)
-> TxBody TopTx DijkstraEra
forall a b. a -> (a -> b) -> b
& (DirectDeposits -> Identity DirectDeposits)
-> TxBody TopTx DijkstraEra -> Identity (TxBody TopTx DijkstraEra)
forall era (l :: TxLevel).
DijkstraEraTxBody era =>
Lens' (TxBody l era) DirectDeposits
forall (l :: TxLevel). Lens' (TxBody l DijkstraEra) DirectDeposits
L.directDepositsTxBodyL ((DirectDeposits -> Identity DirectDeposits)
 -> TxBody TopTx DijkstraEra -> Identity (TxBody TopTx DijkstraEra))
-> DirectDeposits
-> TxBody TopTx DijkstraEra
-> TxBody TopTx DijkstraEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TxBodyContent DijkstraEra -> DirectDeposits
forall era. TxBodyContent era -> DirectDeposits
txDirectDeposits TxBodyContent DijkstraEra
TxBodyContent (LedgerEra era)
bc
          TxBody TopTx DijkstraEra
-> (TxBody TopTx DijkstraEra -> TxBody TopTx DijkstraEra)
-> TxBody TopTx DijkstraEra
forall a b. a -> (a -> b) -> b
& (AccountBalanceIntervals DijkstraEra
 -> Identity (AccountBalanceIntervals DijkstraEra))
-> TxBody TopTx DijkstraEra -> Identity (TxBody TopTx DijkstraEra)
forall era (l :: TxLevel).
DijkstraEraTxBody era =>
Lens' (TxBody l era) (AccountBalanceIntervals era)
forall (l :: TxLevel).
Lens' (TxBody l DijkstraEra) (AccountBalanceIntervals DijkstraEra)
L.accountBalanceIntervalsTxBodyL ((AccountBalanceIntervals DijkstraEra
  -> Identity (AccountBalanceIntervals DijkstraEra))
 -> TxBody TopTx DijkstraEra -> Identity (TxBody TopTx DijkstraEra))
-> AccountBalanceIntervals DijkstraEra
-> TxBody TopTx DijkstraEra
-> TxBody TopTx DijkstraEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TxBodyContent DijkstraEra -> AccountBalanceIntervals DijkstraEra
forall era. TxBodyContent era -> AccountBalanceIntervals era
txAccountBalanceIntervals TxBodyContent DijkstraEra
TxBodyContent (LedgerEra era)
bc
          TxBody TopTx DijkstraEra
-> (TxBody TopTx DijkstraEra -> TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (AccountBalanceIntervals DijkstraEra
 -> Identity (AccountBalanceIntervals DijkstraEra))
-> TxBody TopTx DijkstraEra -> Identity (TxBody TopTx DijkstraEra)
forall era.
DijkstraEraTxBody era =>
Lens' (TxBody TopTx era) (AccountBalanceIntervals era)
Lens'
  (TxBody TopTx DijkstraEra) (AccountBalanceIntervals DijkstraEra)
L.startingAccountBalanceIntervalsTxBodyL ((AccountBalanceIntervals DijkstraEra
  -> Identity (AccountBalanceIntervals DijkstraEra))
 -> TxBody TopTx DijkstraEra -> Identity (TxBody TopTx DijkstraEra))
-> AccountBalanceIntervals DijkstraEra
-> TxBody TopTx DijkstraEra
-> TxBody TopTx DijkstraEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TxBodyContent DijkstraEra -> AccountBalanceIntervals DijkstraEra
forall era. TxBodyContent era -> AccountBalanceIntervals era
txStartingAccountBalanceIntervals TxBodyContent DijkstraEra
TxBodyContent (LedgerEra era)
bc
 where
  reqSignerHashes :: Set (KeyHash Guard)
reqSignerHashes = TxExtraKeyWitnesses -> Set (KeyHash Guard)
convExtraKeyWitnesses (TxBodyContent (LedgerEra era) -> TxExtraKeyWitnesses
forall era. TxBodyContent era -> TxExtraKeyWitnesses
txExtraKeyWits TxBodyContent (LedgerEra era)
bc)

  -- Every field the Dijkstra branch above writes must be empty in Conway.
  dijkstraOnlyFieldsSet :: [Text]
  dijkstraOnlyFieldsSet :: [Text]
dijkstraOnlyFieldsSet =
    [ Text
name
    | (Text
name, Bool
isPresent) <-
        [ (Text
"txGuards", OSet (Credential Guard) -> Bool
forall (f :: * -> *) a. Foldable f => f a -> Bool
present (TxBodyContent (LedgerEra era) -> OSet (Credential Guard)
forall era. TxBodyContent era -> OSet (Credential Guard)
txGuards TxBodyContent (LedgerEra era)
bc))
        , (Text
"txSubTransactions", OMap TxId (Tx SubTx (LedgerEra era)) -> Bool
forall (f :: * -> *) a. Foldable f => f a -> Bool
present (TxBodyContent (LedgerEra era)
-> OMap TxId (Tx SubTx (LedgerEra era))
forall era. TxBodyContent era -> OMap TxId (Tx SubTx era)
txSubTransactions TxBodyContent (LedgerEra era)
bc))
        , (Text
"txRequiredTopLevelGuards", Map (Credential Guard) (StrictMaybe (Data (LedgerEra era))) -> Bool
forall (f :: * -> *) a. Foldable f => f a -> Bool
present (TxBodyContent (LedgerEra era)
-> Map (Credential Guard) (StrictMaybe (Data (LedgerEra era)))
forall era.
TxBodyContent era
-> Map (Credential Guard) (StrictMaybe (Data era))
txRequiredTopLevelGuards TxBodyContent (LedgerEra era)
bc))
        , (Text
"txDirectDeposits", Map AccountAddress Coin -> Bool
forall (f :: * -> *) a. Foldable f => f a -> Bool
present (DirectDeposits -> Map AccountAddress Coin
L.unDirectDeposits (TxBodyContent (LedgerEra era) -> DirectDeposits
forall era. TxBodyContent era -> DirectDeposits
txDirectDeposits TxBodyContent (LedgerEra era)
bc)))
        ,
          ( Text
"txAccountBalanceIntervals"
          , Map AccountAddress (AccountBalanceInterval (LedgerEra era)) -> Bool
forall (f :: * -> *) a. Foldable f => f a -> Bool
present (AccountBalanceIntervals (LedgerEra era)
-> Map AccountAddress (AccountBalanceInterval (LedgerEra era))
forall era.
AccountBalanceIntervals era
-> Map AccountAddress (AccountBalanceInterval era)
L.unAccountBalanceIntervals (TxBodyContent (LedgerEra era)
-> AccountBalanceIntervals (LedgerEra era)
forall era. TxBodyContent era -> AccountBalanceIntervals era
txAccountBalanceIntervals TxBodyContent (LedgerEra era)
bc))
          )
        ,
          ( Text
"txStartingAccountBalanceIntervals"
          , Map AccountAddress (AccountBalanceInterval (LedgerEra era)) -> Bool
forall (f :: * -> *) a. Foldable f => f a -> Bool
present (AccountBalanceIntervals (LedgerEra era)
-> Map AccountAddress (AccountBalanceInterval (LedgerEra era))
forall era.
AccountBalanceIntervals era
-> Map AccountAddress (AccountBalanceInterval era)
L.unAccountBalanceIntervals (TxBodyContent (LedgerEra era)
-> AccountBalanceIntervals (LedgerEra era)
forall era. TxBodyContent era -> AccountBalanceIntervals era
txStartingAccountBalanceIntervals TxBodyContent (LedgerEra era)
bc))
          )
        ]
    , Bool
isPresent
    ]

  present :: Foldable f => f a -> Bool
  present :: forall (f :: * -> *) a. Foldable f => f a -> Bool
present = Bool -> Bool
not (Bool -> Bool) -> (f a -> Bool) -> f a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> Bool
forall a. f a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null

data TxOut era where
  TxOut :: L.EraTxOut era => L.TxOut era -> TxOut era

instance ToJSON (TxOut L.ShelleyEra) where toJSON :: TxOut ShelleyEra -> Value
toJSON = ShelleyBasedEra ShelleyEra
-> TxOut (ShelleyLedgerEra ShelleyEra) -> Value
forall era.
ShelleyBasedEra era -> TxOut (ShelleyLedgerEra era) -> Value
txOutToJson ShelleyBasedEra ShelleyEra
ShelleyBasedEraShelley

instance ToJSON (TxOut L.AllegraEra) where toJSON :: TxOut AllegraEra -> Value
toJSON = ShelleyBasedEra AllegraEra
-> TxOut (ShelleyLedgerEra AllegraEra) -> Value
forall era.
ShelleyBasedEra era -> TxOut (ShelleyLedgerEra era) -> Value
txOutToJson ShelleyBasedEra AllegraEra
ShelleyBasedEraAllegra

instance ToJSON (TxOut L.MaryEra) where toJSON :: TxOut MaryEra -> Value
toJSON = ShelleyBasedEra MaryEra
-> TxOut (ShelleyLedgerEra MaryEra) -> Value
forall era.
ShelleyBasedEra era -> TxOut (ShelleyLedgerEra era) -> Value
txOutToJson ShelleyBasedEra MaryEra
ShelleyBasedEraMary

-- | Note: Unlike the legacy API's @TxOut@, this instance does not render
-- supplemental datums. At the ledger level, a supplemental datum is not
-- stored in the @TxOut@ — only its hash is. The full datum lives in the
-- transaction witness set (@TxDats@). The legacy API bundled the full
-- datum into @TxOut@ for convenience, but since this type wraps the
-- ledger's @TxOut@ directly, supplemental datums are indistinguishable
-- from hash-only datums here.
instance ToJSON (TxOut L.AlonzoEra) where toJSON :: TxOut AlonzoEra -> Value
toJSON = ShelleyBasedEra AlonzoEra
-> TxOut (ShelleyLedgerEra AlonzoEra) -> Value
forall era.
ShelleyBasedEra era -> TxOut (ShelleyLedgerEra era) -> Value
txOutToJson ShelleyBasedEra AlonzoEra
ShelleyBasedEraAlonzo

instance ToJSON (TxOut L.BabbageEra) where toJSON :: TxOut BabbageEra -> Value
toJSON = ShelleyBasedEra BabbageEra
-> TxOut (ShelleyLedgerEra BabbageEra) -> Value
forall era.
ShelleyBasedEra era -> TxOut (ShelleyLedgerEra era) -> Value
txOutToJson ShelleyBasedEra BabbageEra
ShelleyBasedEraBabbage

instance ToJSON (TxOut L.ConwayEra) where toJSON :: TxOut ConwayEra -> Value
toJSON = ShelleyBasedEra ConwayEra
-> TxOut (ShelleyLedgerEra ConwayEra) -> Value
forall era.
ShelleyBasedEra era -> TxOut (ShelleyLedgerEra era) -> Value
txOutToJson ShelleyBasedEra ConwayEra
ShelleyBasedEraConway

txOutToJson :: ShelleyBasedEra era -> TxOut (ShelleyLedgerEra era) -> Aeson.Value
txOutToJson :: forall era.
ShelleyBasedEra era -> TxOut (ShelleyLedgerEra era) -> Value
txOutToJson ShelleyBasedEra era
sbe (TxOut TxOut (ShelleyLedgerEra era)
o) =
  [Pair] -> Value
Aeson.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$
    ShelleyBasedEra era -> TxOut (ShelleyLedgerEra era) -> [Pair]
forall era.
EraTxOut (ShelleyLedgerEra era) =>
ShelleyBasedEra era -> TxOut (ShelleyLedgerEra era) -> [Pair]
txOutBaseJsonFields ShelleyBasedEra era
sbe TxOut (ShelleyLedgerEra era)
o [Pair] -> [Pair] -> [Pair]
forall a. Semigroup a => a -> a -> a
<> [Pair]
alonzoOnwardsFields
 where
  alonzoOnwardsFields :: [Pair]
alonzoOnwardsFields = case ShelleyBasedEra era
sbe of
    ShelleyBasedEra era
ShelleyBasedEraShelley -> []
    ShelleyBasedEra era
ShelleyBasedEraAllegra -> []
    ShelleyBasedEra era
ShelleyBasedEraMary -> []
    ShelleyBasedEra era
ShelleyBasedEraAlonzo -> Maybe (Datum AlonzoEra)
-> Maybe (Maybe (Script AlonzoEra)) -> [Pair]
forall era.
AlonzoEraScript era =>
Maybe (Datum era) -> Maybe (Maybe (Script era)) -> [Pair]
datumAndRefScriptFields (TxOut (ShelleyLedgerEra era)
AlonzoTxOut AlonzoEra
o AlonzoTxOut AlonzoEra
-> Getting
     (Maybe (Datum AlonzoEra))
     (AlonzoTxOut AlonzoEra)
     (Maybe (Datum AlonzoEra))
-> Maybe (Datum AlonzoEra)
forall s a. s -> Getting a s a -> a
^. Getting
  (Maybe (Datum AlonzoEra))
  (TxOut AlonzoEra)
  (Maybe (Datum AlonzoEra))
Getting
  (Maybe (Datum AlonzoEra))
  (AlonzoTxOut AlonzoEra)
  (Maybe (Datum AlonzoEra))
forall era.
AnyEraTxOut era =>
SimpleGetter (TxOut era) (Maybe (Datum era))
SimpleGetter (TxOut AlonzoEra) (Maybe (Datum AlonzoEra))
L.datumTxOutG) (TxOut (ShelleyLedgerEra era)
AlonzoTxOut AlonzoEra
o AlonzoTxOut AlonzoEra
-> Getting
     (Maybe (Maybe (AlonzoScript AlonzoEra)))
     (AlonzoTxOut AlonzoEra)
     (Maybe (Maybe (AlonzoScript AlonzoEra)))
-> Maybe (Maybe (AlonzoScript AlonzoEra))
forall s a. s -> Getting a s a -> a
^. Getting
  (Maybe (Maybe (AlonzoScript AlonzoEra)))
  (TxOut AlonzoEra)
  (Maybe (Maybe (Script AlonzoEra)))
Getting
  (Maybe (Maybe (AlonzoScript AlonzoEra)))
  (AlonzoTxOut AlonzoEra)
  (Maybe (Maybe (AlonzoScript AlonzoEra)))
forall era.
AnyEraTxOut era =>
SimpleGetter (TxOut era) (Maybe (Maybe (Script era)))
SimpleGetter (TxOut AlonzoEra) (Maybe (Maybe (Script AlonzoEra)))
L.referenceScriptTxOutG)
    ShelleyBasedEra era
ShelleyBasedEraBabbage -> Maybe (Datum BabbageEra)
-> Maybe (Maybe (Script BabbageEra)) -> [Pair]
forall era.
AlonzoEraScript era =>
Maybe (Datum era) -> Maybe (Maybe (Script era)) -> [Pair]
datumAndRefScriptFields (TxOut (ShelleyLedgerEra era)
BabbageTxOut BabbageEra
o BabbageTxOut BabbageEra
-> Getting
     (Maybe (Datum BabbageEra))
     (BabbageTxOut BabbageEra)
     (Maybe (Datum BabbageEra))
-> Maybe (Datum BabbageEra)
forall s a. s -> Getting a s a -> a
^. Getting
  (Maybe (Datum BabbageEra))
  (TxOut BabbageEra)
  (Maybe (Datum BabbageEra))
Getting
  (Maybe (Datum BabbageEra))
  (BabbageTxOut BabbageEra)
  (Maybe (Datum BabbageEra))
forall era.
AnyEraTxOut era =>
SimpleGetter (TxOut era) (Maybe (Datum era))
SimpleGetter (TxOut BabbageEra) (Maybe (Datum BabbageEra))
L.datumTxOutG) (TxOut (ShelleyLedgerEra era)
BabbageTxOut BabbageEra
o BabbageTxOut BabbageEra
-> Getting
     (Maybe (Maybe (AlonzoScript BabbageEra)))
     (BabbageTxOut BabbageEra)
     (Maybe (Maybe (AlonzoScript BabbageEra)))
-> Maybe (Maybe (AlonzoScript BabbageEra))
forall s a. s -> Getting a s a -> a
^. Getting
  (Maybe (Maybe (AlonzoScript BabbageEra)))
  (TxOut BabbageEra)
  (Maybe (Maybe (Script BabbageEra)))
Getting
  (Maybe (Maybe (AlonzoScript BabbageEra)))
  (BabbageTxOut BabbageEra)
  (Maybe (Maybe (AlonzoScript BabbageEra)))
forall era.
AnyEraTxOut era =>
SimpleGetter (TxOut era) (Maybe (Maybe (Script era)))
SimpleGetter (TxOut BabbageEra) (Maybe (Maybe (Script BabbageEra)))
L.referenceScriptTxOutG)
    ShelleyBasedEra era
ShelleyBasedEraConway -> Maybe (Datum ConwayEra)
-> Maybe (Maybe (Script ConwayEra)) -> [Pair]
forall era.
AlonzoEraScript era =>
Maybe (Datum era) -> Maybe (Maybe (Script era)) -> [Pair]
datumAndRefScriptFields (TxOut (ShelleyLedgerEra era)
BabbageTxOut ConwayEra
o BabbageTxOut ConwayEra
-> Getting
     (Maybe (Datum ConwayEra))
     (BabbageTxOut ConwayEra)
     (Maybe (Datum ConwayEra))
-> Maybe (Datum ConwayEra)
forall s a. s -> Getting a s a -> a
^. Getting
  (Maybe (Datum ConwayEra))
  (TxOut ConwayEra)
  (Maybe (Datum ConwayEra))
Getting
  (Maybe (Datum ConwayEra))
  (BabbageTxOut ConwayEra)
  (Maybe (Datum ConwayEra))
forall era.
AnyEraTxOut era =>
SimpleGetter (TxOut era) (Maybe (Datum era))
SimpleGetter (TxOut ConwayEra) (Maybe (Datum ConwayEra))
L.datumTxOutG) (TxOut (ShelleyLedgerEra era)
BabbageTxOut ConwayEra
o BabbageTxOut ConwayEra
-> Getting
     (Maybe (Maybe (AlonzoScript ConwayEra)))
     (BabbageTxOut ConwayEra)
     (Maybe (Maybe (AlonzoScript ConwayEra)))
-> Maybe (Maybe (AlonzoScript ConwayEra))
forall s a. s -> Getting a s a -> a
^. Getting
  (Maybe (Maybe (AlonzoScript ConwayEra)))
  (TxOut ConwayEra)
  (Maybe (Maybe (Script ConwayEra)))
Getting
  (Maybe (Maybe (AlonzoScript ConwayEra)))
  (BabbageTxOut ConwayEra)
  (Maybe (Maybe (AlonzoScript ConwayEra)))
forall era.
AnyEraTxOut era =>
SimpleGetter (TxOut era) (Maybe (Maybe (Script era)))
SimpleGetter (TxOut ConwayEra) (Maybe (Maybe (Script ConwayEra)))
L.referenceScriptTxOutG)
    ShelleyBasedEra era
ShelleyBasedEraDijkstra -> Maybe (Datum DijkstraEra)
-> Maybe (Maybe (Script DijkstraEra)) -> [Pair]
forall era.
AlonzoEraScript era =>
Maybe (Datum era) -> Maybe (Maybe (Script era)) -> [Pair]
datumAndRefScriptFields (TxOut (ShelleyLedgerEra era)
BabbageTxOut DijkstraEra
o BabbageTxOut DijkstraEra
-> Getting
     (Maybe (Datum DijkstraEra))
     (BabbageTxOut DijkstraEra)
     (Maybe (Datum DijkstraEra))
-> Maybe (Datum DijkstraEra)
forall s a. s -> Getting a s a -> a
^. Getting
  (Maybe (Datum DijkstraEra))
  (TxOut DijkstraEra)
  (Maybe (Datum DijkstraEra))
Getting
  (Maybe (Datum DijkstraEra))
  (BabbageTxOut DijkstraEra)
  (Maybe (Datum DijkstraEra))
forall era.
AnyEraTxOut era =>
SimpleGetter (TxOut era) (Maybe (Datum era))
SimpleGetter (TxOut DijkstraEra) (Maybe (Datum DijkstraEra))
L.datumTxOutG) (TxOut (ShelleyLedgerEra era)
BabbageTxOut DijkstraEra
o BabbageTxOut DijkstraEra
-> Getting
     (Maybe (Maybe (AlonzoScript DijkstraEra)))
     (BabbageTxOut DijkstraEra)
     (Maybe (Maybe (AlonzoScript DijkstraEra)))
-> Maybe (Maybe (AlonzoScript DijkstraEra))
forall s a. s -> Getting a s a -> a
^. Getting
  (Maybe (Maybe (AlonzoScript DijkstraEra)))
  (TxOut DijkstraEra)
  (Maybe (Maybe (Script DijkstraEra)))
Getting
  (Maybe (Maybe (AlonzoScript DijkstraEra)))
  (BabbageTxOut DijkstraEra)
  (Maybe (Maybe (AlonzoScript DijkstraEra)))
forall era.
AnyEraTxOut era =>
SimpleGetter (TxOut era) (Maybe (Maybe (Script era)))
SimpleGetter
  (TxOut DijkstraEra) (Maybe (Maybe (Script DijkstraEra)))
L.referenceScriptTxOutG)

-- | Emit the datum, inline-datum, and reference-script JSON fields appropriate
-- for the era. Pre-Alonzo emits nothing; Alonzo emits @datumhash@ and @datum@;
-- Babbage+ additionally emits @inlineDatum@, @inlineDatumRaw@, @inlineDatumhash@
-- and @referenceScript@.
datumAndRefScriptFields
  :: L.AlonzoEraScript era
  => Maybe (L.Datum era)
  -> Maybe (Maybe (L.Script era))
  -> [Pair]
datumAndRefScriptFields :: forall era.
AlonzoEraScript era =>
Maybe (Datum era) -> Maybe (Maybe (Script era)) -> [Pair]
datumAndRefScriptFields Maybe (Datum era)
mDatum Maybe (Maybe (Script era))
mRefScript =
  [Pair]
datumFields [Pair] -> [Pair] -> [Pair]
forall a. Semigroup a => a -> a -> a
<> [Pair]
inlineDatumFields [Pair] -> [Pair] -> [Pair]
forall a. Semigroup a => a -> a -> a
<> [Pair]
refScriptFields
 where
  isBabbagePlus :: Bool
isBabbagePlus = Maybe (Maybe (Script era)) -> Bool
forall a. Maybe a -> Bool
isJust Maybe (Maybe (Script era))
mRefScript

  datumFields :: [Pair]
datumFields = case Maybe (Datum era)
mDatum of
    Maybe (Datum era)
Nothing -> []
    Just Datum era
L.NoDatum -> [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, Key
"datum" 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]
    Just (L.DatumHash SafeHash EraIndependentData
dh) -> [Key
"datumhash" Key -> SafeHash EraIndependentData -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= SafeHash EraIndependentData
dh, Key
"datum" 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]
    Just (L.Datum BinaryData era
_) -> [Key
"datum" 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]

  inlineDatumFields :: [Pair]
inlineDatumFields = case Maybe (Datum era)
mDatum of
    Just (L.Datum BinaryData era
bd) ->
      let hsd :: HashableScriptData
hsd = Data era -> HashableScriptData
forall ledgerera. Data ledgerera -> HashableScriptData
Api.fromAlonzoData (BinaryData era -> Data era
forall era. Era era => BinaryData era -> Data era
L.binaryDataToData BinaryData era
bd)
       in [ Key
"inlineDatumhash" Key -> SafeHash EraIndependentData -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= BinaryData era -> SafeHash EraIndependentData
forall era. BinaryData era -> SafeHash EraIndependentData
L.hashBinaryData BinaryData era
bd
          , Key
"inlineDatum" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= HashableScriptData -> Value
Api.scriptDataToJsonDetailedSchema HashableScriptData
hsd
          , Key
"inlineDatumRaw"
              Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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
hsd)
          ]
    Maybe (Datum era)
_
      | Bool
isBabbagePlus -> [Key
"inlineDatum" 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, Key
"inlineDatumRaw" 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]
      | Bool
otherwise -> []

  refScriptFields :: [Pair]
refScriptFields = case Maybe (Maybe (Script era))
mRefScript of
    Maybe (Maybe (Script era))
Nothing -> []
    Just Maybe (Script era)
Nothing -> [Key
"referenceScript" 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]
    Just (Just Script era
script) -> [Key
"referenceScript" Key -> ScriptInAnyLang -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Script era -> ScriptInAnyLang
forall era. AlonzoEraScript era => Script era -> ScriptInAnyLang
ledgerScriptToScriptInAnyLang Script era
script]

-- | Render just the base fields (address and value) shared by all eras.
txOutBaseJsonFields
  :: L.EraTxOut (ShelleyLedgerEra era) => ShelleyBasedEra era -> L.TxOut (ShelleyLedgerEra era) -> [Pair]
txOutBaseJsonFields :: forall era.
EraTxOut (ShelleyLedgerEra era) =>
ShelleyBasedEra era -> TxOut (ShelleyLedgerEra era) -> [Pair]
txOutBaseJsonFields ShelleyBasedEra era
sbe TxOut (ShelleyLedgerEra era)
o =
  [ Key
"address" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Addr -> Value
addrToJson (TxOut (ShelleyLedgerEra era)
o 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)
  , Key
"value" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
forall era.
ShelleyBasedEra era -> Value (ShelleyLedgerEra era) -> Value
fromLedgerValue ShelleyBasedEra era
sbe (TxOut (ShelleyLedgerEra era)
o 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
^. Getting
  (Value (ShelleyLedgerEra era))
  (TxOut (ShelleyLedgerEra era))
  (Value (ShelleyLedgerEra era))
forall era. EraTxOut era => Lens' (TxOut era) (Value era)
Lens' (TxOut (ShelleyLedgerEra era)) (Value (ShelleyLedgerEra era))
L.valueTxOutL)
  ]

-- | Convert a ledger 'L.Addr' to JSON using the same format as the legacy API
-- (bech32 for Shelley addresses, base58 for Byron addresses).
addrToJson :: L.Addr -> Aeson.Value
addrToJson :: Addr -> Value
addrToJson (L.Addr Network
nw Credential Payment
pc StakeReference
scr) = Address ShelleyAddr -> Value
forall a. ToJSON a => a -> Value
toJSON (Network
-> Credential Payment -> StakeReference -> Address ShelleyAddr
ShelleyAddress Network
nw Credential Payment
pc StakeReference
scr)
addrToJson (L.AddrBootstrap (L.BootstrapAddress Address
addr)) = Address ByronAddr -> Value
forall a. ToJSON a => a -> Value
toJSON (Address -> Address ByronAddr
ByronAddress Address
addr)

-- | Convert a ledger 'Script' to a cardano-api 'ScriptInAnyLang' without
-- per-era pattern matching, using 'AlonzoEraScript' methods.
ledgerScriptToScriptInAnyLang
  :: L.AlonzoEraScript era => L.Script era -> ScriptInAnyLang
ledgerScriptToScriptInAnyLang :: forall era. AlonzoEraScript era => Script era -> ScriptInAnyLang
ledgerScriptToScriptInAnyLang Script era
script =
  case Script era -> Maybe (NativeScript era)
forall era. EraScript era => Script era -> Maybe (NativeScript era)
L.getNativeScript Script era
script of
    Just NativeScript era
ns ->
      ScriptLanguage SimpleScript'
-> Script SimpleScript' -> ScriptInAnyLang
forall lang. ScriptLanguage lang -> Script lang -> ScriptInAnyLang
ScriptInAnyLang ScriptLanguage SimpleScript'
SimpleScriptLanguage (SimpleScript -> Script SimpleScript'
OldScript.SimpleScript (NativeScript era -> SimpleScript
forall era.
AllegraEraScript era =>
NativeScript era -> SimpleScript
fromAllegraTimelock NativeScript era
ns))
    Maybe (NativeScript era)
Nothing ->
      case Script era -> Maybe (PlutusScript era)
forall era.
AlonzoEraScript era =>
Script era -> Maybe (PlutusScript era)
L.toPlutusScript Script era
script of
        Just PlutusScript era
ps -> PlutusScript era
-> (forall (l :: Language).
    PlutusLanguage l =>
    Plutus l -> ScriptInAnyLang)
-> ScriptInAnyLang
forall era a.
AlonzoEraScript era =>
PlutusScript era
-> (forall (l :: Language). PlutusLanguage l => Plutus l -> a) -> a
forall a.
PlutusScript era
-> (forall (l :: Language). PlutusLanguage l => Plutus l -> a) -> a
L.withPlutusScript PlutusScript era
ps ((forall (l :: Language).
  PlutusLanguage l =>
  Plutus l -> ScriptInAnyLang)
 -> ScriptInAnyLang)
-> (forall (l :: Language).
    PlutusLanguage l =>
    Plutus l -> ScriptInAnyLang)
-> ScriptInAnyLang
forall a b. (a -> b) -> a -> b
$ \Plutus l
plutus ->
          let sbs :: ShortByteString
sbs = PlutusBinary -> ShortByteString
unPlutusBinary (Plutus l -> PlutusBinary
forall (l :: Language). Plutus l -> PlutusBinary
L.plutusBinary Plutus l
plutus)
           in case Plutus l -> Language
forall (l :: Language) (proxy :: Language -> *).
PlutusLanguage l =>
proxy l -> Language
plutusLanguage Plutus l
plutus of
                Language
Plutus.PlutusV1 ->
                  ScriptLanguage PlutusScriptV1
-> Script PlutusScriptV1 -> ScriptInAnyLang
forall lang. ScriptLanguage lang -> Script lang -> ScriptInAnyLang
ScriptInAnyLang (PlutusScriptVersion PlutusScriptV1 -> ScriptLanguage PlutusScriptV1
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> ScriptLanguage lang
PlutusScriptLanguage PlutusScriptVersion PlutusScriptV1
PlutusScriptV1) (Script PlutusScriptV1 -> ScriptInAnyLang)
-> Script PlutusScriptV1 -> ScriptInAnyLang
forall a b. (a -> b) -> a -> b
$
                    PlutusScriptVersion PlutusScriptV1
-> PlutusScript PlutusScriptV1 -> Script PlutusScriptV1
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> PlutusScript lang -> Script lang
OldScript.PlutusScript PlutusScriptVersion PlutusScriptV1
PlutusScriptV1 (ShortByteString -> PlutusScript PlutusScriptV1
forall lang. ShortByteString -> PlutusScript lang
PlutusScriptSerialised ShortByteString
sbs)
                Language
Plutus.PlutusV2 ->
                  ScriptLanguage PlutusScriptV2
-> Script PlutusScriptV2 -> ScriptInAnyLang
forall lang. ScriptLanguage lang -> Script lang -> ScriptInAnyLang
ScriptInAnyLang (PlutusScriptVersion PlutusScriptV2 -> ScriptLanguage PlutusScriptV2
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> ScriptLanguage lang
PlutusScriptLanguage PlutusScriptVersion PlutusScriptV2
PlutusScriptV2) (Script PlutusScriptV2 -> ScriptInAnyLang)
-> Script PlutusScriptV2 -> ScriptInAnyLang
forall a b. (a -> b) -> a -> b
$
                    PlutusScriptVersion PlutusScriptV2
-> PlutusScript PlutusScriptV2 -> Script PlutusScriptV2
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> PlutusScript lang -> Script lang
OldScript.PlutusScript PlutusScriptVersion PlutusScriptV2
PlutusScriptV2 (ShortByteString -> PlutusScript PlutusScriptV2
forall lang. ShortByteString -> PlutusScript lang
PlutusScriptSerialised ShortByteString
sbs)
                Language
Plutus.PlutusV3 ->
                  ScriptLanguage PlutusScriptV3
-> Script PlutusScriptV3 -> ScriptInAnyLang
forall lang. ScriptLanguage lang -> Script lang -> ScriptInAnyLang
ScriptInAnyLang (PlutusScriptVersion PlutusScriptV3 -> ScriptLanguage PlutusScriptV3
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> ScriptLanguage lang
PlutusScriptLanguage PlutusScriptVersion PlutusScriptV3
PlutusScriptV3) (Script PlutusScriptV3 -> ScriptInAnyLang)
-> Script PlutusScriptV3 -> ScriptInAnyLang
forall a b. (a -> b) -> a -> b
$
                    PlutusScriptVersion PlutusScriptV3
-> PlutusScript PlutusScriptV3 -> Script PlutusScriptV3
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> PlutusScript lang -> Script lang
OldScript.PlutusScript PlutusScriptVersion PlutusScriptV3
PlutusScriptV3 (ShortByteString -> PlutusScript PlutusScriptV3
forall lang. ShortByteString -> PlutusScript lang
PlutusScriptSerialised ShortByteString
sbs)
                Language
Plutus.PlutusV4 ->
                  ScriptLanguage PlutusScriptV4
-> Script PlutusScriptV4 -> ScriptInAnyLang
forall lang. ScriptLanguage lang -> Script lang -> ScriptInAnyLang
ScriptInAnyLang (PlutusScriptVersion PlutusScriptV4 -> ScriptLanguage PlutusScriptV4
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> ScriptLanguage lang
PlutusScriptLanguage PlutusScriptVersion PlutusScriptV4
PlutusScriptV4) (Script PlutusScriptV4 -> ScriptInAnyLang)
-> Script PlutusScriptV4 -> ScriptInAnyLang
forall a b. (a -> b) -> a -> b
$
                    PlutusScriptVersion PlutusScriptV4
-> PlutusScript PlutusScriptV4 -> Script PlutusScriptV4
forall lang.
IsPlutusScriptLanguage lang =>
PlutusScriptVersion lang -> PlutusScript lang -> Script lang
OldScript.PlutusScript PlutusScriptVersion PlutusScriptV4
PlutusScriptV4 (ShortByteString -> PlutusScript PlutusScriptV4
forall lang. ShortByteString -> PlutusScript lang
PlutusScriptSerialised ShortByteString
sbs)
        Maybe (PlutusScript era)
Nothing -> String -> ScriptInAnyLang
forall a. HasCallStack => String -> a
error String
"ledgerScriptToScriptInAnyLang: script is neither native nor Plutus"

-- | Convert a 'ScriptInAnyLang' to a ledger 'L.Script'. Reverse of 'ledgerScriptToScriptInAnyLang'.
scriptInAnyLangToLedgerScript
  :: forall era
   . ( L.AlonzoEraScript era
     , L.NativeScript era ~ Timelock era
     )
  => ScriptInAnyLang -> Parser (L.Script era)
scriptInAnyLangToLedgerScript :: forall era.
(AlonzoEraScript era, NativeScript era ~ Timelock era) =>
ScriptInAnyLang -> Parser (Script era)
scriptInAnyLangToLedgerScript (ScriptInAnyLang ScriptLanguage lang
lang Script lang
script) =
  case (ScriptLanguage lang
lang, Script lang
script) of
    (ScriptLanguage lang
SimpleScriptLanguage, OldScript.SimpleScript SimpleScript
ss) ->
      Script era -> Parser (Script era)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Script era -> Parser (Script era))
-> Script era -> Parser (Script era)
forall a b. (a -> b) -> a -> b
$ NativeScript era -> Script era
forall era. EraScript era => NativeScript era -> Script era
Ledger.fromNativeScript (SimpleScript -> NativeScript era
forall era.
(AllegraEraScript era, NativeScript era ~ Timelock era) =>
SimpleScript -> NativeScript era
toAllegraTimelock SimpleScript
ss)
    (PlutusScriptLanguage PlutusScriptVersion lang
PlutusScriptV1, OldScript.PlutusScript PlutusScriptVersion lang
_ (PlutusScriptSerialised ShortByteString
sbs)) ->
      PlutusScript era -> Script era
forall era. AlonzoEraScript era => PlutusScript era -> Script era
L.fromPlutusScript
        (PlutusScript era -> Script era)
-> Parser (PlutusScript era) -> Parser (Script era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Plutus 'PlutusV1 -> Parser (PlutusScript era)
forall era (l :: Language) (m :: * -> *).
(AlonzoEraScript era, PlutusLanguage l, MonadFail m) =>
Plutus l -> m (PlutusScript era)
forall (l :: Language) (m :: * -> *).
(PlutusLanguage l, MonadFail m) =>
Plutus l -> m (PlutusScript era)
L.mkPlutusScript (PlutusBinary -> Plutus 'PlutusV1
forall (l :: Language). PlutusBinary -> Plutus l
Plutus.Plutus (ShortByteString -> PlutusBinary
PlutusBinary ShortByteString
sbs) :: Plutus.Plutus 'Plutus.PlutusV1)
    (PlutusScriptLanguage PlutusScriptVersion lang
PlutusScriptV2, OldScript.PlutusScript PlutusScriptVersion lang
_ (PlutusScriptSerialised ShortByteString
sbs)) ->
      PlutusScript era -> Script era
forall era. AlonzoEraScript era => PlutusScript era -> Script era
L.fromPlutusScript
        (PlutusScript era -> Script era)
-> Parser (PlutusScript era) -> Parser (Script era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Plutus 'PlutusV2 -> Parser (PlutusScript era)
forall era (l :: Language) (m :: * -> *).
(AlonzoEraScript era, PlutusLanguage l, MonadFail m) =>
Plutus l -> m (PlutusScript era)
forall (l :: Language) (m :: * -> *).
(PlutusLanguage l, MonadFail m) =>
Plutus l -> m (PlutusScript era)
L.mkPlutusScript (PlutusBinary -> Plutus 'PlutusV2
forall (l :: Language). PlutusBinary -> Plutus l
Plutus.Plutus (ShortByteString -> PlutusBinary
PlutusBinary ShortByteString
sbs) :: Plutus.Plutus 'Plutus.PlutusV2)
    (PlutusScriptLanguage PlutusScriptVersion lang
PlutusScriptV3, OldScript.PlutusScript PlutusScriptVersion lang
_ (PlutusScriptSerialised ShortByteString
sbs)) ->
      PlutusScript era -> Script era
forall era. AlonzoEraScript era => PlutusScript era -> Script era
L.fromPlutusScript
        (PlutusScript era -> Script era)
-> Parser (PlutusScript era) -> Parser (Script era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Plutus 'PlutusV3 -> Parser (PlutusScript era)
forall era (l :: Language) (m :: * -> *).
(AlonzoEraScript era, PlutusLanguage l, MonadFail m) =>
Plutus l -> m (PlutusScript era)
forall (l :: Language) (m :: * -> *).
(PlutusLanguage l, MonadFail m) =>
Plutus l -> m (PlutusScript era)
L.mkPlutusScript (PlutusBinary -> Plutus 'PlutusV3
forall (l :: Language). PlutusBinary -> Plutus l
Plutus.Plutus (ShortByteString -> PlutusBinary
PlutusBinary ShortByteString
sbs) :: Plutus.Plutus 'Plutus.PlutusV3)
    (PlutusScriptLanguage PlutusScriptVersion lang
PlutusScriptV4, OldScript.PlutusScript PlutusScriptVersion lang
_ (PlutusScriptSerialised ShortByteString
sbs)) ->
      PlutusScript era -> Script era
forall era. AlonzoEraScript era => PlutusScript era -> Script era
L.fromPlutusScript
        (PlutusScript era -> Script era)
-> Parser (PlutusScript era) -> Parser (Script era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Plutus 'PlutusV4 -> Parser (PlutusScript era)
forall era (l :: Language) (m :: * -> *).
(AlonzoEraScript era, PlutusLanguage l, MonadFail m) =>
Plutus l -> m (PlutusScript era)
forall (l :: Language) (m :: * -> *).
(PlutusLanguage l, MonadFail m) =>
Plutus l -> m (PlutusScript era)
L.mkPlutusScript (PlutusBinary -> Plutus 'PlutusV4
forall (l :: Language). PlutusBinary -> Plutus l
Plutus.Plutus (ShortByteString -> PlutusBinary
PlutusBinary ShortByteString
sbs) :: Plutus.Plutus 'Plutus.PlutusV4)

deriving instance (Show (TxOut era))

deriving instance (Eq (TxOut era))

-- | Pre-Alonzo eras have no datums or reference scripts, so parsing
instance FromJSON (TxOut L.ShelleyEra) where
  parseJSON :: Value -> Parser (TxOut ShelleyEra)
parseJSON = String
-> (Object -> Parser (TxOut ShelleyEra))
-> Value
-> Parser (TxOut ShelleyEra)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Aeson.withObject String
"TxOut" (ShelleyBasedEra ShelleyEra
-> Object -> Parser (TxOut (ShelleyLedgerEra ShelleyEra))
forall era.
ShelleyBasedEra era
-> Object -> Parser (TxOut (ShelleyLedgerEra era))
txOutParseJson ShelleyBasedEra ShelleyEra
ShelleyBasedEraShelley)

instance FromJSON (TxOut L.AllegraEra) where
  parseJSON :: Value -> Parser (TxOut AllegraEra)
parseJSON = String
-> (Object -> Parser (TxOut AllegraEra))
-> Value
-> Parser (TxOut AllegraEra)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Aeson.withObject String
"TxOut" (ShelleyBasedEra AllegraEra
-> Object -> Parser (TxOut (ShelleyLedgerEra AllegraEra))
forall era.
ShelleyBasedEra era
-> Object -> Parser (TxOut (ShelleyLedgerEra era))
txOutParseJson ShelleyBasedEra AllegraEra
ShelleyBasedEraAllegra)

instance FromJSON (TxOut L.MaryEra) where
  parseJSON :: Value -> Parser (TxOut MaryEra)
parseJSON = String
-> (Object -> Parser (TxOut MaryEra))
-> Value
-> Parser (TxOut MaryEra)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Aeson.withObject String
"TxOut" (ShelleyBasedEra MaryEra
-> Object -> Parser (TxOut (ShelleyLedgerEra MaryEra))
forall era.
ShelleyBasedEra era
-> Object -> Parser (TxOut (ShelleyLedgerEra era))
txOutParseJson ShelleyBasedEra MaryEra
ShelleyBasedEraMary)

instance FromJSON (TxOut L.AlonzoEra) where
  parseJSON :: Value -> Parser (TxOut AlonzoEra)
parseJSON = String
-> (Object -> Parser (TxOut AlonzoEra))
-> Value
-> Parser (TxOut AlonzoEra)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Aeson.withObject String
"TxOut" (ShelleyBasedEra AlonzoEra
-> Object -> Parser (TxOut (ShelleyLedgerEra AlonzoEra))
forall era.
ShelleyBasedEra era
-> Object -> Parser (TxOut (ShelleyLedgerEra era))
txOutParseJson ShelleyBasedEra AlonzoEra
ShelleyBasedEraAlonzo)

instance FromJSON (TxOut L.BabbageEra) where
  parseJSON :: Value -> Parser (TxOut BabbageEra)
parseJSON = String
-> (Object -> Parser (TxOut BabbageEra))
-> Value
-> Parser (TxOut BabbageEra)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Aeson.withObject String
"TxOut" (ShelleyBasedEra BabbageEra
-> Object -> Parser (TxOut (ShelleyLedgerEra BabbageEra))
forall era.
ShelleyBasedEra era
-> Object -> Parser (TxOut (ShelleyLedgerEra era))
txOutParseJson ShelleyBasedEra BabbageEra
ShelleyBasedEraBabbage)

instance FromJSON (TxOut L.ConwayEra) where
  parseJSON :: Value -> Parser (TxOut ConwayEra)
parseJSON = String
-> (Object -> Parser (TxOut ConwayEra))
-> Value
-> Parser (TxOut ConwayEra)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Aeson.withObject String
"TxOut" (ShelleyBasedEra ConwayEra
-> Object -> Parser (TxOut (ShelleyLedgerEra ConwayEra))
forall era.
ShelleyBasedEra era
-> Object -> Parser (TxOut (ShelleyLedgerEra era))
txOutParseJson ShelleyBasedEra ConwayEra
ShelleyBasedEraConway)

txOutParseJson
  :: ShelleyBasedEra era -> Aeson.Object -> Parser (TxOut (ShelleyLedgerEra era))
txOutParseJson :: forall era.
ShelleyBasedEra era
-> Object -> Parser (TxOut (ShelleyLedgerEra era))
txOutParseJson ShelleyBasedEra era
sbe Object
o = do
  addr <- Value -> Parser Addr
addrFromJson (Value -> Parser Addr) -> Parser Value -> Parser Addr
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Object
o Object -> Key -> Parser Value
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"address"
  apiVal <- parseJSON =<< o .: "value"
  let mv = Value -> MaryValue
toMaryValue Value
apiVal
  case sbe of
    ShelleyBasedEra era
ShelleyBasedEraShelley -> do
      let L.MaryValue Coin
_ MultiAsset
ma = MaryValue
mv
      Bool -> Parser () -> Parser ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (MultiAsset
ma MultiAsset -> MultiAsset -> Bool
forall a. Eq a => a -> a -> Bool
== MultiAsset
forall a. Monoid a => a
mempty) (Parser () -> Parser ()) -> Parser () -> Parser ()
forall a b. (a -> b) -> a -> b
$
        String -> Parser ()
forall a. HasCallStack => String -> Parser a
forall (m :: * -> *) a.
(MonadFail m, HasCallStack) =>
String -> m a
fail String
"txOutParseJson: ada-only era output cannot carry a multi-asset value"
      TxOut (ShelleyLedgerEra era)
-> Parser (TxOut (ShelleyLedgerEra era))
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TxOut (ShelleyLedgerEra era)
 -> Parser (TxOut (ShelleyLedgerEra era)))
-> (TxOut ShelleyEra -> TxOut (ShelleyLedgerEra era))
-> TxOut ShelleyEra
-> Parser (TxOut (ShelleyLedgerEra era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxOut ShelleyEra -> TxOut ShelleyEra
TxOut ShelleyEra -> TxOut (ShelleyLedgerEra era)
forall era. EraTxOut era => TxOut era -> TxOut era
TxOut (TxOut ShelleyEra -> Parser (TxOut (ShelleyLedgerEra era)))
-> TxOut ShelleyEra -> Parser (TxOut (ShelleyLedgerEra era))
forall a b. (a -> b) -> a -> b
$ Addr -> Value ShelleyEra -> TxOut ShelleyEra
forall era.
(EraTxOut era, HasCallStack) =>
Addr -> Value era -> TxOut era
L.mkBasicTxOut Addr
addr (MaryValue -> Coin
forall t. Val t => t -> Coin
L.coin MaryValue
mv)
    ShelleyBasedEra era
ShelleyBasedEraAllegra -> do
      let L.MaryValue Coin
_ MultiAsset
ma = MaryValue
mv
      Bool -> Parser () -> Parser ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (MultiAsset
ma MultiAsset -> MultiAsset -> Bool
forall a. Eq a => a -> a -> Bool
== MultiAsset
forall a. Monoid a => a
mempty) (Parser () -> Parser ()) -> Parser () -> Parser ()
forall a b. (a -> b) -> a -> b
$
        String -> Parser ()
forall a. HasCallStack => String -> Parser a
forall (m :: * -> *) a.
(MonadFail m, HasCallStack) =>
String -> m a
fail String
"txOutParseJson: ada-only era output cannot carry a multi-asset value"
      TxOut (ShelleyLedgerEra era)
-> Parser (TxOut (ShelleyLedgerEra era))
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TxOut (ShelleyLedgerEra era)
 -> Parser (TxOut (ShelleyLedgerEra era)))
-> (TxOut AllegraEra -> TxOut (ShelleyLedgerEra era))
-> TxOut AllegraEra
-> Parser (TxOut (ShelleyLedgerEra era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxOut AllegraEra -> TxOut AllegraEra
TxOut AllegraEra -> TxOut (ShelleyLedgerEra era)
forall era. EraTxOut era => TxOut era -> TxOut era
TxOut (TxOut AllegraEra -> Parser (TxOut (ShelleyLedgerEra era)))
-> TxOut AllegraEra -> Parser (TxOut (ShelleyLedgerEra era))
forall a b. (a -> b) -> a -> b
$ Addr -> Value AllegraEra -> TxOut AllegraEra
forall era.
(EraTxOut era, HasCallStack) =>
Addr -> Value era -> TxOut era
L.mkBasicTxOut Addr
addr (MaryValue -> Coin
forall t. Val t => t -> Coin
L.coin MaryValue
mv)
    ShelleyBasedEra era
ShelleyBasedEraMary -> TxOut (ShelleyLedgerEra era)
-> Parser (TxOut (ShelleyLedgerEra era))
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TxOut (ShelleyLedgerEra era)
 -> Parser (TxOut (ShelleyLedgerEra era)))
-> (TxOut MaryEra -> TxOut (ShelleyLedgerEra era))
-> TxOut MaryEra
-> Parser (TxOut (ShelleyLedgerEra era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxOut MaryEra -> TxOut MaryEra
TxOut MaryEra -> TxOut (ShelleyLedgerEra era)
forall era. EraTxOut era => TxOut era -> TxOut era
TxOut (TxOut MaryEra -> Parser (TxOut (ShelleyLedgerEra era)))
-> TxOut MaryEra -> Parser (TxOut (ShelleyLedgerEra era))
forall a b. (a -> b) -> a -> b
$ Addr -> Value MaryEra -> TxOut MaryEra
forall era.
(EraTxOut era, HasCallStack) =>
Addr -> Value era -> TxOut era
L.mkBasicTxOut Addr
addr Value MaryEra
MaryValue
mv
    ShelleyBasedEra era
ShelleyBasedEraAlonzo -> do
      let base :: TxOut AlonzoEra
base = Addr -> Value AlonzoEra -> TxOut AlonzoEra
forall era.
(EraTxOut era, HasCallStack) =>
Addr -> Value era -> TxOut era
L.mkBasicTxOut Addr
addr Value AlonzoEra
MaryValue
mv
      mDatumHash <- Object
o Object -> Key -> Parser (Maybe (SafeHash EraIndependentData))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"datumhash"
      pure . TxOut $ case mDatumHash of
        Maybe (SafeHash EraIndependentData)
Nothing -> TxOut AlonzoEra
base
        Just SafeHash EraIndependentData
dh -> TxOut AlonzoEra
AlonzoTxOut AlonzoEra
base AlonzoTxOut AlonzoEra
-> (AlonzoTxOut AlonzoEra -> TxOut AlonzoEra) -> TxOut AlonzoEra
forall a b. a -> (a -> b) -> b
& (StrictMaybe (SafeHash EraIndependentData)
 -> Identity (StrictMaybe (SafeHash EraIndependentData)))
-> TxOut AlonzoEra -> Identity (TxOut AlonzoEra)
(StrictMaybe (SafeHash EraIndependentData)
 -> Identity (StrictMaybe (SafeHash EraIndependentData)))
-> AlonzoTxOut AlonzoEra -> Identity (TxOut AlonzoEra)
forall era.
AlonzoEraTxOut era =>
Lens' (TxOut era) (StrictMaybe (SafeHash EraIndependentData))
Lens' (TxOut AlonzoEra) (StrictMaybe (SafeHash EraIndependentData))
L.dataHashTxOutL ((StrictMaybe (SafeHash EraIndependentData)
  -> Identity (StrictMaybe (SafeHash EraIndependentData)))
 -> AlonzoTxOut AlonzoEra -> Identity (TxOut AlonzoEra))
-> StrictMaybe (SafeHash EraIndependentData)
-> AlonzoTxOut AlonzoEra
-> TxOut AlonzoEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ SafeHash EraIndependentData
-> StrictMaybe (SafeHash EraIndependentData)
forall a. a -> StrictMaybe a
SJust SafeHash EraIndependentData
dh
    ShelleyBasedEra era
ShelleyBasedEraBabbage ->
      TxOut BabbageEra -> Object -> Parser (TxOut BabbageEra)
forall era.
(BabbageEraTxOut era, NativeScript era ~ Timelock era) =>
TxOut era -> Object -> Parser (TxOut era)
babbageOnwardsTxOutParseJson (Addr -> Value BabbageEra -> TxOut BabbageEra
forall era.
(EraTxOut era, HasCallStack) =>
Addr -> Value era -> TxOut era
L.mkBasicTxOut Addr
addr Value BabbageEra
MaryValue
mv) Object
o
    ShelleyBasedEra era
ShelleyBasedEraConway ->
      TxOut ConwayEra -> Object -> Parser (TxOut ConwayEra)
forall era.
(BabbageEraTxOut era, NativeScript era ~ Timelock era) =>
TxOut era -> Object -> Parser (TxOut era)
babbageOnwardsTxOutParseJson (Addr -> Value ConwayEra -> TxOut ConwayEra
forall era.
(EraTxOut era, HasCallStack) =>
Addr -> Value era -> TxOut era
L.mkBasicTxOut Addr
addr Value ConwayEra
MaryValue
mv) Object
o
    ShelleyBasedEra era
ShelleyBasedEraDijkstra -> String -> Parser (TxOut (ShelleyLedgerEra era))
forall a. HasCallStack => String -> a
error String
"TODO Dijkstra: txOutParseJson: era not supported"

-- | Parse a ledger 'L.Addr' from JSON. Reverse of 'addrToJson'.
addrFromJson :: Aeson.Value -> Parser L.Addr
addrFromJson :: Value -> Parser Addr
addrFromJson = String -> (Text -> Parser Addr) -> Value -> Parser Addr
forall a. String -> (Text -> Parser a) -> Value -> Parser a
Aeson.withText String
"Address" ((Text -> Parser Addr) -> Value -> Parser Addr)
-> (Text -> Parser Addr) -> Value -> Parser Addr
forall a b. (a -> b) -> a -> b
$ \Text
txt ->
  case AsType AddressAny -> Text -> Maybe AddressAny
forall addr.
SerialiseAddress addr =>
AsType addr -> Text -> Maybe addr
deserialiseAddress AsType AddressAny
AsAddressAny Text
txt of
    Maybe AddressAny
Nothing -> String -> Parser Addr
forall a. HasCallStack => String -> Parser a
forall (m :: * -> *) a.
(MonadFail m, HasCallStack) =>
String -> m a
fail (String -> Parser Addr) -> String -> Parser Addr
forall a b. (a -> b) -> a -> b
$ String
"addrFromJson: invalid address: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Text -> String
forall a. Show a => a -> String
show Text
txt
    Just AddressAny
addrAny -> Addr -> Parser Addr
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Addr -> Parser Addr) -> Addr -> Parser Addr
forall a b. (a -> b) -> a -> b
$ case AddressAny
addrAny of
      AddressByron (ByronAddress Address
addr) -> BootstrapAddress -> Addr
L.AddrBootstrap (Address -> BootstrapAddress
L.BootstrapAddress Address
addr)
      AddressShelley (ShelleyAddress Network
nw Credential Payment
pc StakeReference
scr) -> Network -> Credential Payment -> StakeReference -> Addr
L.Addr Network
nw Credential Payment
pc StakeReference
scr

-- | Parse a Babbage+ TxOut with datum and reference script support.
babbageOnwardsTxOutParseJson
  :: forall era
   . ( L.BabbageEraTxOut era
     , L.NativeScript era ~ Timelock era
     )
  => L.TxOut era -> Aeson.Object -> Parser (TxOut era)
babbageOnwardsTxOutParseJson :: forall era.
(BabbageEraTxOut era, NativeScript era ~ Timelock era) =>
TxOut era -> Object -> Parser (TxOut era)
babbageOnwardsTxOutParseJson TxOut era
baseTxOut Object
o = do
  -- Parse datum fields
  mDatumHash <- Object
o Object -> Key -> Parser (Maybe (SafeHash EraIndependentData))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"datumhash"
  mInlineDatumRaw <- o .:? "inlineDatumRaw"
  mInlineDatumHash <- o .:? "inlineDatumhash"
  -- Parse reference script
  mRefScript <- o .:? "referenceScript"
  -- Determine datum
  datum <- case mInlineDatumRaw of
    Just Text
rawHex -> do
      expectedHash <-
        Parser (SafeHash EraIndependentData)
-> (SafeHash EraIndependentData
    -> Parser (SafeHash EraIndependentData))
-> Maybe (SafeHash EraIndependentData)
-> Parser (SafeHash EraIndependentData)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
          (String -> Parser (SafeHash EraIndependentData)
forall a. HasCallStack => String -> Parser a
forall (m :: * -> *) a.
(MonadFail m, HasCallStack) =>
String -> m a
fail String
"babbageOnwardsTxOutParseJson: inlineDatumRaw present without inlineDatumhash")
          SafeHash EraIndependentData -> Parser (SafeHash EraIndependentData)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
          Maybe (SafeHash EraIndependentData)
mInlineDatumHash
      rawBytes <-
        failEitherWith
          (("babbageOnwardsTxOutParseJson: failed to hex-decode inlineDatumRaw: " <>) . show)
          $ Base16.decode (Text.encodeUtf8 rawHex)
      binaryData <-
        failEitherWith
          ("babbageOnwardsTxOutParseJson: failed to CBOR-decode inlineDatumRaw: " <>)
          $ L.makeBinaryData (SBS.toShort rawBytes)
      when (L.hashBinaryData binaryData /= expectedHash) $
        fail $
          mconcat
            [ "babbageOnwardsTxOutParseJson: inline datum hash mismatch: "
            , "expected "
            , show expectedHash
            , ", got "
            , show (L.hashBinaryData binaryData)
            ]
      pure $ L.Datum binaryData
    Maybe Text
Nothing -> do
      Bool -> Parser () -> Parser ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Maybe (SafeHash EraIndependentData) -> Bool
forall a. Maybe a -> Bool
isJust Maybe (SafeHash EraIndependentData)
mInlineDatumHash) (Parser () -> Parser ()) -> Parser () -> Parser ()
forall a b. (a -> b) -> a -> b
$
        String -> Parser ()
forall a. HasCallStack => String -> Parser a
forall (m :: * -> *) a.
(MonadFail m, HasCallStack) =>
String -> m a
fail String
"babbageOnwardsTxOutParseJson: inlineDatumhash present without inlineDatumRaw"
      Datum era -> Parser (Datum era)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Datum era -> Parser (Datum era))
-> Datum era -> Parser (Datum era)
forall a b. (a -> b) -> a -> b
$ Datum era
-> (SafeHash EraIndependentData -> Datum era)
-> Maybe (SafeHash EraIndependentData)
-> Datum era
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Datum era
forall era. Datum era
L.NoDatum SafeHash EraIndependentData -> Datum era
forall era. SafeHash EraIndependentData -> Datum era
L.DatumHash Maybe (SafeHash EraIndependentData)
mDatumHash
  -- Determine reference script
  refScript <- L.maybeToStrictMaybe <$> forM mRefScript scriptInAnyLangToLedgerScript
  -- Construct TxOut
  pure . TxOut $
    baseTxOut
      & L.datumTxOutL .~ datum
      & L.referenceScriptTxOutL .~ refScript

data Datum ctx era where
  TxOutDatumHash
    :: L.DataHash
    -> Datum ctx era
  TxOutSupplementalDatum
    :: L.DataHash
    -> L.Data era
    -> Datum CtxTx era
  TxOutDatumInline
    :: L.DataHash
    -> L.Data era
    -> Datum ctx era

deriving instance (Show (Datum ctx era))

deriving instance (Eq (Datum ctx era))

extractDatumsAndHashes :: Datum ctx era -> Maybe (L.DataHash, L.Data era)
extractDatumsAndHashes :: forall ctx era.
Datum ctx era -> Maybe (SafeHash EraIndependentData, Data era)
extractDatumsAndHashes TxOutDatumHash{} = Maybe (SafeHash EraIndependentData, Data era)
forall a. Maybe a
Nothing
extractDatumsAndHashes (TxOutSupplementalDatum SafeHash EraIndependentData
h Data era
d) = (SafeHash EraIndependentData, Data era)
-> Maybe (SafeHash EraIndependentData, Data era)
forall a. a -> Maybe a
Just (SafeHash EraIndependentData
h, Data era
d)
extractDatumsAndHashes (TxOutDatumInline SafeHash EraIndependentData
h Data era
d) = (SafeHash EraIndependentData, Data era)
-> Maybe (SafeHash EraIndependentData, Data era)
forall a. a -> Maybe a
Just (SafeHash EraIndependentData
h, Data era
d)

data TxInsReference era = TxInsReference [TxIn] (Set (Datum CtxTx era))

newtype TxTotalCollateral = TxTotalCollateral {TxTotalCollateral -> Coin
unTxTotalCollateral :: L.Coin}

newtype TxReturnCollateral era = TxReturnCollateral {forall era. TxReturnCollateral era -> TxOut era
unTxReturnCollateral :: L.TxOut era}

newtype TxValidityLowerBound = TxValidityLowerBound L.SlotNo

newtype TxExtraKeyWitnesses = TxExtraKeyWitnesses [Hash PaymentKey]

newtype TxWithdrawals era = TxWithdrawals {forall era.
TxWithdrawals era -> [(StakeAddress, Coin, AnyWitness era)]
unTxWithdrawals :: [(StakeAddress, L.Coin, AnyWitness era)]}
  deriving (TxWithdrawals era -> TxWithdrawals era -> Bool
(TxWithdrawals era -> TxWithdrawals era -> Bool)
-> (TxWithdrawals era -> TxWithdrawals era -> Bool)
-> Eq (TxWithdrawals era)
forall era. TxWithdrawals era -> TxWithdrawals era -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall era. TxWithdrawals era -> TxWithdrawals era -> Bool
== :: TxWithdrawals era -> TxWithdrawals era -> Bool
$c/= :: forall era. TxWithdrawals era -> TxWithdrawals era -> Bool
/= :: TxWithdrawals era -> TxWithdrawals era -> Bool
Eq, Int -> TxWithdrawals era -> ShowS
[TxWithdrawals era] -> ShowS
TxWithdrawals era -> String
(Int -> TxWithdrawals era -> ShowS)
-> (TxWithdrawals era -> String)
-> ([TxWithdrawals era] -> ShowS)
-> Show (TxWithdrawals era)
forall era. Int -> TxWithdrawals era -> ShowS
forall era. [TxWithdrawals era] -> ShowS
forall era. TxWithdrawals era -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall era. Int -> TxWithdrawals era -> ShowS
showsPrec :: Int -> TxWithdrawals era -> ShowS
$cshow :: forall era. TxWithdrawals era -> String
show :: TxWithdrawals era -> String
$cshowList :: forall era. [TxWithdrawals era] -> ShowS
showList :: [TxWithdrawals era] -> ShowS
Show)

newtype TxCertificates era
  = TxCertificates
  {forall era.
TxCertificates era
-> OMap (Certificate era) (Maybe (AnyWitness era))
unTxCertificates :: OMap (Exp.Certificate era) (Maybe (AnyWitness era))}
  deriving (Int -> TxCertificates era -> ShowS
[TxCertificates era] -> ShowS
TxCertificates era -> String
(Int -> TxCertificates era -> ShowS)
-> (TxCertificates era -> String)
-> ([TxCertificates era] -> ShowS)
-> Show (TxCertificates era)
forall era. Int -> TxCertificates era -> ShowS
forall era. [TxCertificates era] -> ShowS
forall era. TxCertificates era -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall era. Int -> TxCertificates era -> ShowS
showsPrec :: Int -> TxCertificates era -> ShowS
$cshow :: forall era. TxCertificates era -> String
show :: TxCertificates era -> String
$cshowList :: forall era. [TxCertificates era] -> ShowS
showList :: [TxCertificates era] -> ShowS
Show, TxCertificates era -> TxCertificates era -> Bool
(TxCertificates era -> TxCertificates era -> Bool)
-> (TxCertificates era -> TxCertificates era -> Bool)
-> Eq (TxCertificates era)
forall era. TxCertificates era -> TxCertificates era -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall era. TxCertificates era -> TxCertificates era -> Bool
== :: TxCertificates era -> TxCertificates era -> Bool
$c/= :: forall era. TxCertificates era -> TxCertificates era -> Bool
/= :: TxCertificates era -> TxCertificates era -> Bool
Eq)

-- | Create 'TxCertificates'. Note that 'Certificate era' will be deduplicated. Certificates that
-- require a witness will be stored with 'Just' the caller-supplied witness; those that do not (e.g.
-- deposit-less stake registration in Conway) will be stored with 'Nothing'.
--
-- Note that, when building a transaction in Conway era, a witness is not required for staking credential
-- registration, but this is only the case during the transitional period of Conway era and only for staking
-- credential registration certificates without a deposit. Future eras will require a witness for
-- registration certificates, because the one without a deposit will be removed.
mkTxCertificates
  :: forall era
   . Era era
  -> [(Exp.Certificate (LedgerEra era), AnyWitness (LedgerEra era))]
  -> TxCertificates (LedgerEra era)
mkTxCertificates :: forall era.
Era era
-> [(Certificate (LedgerEra era), AnyWitness (LedgerEra era))]
-> TxCertificates (LedgerEra era)
mkTxCertificates Era era
era [(Certificate (LedgerEra era), AnyWitness (LedgerEra era))]
certs = OMap
  (Certificate (LedgerEra era)) (Maybe (AnyWitness (LedgerEra era)))
-> TxCertificates (LedgerEra era)
forall era.
OMap (Certificate era) (Maybe (AnyWitness era))
-> TxCertificates era
TxCertificates (OMap
   (Certificate (LedgerEra era)) (Maybe (AnyWitness (LedgerEra era)))
 -> TxCertificates (LedgerEra era))
-> ([(Certificate (LedgerEra era),
      Maybe (AnyWitness (LedgerEra era)))]
    -> OMap
         (Certificate (LedgerEra era)) (Maybe (AnyWitness (LedgerEra era))))
-> [(Certificate (LedgerEra era),
     Maybe (AnyWitness (LedgerEra era)))]
-> TxCertificates (LedgerEra era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Certificate (LedgerEra era), Maybe (AnyWitness (LedgerEra era)))]
-> OMap
     (Certificate (LedgerEra era)) (Maybe (AnyWitness (LedgerEra era)))
forall k v. Ord k => [(k, v)] -> OMap k v
OMap.fromList ([(Certificate (LedgerEra era),
   Maybe (AnyWitness (LedgerEra era)))]
 -> TxCertificates (LedgerEra era))
-> [(Certificate (LedgerEra era),
     Maybe (AnyWitness (LedgerEra era)))]
-> TxCertificates (LedgerEra era)
forall a b. (a -> b) -> a -> b
$ ((Certificate (LedgerEra era), AnyWitness (LedgerEra era))
 -> (Certificate (LedgerEra era),
     Maybe (AnyWitness (LedgerEra era))))
-> [(Certificate (LedgerEra era), AnyWitness (LedgerEra era))]
-> [(Certificate (LedgerEra era),
     Maybe (AnyWitness (LedgerEra era)))]
forall a b. (a -> b) -> [a] -> [b]
map (Certificate (LedgerEra era), AnyWitness (LedgerEra era))
-> (Certificate (LedgerEra era),
    Maybe (AnyWitness (LedgerEra era)))
getStakeCred [(Certificate (LedgerEra era), AnyWitness (LedgerEra era))]
certs
 where
  getStakeCred
    :: (Exp.Certificate (LedgerEra era), AnyWitness (LedgerEra era))
    -> ( Exp.Certificate (LedgerEra era)
       , Maybe (AnyWitness (LedgerEra era))
       )
  getStakeCred :: (Certificate (LedgerEra era), AnyWitness (LedgerEra era))
-> (Certificate (LedgerEra era),
    Maybe (AnyWitness (LedgerEra era)))
getStakeCred (c :: Certificate (LedgerEra era)
c@(Exp.Certificate TxCert (LedgerEra era)
cert), AnyWitness (LedgerEra era)
wit) =
    (Certificate (LedgerEra era)
c, AnyWitness (LedgerEra era)
wit AnyWitness (LedgerEra era)
-> Maybe StakeCredential -> Maybe (AnyWitness (LedgerEra era))
forall a b. a -> Maybe b -> Maybe a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ShelleyBasedEra era
-> TxCert (ShelleyLedgerEra era) -> Maybe StakeCredential
forall era.
ShelleyBasedEra era
-> TxCert (ShelleyLedgerEra era) -> Maybe StakeCredential
getTxCertWitness (Era era -> ShelleyBasedEra era
forall era. Era era -> ShelleyBasedEra era
forall a (f :: a -> *) (g :: a -> *) (era :: a).
Convert f g =>
f era -> g era
convert Era era
era) (Era era
-> (EraCommonConstraints era => TxCert (ShelleyLedgerEra era))
-> TxCert (ShelleyLedgerEra era)
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints Era era
era TxCert (ShelleyLedgerEra era)
TxCert (LedgerEra era)
EraCommonConstraints era => TxCert (ShelleyLedgerEra era)
cert))

newtype TxMintValue era
  = TxMintValue
  { forall era.
TxMintValue era
-> Map PolicyId (PolicyAssets, AnyScriptWitness era)
unTxMintValue
      :: Map
           PolicyId
           ( PolicyAssets
           , AnyScriptWitness era
           )
  }
  deriving (TxMintValue era -> TxMintValue era -> Bool
(TxMintValue era -> TxMintValue era -> Bool)
-> (TxMintValue era -> TxMintValue era -> Bool)
-> Eq (TxMintValue era)
forall era. TxMintValue era -> TxMintValue era -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall era. TxMintValue era -> TxMintValue era -> Bool
== :: TxMintValue era -> TxMintValue era -> Bool
$c/= :: forall era. TxMintValue era -> TxMintValue era -> Bool
/= :: TxMintValue era -> TxMintValue era -> Bool
Eq, Int -> TxMintValue era -> ShowS
[TxMintValue era] -> ShowS
TxMintValue era -> String
(Int -> TxMintValue era -> ShowS)
-> (TxMintValue era -> String)
-> ([TxMintValue era] -> ShowS)
-> Show (TxMintValue era)
forall era. Int -> TxMintValue era -> ShowS
forall era. [TxMintValue era] -> ShowS
forall era. TxMintValue era -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall era. Int -> TxMintValue era -> ShowS
showsPrec :: Int -> TxMintValue era -> ShowS
$cshow :: forall era. TxMintValue era -> String
show :: TxMintValue era -> String
$cshowList :: forall era. [TxMintValue era] -> ShowS
showList :: [TxMintValue era] -> ShowS
Show)

-- | Convert 'TxMintValue' to a more handy 'Value'.
txMintValueToValue :: TxMintValue era -> Value
txMintValueToValue :: forall era. TxMintValue era -> Value
txMintValueToValue (TxMintValue Map PolicyId (PolicyAssets, AnyScriptWitness era)
policiesWithAssets) =
  [Value] -> Value
forall a. Monoid a => [a] -> a
mconcat
    [ PolicyId -> PolicyAssets -> Value
policyAssetsToValue PolicyId
policyId PolicyAssets
assets
    | (PolicyId
policyId, (PolicyAssets
assets, AnyScriptWitness era
_witness)) <- Map PolicyId (PolicyAssets, AnyScriptWitness era)
-> [Item (Map PolicyId (PolicyAssets, AnyScriptWitness era))]
forall l. IsList l => l -> [Item l]
toList Map PolicyId (PolicyAssets, AnyScriptWitness era)
policiesWithAssets
    ]

newtype TxProposalProcedures era
  = TxProposalProcedures
      ( OMap
          (L.ProposalProcedure era)
          (AnyWitness era)
      )
  deriving (Int -> TxProposalProcedures era -> ShowS
[TxProposalProcedures era] -> ShowS
TxProposalProcedures era -> String
(Int -> TxProposalProcedures era -> ShowS)
-> (TxProposalProcedures era -> String)
-> ([TxProposalProcedures era] -> ShowS)
-> Show (TxProposalProcedures era)
forall era.
EraPParams era =>
Int -> TxProposalProcedures era -> ShowS
forall era. EraPParams era => [TxProposalProcedures era] -> ShowS
forall era. EraPParams era => TxProposalProcedures era -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall era.
EraPParams era =>
Int -> TxProposalProcedures era -> ShowS
showsPrec :: Int -> TxProposalProcedures era -> ShowS
$cshow :: forall era. EraPParams era => TxProposalProcedures era -> String
show :: TxProposalProcedures era -> String
$cshowList :: forall era. EraPParams era => [TxProposalProcedures era] -> ShowS
showList :: [TxProposalProcedures era] -> ShowS
Show, TxProposalProcedures era -> TxProposalProcedures era -> Bool
(TxProposalProcedures era -> TxProposalProcedures era -> Bool)
-> (TxProposalProcedures era -> TxProposalProcedures era -> Bool)
-> Eq (TxProposalProcedures era)
forall era.
EraPParams era =>
TxProposalProcedures era -> TxProposalProcedures era -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall era.
EraPParams era =>
TxProposalProcedures era -> TxProposalProcedures era -> Bool
== :: TxProposalProcedures era -> TxProposalProcedures era -> Bool
$c/= :: forall era.
EraPParams era =>
TxProposalProcedures era -> TxProposalProcedures era -> Bool
/= :: TxProposalProcedures era -> TxProposalProcedures era -> Bool
Eq)

-- | A smart constructor for 'TxProposalProcedures'. It makes sure that the value produced is consistent - the
-- witnessed proposals are also present in the first constructor parameter.
mkTxProposalProcedures
  :: forall era
   . IsEra era
  => [(L.ProposalProcedure (LedgerEra era), AnyWitness (LedgerEra era))]
  -> TxProposalProcedures (LedgerEra era)
mkTxProposalProcedures :: forall era.
IsEra era =>
[(ProposalProcedure (LedgerEra era), AnyWitness (LedgerEra era))]
-> TxProposalProcedures (LedgerEra era)
mkTxProposalProcedures [(ProposalProcedure (LedgerEra era), AnyWitness (LedgerEra era))]
proposals = do
  OMap
  (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era))
-> TxProposalProcedures (LedgerEra era)
forall era.
OMap (ProposalProcedure era) (AnyWitness era)
-> TxProposalProcedures era
TxProposalProcedures (OMap
   (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era))
 -> TxProposalProcedures (LedgerEra era))
-> OMap
     (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era))
-> TxProposalProcedures (LedgerEra era)
forall a b. (a -> b) -> a -> b
$
    Era era
-> (EraCommonConstraints era =>
    OMap
      (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era)))
-> OMap
     (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era))
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era =>
  OMap
    (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era)))
 -> OMap
      (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era)))
-> (EraCommonConstraints era =>
    OMap
      (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era)))
-> OMap
     (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era))
forall a b. (a -> b) -> a -> b
$
      [(ProposalProcedure (LedgerEra era), AnyWitness (LedgerEra era))]
-> OMap
     (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era))
forall k v. Ord k => [(k, v)] -> OMap k v
OMap.fromList [(ProposalProcedure (LedgerEra era), AnyWitness (LedgerEra era))]
proposals

data TxVotingProcedures era
  = TxVotingProcedures
      (L.VotingProcedures era)
      (Map L.Voter (AnyWitness era))
  deriving (TxVotingProcedures era -> TxVotingProcedures era -> Bool
(TxVotingProcedures era -> TxVotingProcedures era -> Bool)
-> (TxVotingProcedures era -> TxVotingProcedures era -> Bool)
-> Eq (TxVotingProcedures era)
forall era.
TxVotingProcedures era -> TxVotingProcedures era -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall era.
TxVotingProcedures era -> TxVotingProcedures era -> Bool
== :: TxVotingProcedures era -> TxVotingProcedures era -> Bool
$c/= :: forall era.
TxVotingProcedures era -> TxVotingProcedures era -> Bool
/= :: TxVotingProcedures era -> TxVotingProcedures era -> Bool
Eq, Int -> TxVotingProcedures era -> ShowS
[TxVotingProcedures era] -> ShowS
TxVotingProcedures era -> String
(Int -> TxVotingProcedures era -> ShowS)
-> (TxVotingProcedures era -> String)
-> ([TxVotingProcedures era] -> ShowS)
-> Show (TxVotingProcedures era)
forall era. Int -> TxVotingProcedures era -> ShowS
forall era. [TxVotingProcedures era] -> ShowS
forall era. TxVotingProcedures era -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall era. Int -> TxVotingProcedures era -> ShowS
showsPrec :: Int -> TxVotingProcedures era -> ShowS
$cshow :: forall era. TxVotingProcedures era -> String
show :: TxVotingProcedures era -> String
$cshowList :: forall era. [TxVotingProcedures era] -> ShowS
showList :: [TxVotingProcedures era] -> ShowS
Show)

-- | Create voting procedures from map of voting procedures and optional witnesses.
-- Validates the function argument, to make sure the list of votes is legal.
-- See 'mergeVotingProcedures' for validation rules.
mkTxVotingProcedures
  :: forall era
   . [(L.VotingProcedures era, AnyWitness era)]
  -> Either (VotingError era) (TxVotingProcedures era)
mkTxVotingProcedures :: forall era.
[(VotingProcedures era, AnyWitness era)]
-> Either (VotingError era) (TxVotingProcedures era)
mkTxVotingProcedures [(VotingProcedures era, AnyWitness era)]
votingProcedures = do
  procedure <-
    (VotingProcedures era
 -> (VotingProcedures era, AnyWitness era)
 -> Either (VotingError era) (VotingProcedures era))
-> VotingProcedures era
-> [(VotingProcedures era, AnyWitness era)]
-> Either (VotingError era) (VotingProcedures era)
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM VotingProcedures era
-> (VotingProcedures era, AnyWitness era)
-> Either (VotingError era) (VotingProcedures era)
f (Map Voter (Map GovActionId (VotingProcedure era))
-> VotingProcedures era
forall era.
Map Voter (Map GovActionId (VotingProcedure era))
-> VotingProcedures era
L.VotingProcedures Map Voter (Map GovActionId (VotingProcedure era))
forall k a. Map k a
Map.empty) [(VotingProcedures era, AnyWitness era)]
votingProcedures
  votingScriptWitnessMap <-
    foldM
      (\Map Voter (AnyWitness era)
acc (VotingProcedures era, AnyWitness era)
next -> Map Voter (AnyWitness era)
-> Map Voter (AnyWitness era) -> Map Voter (AnyWitness era)
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union Map Voter (AnyWitness era)
acc (Map Voter (AnyWitness era) -> Map Voter (AnyWitness era))
-> Either (VotingError era) (Map Voter (AnyWitness era))
-> Either (VotingError era) (Map Voter (AnyWitness era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (VotingProcedures era
 -> AnyWitness era
 -> Either (VotingError era) (Map Voter (AnyWitness era)))
-> (VotingProcedures era, AnyWitness era)
-> Either (VotingError era) (Map Voter (AnyWitness era))
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry VotingProcedures era
-> AnyWitness era
-> Either (VotingError era) (Map Voter (AnyWitness era))
votingScriptWitnessSingleton (VotingProcedures era, AnyWitness era)
next)
      Map.empty
      votingProcedures
  pure $ TxVotingProcedures procedure votingScriptWitnessMap
 where
  f
    :: L.VotingProcedures era
    -> (L.VotingProcedures era, AnyWitness era)
    -> Either (VotingError era) (L.VotingProcedures era)
  f :: VotingProcedures era
-> (VotingProcedures era, AnyWitness era)
-> Either (VotingError era) (VotingProcedures era)
f VotingProcedures era
acc (VotingProcedures era
procedure, AnyWitness era
_witness) = VotingProcedures era
-> VotingProcedures era
-> Either (VotingError era) (VotingProcedures era)
forall era.
VotingProcedures era
-> VotingProcedures era
-> Either (VotingError era) (VotingProcedures era)
mergeVotingProcedures VotingProcedures era
acc VotingProcedures era
procedure

  votingScriptWitnessSingleton
    :: L.VotingProcedures era
    -> AnyWitness era
    -> Either (VotingError era) (Map L.Voter (AnyWitness era))
  votingScriptWitnessSingleton :: VotingProcedures era
-> AnyWitness era
-> Either (VotingError era) (Map Voter (AnyWitness era))
votingScriptWitnessSingleton VotingProcedures era
lVotingProcedures AnyWitness era
scriptWitness =
    case (Voter, Map GovActionId (VotingProcedure era)) -> Voter
forall a b. (a, b) -> a
fst ((Voter, Map GovActionId (VotingProcedure era)) -> Voter)
-> Maybe (Voter, Map GovActionId (VotingProcedure era))
-> Maybe Voter
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map Voter (Map GovActionId (VotingProcedure era))
-> Maybe (Voter, Map GovActionId (VotingProcedure era))
forall k a. Map k a -> Maybe (k, a)
Map.lookupMin (VotingProcedures era
-> Map Voter (Map GovActionId (VotingProcedure era))
forall era.
VotingProcedures era
-> Map Voter (Map GovActionId (VotingProcedure era))
L.unVotingProcedures VotingProcedures era
lVotingProcedures) of
      Maybe Voter
Nothing -> VotingError era
-> Either (VotingError era) (Map Voter (AnyWitness era))
forall a b. a -> Either a b
Left (VotingError era
 -> Either (VotingError era) (Map Voter (AnyWitness era)))
-> VotingError era
-> Either (VotingError era) (Map Voter (AnyWitness era))
forall a b. (a -> b) -> a -> b
$ VotingProcedures era -> VotingError era
forall era. VotingProcedures era -> VotingError era
VotingScriptWitnessWithoutVoter VotingProcedures era
lVotingProcedures
      Just Voter
voter -> Map Voter (AnyWitness era)
-> Either (VotingError era) (Map Voter (AnyWitness era))
forall a b. b -> Either a b
Right (Map Voter (AnyWitness era)
 -> Either (VotingError era) (Map Voter (AnyWitness era)))
-> Map Voter (AnyWitness era)
-> Either (VotingError era) (Map Voter (AnyWitness era))
forall a b. (a -> b) -> a -> b
$ Voter -> AnyWitness era -> Map Voter (AnyWitness era)
forall k a. k -> a -> Map k a
Map.singleton Voter
voter AnyWitness era
scriptWitness

-- | Content of a transaction body at either transaction level.
--
-- The transaction level is the ledger's 'L.TxLevel' kind. A 'L.TopTx' body is
-- an ordinary transaction, the thing that is submitted to the chain. A
-- 'L.SubTx' body is a Dijkstra sub-transaction: a transaction built and signed
-- on its own, then embedded whole in a top-level transaction's
-- 'txSubTransactions'. Both levels share most of their fields; a
-- sub-transaction has no fee, collateral, script validity flag, required
-- signers or sub-transactions of its own, since the top level carries those.
--
-- The fields shared by both levels live directly in the record. The fields that
-- exist only in a top-level body live in 'TopTxOnlyFields'. Use the
-- 'TxBodyContent' pattern for a top-level body and the 'SubTxBodyContent'
-- pattern for a sub-transaction body: each presents a flat record, so the
-- nesting is never visible outside this module. A function typed
-- @BodyContent l era@ works on bodies of either level.
data BodyContent (l :: L.TxLevel) era
  = BodyContent
  { forall (l :: TxLevel) era.
BodyContent l era -> [(TxIn, AnyWitness era)]
bcIns :: [(TxIn, AnyWitness era)]
  , forall (l :: TxLevel) era. BodyContent l era -> TxInsReference era
bcInsReference :: TxInsReference era
  , forall (l :: TxLevel) era. BodyContent l era -> [TxOut era]
bcOuts :: [TxOut era]
  , forall (l :: TxLevel) era. BodyContent l era -> Maybe SlotNo
bcValidityLowerBound :: Maybe L.SlotNo
  , forall (l :: TxLevel) era. BodyContent l era -> Maybe SlotNo
bcValidityUpperBound :: Maybe L.SlotNo
  , forall (l :: TxLevel) era. BodyContent l era -> TxMetadata
bcMetadata :: TxMetadata
  , forall (l :: TxLevel) era. BodyContent l era -> [SimpleScript era]
bcAuxScripts :: [SimpleScript era]
  , forall (l :: TxLevel) era. BodyContent l era -> Maybe (PParams era)
bcProtocolParams :: Maybe (L.PParams era)
  , forall (l :: TxLevel) era. BodyContent l era -> TxWithdrawals era
bcWithdrawals :: TxWithdrawals era
  , forall (l :: TxLevel) era. BodyContent l era -> TxCertificates era
bcCertificates :: TxCertificates era
  , forall (l :: TxLevel) era. BodyContent l era -> TxMintValue era
bcMintValue :: TxMintValue era
  , forall (l :: TxLevel) era.
BodyContent l era -> Maybe (TxProposalProcedures era)
bcProposalProcedures :: Maybe (TxProposalProcedures era)
  , forall (l :: TxLevel) era.
BodyContent l era -> Maybe (TxVotingProcedures era)
bcVotingProcedures :: Maybe (TxVotingProcedures era)
  , forall (l :: TxLevel) era. BodyContent l era -> Maybe Coin
bcCurrentTreasuryValue :: Maybe L.Coin
  -- ^ Current treasury value
  , forall (l :: TxLevel) era. BodyContent l era -> Maybe Coin
bcTreasuryDonation :: Maybe L.Coin
  -- ^ Treasury donation to perform
  , forall (l :: TxLevel) era.
BodyContent l era -> Map (SafeHash EraIndependentData) (Data era)
bcSupplementalDatums :: Map L.DataHash (L.Data era)
  -- ^ Supplemental datums are datums whose hashes correspond to output datum hashes.
  -- They are included in the transaction witness set for communication purposes only.
  -- ------------------------------------------------------------
  -- Fields below are new in the Dijkstra era.
  -- ------------------------------------------------------------
  , forall (l :: TxLevel) era.
BodyContent l era -> OSet (Credential Guard)
bcGuards :: OSet (L.Credential L.Guard)
  , forall (l :: TxLevel) era.
BodyContent l era
-> Map (Credential Guard) (StrictMaybe (Data era))
bcRequiredTopLevelGuards :: Map (L.Credential L.Guard) (StrictMaybe (L.Data era))
  , forall (l :: TxLevel) era. BodyContent l era -> DirectDeposits
bcDirectDeposits :: L.DirectDeposits
  , forall (l :: TxLevel) era.
BodyContent l era -> AccountBalanceIntervals era
bcAccountBalanceIntervals :: L.AccountBalanceIntervals era
  , forall (l :: TxLevel) era.
BodyContent l era -> TopTxOnlyFields l era
bcTopTxOnlyFields :: TopTxOnlyFields l era
  }

-- | The fields that exist only in a top-level transaction body. Matching a
-- constructor tells you the level of the enclosing 'BodyContent'.
data TopTxOnlyFields (l :: L.TxLevel) era where
  TopTxFields
    :: { forall era. TopTxOnlyFields TopTx era -> [TxIn]
tlInsCollateral :: [TxIn]
       , forall era. TopTxOnlyFields TopTx era -> Maybe TxTotalCollateral
tlTotalCollateral :: Maybe TxTotalCollateral
       , forall era.
TopTxOnlyFields TopTx era -> Maybe (TxReturnCollateral era)
tlReturnCollateral :: Maybe (TxReturnCollateral era)
       , forall era. TopTxOnlyFields TopTx era -> Coin
tlFee :: L.Coin
       , forall era. TopTxOnlyFields TopTx era -> TxExtraKeyWitnesses
tlExtraKeyWits :: TxExtraKeyWitnesses
       , forall era. TopTxOnlyFields TopTx era -> ScriptValidity
tlScriptValidity :: ScriptValidity
       , forall era. TopTxOnlyFields TopTx era -> OMap TxId (Tx SubTx era)
tlSubTransactions :: LOMap.OMap L.TxId (L.Tx L.SubTx era)
       , forall era.
TopTxOnlyFields TopTx era -> AccountBalanceIntervals era
tlStartingAccountBalanceIntervals :: L.AccountBalanceIntervals era
       }
    -> TopTxOnlyFields L.TopTx era
  -- | These fields do not exist in a sub-transaction body.
  AbsentInSubTx :: TopTxOnlyFields L.SubTx era

-- | Content of a top-level transaction body. See the 'TxBodyContent' pattern.
type TxBodyContent = BodyContent L.TopTx

-- | Content of a Dijkstra sub-transaction body. See the 'SubTxBodyContent' pattern.
--
-- Compared to a top-level 'TxBodyContent', a sub-transaction body has no
-- collateral inputs, no total or return collateral, no fee, no extra key
-- witnesses (guards replace them), no script validity flag, no
-- sub-transactions of its own and no starting account balance intervals.
type SubTxBodyContent = BodyContent L.SubTx

-- | A top-level transaction body as one flat record.
pattern TxBodyContent
  :: [(TxIn, AnyWitness era)]
  -> [TxIn]
  -> TxInsReference era
  -> [TxOut era]
  -> Maybe TxTotalCollateral
  -> Maybe (TxReturnCollateral era)
  -> L.Coin
  -> Maybe L.SlotNo
  -> Maybe L.SlotNo
  -> TxMetadata
  -> [SimpleScript era]
  -> TxExtraKeyWitnesses
  -> Maybe (L.PParams era)
  -> TxWithdrawals era
  -> TxCertificates era
  -> TxMintValue era
  -> ScriptValidity
  -> Maybe (TxProposalProcedures era)
  -> Maybe (TxVotingProcedures era)
  -> Maybe L.Coin
  -> Maybe L.Coin
  -> Map L.DataHash (L.Data era)
  -> OSet (L.Credential L.Guard)
  -> LOMap.OMap L.TxId (L.Tx L.SubTx era)
  -> Map (L.Credential L.Guard) (StrictMaybe (L.Data era))
  -> L.DirectDeposits
  -> L.AccountBalanceIntervals era
  -> L.AccountBalanceIntervals era
  -> TxBodyContent era
pattern $bTxBodyContent :: forall era.
[(TxIn, AnyWitness era)]
-> [TxIn]
-> TxInsReference era
-> [TxOut era]
-> Maybe TxTotalCollateral
-> Maybe (TxReturnCollateral era)
-> Coin
-> Maybe SlotNo
-> Maybe SlotNo
-> TxMetadata
-> [SimpleScript era]
-> TxExtraKeyWitnesses
-> Maybe (PParams era)
-> TxWithdrawals era
-> TxCertificates era
-> TxMintValue era
-> ScriptValidity
-> Maybe (TxProposalProcedures era)
-> Maybe (TxVotingProcedures era)
-> Maybe Coin
-> Maybe Coin
-> Map (SafeHash EraIndependentData) (Data era)
-> OSet (Credential Guard)
-> OMap TxId (Tx SubTx era)
-> Map (Credential Guard) (StrictMaybe (Data era))
-> DirectDeposits
-> AccountBalanceIntervals era
-> AccountBalanceIntervals era
-> TxBodyContent era
$mTxBodyContent :: forall {r} {era}.
TxBodyContent era
-> ([(TxIn, AnyWitness era)]
    -> [TxIn]
    -> TxInsReference era
    -> [TxOut era]
    -> Maybe TxTotalCollateral
    -> Maybe (TxReturnCollateral era)
    -> Coin
    -> Maybe SlotNo
    -> Maybe SlotNo
    -> TxMetadata
    -> [SimpleScript era]
    -> TxExtraKeyWitnesses
    -> Maybe (PParams era)
    -> TxWithdrawals era
    -> TxCertificates era
    -> TxMintValue era
    -> ScriptValidity
    -> Maybe (TxProposalProcedures era)
    -> Maybe (TxVotingProcedures era)
    -> Maybe Coin
    -> Maybe Coin
    -> Map (SafeHash EraIndependentData) (Data era)
    -> OSet (Credential Guard)
    -> OMap TxId (Tx SubTx era)
    -> Map (Credential Guard) (StrictMaybe (Data era))
    -> DirectDeposits
    -> AccountBalanceIntervals era
    -> AccountBalanceIntervals era
    -> r)
-> ((# #) -> r)
-> r
TxBodyContent
  { forall era. TxBodyContent era -> [(TxIn, AnyWitness era)]
txIns
  , forall era. TxBodyContent era -> [TxIn]
txInsCollateral
  , forall era. TxBodyContent era -> TxInsReference era
txInsReference
  , forall era. TxBodyContent era -> [TxOut era]
txOuts
  , forall era. TxBodyContent era -> Maybe TxTotalCollateral
txTotalCollateral
  , forall era. TxBodyContent era -> Maybe (TxReturnCollateral era)
txReturnCollateral
  , forall era. TxBodyContent era -> Coin
txFee
  , forall era. TxBodyContent era -> Maybe SlotNo
txValidityLowerBound
  , forall era. TxBodyContent era -> Maybe SlotNo
txValidityUpperBound
  , forall era. TxBodyContent era -> TxMetadata
txMetadata
  , forall era. TxBodyContent era -> [SimpleScript era]
txAuxScripts
  , forall era. TxBodyContent era -> TxExtraKeyWitnesses
txExtraKeyWits
  , forall era. TxBodyContent era -> Maybe (PParams era)
txProtocolParams
  , forall era. TxBodyContent era -> TxWithdrawals era
txWithdrawals
  , forall era. TxBodyContent era -> TxCertificates era
txCertificates
  , forall era. TxBodyContent era -> TxMintValue era
txMintValue
  , forall era. TxBodyContent era -> ScriptValidity
txScriptValidity
  , forall era. TxBodyContent era -> Maybe (TxProposalProcedures era)
txProposalProcedures
  , forall era. TxBodyContent era -> Maybe (TxVotingProcedures era)
txVotingProcedures
  , forall era. TxBodyContent era -> Maybe Coin
txCurrentTreasuryValue
  , forall era. TxBodyContent era -> Maybe Coin
txTreasuryDonation
  , forall era.
TxBodyContent era -> Map (SafeHash EraIndependentData) (Data era)
txSupplementalDatums
  , forall era. TxBodyContent era -> OSet (Credential Guard)
txGuards
  , forall era. TxBodyContent era -> OMap TxId (Tx SubTx era)
txSubTransactions
  , forall era.
TxBodyContent era
-> Map (Credential Guard) (StrictMaybe (Data era))
txRequiredTopLevelGuards
  , forall era. TxBodyContent era -> DirectDeposits
txDirectDeposits
  , forall era. TxBodyContent era -> AccountBalanceIntervals era
txAccountBalanceIntervals
  , forall era. TxBodyContent era -> AccountBalanceIntervals era
txStartingAccountBalanceIntervals
  } =
  BodyContent
    { bcIns = txIns
    , bcInsReference = txInsReference
    , bcOuts = txOuts
    , bcValidityLowerBound = txValidityLowerBound
    , bcValidityUpperBound = txValidityUpperBound
    , bcMetadata = txMetadata
    , bcAuxScripts = txAuxScripts
    , bcProtocolParams = txProtocolParams
    , bcWithdrawals = txWithdrawals
    , bcCertificates = txCertificates
    , bcMintValue = txMintValue
    , bcProposalProcedures = txProposalProcedures
    , bcVotingProcedures = txVotingProcedures
    , bcCurrentTreasuryValue = txCurrentTreasuryValue
    , bcTreasuryDonation = txTreasuryDonation
    , bcSupplementalDatums = txSupplementalDatums
    , bcGuards = txGuards
    , bcRequiredTopLevelGuards = txRequiredTopLevelGuards
    , bcDirectDeposits = txDirectDeposits
    , bcAccountBalanceIntervals = txAccountBalanceIntervals
    , bcTopTxOnlyFields =
      TopTxFields
        { tlInsCollateral = txInsCollateral
        , tlTotalCollateral = txTotalCollateral
        , tlReturnCollateral = txReturnCollateral
        , tlFee = txFee
        , tlExtraKeyWits = txExtraKeyWits
        , tlScriptValidity = txScriptValidity
        , tlSubTransactions = txSubTransactions
        , tlStartingAccountBalanceIntervals = txStartingAccountBalanceIntervals
        }
    }

{-# COMPLETE TxBodyContent #-}

-- | A sub-transaction body as one flat record.
pattern SubTxBodyContent
  :: [(TxIn, AnyWitness era)]
  -> TxInsReference era
  -> [TxOut era]
  -> Maybe L.SlotNo
  -> Maybe L.SlotNo
  -> TxMetadata
  -> [SimpleScript era]
  -> Maybe (L.PParams era)
  -> TxWithdrawals era
  -> TxCertificates era
  -> TxMintValue era
  -> Maybe (TxProposalProcedures era)
  -> Maybe (TxVotingProcedures era)
  -> Maybe L.Coin
  -> Maybe L.Coin
  -> Map L.DataHash (L.Data era)
  -> OSet (L.Credential L.Guard)
  -> Map (L.Credential L.Guard) (StrictMaybe (L.Data era))
  -> L.DirectDeposits
  -> L.AccountBalanceIntervals era
  -> SubTxBodyContent era
pattern $bSubTxBodyContent :: forall era.
[(TxIn, AnyWitness era)]
-> TxInsReference era
-> [TxOut era]
-> Maybe SlotNo
-> Maybe SlotNo
-> TxMetadata
-> [SimpleScript era]
-> Maybe (PParams era)
-> TxWithdrawals era
-> TxCertificates era
-> TxMintValue era
-> Maybe (TxProposalProcedures era)
-> Maybe (TxVotingProcedures era)
-> Maybe Coin
-> Maybe Coin
-> Map (SafeHash EraIndependentData) (Data era)
-> OSet (Credential Guard)
-> Map (Credential Guard) (StrictMaybe (Data era))
-> DirectDeposits
-> AccountBalanceIntervals era
-> SubTxBodyContent era
$mSubTxBodyContent :: forall {r} {era}.
SubTxBodyContent era
-> ([(TxIn, AnyWitness era)]
    -> TxInsReference era
    -> [TxOut era]
    -> Maybe SlotNo
    -> Maybe SlotNo
    -> TxMetadata
    -> [SimpleScript era]
    -> Maybe (PParams era)
    -> TxWithdrawals era
    -> TxCertificates era
    -> TxMintValue era
    -> Maybe (TxProposalProcedures era)
    -> Maybe (TxVotingProcedures era)
    -> Maybe Coin
    -> Maybe Coin
    -> Map (SafeHash EraIndependentData) (Data era)
    -> OSet (Credential Guard)
    -> Map (Credential Guard) (StrictMaybe (Data era))
    -> DirectDeposits
    -> AccountBalanceIntervals era
    -> r)
-> ((# #) -> r)
-> r
SubTxBodyContent
  { forall era. SubTxBodyContent era -> [(TxIn, AnyWitness era)]
subTxIns
  , forall era. SubTxBodyContent era -> TxInsReference era
subTxInsReference
  , forall era. SubTxBodyContent era -> [TxOut era]
subTxOuts
  , forall era. SubTxBodyContent era -> Maybe SlotNo
subTxValidityLowerBound
  , forall era. SubTxBodyContent era -> Maybe SlotNo
subTxValidityUpperBound
  , forall era. SubTxBodyContent era -> TxMetadata
subTxMetadata
  , forall era. SubTxBodyContent era -> [SimpleScript era]
subTxAuxScripts
  , forall era. SubTxBodyContent era -> Maybe (PParams era)
subTxProtocolParams
  , forall era. SubTxBodyContent era -> TxWithdrawals era
subTxWithdrawals
  , forall era. SubTxBodyContent era -> TxCertificates era
subTxCertificates
  , forall era. SubTxBodyContent era -> TxMintValue era
subTxMintValue
  , forall era.
SubTxBodyContent era -> Maybe (TxProposalProcedures era)
subTxProposalProcedures
  , forall era. SubTxBodyContent era -> Maybe (TxVotingProcedures era)
subTxVotingProcedures
  , forall era. SubTxBodyContent era -> Maybe Coin
subTxCurrentTreasuryValue
  , forall era. SubTxBodyContent era -> Maybe Coin
subTxTreasuryDonation
  , forall era.
SubTxBodyContent era
-> Map (SafeHash EraIndependentData) (Data era)
subTxSupplementalDatums
  , forall era. SubTxBodyContent era -> OSet (Credential Guard)
subTxGuards
  , forall era.
SubTxBodyContent era
-> Map (Credential Guard) (StrictMaybe (Data era))
subTxRequiredTopLevelGuards
  , forall era. SubTxBodyContent era -> DirectDeposits
subTxDirectDeposits
  , forall era. SubTxBodyContent era -> AccountBalanceIntervals era
subTxAccountBalanceIntervals
  } =
  BodyContent
    { bcIns = subTxIns
    , bcInsReference = subTxInsReference
    , bcOuts = subTxOuts
    , bcValidityLowerBound = subTxValidityLowerBound
    , bcValidityUpperBound = subTxValidityUpperBound
    , bcMetadata = subTxMetadata
    , bcAuxScripts = subTxAuxScripts
    , bcProtocolParams = subTxProtocolParams
    , bcWithdrawals = subTxWithdrawals
    , bcCertificates = subTxCertificates
    , bcMintValue = subTxMintValue
    , bcProposalProcedures = subTxProposalProcedures
    , bcVotingProcedures = subTxVotingProcedures
    , bcCurrentTreasuryValue = subTxCurrentTreasuryValue
    , bcTreasuryDonation = subTxTreasuryDonation
    , bcSupplementalDatums = subTxSupplementalDatums
    , bcGuards = subTxGuards
    , bcRequiredTopLevelGuards = subTxRequiredTopLevelGuards
    , bcDirectDeposits = subTxDirectDeposits
    , bcAccountBalanceIntervals = subTxAccountBalanceIntervals
    , bcTopTxOnlyFields = AbsentInSubTx
    }

{-# COMPLETE SubTxBodyContent #-}

defaultTxBodyContent :: TxBodyContent era
defaultTxBodyContent :: forall era. TxBodyContent era
defaultTxBodyContent =
  TopTxOnlyFields TopTx era -> BodyContent TopTx era
forall (l :: TxLevel) era.
TopTxOnlyFields l era -> BodyContent l era
defaultBodyContent
    TopTxFields
      { tlInsCollateral :: [TxIn]
tlInsCollateral = []
      , tlTotalCollateral :: Maybe TxTotalCollateral
tlTotalCollateral = Maybe TxTotalCollateral
forall a. Maybe a
Nothing
      , tlReturnCollateral :: Maybe (TxReturnCollateral era)
tlReturnCollateral = Maybe (TxReturnCollateral era)
forall a. Maybe a
Nothing
      , tlFee :: Coin
tlFee = Coin
0
      , tlExtraKeyWits :: TxExtraKeyWitnesses
tlExtraKeyWits = [Hash PaymentKey] -> TxExtraKeyWitnesses
TxExtraKeyWitnesses []
      , tlScriptValidity :: ScriptValidity
tlScriptValidity = ScriptValidity
ScriptValid
      , tlSubTransactions :: OMap TxId (Tx SubTx era)
tlSubTransactions = OMap TxId (Tx SubTx era)
forall k v. OMap k v
LOMap.empty
      , tlStartingAccountBalanceIntervals :: AccountBalanceIntervals era
tlStartingAccountBalanceIntervals = Map AccountAddress (AccountBalanceInterval era)
-> AccountBalanceIntervals era
forall era.
Map AccountAddress (AccountBalanceInterval era)
-> AccountBalanceIntervals era
L.AccountBalanceIntervals Map AccountAddress (AccountBalanceInterval era)
forall a. Monoid a => a
mempty
      }

defaultSubTxBodyContent :: SubTxBodyContent era
defaultSubTxBodyContent :: forall era. SubTxBodyContent era
defaultSubTxBodyContent = TopTxOnlyFields SubTx era -> BodyContent SubTx era
forall (l :: TxLevel) era.
TopTxOnlyFields l era -> BodyContent l era
defaultBodyContent TopTxOnlyFields SubTx era
forall era. TopTxOnlyFields SubTx era
AbsentInSubTx

-- | Empty shared fields around the given top-level-only fields.
defaultBodyContent :: TopTxOnlyFields l era -> BodyContent l era
defaultBodyContent :: forall (l :: TxLevel) era.
TopTxOnlyFields l era -> BodyContent l era
defaultBodyContent TopTxOnlyFields l era
topTxOnlyFields =
  BodyContent
    { bcIns :: [(TxIn, AnyWitness era)]
bcIns = []
    , bcInsReference :: TxInsReference era
bcInsReference = [TxIn] -> Set (Datum CtxTx era) -> TxInsReference era
forall era. [TxIn] -> Set (Datum CtxTx era) -> TxInsReference era
TxInsReference [TxIn]
forall a. Monoid a => a
mempty Set (Datum CtxTx era)
forall a. Set a
Set.empty
    , bcOuts :: [TxOut era]
bcOuts = []
    , bcValidityLowerBound :: Maybe SlotNo
bcValidityLowerBound = Maybe SlotNo
forall a. Maybe a
Nothing
    , bcValidityUpperBound :: Maybe SlotNo
bcValidityUpperBound = Maybe SlotNo
forall a. Maybe a
Nothing
    , bcMetadata :: TxMetadata
bcMetadata = Map Word64 TxMetadataValue -> TxMetadata
TxMetadata Map Word64 TxMetadataValue
forall a. Monoid a => a
mempty
    , bcAuxScripts :: [SimpleScript era]
bcAuxScripts = []
    , bcProtocolParams :: Maybe (PParams era)
bcProtocolParams = Maybe (PParams era)
forall a. Maybe a
Nothing
    , bcWithdrawals :: TxWithdrawals era
bcWithdrawals = [(StakeAddress, Coin, AnyWitness era)] -> TxWithdrawals era
forall era.
[(StakeAddress, Coin, AnyWitness era)] -> TxWithdrawals era
TxWithdrawals [(StakeAddress, Coin, AnyWitness era)]
forall a. Monoid a => a
mempty
    , bcCertificates :: TxCertificates era
bcCertificates = OMap (Certificate era) (Maybe (AnyWitness era))
-> TxCertificates era
forall era.
OMap (Certificate era) (Maybe (AnyWitness era))
-> TxCertificates era
TxCertificates OMap (Certificate era) (Maybe (AnyWitness era))
forall k v. OMap k v
OMap.empty
    , bcMintValue :: TxMintValue era
bcMintValue = Map PolicyId (PolicyAssets, AnyScriptWitness era)
-> TxMintValue era
forall era.
Map PolicyId (PolicyAssets, AnyScriptWitness era)
-> TxMintValue era
TxMintValue Map PolicyId (PolicyAssets, AnyScriptWitness era)
forall a. Monoid a => a
mempty
    , bcProposalProcedures :: Maybe (TxProposalProcedures era)
bcProposalProcedures = Maybe (TxProposalProcedures era)
forall a. Maybe a
Nothing
    , bcVotingProcedures :: Maybe (TxVotingProcedures era)
bcVotingProcedures = Maybe (TxVotingProcedures era)
forall a. Maybe a
Nothing
    , bcCurrentTreasuryValue :: Maybe Coin
bcCurrentTreasuryValue = Maybe Coin
forall a. Maybe a
Nothing
    , bcTreasuryDonation :: Maybe Coin
bcTreasuryDonation = Maybe Coin
forall a. Maybe a
Nothing
    , bcSupplementalDatums :: Map (SafeHash EraIndependentData) (Data era)
bcSupplementalDatums = Map (SafeHash EraIndependentData) (Data era)
forall a. Monoid a => a
mempty
    , bcGuards :: OSet (Credential Guard)
bcGuards = OSet (Credential Guard)
forall a. OSet a
OSet.empty
    , bcRequiredTopLevelGuards :: Map (Credential Guard) (StrictMaybe (Data era))
bcRequiredTopLevelGuards = Map (Credential Guard) (StrictMaybe (Data era))
forall a. Monoid a => a
mempty
    , bcDirectDeposits :: DirectDeposits
bcDirectDeposits = Map AccountAddress Coin -> DirectDeposits
L.DirectDeposits Map AccountAddress Coin
forall a. Monoid a => a
mempty
    , bcAccountBalanceIntervals :: AccountBalanceIntervals era
bcAccountBalanceIntervals = Map AccountAddress (AccountBalanceInterval era)
-> AccountBalanceIntervals era
forall era.
Map AccountAddress (AccountBalanceInterval era)
-> AccountBalanceIntervals era
L.AccountBalanceIntervals Map AccountAddress (AccountBalanceInterval era)
forall a. Monoid a => a
mempty
    , bcTopTxOnlyFields :: TopTxOnlyFields l era
bcTopTxOnlyFields = TopTxOnlyFields l era
topTxOnlyFields
    }

extractAllIndexedPlutusScriptWitnesses
  :: forall era
   . Era era
  -> TxBodyContent (LedgerEra era)
  -> Either
       CBOR.DecoderError
       [AnyIndexedPlutusScriptWitness (LedgerEra era)]
extractAllIndexedPlutusScriptWitnesses :: forall era.
Era era
-> TxBodyContent (LedgerEra era)
-> Either
     DecoderError [AnyIndexedPlutusScriptWitness (LedgerEra era)]
extractAllIndexedPlutusScriptWitnesses Era era
era TxBodyContent (LedgerEra era)
b = Era era
-> (EraCommonConstraints era =>
    Either
      DecoderError [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> Either
     DecoderError [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints Era era
era ((EraCommonConstraints era =>
  Either
    DecoderError [AnyIndexedPlutusScriptWitness (LedgerEra era)])
 -> Either
      DecoderError [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> (EraCommonConstraints era =>
    Either
      DecoderError [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> Either
     DecoderError [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall a b. (a -> b) -> a -> b
$ do
  let txInWits :: [(Witnessable 'TxInItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
txInWits = [(TxIn, AnyWitness (LedgerEra era))]
-> [(Witnessable 'TxInItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era.
IsEra era =>
[(TxIn, AnyWitness (LedgerEra era))]
-> [(Witnessable 'TxInItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableTxIns ([(TxIn, AnyWitness (LedgerEra era))]
 -> [(Witnessable 'TxInItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> [(TxIn, AnyWitness (LedgerEra era))]
-> [(Witnessable 'TxInItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall a b. (a -> b) -> a -> b
$ TxBodyContent (LedgerEra era)
-> [(TxIn, AnyWitness (LedgerEra era))]
forall era. TxBodyContent era -> [(TxIn, AnyWitness era)]
txIns TxBodyContent (LedgerEra era)
b
      certWits :: [(Witnessable 'CertItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
certWits = TxCertificates (LedgerEra era)
-> [(Witnessable 'CertItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era.
IsEra era =>
TxCertificates (LedgerEra era)
-> [(Witnessable 'CertItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableCertificates (TxCertificates (LedgerEra era)
 -> [(Witnessable 'CertItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> TxCertificates (LedgerEra era)
-> [(Witnessable 'CertItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall a b. (a -> b) -> a -> b
$ TxBodyContent (LedgerEra era) -> TxCertificates (LedgerEra era)
forall era. TxBodyContent era -> TxCertificates era
txCertificates TxBodyContent (LedgerEra era)
b
      mintWits :: [(Witnessable 'MintItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
mintWits = [(Witnessable 'MintItem (LedgerEra era)
wit, AnyScriptWitness (LedgerEra era) -> AnyWitness (LedgerEra era)
forall era. AnyScriptWitness era -> AnyWitness era
anyScriptWitnessToAnyWitness AnyScriptWitness (LedgerEra era)
sw) | (Witnessable 'MintItem (LedgerEra era)
wit, AnyScriptWitness (LedgerEra era)
sw) <- TxMintValue (LedgerEra era)
-> [(Witnessable 'MintItem (LedgerEra era),
     AnyScriptWitness (LedgerEra era))]
forall era.
IsEra era =>
TxMintValue (LedgerEra era)
-> [(Witnessable 'MintItem (LedgerEra era),
     AnyScriptWitness (LedgerEra era))]
extractWitnessableMints (TxMintValue (LedgerEra era)
 -> [(Witnessable 'MintItem (LedgerEra era),
      AnyScriptWitness (LedgerEra era))])
-> TxMintValue (LedgerEra era)
-> [(Witnessable 'MintItem (LedgerEra era),
     AnyScriptWitness (LedgerEra era))]
forall a b. (a -> b) -> a -> b
$ TxBodyContent (LedgerEra era) -> TxMintValue (LedgerEra era)
forall era. TxBodyContent era -> TxMintValue era
txMintValue TxBodyContent (LedgerEra era)
b]
      withdrawalWits :: [(Witnessable 'WithdrawalItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
withdrawalWits = TxWithdrawals (LedgerEra era)
-> [(Witnessable 'WithdrawalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era.
IsEra era =>
TxWithdrawals (LedgerEra era)
-> [(Witnessable 'WithdrawalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableWithdrawals (TxWithdrawals (LedgerEra era)
 -> [(Witnessable 'WithdrawalItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> TxWithdrawals (LedgerEra era)
-> [(Witnessable 'WithdrawalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall a b. (a -> b) -> a -> b
$ TxBodyContent (LedgerEra era) -> TxWithdrawals (LedgerEra era)
forall era. TxBodyContent era -> TxWithdrawals era
txWithdrawals TxBodyContent (LedgerEra era)
b
      proposalScriptWits :: [(Witnessable 'ProposalItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
proposalScriptWits = Maybe (TxProposalProcedures (LedgerEra era))
-> [(Witnessable 'ProposalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era.
IsEra era =>
Maybe (TxProposalProcedures (LedgerEra era))
-> [(Witnessable 'ProposalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableProposals (Maybe (TxProposalProcedures (LedgerEra era))
 -> [(Witnessable 'ProposalItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> Maybe (TxProposalProcedures (LedgerEra era))
-> [(Witnessable 'ProposalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall a b. (a -> b) -> a -> b
$ TxBodyContent (LedgerEra era)
-> Maybe (TxProposalProcedures (LedgerEra era))
forall era. TxBodyContent era -> Maybe (TxProposalProcedures era)
txProposalProcedures TxBodyContent (LedgerEra era)
b
      voteWits :: [(Witnessable 'VoterItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
voteWits = Maybe (TxVotingProcedures (LedgerEra era))
-> [(Witnessable 'VoterItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era.
IsEra era =>
Maybe (TxVotingProcedures (LedgerEra era))
-> [(Witnessable 'VoterItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableVotes (Maybe (TxVotingProcedures (LedgerEra era))
 -> [(Witnessable 'VoterItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> Maybe (TxVotingProcedures (LedgerEra era))
-> [(Witnessable 'VoterItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall a b. (a -> b) -> a -> b
$ TxBodyContent (LedgerEra era)
-> Maybe (TxVotingProcedures (LedgerEra era))
forall era. TxBodyContent era -> Maybe (TxVotingProcedures era)
txVotingProcedures TxBodyContent (LedgerEra era)
b

  let indexedScriptTxInWits :: [AnyIndexedPlutusScriptWitness (LedgerEra era)]
indexedScriptTxInWits = Era era
-> (EraCommonConstraints era =>
    [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints Era era
era ((EraCommonConstraints era =>
  [AnyIndexedPlutusScriptWitness (LedgerEra era)])
 -> [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> (EraCommonConstraints era =>
    [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall a b. (a -> b) -> a -> b
$ [(Witnessable 'TxInItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall era (witnessable :: WitnessableItem).
AlonzoEraScript era =>
[(Witnessable witnessable era, AnyWitness era)]
-> [AnyIndexedPlutusScriptWitness era]
createIndexedPlutusScriptWitnesses [(Witnessable 'TxInItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
txInWits
      indexedCertScriptWits :: [AnyIndexedPlutusScriptWitness (LedgerEra era)]
indexedCertScriptWits = Era era
-> (EraCommonConstraints era =>
    [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints Era era
era ((EraCommonConstraints era =>
  [AnyIndexedPlutusScriptWitness (LedgerEra era)])
 -> [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> (EraCommonConstraints era =>
    [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall a b. (a -> b) -> a -> b
$ [(Witnessable 'CertItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall era (witnessable :: WitnessableItem).
AlonzoEraScript era =>
[(Witnessable witnessable era, AnyWitness era)]
-> [AnyIndexedPlutusScriptWitness era]
createIndexedPlutusScriptWitnesses [(Witnessable 'CertItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
certWits
      indexedMintScriptWits :: [AnyIndexedPlutusScriptWitness (LedgerEra era)]
indexedMintScriptWits = Era era
-> (EraCommonConstraints era =>
    [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints Era era
era ((EraCommonConstraints era =>
  [AnyIndexedPlutusScriptWitness (LedgerEra era)])
 -> [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> (EraCommonConstraints era =>
    [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall a b. (a -> b) -> a -> b
$ [(Witnessable 'MintItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall era (witnessable :: WitnessableItem).
AlonzoEraScript era =>
[(Witnessable witnessable era, AnyWitness era)]
-> [AnyIndexedPlutusScriptWitness era]
createIndexedPlutusScriptWitnesses [(Witnessable 'MintItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
mintWits
      indexedWithdrawalScriptWits :: [AnyIndexedPlutusScriptWitness (LedgerEra era)]
indexedWithdrawalScriptWits = Era era
-> (EraCommonConstraints era =>
    [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints Era era
era ((EraCommonConstraints era =>
  [AnyIndexedPlutusScriptWitness (LedgerEra era)])
 -> [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> (EraCommonConstraints era =>
    [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall a b. (a -> b) -> a -> b
$ [(Witnessable 'WithdrawalItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall era (witnessable :: WitnessableItem).
AlonzoEraScript era =>
[(Witnessable witnessable era, AnyWitness era)]
-> [AnyIndexedPlutusScriptWitness era]
createIndexedPlutusScriptWitnesses [(Witnessable 'WithdrawalItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
withdrawalWits
      indexedProposalScriptWits :: [AnyIndexedPlutusScriptWitness (LedgerEra era)]
indexedProposalScriptWits = Era era
-> (EraCommonConstraints era =>
    [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints Era era
era ((EraCommonConstraints era =>
  [AnyIndexedPlutusScriptWitness (LedgerEra era)])
 -> [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> (EraCommonConstraints era =>
    [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall a b. (a -> b) -> a -> b
$ [(Witnessable 'ProposalItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall era (witnessable :: WitnessableItem).
AlonzoEraScript era =>
[(Witnessable witnessable era, AnyWitness era)]
-> [AnyIndexedPlutusScriptWitness era]
createIndexedPlutusScriptWitnesses [(Witnessable 'ProposalItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
proposalScriptWits
      indexedVoteScriptWits :: [AnyIndexedPlutusScriptWitness (LedgerEra era)]
indexedVoteScriptWits = Era era
-> (EraCommonConstraints era =>
    [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints Era era
era ((EraCommonConstraints era =>
  [AnyIndexedPlutusScriptWitness (LedgerEra era)])
 -> [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> (EraCommonConstraints era =>
    [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall a b. (a -> b) -> a -> b
$ [(Witnessable 'VoterItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall era (witnessable :: WitnessableItem).
AlonzoEraScript era =>
[(Witnessable witnessable era, AnyWitness era)]
-> [AnyIndexedPlutusScriptWitness era]
createIndexedPlutusScriptWitnesses [(Witnessable 'VoterItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
voteWits
  [AnyIndexedPlutusScriptWitness (LedgerEra era)]
-> Either
     DecoderError [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall a. a -> Either DecoderError a
forall (m :: * -> *) a. Monad m => a -> m a
return ([AnyIndexedPlutusScriptWitness (LedgerEra era)]
 -> Either
      DecoderError [AnyIndexedPlutusScriptWitness (LedgerEra era)])
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
-> Either
     DecoderError [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall a b. (a -> b) -> a -> b
$
    [[AnyIndexedPlutusScriptWitness (LedgerEra era)]]
-> [AnyIndexedPlutusScriptWitness (LedgerEra era)]
forall a. Monoid a => [a] -> a
mconcat
      [ [AnyIndexedPlutusScriptWitness (LedgerEra era)]
indexedScriptTxInWits
      , [AnyIndexedPlutusScriptWitness (LedgerEra era)]
indexedMintScriptWits
      , [AnyIndexedPlutusScriptWitness (LedgerEra era)]
indexedCertScriptWits
      , [AnyIndexedPlutusScriptWitness (LedgerEra era)]
indexedWithdrawalScriptWits
      , [AnyIndexedPlutusScriptWitness (LedgerEra era)]
indexedProposalScriptWits
      , [AnyIndexedPlutusScriptWitness (LedgerEra era)]
indexedVoteScriptWits
      ]

extractWitnessableTxIns
  :: forall era
   . IsEra era
  => [(TxIn, AnyWitness (LedgerEra era))]
  -> [(Witnessable TxInItem (LedgerEra era), AnyWitness (LedgerEra era))]
extractWitnessableTxIns :: forall era.
IsEra era =>
[(TxIn, AnyWitness (LedgerEra era))]
-> [(Witnessable 'TxInItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableTxIns [(TxIn, AnyWitness (LedgerEra era))]
tIns =
  Era era
-> (EraCommonConstraints era =>
    [(Witnessable 'TxInItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> [(Witnessable 'TxInItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era =>
  [(Witnessable 'TxInItem (LedgerEra era),
    AnyWitness (LedgerEra era))])
 -> [(Witnessable 'TxInItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> (EraCommonConstraints era =>
    [(Witnessable 'TxInItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> [(Witnessable 'TxInItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall a b. (a -> b) -> a -> b
$
    [(Witnessable 'TxInItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> [(Witnessable 'TxInItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall a. Eq a => [a] -> [a]
List.nub [(TxIn -> Witnessable 'TxInItem (LedgerEra era)
forall era.
AlonzoEraScript era =>
TxIn -> Witnessable 'TxInItem era
WitTxIn TxIn
txin, AnyWitness (LedgerEra era)
wit) | (TxIn
txin, AnyWitness (LedgerEra era)
wit) <- [(TxIn, AnyWitness (LedgerEra era))]
tIns]

-- | Wrap every certificate as a 'Witnessable', paired with its witness.
--
-- An unwitnessed certificate still occupies a redeemer index slot: the
-- ledger indexes the 'Certifying' purpose by position in the full
-- certificate sequence, not just the witnessed subset, so the result below
-- keeps one entry per certificate in insertion order.
--
-- In the Conway era only, a certificate may legitimately have no witness
-- (deposit-less stake registration), so a missing witness defaults to
-- 'AnyKeyWitnessPlaceholder'. From Dijkstra onwards 'mkTxCertificates'
-- guarantees every entry has a 'Just' witness, so the placeholder is dead
-- code for those eras.
extractWitnessableCertificates
  :: forall era
   . IsEra era
  => TxCertificates (LedgerEra era)
  -> [(Witnessable CertItem (LedgerEra era), AnyWitness (LedgerEra era))]
extractWitnessableCertificates :: forall era.
IsEra era =>
TxCertificates (LedgerEra era)
-> [(Witnessable 'CertItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableCertificates (TxCertificates OMap
  (Certificate (LedgerEra era)) (Maybe (AnyWitness (LedgerEra era)))
certs) =
  Era era
-> (EraCommonConstraints era =>
    [(Witnessable 'CertItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> [(Witnessable 'CertItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era =>
  [(Witnessable 'CertItem (LedgerEra era),
    AnyWitness (LedgerEra era))])
 -> [(Witnessable 'CertItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> (EraCommonConstraints era =>
    [(Witnessable 'CertItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> [(Witnessable 'CertItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall a b. (a -> b) -> a -> b
$
    [(Witnessable 'CertItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> [(Witnessable 'CertItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall a. Eq a => [a] -> [a]
List.nub
      [ (TxCert (LedgerEra era) -> Witnessable 'CertItem (LedgerEra era)
forall era.
(EraTxCert era, AlonzoEraScript era) =>
TxCert era -> Witnessable 'CertItem era
WitTxCert TxCert (LedgerEra era)
cert, AnyWitness (LedgerEra era)
wit)
      | (Exp.Certificate TxCert (LedgerEra era)
cert, Maybe (AnyWitness (LedgerEra era))
mWit) <- OMap
  (Certificate (LedgerEra era)) (Maybe (AnyWitness (LedgerEra era)))
-> [Item
      (OMap
         (Certificate (LedgerEra era))
         (Maybe (AnyWitness (LedgerEra era))))]
forall l. IsList l => l -> [Item l]
toList OMap
  (Certificate (LedgerEra era)) (Maybe (AnyWitness (LedgerEra era)))
certs
      , let wit :: AnyWitness (LedgerEra era)
wit = AnyWitness (LedgerEra era)
-> Maybe (AnyWitness (LedgerEra era)) -> AnyWitness (LedgerEra era)
forall a. a -> Maybe a -> a
fromMaybe AnyWitness (LedgerEra era)
forall era. AnyWitness era
AnyKeyWitnessPlaceholder Maybe (AnyWitness (LedgerEra era))
mWit
      ]

extractWitnessableMints
  :: forall era
   . IsEra era
  => TxMintValue (LedgerEra era)
  -> [(Witnessable MintItem (LedgerEra era), AnyScriptWitness (LedgerEra era))]
extractWitnessableMints :: forall era.
IsEra era =>
TxMintValue (LedgerEra era)
-> [(Witnessable 'MintItem (LedgerEra era),
     AnyScriptWitness (LedgerEra era))]
extractWitnessableMints TxMintValue (LedgerEra era)
mVal =
  Era era
-> (EraCommonConstraints era =>
    [(Witnessable 'MintItem (LedgerEra era),
      AnyScriptWitness (LedgerEra era))])
-> [(Witnessable 'MintItem (LedgerEra era),
     AnyScriptWitness (LedgerEra era))]
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era =>
  [(Witnessable 'MintItem (LedgerEra era),
    AnyScriptWitness (LedgerEra era))])
 -> [(Witnessable 'MintItem (LedgerEra era),
      AnyScriptWitness (LedgerEra era))])
-> (EraCommonConstraints era =>
    [(Witnessable 'MintItem (LedgerEra era),
      AnyScriptWitness (LedgerEra era))])
-> [(Witnessable 'MintItem (LedgerEra era),
     AnyScriptWitness (LedgerEra era))]
forall a b. (a -> b) -> a -> b
$
    [(Witnessable 'MintItem (LedgerEra era),
  AnyScriptWitness (LedgerEra era))]
-> [(Witnessable 'MintItem (LedgerEra era),
     AnyScriptWitness (LedgerEra era))]
forall a. Eq a => [a] -> [a]
List.nub
      [ (PolicyId -> PolicyAssets -> Witnessable 'MintItem (LedgerEra era)
forall era.
AlonzoEraScript era =>
PolicyId -> PolicyAssets -> Witnessable 'MintItem era
WitMint PolicyId
policyId PolicyAssets
policyAssets, AnyScriptWitness (LedgerEra era)
wit)
      | (PolicyId
policyId, (PolicyAssets
policyAssets, AnyScriptWitness (LedgerEra era)
wit)) <- TxMintValue (LedgerEra era)
-> [(PolicyId, (PolicyAssets, AnyScriptWitness (LedgerEra era)))]
forall {era}.
TxMintValue era
-> [(PolicyId, (PolicyAssets, AnyScriptWitness era))]
getMints TxMintValue (LedgerEra era)
mVal
      ]
 where
  getMints :: TxMintValue era
-> [Item (Map PolicyId (PolicyAssets, AnyScriptWitness era))]
getMints (TxMintValue Map PolicyId (PolicyAssets, AnyScriptWitness era)
txms) = Map PolicyId (PolicyAssets, AnyScriptWitness era)
-> [Item (Map PolicyId (PolicyAssets, AnyScriptWitness era))]
forall l. IsList l => l -> [Item l]
toList Map PolicyId (PolicyAssets, AnyScriptWitness era)
txms

extractWitnessableWithdrawals
  :: forall era
   . IsEra era
  => TxWithdrawals (LedgerEra era)
  -> [(Witnessable WithdrawalItem (LedgerEra era), AnyWitness (LedgerEra era))]
extractWitnessableWithdrawals :: forall era.
IsEra era =>
TxWithdrawals (LedgerEra era)
-> [(Witnessable 'WithdrawalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableWithdrawals TxWithdrawals (LedgerEra era)
txWithDrawals =
  Era era
-> (EraCommonConstraints era =>
    [(Witnessable 'WithdrawalItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> [(Witnessable 'WithdrawalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era =>
  [(Witnessable 'WithdrawalItem (LedgerEra era),
    AnyWitness (LedgerEra era))])
 -> [(Witnessable 'WithdrawalItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> (EraCommonConstraints era =>
    [(Witnessable 'WithdrawalItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> [(Witnessable 'WithdrawalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall a b. (a -> b) -> a -> b
$
    [(Witnessable 'WithdrawalItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> [(Witnessable 'WithdrawalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall a. Eq a => [a] -> [a]
List.nub
      [ (StakeAddress -> Coin -> Witnessable 'WithdrawalItem (LedgerEra era)
forall era.
AlonzoEraScript era =>
StakeAddress -> Coin -> Witnessable 'WithdrawalItem era
WitWithdrawal StakeAddress
addr Coin
withAmt, AnyWitness (LedgerEra era)
wit)
      | (StakeAddress
addr, Coin
withAmt, AnyWitness (LedgerEra era)
wit) <- TxWithdrawals (LedgerEra era)
-> [(StakeAddress, Coin, AnyWitness (LedgerEra era))]
forall era.
TxWithdrawals era -> [(StakeAddress, Coin, AnyWitness era)]
getWithdrawals TxWithdrawals (LedgerEra era)
txWithDrawals
      ]
 where
  getWithdrawals :: TxWithdrawals era -> [(StakeAddress, Coin, AnyWitness era)]
getWithdrawals (TxWithdrawals [(StakeAddress, Coin, AnyWitness era)]
txws) = [(StakeAddress, Coin, AnyWitness era)]
txws

extractWitnessableVotes
  :: forall era
   . IsEra era
  => Maybe (TxVotingProcedures (LedgerEra era))
  -> [(Witnessable VoterItem (LedgerEra era), AnyWitness (LedgerEra era))]
extractWitnessableVotes :: forall era.
IsEra era =>
Maybe (TxVotingProcedures (LedgerEra era))
-> [(Witnessable 'VoterItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableVotes Maybe (TxVotingProcedures (LedgerEra era))
Nothing = []
extractWitnessableVotes (Just TxVotingProcedures (LedgerEra era)
txVoteProc) =
  Era era
-> (EraCommonConstraints era =>
    [(Witnessable 'VoterItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> [(Witnessable 'VoterItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era =>
  [(Witnessable 'VoterItem (LedgerEra era),
    AnyWitness (LedgerEra era))])
 -> [(Witnessable 'VoterItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> (EraCommonConstraints era =>
    [(Witnessable 'VoterItem (LedgerEra era),
      AnyWitness (LedgerEra era))])
-> [(Witnessable 'VoterItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall a b. (a -> b) -> a -> b
$
    [(Witnessable 'VoterItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> [(Witnessable 'VoterItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall a. Eq a => [a] -> [a]
List.nub
      [ (Voter -> Witnessable 'VoterItem (LedgerEra era)
forall era.
ConwayEraScript era =>
Voter -> Witnessable 'VoterItem era
WitVote Voter
vote, AnyWitness (LedgerEra era)
wit)
      | (Voter
vote, AnyWitness (LedgerEra era)
wit) <- TxVotingProcedures (LedgerEra era)
-> [(Voter, AnyWitness (LedgerEra era))]
getVotes TxVotingProcedures (LedgerEra era)
txVoteProc
      ]
 where
  -- Uses a total 'Map.findWithDefault' (placeholder witness on a miss),
  -- not a lookup that skips missing voters. A skipped voter would shrink
  -- this list and shift every later voter's redeemer index.
  --
  -- 'mkTxVotingProcedures' builds 'scriptWitnessedVotes' in lockstep with
  -- 'allVotingProcedures', assuming exactly one voter per merged
  -- 'L.VotingProcedures' value, so a miss should not normally happen.
  getVotes
    :: TxVotingProcedures (LedgerEra era)
    -> [(L.Voter, AnyWitness (LedgerEra era))]
  getVotes :: TxVotingProcedures (LedgerEra era)
-> [(Voter, AnyWitness (LedgerEra era))]
getVotes (TxVotingProcedures VotingProcedures (LedgerEra era)
allVotingProcedures Map Voter (AnyWitness (LedgerEra era))
scriptWitnessedVotes) =
    [ (Voter
voter, AnyWitness (LedgerEra era)
wit)
    | (Voter
voter, Map GovActionId (VotingProcedure (LedgerEra era))
_) <- Map Voter (Map GovActionId (VotingProcedure (LedgerEra era)))
-> [Item
      (Map Voter (Map GovActionId (VotingProcedure (LedgerEra era))))]
forall l. IsList l => l -> [Item l]
toList (Map Voter (Map GovActionId (VotingProcedure (LedgerEra era)))
 -> [Item
       (Map Voter (Map GovActionId (VotingProcedure (LedgerEra era))))])
-> Map Voter (Map GovActionId (VotingProcedure (LedgerEra era)))
-> [Item
      (Map Voter (Map GovActionId (VotingProcedure (LedgerEra era))))]
forall a b. (a -> b) -> a -> b
$ VotingProcedures (LedgerEra era)
-> Map Voter (Map GovActionId (VotingProcedure (LedgerEra era)))
forall era.
VotingProcedures era
-> Map Voter (Map GovActionId (VotingProcedure era))
L.unVotingProcedures VotingProcedures (LedgerEra era)
allVotingProcedures
    , let wit :: AnyWitness (LedgerEra era)
wit = AnyWitness (LedgerEra era)
-> Voter
-> Map Voter (AnyWitness (LedgerEra era))
-> AnyWitness (LedgerEra era)
forall k a. Ord k => a -> k -> Map k a -> a
Map.findWithDefault AnyWitness (LedgerEra era)
forall era. AnyWitness era
AnyKeyWitnessPlaceholder Voter
voter Map Voter (AnyWitness (LedgerEra era))
scriptWitnessedVotes
    ]

extractWitnessableProposals
  :: forall era
   . IsEra era
  => Maybe
       (TxProposalProcedures (LedgerEra era))
  -> [(Witnessable ProposalItem (LedgerEra era), AnyWitness (LedgerEra era))]
extractWitnessableProposals :: forall era.
IsEra era =>
Maybe (TxProposalProcedures (LedgerEra era))
-> [(Witnessable 'ProposalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableProposals Maybe (TxProposalProcedures (LedgerEra era))
Nothing = []
extractWitnessableProposals (Just TxProposalProcedures (LedgerEra era)
txPropProcedures) =
  [(Witnessable 'ProposalItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> [(Witnessable 'ProposalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall a. Eq a => [a] -> [a]
List.nub
    [ (Era era
-> (EraCommonConstraints era =>
    Witnessable 'ProposalItem (LedgerEra era))
-> Witnessable 'ProposalItem (LedgerEra era)
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) (ProposalProcedure (LedgerEra era)
-> Witnessable 'ProposalItem (LedgerEra era)
forall era.
(ConwayEraScript era, EraPParams era) =>
ProposalProcedure era -> Witnessable 'ProposalItem era
WitProposal ProposalProcedure (LedgerEra era)
prop), AnyWitness (LedgerEra era)
wit)
    | (ProposalProcedure (LedgerEra era)
prop, AnyWitness (LedgerEra era)
wit) <-
        TxProposalProcedures (LedgerEra era)
-> [(ProposalProcedure (LedgerEra era),
     AnyWitness (LedgerEra era))]
getProposals TxProposalProcedures (LedgerEra era)
txPropProcedures
    ]
 where
  getProposals
    :: TxProposalProcedures (LedgerEra era)
    -> [(L.ProposalProcedure (LedgerEra era), AnyWitness (LedgerEra era))]
  getProposals :: TxProposalProcedures (LedgerEra era)
-> [(ProposalProcedure (LedgerEra era),
     AnyWitness (LedgerEra era))]
getProposals (TxProposalProcedures OMap
  (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era))
txps) =
    Era era
-> (EraCommonConstraints era =>
    [(ProposalProcedure (LedgerEra era), AnyWitness (LedgerEra era))])
-> [(ProposalProcedure (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) (OMap
  (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era))
-> [Item
      (OMap
         (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era)))]
forall l. IsList l => l -> [Item l]
toList OMap
  (ProposalProcedure (LedgerEra era)) (AnyWitness (LedgerEra era))
txps)

-- | Collect the script witness requirements of a body at either level. Every
-- field involved is shared between top-level and sub-transaction bodies.
collectTxBodyScriptWitnessRequirements
  :: forall l era
   . IsEra era
  => BodyContent l (LedgerEra era)
  -> TxScriptWitnessRequirements (LedgerEra era)
collectTxBodyScriptWitnessRequirements :: forall (l :: TxLevel) era.
IsEra era =>
BodyContent l (LedgerEra era)
-> TxScriptWitnessRequirements (LedgerEra era)
collectTxBodyScriptWitnessRequirements
  BodyContent
    { [(TxIn, AnyWitness (LedgerEra era))]
bcIns :: forall (l :: TxLevel) era.
BodyContent l era -> [(TxIn, AnyWitness era)]
bcIns :: [(TxIn, AnyWitness (LedgerEra era))]
bcIns
    , TxInsReference (LedgerEra era)
bcInsReference :: forall (l :: TxLevel) era. BodyContent l era -> TxInsReference era
bcInsReference :: TxInsReference (LedgerEra era)
bcInsReference
    , TxCertificates (LedgerEra era)
bcCertificates :: forall (l :: TxLevel) era. BodyContent l era -> TxCertificates era
bcCertificates :: TxCertificates (LedgerEra era)
bcCertificates
    , TxMintValue (LedgerEra era)
bcMintValue :: forall (l :: TxLevel) era. BodyContent l era -> TxMintValue era
bcMintValue :: TxMintValue (LedgerEra era)
bcMintValue
    , TxWithdrawals (LedgerEra era)
bcWithdrawals :: forall (l :: TxLevel) era. BodyContent l era -> TxWithdrawals era
bcWithdrawals :: TxWithdrawals (LedgerEra era)
bcWithdrawals
    , Maybe (TxVotingProcedures (LedgerEra era))
bcVotingProcedures :: forall (l :: TxLevel) era.
BodyContent l era -> Maybe (TxVotingProcedures era)
bcVotingProcedures :: Maybe (TxVotingProcedures (LedgerEra era))
bcVotingProcedures
    , Maybe (TxProposalProcedures (LedgerEra era))
bcProposalProcedures :: forall (l :: TxLevel) era.
BodyContent l era -> Maybe (TxProposalProcedures era)
bcProposalProcedures :: Maybe (TxProposalProcedures (LedgerEra era))
bcProposalProcedures
    , Map (SafeHash EraIndependentData) (Data (LedgerEra era))
bcSupplementalDatums :: forall (l :: TxLevel) era.
BodyContent l era -> Map (SafeHash EraIndependentData) (Data era)
bcSupplementalDatums :: Map (SafeHash EraIndependentData) (Data (LedgerEra era))
bcSupplementalDatums
    } = Era era
-> (EraCommonConstraints era =>
    TxScriptWitnessRequirements (LedgerEra era))
-> TxScriptWitnessRequirements (LedgerEra era)
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era =>
  TxScriptWitnessRequirements (LedgerEra era))
 -> TxScriptWitnessRequirements (LedgerEra era))
-> (EraCommonConstraints era =>
    TxScriptWitnessRequirements (LedgerEra era))
-> TxScriptWitnessRequirements (LedgerEra era)
forall a b. (a -> b) -> a -> b
$ do
    let supplementaldatums :: TxScriptWitnessRequirements (LedgerEra era)
supplementaldatums =
          Set Language
-> [Script (LedgerEra era)]
-> TxDats (LedgerEra era)
-> Redeemers (LedgerEra era)
-> TxScriptWitnessRequirements (LedgerEra era)
forall era.
Set Language
-> [Script era]
-> TxDats era
-> Redeemers era
-> TxScriptWitnessRequirements era
TxScriptWitnessRequirements
            Set Language
forall a. Monoid a => a
mempty
            [Script (LedgerEra era)]
forall a. Monoid a => a
mempty
            (TxInsReference (LedgerEra era)
-> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
-> TxDats (LedgerEra era)
forall era.
IsEra era =>
TxInsReference (LedgerEra era)
-> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
-> TxDats (LedgerEra era)
getDatums TxInsReference (LedgerEra era)
bcInsReference Map (SafeHash EraIndependentData) (Data (LedgerEra era))
bcSupplementalDatums)
            Redeemers (LedgerEra era)
forall a. Monoid a => a
mempty

    let txInWits :: TxScriptWitnessRequirements (LedgerEra era)
txInWits =
          Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
    [(Witnessable 'TxInItem (LedgerEra era),
      AnyWitness (LedgerEra era))]
    -> TxScriptWitnessRequirements (LedgerEra era))
-> [(Witnessable 'TxInItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall era a.
Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) => a) -> a
obtainMonoidConstraint (forall era. IsEra era => Era era
useEra @era) Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
[(Witnessable 'TxInItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
[(Witnessable 'TxInItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall era (witnessable :: WitnessableItem).
(AlonzoEraScript era, Monoid (TxScriptWitnessRequirements era)) =>
[(Witnessable witnessable era, AnyWitness era)]
-> TxScriptWitnessRequirements era
getTxScriptWitnessesRequirements ([(Witnessable 'TxInItem (LedgerEra era),
   AnyWitness (LedgerEra era))]
 -> TxScriptWitnessRequirements (LedgerEra era))
-> [(Witnessable 'TxInItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall a b. (a -> b) -> a -> b
$
            [(TxIn, AnyWitness (LedgerEra era))]
-> [(Witnessable 'TxInItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era.
IsEra era =>
[(TxIn, AnyWitness (LedgerEra era))]
-> [(Witnessable 'TxInItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableTxIns [(TxIn, AnyWitness (LedgerEra era))]
bcIns
        txWithdrawalWits :: TxScriptWitnessRequirements (LedgerEra era)
txWithdrawalWits =
          Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
    [(Witnessable 'WithdrawalItem (LedgerEra era),
      AnyWitness (LedgerEra era))]
    -> TxScriptWitnessRequirements (LedgerEra era))
-> [(Witnessable 'WithdrawalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall era a.
Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) => a) -> a
obtainMonoidConstraint (forall era. IsEra era => Era era
useEra @era) Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
[(Witnessable 'WithdrawalItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
[(Witnessable 'WithdrawalItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall era (witnessable :: WitnessableItem).
(AlonzoEraScript era, Monoid (TxScriptWitnessRequirements era)) =>
[(Witnessable witnessable era, AnyWitness era)]
-> TxScriptWitnessRequirements era
getTxScriptWitnessesRequirements ([(Witnessable 'WithdrawalItem (LedgerEra era),
   AnyWitness (LedgerEra era))]
 -> TxScriptWitnessRequirements (LedgerEra era))
-> [(Witnessable 'WithdrawalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall a b. (a -> b) -> a -> b
$
            TxWithdrawals (LedgerEra era)
-> [(Witnessable 'WithdrawalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era.
IsEra era =>
TxWithdrawals (LedgerEra era)
-> [(Witnessable 'WithdrawalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableWithdrawals TxWithdrawals (LedgerEra era)
bcWithdrawals
        txCertWits :: TxScriptWitnessRequirements (LedgerEra era)
txCertWits =
          Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
    [(Witnessable 'CertItem (LedgerEra era),
      AnyWitness (LedgerEra era))]
    -> TxScriptWitnessRequirements (LedgerEra era))
-> [(Witnessable 'CertItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall era a.
Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) => a) -> a
obtainMonoidConstraint (forall era. IsEra era => Era era
useEra @era) Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
[(Witnessable 'CertItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
[(Witnessable 'CertItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall era (witnessable :: WitnessableItem).
(AlonzoEraScript era, Monoid (TxScriptWitnessRequirements era)) =>
[(Witnessable witnessable era, AnyWitness era)]
-> TxScriptWitnessRequirements era
getTxScriptWitnessesRequirements ([(Witnessable 'CertItem (LedgerEra era),
   AnyWitness (LedgerEra era))]
 -> TxScriptWitnessRequirements (LedgerEra era))
-> [(Witnessable 'CertItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall a b. (a -> b) -> a -> b
$
            TxCertificates (LedgerEra era)
-> [(Witnessable 'CertItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era.
IsEra era =>
TxCertificates (LedgerEra era)
-> [(Witnessable 'CertItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableCertificates TxCertificates (LedgerEra era)
bcCertificates
        txMintWits :: TxScriptWitnessRequirements (LedgerEra era)
txMintWits =
          Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
    [(Witnessable 'MintItem (LedgerEra era),
      AnyWitness (LedgerEra era))]
    -> TxScriptWitnessRequirements (LedgerEra era))
-> [(Witnessable 'MintItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall era a.
Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) => a) -> a
obtainMonoidConstraint (forall era. IsEra era => Era era
useEra @era) Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
[(Witnessable 'MintItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
[(Witnessable 'MintItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall era (witnessable :: WitnessableItem).
(AlonzoEraScript era, Monoid (TxScriptWitnessRequirements era)) =>
[(Witnessable witnessable era, AnyWitness era)]
-> TxScriptWitnessRequirements era
getTxScriptWitnessesRequirements ([(Witnessable 'MintItem (LedgerEra era),
   AnyWitness (LedgerEra era))]
 -> TxScriptWitnessRequirements (LedgerEra era))
-> [(Witnessable 'MintItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall a b. (a -> b) -> a -> b
$
            [(Witnessable 'MintItem (LedgerEra era)
wit, AnyScriptWitness (LedgerEra era) -> AnyWitness (LedgerEra era)
forall era. AnyScriptWitness era -> AnyWitness era
anyScriptWitnessToAnyWitness AnyScriptWitness (LedgerEra era)
sw) | (Witnessable 'MintItem (LedgerEra era)
wit, AnyScriptWitness (LedgerEra era)
sw) <- TxMintValue (LedgerEra era)
-> [(Witnessable 'MintItem (LedgerEra era),
     AnyScriptWitness (LedgerEra era))]
forall era.
IsEra era =>
TxMintValue (LedgerEra era)
-> [(Witnessable 'MintItem (LedgerEra era),
     AnyScriptWitness (LedgerEra era))]
extractWitnessableMints TxMintValue (LedgerEra era)
bcMintValue]
        txVotingWits :: TxScriptWitnessRequirements (LedgerEra era)
txVotingWits =
          Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
    [(Witnessable 'VoterItem (LedgerEra era),
      AnyWitness (LedgerEra era))]
    -> TxScriptWitnessRequirements (LedgerEra era))
-> [(Witnessable 'VoterItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall era a.
Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) => a) -> a
obtainMonoidConstraint (forall era. IsEra era => Era era
useEra @era) Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
[(Witnessable 'VoterItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
[(Witnessable 'VoterItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall era (witnessable :: WitnessableItem).
(AlonzoEraScript era, Monoid (TxScriptWitnessRequirements era)) =>
[(Witnessable witnessable era, AnyWitness era)]
-> TxScriptWitnessRequirements era
getTxScriptWitnessesRequirements ([(Witnessable 'VoterItem (LedgerEra era),
   AnyWitness (LedgerEra era))]
 -> TxScriptWitnessRequirements (LedgerEra era))
-> [(Witnessable 'VoterItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall a b. (a -> b) -> a -> b
$
            Maybe (TxVotingProcedures (LedgerEra era))
-> [(Witnessable 'VoterItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era.
IsEra era =>
Maybe (TxVotingProcedures (LedgerEra era))
-> [(Witnessable 'VoterItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableVotes Maybe (TxVotingProcedures (LedgerEra era))
bcVotingProcedures
        txProposalWits :: TxScriptWitnessRequirements (LedgerEra era)
txProposalWits =
          Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
    [(Witnessable 'ProposalItem (LedgerEra era),
      AnyWitness (LedgerEra era))]
    -> TxScriptWitnessRequirements (LedgerEra era))
-> [(Witnessable 'ProposalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall era a.
Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) => a) -> a
obtainMonoidConstraint (forall era. IsEra era => Era era
useEra @era) Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
[(Witnessable 'ProposalItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
[(Witnessable 'ProposalItem (LedgerEra era),
  AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall era (witnessable :: WitnessableItem).
(AlonzoEraScript era, Monoid (TxScriptWitnessRequirements era)) =>
[(Witnessable witnessable era, AnyWitness era)]
-> TxScriptWitnessRequirements era
getTxScriptWitnessesRequirements ([(Witnessable 'ProposalItem (LedgerEra era),
   AnyWitness (LedgerEra era))]
 -> TxScriptWitnessRequirements (LedgerEra era))
-> [(Witnessable 'ProposalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
-> TxScriptWitnessRequirements (LedgerEra era)
forall a b. (a -> b) -> a -> b
$
            Maybe (TxProposalProcedures (LedgerEra era))
-> [(Witnessable 'ProposalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
forall era.
IsEra era =>
Maybe (TxProposalProcedures (LedgerEra era))
-> [(Witnessable 'ProposalItem (LedgerEra era),
     AnyWitness (LedgerEra era))]
extractWitnessableProposals Maybe (TxProposalProcedures (LedgerEra era))
bcProposalProcedures

    Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
    TxScriptWitnessRequirements (LedgerEra era))
-> TxScriptWitnessRequirements (LedgerEra era)
forall era a.
Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) => a) -> a
obtainMonoidConstraint (forall era. IsEra era => Era era
useEra @era) ((Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
  TxScriptWitnessRequirements (LedgerEra era))
 -> TxScriptWitnessRequirements (LedgerEra era))
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) =>
    TxScriptWitnessRequirements (LedgerEra era))
-> TxScriptWitnessRequirements (LedgerEra era)
forall a b. (a -> b) -> a -> b
$
      [TxScriptWitnessRequirements (LedgerEra era)]
-> TxScriptWitnessRequirements (LedgerEra era)
forall a. Monoid a => [a] -> a
mconcat
        [ TxScriptWitnessRequirements (LedgerEra era)
supplementaldatums
        , TxScriptWitnessRequirements (LedgerEra era)
txInWits
        , TxScriptWitnessRequirements (LedgerEra era)
txWithdrawalWits
        , TxScriptWitnessRequirements (LedgerEra era)
txCertWits
        , TxScriptWitnessRequirements (LedgerEra era)
txMintWits
        , TxScriptWitnessRequirements (LedgerEra era)
txVotingWits
        , TxScriptWitnessRequirements (LedgerEra era)
txProposalWits
        ]

obtainMonoidConstraint
  :: Era era
  -> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) => a)
  -> a
obtainMonoidConstraint :: forall era a.
Era era
-> (Monoid (TxScriptWitnessRequirements (LedgerEra era)) => a) -> a
obtainMonoidConstraint Era era
eon = case Era era
eon of
  Era era
ConwayEra -> a -> a
(Monoid (TxScriptWitnessRequirements (LedgerEra era)) => a) -> a
forall a. a -> a
id
  Era era
DijkstraEra -> a -> a
(Monoid (TxScriptWitnessRequirements (LedgerEra era)) => a) -> a
forall a. a -> a
id

-- | Collect datums for the transaction witness set ('TxDats'):
-- 1. supplemental datums provided explicitly
-- 2. datums from reference inputs
--
-- Supplemental datums are datums whose hashes correspond to datum hashes
-- in transaction outputs. They are included for communication purposes only
-- (the Alonzo ledger spec uses subset equality for these).
--
-- Note that this function does not check whose datum hashes are present in the reference inputs. This means if there
-- are redundant datums in 'TxInsReference', a submission of such transaction will fail.
getDatums
  :: forall era
   . IsEra era
  => TxInsReference (LedgerEra era)
  -- ^ reference inputs
  -> Map L.DataHash (L.Data (LedgerEra era))
  -- ^ supplemental datums
  -> L.TxDats (LedgerEra era)
getDatums :: forall era.
IsEra era =>
TxInsReference (LedgerEra era)
-> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
-> TxDats (LedgerEra era)
getDatums TxInsReference (LedgerEra era)
txInsRef Map (SafeHash EraIndependentData) (Data (LedgerEra era))
supplementalDats = do
  let TxInsReference [TxIn]
_ Set (Datum CtxTx (LedgerEra era))
datumSet = TxInsReference (LedgerEra era)
txInsRef
      refInDatums :: [(SafeHash EraIndependentData, Data (LedgerEra era))]
refInDatums = (Datum CtxTx (LedgerEra era)
 -> Maybe (SafeHash EraIndependentData, Data (LedgerEra era)))
-> [Datum CtxTx (LedgerEra era)]
-> [(SafeHash EraIndependentData, Data (LedgerEra era))]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Datum CtxTx (LedgerEra era)
-> Maybe (SafeHash EraIndependentData, Data (LedgerEra era))
forall ctx era.
Datum ctx era -> Maybe (SafeHash EraIndependentData, Data era)
extractDatumsAndHashes ([Datum CtxTx (LedgerEra era)]
 -> [(SafeHash EraIndependentData, Data (LedgerEra era))])
-> [Datum CtxTx (LedgerEra era)]
-> [(SafeHash EraIndependentData, Data (LedgerEra era))]
forall a b. (a -> b) -> a -> b
$ Set (Datum CtxTx (LedgerEra era)) -> [Datum CtxTx (LedgerEra era)]
forall a. Set a -> [a]
Set.toList Set (Datum CtxTx (LedgerEra era))
datumSet
  Era era
-> (EraCommonConstraints era => TxDats (LedgerEra era))
-> TxDats (LedgerEra era)
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era => TxDats (LedgerEra era))
 -> TxDats (LedgerEra era))
-> (EraCommonConstraints era => TxDats (LedgerEra era))
-> TxDats (LedgerEra era)
forall a b. (a -> b) -> a -> b
$
    Map (SafeHash EraIndependentData) (Data (LedgerEra era))
-> TxDats (LedgerEra era)
forall era.
Era era =>
Map (SafeHash EraIndependentData) (Data era) -> TxDats era
L.TxDats (Map (SafeHash EraIndependentData) (Data (LedgerEra era))
 -> TxDats (LedgerEra era))
-> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
-> TxDats (LedgerEra era)
forall a b. (a -> b) -> a -> b
$
      [Item (Map (SafeHash EraIndependentData) (Data (LedgerEra era)))]
-> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
forall l. IsList l => [Item l] -> l
fromList [(SafeHash EraIndependentData, Data (LedgerEra era))]
[Item (Map (SafeHash EraIndependentData) (Data (LedgerEra era)))]
refInDatums Map (SafeHash EraIndependentData) (Data (LedgerEra era))
-> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
-> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
forall a. Semigroup a => a -> a -> a
<> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
supplementalDats

-- Getters and Setters

-- Shared by both levels. These work on a 'TxBodyContent' and on a
-- 'SubTxBodyContent' alike.

setTxAuxScripts :: [SimpleScript era] -> BodyContent l era -> BodyContent l era
setTxAuxScripts :: forall era (l :: TxLevel).
[SimpleScript era] -> BodyContent l era -> BodyContent l era
setTxAuxScripts [SimpleScript era]
v BodyContent l era
bc = BodyContent l era
bc{bcAuxScripts = v}

setTxIns :: [(TxIn, AnyWitness era)] -> BodyContent l era -> BodyContent l era
setTxIns :: forall era (l :: TxLevel).
[(TxIn, AnyWitness era)] -> BodyContent l era -> BodyContent l era
setTxIns [(TxIn, AnyWitness era)]
v BodyContent l era
bc = BodyContent l era
bc{bcIns = v}

setTxInsReference :: TxInsReference era -> BodyContent l era -> BodyContent l era
setTxInsReference :: forall era (l :: TxLevel).
TxInsReference era -> BodyContent l era -> BodyContent l era
setTxInsReference TxInsReference era
v BodyContent l era
bc = BodyContent l era
bc{bcInsReference = v}

setTxProtocolParams :: L.PParams era -> BodyContent l era -> BodyContent l era
setTxProtocolParams :: forall era (l :: TxLevel).
PParams era -> BodyContent l era -> BodyContent l era
setTxProtocolParams PParams era
v BodyContent l era
bc = BodyContent l era
bc{bcProtocolParams = Just v}

setTxValidityLowerBound :: L.SlotNo -> BodyContent l era -> BodyContent l era
setTxValidityLowerBound :: forall (l :: TxLevel) era.
SlotNo -> BodyContent l era -> BodyContent l era
setTxValidityLowerBound SlotNo
v BodyContent l era
bc = BodyContent l era
bc{bcValidityLowerBound = Just v}

setTxValidityUpperBound :: L.SlotNo -> BodyContent l era -> BodyContent l era
setTxValidityUpperBound :: forall (l :: TxLevel) era.
SlotNo -> BodyContent l era -> BodyContent l era
setTxValidityUpperBound SlotNo
v BodyContent l era
bc = BodyContent l era
bc{bcValidityUpperBound = Just v}

setTxMetadata :: TxMetadata -> BodyContent l era -> BodyContent l era
setTxMetadata :: forall (l :: TxLevel) era.
TxMetadata -> BodyContent l era -> BodyContent l era
setTxMetadata TxMetadata
v BodyContent l era
bc = BodyContent l era
bc{bcMetadata = v}

setTxOuts :: [TxOut era] -> BodyContent l era -> BodyContent l era
setTxOuts :: forall era (l :: TxLevel).
[TxOut era] -> BodyContent l era -> BodyContent l era
setTxOuts [TxOut era]
v BodyContent l era
bc = BodyContent l era
bc{bcOuts = v}

modTxOuts :: ([TxOut era] -> [TxOut era]) -> BodyContent l era -> BodyContent l era
modTxOuts :: forall era (l :: TxLevel).
([TxOut era] -> [TxOut era])
-> BodyContent l era -> BodyContent l era
modTxOuts [TxOut era] -> [TxOut era]
f BodyContent l era
bc = BodyContent l era
bc{bcOuts = f (bcOuts bc)}

setTxMintValue :: TxMintValue era -> BodyContent l era -> BodyContent l era
setTxMintValue :: forall era (l :: TxLevel).
TxMintValue era -> BodyContent l era -> BodyContent l era
setTxMintValue TxMintValue era
v BodyContent l era
bc = BodyContent l era
bc{bcMintValue = v}

setTxCertificates :: TxCertificates era -> BodyContent l era -> BodyContent l era
setTxCertificates :: forall era (l :: TxLevel).
TxCertificates era -> BodyContent l era -> BodyContent l era
setTxCertificates TxCertificates era
v BodyContent l era
bc = BodyContent l era
bc{bcCertificates = v}

setTxWithdrawals :: TxWithdrawals era -> BodyContent l era -> BodyContent l era
setTxWithdrawals :: forall era (l :: TxLevel).
TxWithdrawals era -> BodyContent l era -> BodyContent l era
setTxWithdrawals TxWithdrawals era
v BodyContent l era
bc = BodyContent l era
bc{bcWithdrawals = v}

setTxVotingProcedures :: TxVotingProcedures era -> BodyContent l era -> BodyContent l era
setTxVotingProcedures :: forall era (l :: TxLevel).
TxVotingProcedures era -> BodyContent l era -> BodyContent l era
setTxVotingProcedures TxVotingProcedures era
v BodyContent l era
bc = BodyContent l era
bc{bcVotingProcedures = Just v}

setTxProposalProcedures :: TxProposalProcedures era -> BodyContent l era -> BodyContent l era
setTxProposalProcedures :: forall era (l :: TxLevel).
TxProposalProcedures era -> BodyContent l era -> BodyContent l era
setTxProposalProcedures TxProposalProcedures era
v BodyContent l era
bc = BodyContent l era
bc{bcProposalProcedures = Just v}

setTxCurrentTreasuryValue :: L.Coin -> BodyContent l era -> BodyContent l era
setTxCurrentTreasuryValue :: forall (l :: TxLevel) era.
Coin -> BodyContent l era -> BodyContent l era
setTxCurrentTreasuryValue Coin
v BodyContent l era
bc = BodyContent l era
bc{bcCurrentTreasuryValue = Just v}

setTxTreasuryDonation :: L.Coin -> BodyContent l era -> BodyContent l era
setTxTreasuryDonation :: forall (l :: TxLevel) era.
Coin -> BodyContent l era -> BodyContent l era
setTxTreasuryDonation Coin
v BodyContent l era
bc = BodyContent l era
bc{bcTreasuryDonation = Just v}

setTxSupplementalDatums :: Map L.DataHash (L.Data era) -> BodyContent l era -> BodyContent l era
setTxSupplementalDatums :: forall era (l :: TxLevel).
Map (SafeHash EraIndependentData) (Data era)
-> BodyContent l era -> BodyContent l era
setTxSupplementalDatums Map (SafeHash EraIndependentData) (Data era)
v BodyContent l era
bc = BodyContent l era
bc{bcSupplementalDatums = v}

setTxGuards :: OSet (L.Credential L.Guard) -> BodyContent l era -> BodyContent l era
setTxGuards :: forall (l :: TxLevel) era.
OSet (Credential Guard) -> BodyContent l era -> BodyContent l era
setTxGuards OSet (Credential Guard)
v BodyContent l era
bc = BodyContent l era
bc{bcGuards = v}

setTxRequiredTopLevelGuards
  :: Map (L.Credential L.Guard) (StrictMaybe (L.Data era)) -> BodyContent l era -> BodyContent l era
setTxRequiredTopLevelGuards :: forall era (l :: TxLevel).
Map (Credential Guard) (StrictMaybe (Data era))
-> BodyContent l era -> BodyContent l era
setTxRequiredTopLevelGuards Map (Credential Guard) (StrictMaybe (Data era))
v BodyContent l era
bc = BodyContent l era
bc{bcRequiredTopLevelGuards = v}

setTxDirectDeposits :: L.DirectDeposits -> BodyContent l era -> BodyContent l era
setTxDirectDeposits :: forall (l :: TxLevel) era.
DirectDeposits -> BodyContent l era -> BodyContent l era
setTxDirectDeposits DirectDeposits
v BodyContent l era
bc = BodyContent l era
bc{bcDirectDeposits = v}

setTxAccountBalanceIntervals
  :: L.AccountBalanceIntervals era -> BodyContent l era -> BodyContent l era
setTxAccountBalanceIntervals :: forall era (l :: TxLevel).
AccountBalanceIntervals era
-> BodyContent l era -> BodyContent l era
setTxAccountBalanceIntervals AccountBalanceIntervals era
v BodyContent l era
bc = BodyContent l era
bc{bcAccountBalanceIntervals = v}

-- Top-level bodies only. A sub-transaction body has none of these fields.

setTxExtraKeyWits :: TxExtraKeyWitnesses -> TxBodyContent era -> TxBodyContent era
setTxExtraKeyWits :: forall era.
TxExtraKeyWitnesses -> TxBodyContent era -> TxBodyContent era
setTxExtraKeyWits TxExtraKeyWitnesses
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txExtraKeyWits = v}

setTxInsCollateral :: [TxIn] -> TxBodyContent era -> TxBodyContent era
setTxInsCollateral :: forall era. [TxIn] -> TxBodyContent era -> TxBodyContent era
setTxInsCollateral [TxIn]
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txInsCollateral = v}

setTxReturnCollateral :: TxReturnCollateral era -> TxBodyContent era -> TxBodyContent era
setTxReturnCollateral :: forall era.
TxReturnCollateral era -> TxBodyContent era -> TxBodyContent era
setTxReturnCollateral TxReturnCollateral era
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txReturnCollateral = Just v}

setTxTotalCollateral :: TxTotalCollateral -> TxBodyContent era -> TxBodyContent era
setTxTotalCollateral :: forall era.
TxTotalCollateral -> TxBodyContent era -> TxBodyContent era
setTxTotalCollateral TxTotalCollateral
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txTotalCollateral = Just v}

setTxFee :: L.Coin -> TxBodyContent era -> TxBodyContent era
setTxFee :: forall era. Coin -> TxBodyContent era -> TxBodyContent era
setTxFee Coin
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txFee = v}

setTxScriptValidity :: ScriptValidity -> TxBodyContent era -> TxBodyContent era
setTxScriptValidity :: forall era.
ScriptValidity -> TxBodyContent era -> TxBodyContent era
setTxScriptValidity ScriptValidity
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txScriptValidity = v}

-- | Sub-transactions are keyed by their transaction id, which is derived from
-- each sub-transaction here so callers never compute it by hand.
setTxSubTransactions :: L.EraTx era => [L.Tx L.SubTx era] -> TxBodyContent era -> TxBodyContent era
setTxSubTransactions :: forall era.
EraTx era =>
[Tx SubTx era] -> TxBodyContent era -> TxBodyContent era
setTxSubTransactions [Tx SubTx era]
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txSubTransactions = LOMap.fromFoldable v}

setTxStartingAccountBalanceIntervals
  :: L.AccountBalanceIntervals era -> TxBodyContent era -> TxBodyContent era
setTxStartingAccountBalanceIntervals :: forall era.
AccountBalanceIntervals era
-> TxBodyContent era -> TxBodyContent era
setTxStartingAccountBalanceIntervals AccountBalanceIntervals era
v TxBodyContent era
txBodyContent =
  TxBodyContent era
txBodyContent{txStartingAccountBalanceIntervals = v}