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

module Cardano.Api.Experimental.Tx.Internal.BodyContent.New
  ( TxCertificates (..)
  , TxReturnCollateral (..)
  , TxTotalCollateral (..)
  , TxExtraKeyWitnesses (..)
  , TxInsReference (..)
  , TxMintValue (..)
  , TxOut (..)
  , TxProposalProcedures (..)
  , TxValidityLowerBound (..)
  , TxVotingProcedures (..)
  , TxWithdrawals (..)
  , TxBodyContent (..)
  , Datum (..)
  , MakeUnsignedTxError (..)
  , defaultTxBodyContent
  , extractDatumsAndHashes
  , getDatums
  , collectTxBodyScriptWitnessRequirements
  , makeUnsignedTx
  , extractAllIndexedPlutusScriptWitnesses
  , txMintValueToValue
  , mkTxCertificates
  , mkTxVotingProcedures
  , mkTxProposalProcedures

    -- * Getters and Setters
  , modTxOuts
  , setTxAuxScripts
  , setTxCertificates
  , setTxReturnCollateral
  , setTxTotalCollateral
  , setTxCurrentTreasuryValue
  , setTxExtraKeyWits
  , setTxFee
  , setTxIns
  , setTxInsCollateral
  , setTxInsReference
  , setTxMetadata
  , setTxMintValue
  , setTxOuts
  , setTxProposalProcedures
  , setTxProtocolParams
  , setTxScriptValidity
  , setTxSupplementalDatums
  , setTxTreasuryDonation
  , setTxValidityLowerBound
  , setTxValidityUpperBound
  , setTxVotingProcedures
  , setTxWithdrawals

    -- * Internal conversions
  , convProposalProcedures
  , 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.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 Ledger
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.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.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.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
  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."
      ]

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
DijkstraEra TxBodyContent (LedgerEra era)
_ = String -> Either MakeUnsignedTxError (UnsignedTx DijkstraEra)
forall a. HasCallStack => String -> a
error String
"TODO Dijkstra: makeUnsignedTx: era not supported"
makeUnsignedTx era :: Era era
era@Era era
ConwayEra 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 ConwayEra)]
scripts TxDats (LedgerEra ConwayEra)
datums Redeemers (LedgerEra ConwayEra)
redeemers = TxBodyContent (LedgerEra ConwayEra)
-> TxScriptWitnessRequirements (LedgerEra ConwayEra)
forall era.
IsEra era =>
TxBodyContent (LedgerEra era)
-> TxScriptWitnessRequirements (LedgerEra era)
collectTxBodyScriptWitnessRequirements TxBodyContent (LedgerEra era)
TxBodyContent (LedgerEra ConwayEra)
bc

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

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

  scriptIntegrityHash <-
    Maybe (PParams (LedgerEra ConwayEra))
-> Redeemers (LedgerEra ConwayEra)
-> TxDats (LedgerEra ConwayEra)
-> 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 ConwayEra)
Maybe (PParams (LedgerEra ConwayEra))
protocolParameters
      Redeemers (LedgerEra ConwayEra)
redeemers
      TxDats (LedgerEra ConwayEra)
datums
      Set Language
languages

  let setMint = TxMintValue ConwayEra -> MultiAsset
forall era. TxMintValue era -> MultiAsset
convMintValue TxMintValue ConwayEra
apiMintValue
      setReqSignerHashes = TxExtraKeyWitnesses -> Set (KeyHash Guard)
convExtraKeyWitnesses TxExtraKeyWitnesses
apiExtraKeyWitnesses
      ledgerTxBody =
        TxBody TopTx ConwayEra
forall era (l :: TxLevel).
(EraTxBody era, Typeable l) =>
TxBody l era
forall (l :: TxLevel). Typeable l => TxBody l ConwayEra
L.mkBasicTxBody
          TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
forall a b. a -> (a -> b) -> b
& (Set TxIn -> Identity (Set TxIn))
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era (l :: TxLevel).
EraTxBody era =>
Lens' (TxBody l era) (Set TxIn)
forall (l :: TxLevel). Lens' (TxBody l ConwayEra) (Set TxIn)
L.inputsTxBodyL ((Set TxIn -> Identity (Set TxIn))
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> Set TxIn -> TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Set TxIn
txins
          TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
forall a b. a -> (a -> b) -> b
& (Set TxIn -> Identity (Set TxIn))
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era.
AlonzoEraTxBody era =>
Lens' (TxBody TopTx era) (Set TxIn)
Lens' (TxBody TopTx ConwayEra) (Set TxIn)
L.collateralInputsTxBodyL ((Set TxIn -> Identity (Set TxIn))
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> Set TxIn -> TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Set TxIn
collTxIns
          TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
forall a b. a -> (a -> b) -> b
& (Set TxIn -> Identity (Set TxIn))
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era (l :: TxLevel).
BabbageEraTxBody era =>
Lens' (TxBody l era) (Set TxIn)
forall (l :: TxLevel). Lens' (TxBody l ConwayEra) (Set TxIn)
L.referenceInputsTxBodyL ((Set TxIn -> Identity (Set TxIn))
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> Set TxIn -> TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Set TxIn
refTxIns
          TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
forall a b. a -> (a -> b) -> b
& (StrictSeq (TxOut ConwayEra)
 -> Identity (StrictSeq (TxOut ConwayEra)))
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era (l :: TxLevel).
EraTxBody era =>
Lens' (TxBody l era) (StrictSeq (TxOut era))
forall (l :: TxLevel).
Lens' (TxBody l ConwayEra) (StrictSeq (TxOut ConwayEra))
L.outputsTxBodyL ((StrictSeq (TxOut ConwayEra)
  -> Identity (StrictSeq (TxOut ConwayEra)))
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> StrictSeq (TxOut ConwayEra)
-> TxBody TopTx ConwayEra
-> TxBody TopTx ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ StrictSeq (TxOut ConwayEra)
outs
          TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
forall a b. a -> (a -> b) -> b
& (StrictMaybe Coin -> Identity (StrictMaybe Coin))
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era.
BabbageEraTxBody era =>
Lens' (TxBody TopTx era) (StrictMaybe Coin)
Lens' (TxBody TopTx ConwayEra) (StrictMaybe Coin)
L.totalCollateralTxBodyL ((StrictMaybe Coin -> Identity (StrictMaybe Coin))
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> StrictMaybe Coin
-> TxBody TopTx ConwayEra
-> TxBody TopTx ConwayEra
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 ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
forall a b. a -> (a -> b) -> b
& (StrictMaybe (TxOut ConwayEra)
 -> Identity (StrictMaybe (TxOut ConwayEra)))
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era.
BabbageEraTxBody era =>
Lens' (TxBody TopTx era) (StrictMaybe (TxOut era))
Lens' (TxBody TopTx ConwayEra) (StrictMaybe (TxOut ConwayEra))
L.collateralReturnTxBodyL ((StrictMaybe (TxOut ConwayEra)
  -> Identity (StrictMaybe (TxOut ConwayEra)))
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> StrictMaybe (TxOut ConwayEra)
-> TxBody TopTx ConwayEra
-> TxBody TopTx ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe (TxOut ConwayEra) -> StrictMaybe (TxOut ConwayEra)
forall a. Maybe a -> StrictMaybe a
L.maybeToStrictMaybe Maybe (TxOut ConwayEra)
retCollateral
          TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
forall a b. a -> (a -> b) -> b
& (Coin -> Identity Coin)
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era. EraTxBody era => Lens' (TxBody TopTx era) Coin
Lens' (TxBody TopTx ConwayEra) Coin
L.feeTxBodyL ((Coin -> Identity Coin)
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> Coin -> TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Coin
fee
          TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
forall a b. a -> (a -> b) -> b
& (ValidityInterval -> Identity ValidityInterval)
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era (l :: TxLevel).
AllegraEraTxBody era =>
Lens' (TxBody l era) ValidityInterval
forall (l :: TxLevel). Lens' (TxBody l ConwayEra) ValidityInterval
L.vldtTxBodyL ((ValidityInterval -> Identity ValidityInterval)
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> ((StrictMaybe SlotNo -> Identity (StrictMaybe SlotNo))
    -> ValidityInterval -> Identity ValidityInterval)
-> (StrictMaybe SlotNo -> Identity (StrictMaybe SlotNo))
-> TxBody TopTx ConwayEra
-> Identity (TxBody TopTx ConwayEra)
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 ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> StrictMaybe SlotNo
-> TxBody TopTx ConwayEra
-> TxBody TopTx ConwayEra
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 ConwayEra -> Maybe SlotNo
forall era. TxBodyContent era -> Maybe SlotNo
txValidityLowerBound TxBodyContent ConwayEra
TxBodyContent (LedgerEra era)
bc)
          TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
forall a b. a -> (a -> b) -> b
& (ValidityInterval -> Identity ValidityInterval)
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era (l :: TxLevel).
AllegraEraTxBody era =>
Lens' (TxBody l era) ValidityInterval
forall (l :: TxLevel). Lens' (TxBody l ConwayEra) ValidityInterval
L.vldtTxBodyL ((ValidityInterval -> Identity ValidityInterval)
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> ((StrictMaybe SlotNo -> Identity (StrictMaybe SlotNo))
    -> ValidityInterval -> Identity ValidityInterval)
-> (StrictMaybe SlotNo -> Identity (StrictMaybe SlotNo))
-> TxBody TopTx ConwayEra
-> Identity (TxBody TopTx ConwayEra)
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 ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> StrictMaybe SlotNo
-> TxBody TopTx ConwayEra
-> TxBody TopTx ConwayEra
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 ConwayEra -> Maybe SlotNo
forall era. TxBodyContent era -> Maybe SlotNo
txValidityUpperBound TxBodyContent ConwayEra
TxBodyContent (LedgerEra era)
bc)
          TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
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)
setReqSignerHashes
          TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
forall a b. a -> (a -> b) -> b
& (StrictMaybe ScriptIntegrityHash
 -> Identity (StrictMaybe ScriptIntegrityHash))
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era (l :: TxLevel).
AlonzoEraTxBody era =>
Lens' (TxBody l era) (StrictMaybe ScriptIntegrityHash)
forall (l :: TxLevel).
Lens' (TxBody l ConwayEra) (StrictMaybe ScriptIntegrityHash)
L.scriptIntegrityHashTxBodyL ((StrictMaybe ScriptIntegrityHash
  -> Identity (StrictMaybe ScriptIntegrityHash))
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> StrictMaybe ScriptIntegrityHash
-> TxBody TopTx ConwayEra
-> TxBody TopTx ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ StrictMaybe ScriptIntegrityHash
scriptIntegrityHash
          TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
forall a b. a -> (a -> b) -> b
& (Withdrawals -> Identity Withdrawals)
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era (l :: TxLevel).
EraTxBody era =>
Lens' (TxBody l era) Withdrawals
forall (l :: TxLevel). Lens' (TxBody l ConwayEra) Withdrawals
L.withdrawalsTxBodyL ((Withdrawals -> Identity Withdrawals)
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> Withdrawals -> TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Withdrawals
withdrawals
          TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
forall a b. a -> (a -> b) -> b
& (StrictSeq (TxCert ConwayEra)
 -> Identity (StrictSeq (TxCert ConwayEra)))
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
(StrictSeq (ConwayTxCert ConwayEra)
 -> Identity (StrictSeq (ConwayTxCert ConwayEra)))
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era (l :: TxLevel).
EraTxBody era =>
Lens' (TxBody l era) (StrictSeq (TxCert era))
forall (l :: TxLevel).
Lens' (TxBody l ConwayEra) (StrictSeq (TxCert ConwayEra))
L.certsTxBodyL ((StrictSeq (ConwayTxCert ConwayEra)
  -> Identity (StrictSeq (ConwayTxCert ConwayEra)))
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> StrictSeq (ConwayTxCert ConwayEra)
-> TxBody TopTx ConwayEra
-> TxBody TopTx ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ StrictSeq (TxCert (LedgerEra ConwayEra))
StrictSeq (ConwayTxCert ConwayEra)
certs
          TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
forall a b. a -> (a -> b) -> b
& (MultiAsset -> Identity MultiAsset)
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era (l :: TxLevel).
MaryEraTxBody era =>
Lens' (TxBody l era) MultiAsset
forall (l :: TxLevel). Lens' (TxBody l ConwayEra) MultiAsset
L.mintTxBodyL ((MultiAsset -> Identity MultiAsset)
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> MultiAsset -> TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra
forall s t a b. ASetter s t a b -> b -> s -> t
.~ MultiAsset
setMint
          TxBody TopTx ConwayEra
-> (TxBody TopTx ConwayEra -> TxBody TopTx ConwayEra)
-> TxBody TopTx ConwayEra
forall a b. a -> (a -> b) -> b
& (StrictMaybe TxAuxDataHash -> Identity (StrictMaybe TxAuxDataHash))
-> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra)
forall era (l :: TxLevel).
EraTxBody era =>
Lens' (TxBody l era) (StrictMaybe TxAuxDataHash)
forall (l :: TxLevel).
Lens' (TxBody l ConwayEra) (StrictMaybe TxAuxDataHash)
L.auxDataHashTxBodyL ((StrictMaybe TxAuxDataHash
  -> Identity (StrictMaybe TxAuxDataHash))
 -> TxBody TopTx ConwayEra -> Identity (TxBody TopTx ConwayEra))
-> StrictMaybe TxAuxDataHash
-> TxBody TopTx ConwayEra
-> TxBody TopTx ConwayEra
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 ConwayEra -> TxAuxDataHash
forall era. EraTxAuxData era => TxAuxData era -> TxAuxDataHash
Ledger.hashTxAuxData (TxAuxData ConwayEra -> TxAuxDataHash)
-> Maybe (TxAuxData ConwayEra) -> Maybe TxAuxDataHash
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (TxAuxData ConwayEra)
Maybe (TxAuxData (LedgerEra ConwayEra))
txAuxData)

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

  let eraSpecificTxBody = Era era
-> TxBody TopTx (LedgerEra era)
-> TxBodyContent (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
forall era.
Era era
-> TxBody TopTx (LedgerEra era)
-> TxBodyContent (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
eraSpecificLedgerTxBody Era era
era TxBody TopTx ConwayEra
TxBody TopTx (LedgerEra era)
ledgerTxBody TxBodyContent (LedgerEra era)
bc
  Right $
    UnsignedTx $
      L.mkBasicTx eraSpecificTxBody
        & L.witsTxL .~ scriptWitnesses
        & L.auxDataTxL .~ L.maybeToStrictMaybe (toAuxiliaryData (txMetadata bc) (txAuxScripts bc))
        & L.isValidTxL .~ 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 (StakeCredential, 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 (StakeCredential, AnyWitness (LedgerEra era)))]
    -> [Item (StrictSeq (TxCert (LedgerEra era)))])
-> [(Certificate (LedgerEra era),
     Maybe (StakeCredential, AnyWitness (LedgerEra era)))]
-> StrictSeq (TxCert (LedgerEra era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Certificate (LedgerEra era),
  Maybe (StakeCredential, AnyWitness (LedgerEra era)))
 -> Item (StrictSeq (TxCert (LedgerEra era))))
-> [(Certificate (LedgerEra era),
     Maybe (StakeCredential, AnyWitness (LedgerEra era)))]
-> [Item (StrictSeq (TxCert (LedgerEra era)))]
forall a b. (a -> b) -> [a] -> [b]
map (\(Exp.Certificate TxCert (LedgerEra era)
c, Maybe (StakeCredential, AnyWitness (LedgerEra era))
_) -> Item (StrictSeq (TxCert (LedgerEra era)))
TxCert (LedgerEra era)
c) ([(Certificate (LedgerEra era),
   Maybe (StakeCredential, AnyWitness (LedgerEra era)))]
 -> StrictSeq (TxCert (LedgerEra era)))
-> [(Certificate (LedgerEra era),
     Maybe (StakeCredential, AnyWitness (LedgerEra era)))]
-> StrictSeq (TxCert (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ OMap
  (Certificate (LedgerEra era))
  (Maybe (StakeCredential, AnyWitness (LedgerEra era)))
-> [Item
      (OMap
         (Certificate (LedgerEra era))
         (Maybe (StakeCredential, AnyWitness (LedgerEra era))))]
forall l. IsList l => l -> [Item l]
toList OMap
  (Certificate (LedgerEra era))
  (Maybe (StakeCredential, 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

eraSpecificLedgerTxBody
  :: Era era
  -> L.TxBody L.TopTx (LedgerEra era)
  -> TxBodyContent (LedgerEra era)
  -> L.TxBody L.TopTx (LedgerEra era)
eraSpecificLedgerTxBody :: forall era.
Era era
-> TxBody TopTx (LedgerEra era)
-> TxBodyContent (LedgerEra era)
-> TxBody TopTx (LedgerEra era)
eraSpecificLedgerTxBody Era era
era TxBody TopTx (LedgerEra era)
ledgerbody TxBodyContent (LedgerEra era)
bc =
  Era era -> TxBody TopTx (LedgerEra era)
body Era era
era
 where
  body :: Era era -> TxBody TopTx (LedgerEra era)
body Era era
e =
    let propProcedures :: Maybe (TxProposalProcedures (LedgerEra era))
propProcedures = TxBodyContent (LedgerEra era)
-> Maybe (TxProposalProcedures (LedgerEra era))
forall era. TxBodyContent era -> Maybe (TxProposalProcedures era)
txProposalProcedures TxBodyContent (LedgerEra era)
bc
        voteProcedures :: Maybe (TxVotingProcedures (LedgerEra era))
voteProcedures = TxBodyContent (LedgerEra era)
-> Maybe (TxVotingProcedures (LedgerEra era))
forall era. TxBodyContent era -> Maybe (TxVotingProcedures era)
txVotingProcedures TxBodyContent (LedgerEra era)
bc
        treasuryDonation :: Maybe Coin
treasuryDonation = TxBodyContent (LedgerEra era) -> Maybe Coin
forall era. TxBodyContent era -> Maybe Coin
txTreasuryDonation TxBodyContent (LedgerEra era)
bc
        currentTreasuryValue :: Maybe Coin
currentTreasuryValue = TxBodyContent (LedgerEra era) -> Maybe Coin
forall era. TxBodyContent era -> Maybe Coin
txCurrentTreasuryValue TxBodyContent (LedgerEra era)
bc
     in Era era
-> (EraCommonConstraints era => TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints Era era
e ((EraCommonConstraints era => TxBody TopTx (LedgerEra era))
 -> TxBody TopTx (LedgerEra era))
-> (EraCommonConstraints era => TxBody TopTx (LedgerEra era))
-> TxBody TopTx (LedgerEra era)
forall a b. (a -> b) -> a -> b
$
          TxBody TopTx (LedgerEra era)
ledgerbody
            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 Maybe (TxProposalProcedures (LedgerEra era))
propProcedures
            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 Maybe (TxVotingProcedures (LedgerEra era))
voteProcedures
            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) Maybe Coin
treasuryDonation
            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 Maybe Coin
currentTreasuryValue

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 <- fmap 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 (StakeCredential, AnyWitness era))
unTxCertificates :: OMap (Exp.Certificate era) (Maybe (StakeCredential, 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. Only Certificates with a
-- stake credential will be in the result.
--
-- 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 (StakeCredential, AnyWitness (LedgerEra era)))
-> TxCertificates (LedgerEra era)
forall era.
OMap (Certificate era) (Maybe (StakeCredential, AnyWitness era))
-> TxCertificates era
TxCertificates (OMap
   (Certificate (LedgerEra era))
   (Maybe (StakeCredential, AnyWitness (LedgerEra era)))
 -> TxCertificates (LedgerEra era))
-> ([(Certificate (LedgerEra era),
      Maybe (StakeCredential, AnyWitness (LedgerEra era)))]
    -> OMap
         (Certificate (LedgerEra era))
         (Maybe (StakeCredential, AnyWitness (LedgerEra era))))
-> [(Certificate (LedgerEra era),
     Maybe (StakeCredential, AnyWitness (LedgerEra era)))]
-> TxCertificates (LedgerEra era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Certificate (LedgerEra era),
  Maybe (StakeCredential, AnyWitness (LedgerEra era)))]
-> OMap
     (Certificate (LedgerEra era))
     (Maybe (StakeCredential, AnyWitness (LedgerEra era)))
forall k v. Ord k => [(k, v)] -> OMap k v
OMap.fromList ([(Certificate (LedgerEra era),
   Maybe (StakeCredential, AnyWitness (LedgerEra era)))]
 -> TxCertificates (LedgerEra era))
-> [(Certificate (LedgerEra era),
     Maybe (StakeCredential, AnyWitness (LedgerEra era)))]
-> TxCertificates (LedgerEra era)
forall a b. (a -> b) -> a -> b
$ ((Certificate (LedgerEra era), AnyWitness (LedgerEra era))
 -> (Certificate (LedgerEra era),
     Maybe (StakeCredential, AnyWitness (LedgerEra era))))
-> [(Certificate (LedgerEra era), AnyWitness (LedgerEra era))]
-> [(Certificate (LedgerEra era),
     Maybe (StakeCredential, AnyWitness (LedgerEra era)))]
forall a b. (a -> b) -> [a] -> [b]
map (Certificate (LedgerEra era), AnyWitness (LedgerEra era))
-> (Certificate (LedgerEra era),
    Maybe (StakeCredential, 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 (StakeCredential, AnyWitness (LedgerEra era))
       )
  getStakeCred :: (Certificate (LedgerEra era), AnyWitness (LedgerEra era))
-> (Certificate (LedgerEra era),
    Maybe (StakeCredential, 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) (StakeCredential -> (StakeCredential, AnyWitness (LedgerEra era)))
-> Maybe StakeCredential
-> Maybe (StakeCredential, AnyWitness (LedgerEra era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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

data TxBodyContent era
  = TxBodyContent
  { forall era. TxBodyContent era -> [(TxIn, AnyWitness era)]
txIns :: [(TxIn, AnyWitness era)]
  , forall era. TxBodyContent era -> [TxIn]
txInsCollateral :: [TxIn]
  , forall era. TxBodyContent era -> TxInsReference era
txInsReference :: TxInsReference era
  , forall era. TxBodyContent era -> [TxOut era]
txOuts :: [TxOut era]
  , forall era. TxBodyContent era -> Maybe TxTotalCollateral
txTotalCollateral :: Maybe TxTotalCollateral
  , forall era. TxBodyContent era -> Maybe (TxReturnCollateral era)
txReturnCollateral :: Maybe (TxReturnCollateral era)
  , forall era. TxBodyContent era -> Coin
txFee :: L.Coin
  , forall era. TxBodyContent era -> Maybe SlotNo
txValidityLowerBound :: Maybe L.SlotNo
  , forall era. TxBodyContent era -> Maybe SlotNo
txValidityUpperBound :: Maybe L.SlotNo
  , forall era. TxBodyContent era -> TxMetadata
txMetadata :: TxMetadata
  , forall era. TxBodyContent era -> [SimpleScript era]
txAuxScripts :: [SimpleScript era]
  , forall era. TxBodyContent era -> TxExtraKeyWitnesses
txExtraKeyWits :: TxExtraKeyWitnesses
  , forall era. TxBodyContent era -> Maybe (PParams era)
txProtocolParams :: Maybe (L.PParams era)
  , forall era. TxBodyContent era -> TxWithdrawals era
txWithdrawals :: TxWithdrawals era
  , forall era. TxBodyContent era -> TxCertificates era
txCertificates :: TxCertificates era
  , forall era. TxBodyContent era -> TxMintValue era
txMintValue :: TxMintValue era
  , forall era. TxBodyContent era -> ScriptValidity
txScriptValidity :: ScriptValidity
  , forall era. TxBodyContent era -> Maybe (TxProposalProcedures era)
txProposalProcedures :: Maybe (TxProposalProcedures era)
  , forall era. TxBodyContent era -> Maybe (TxVotingProcedures era)
txVotingProcedures :: Maybe (TxVotingProcedures era)
  , forall era. TxBodyContent era -> Maybe Coin
txCurrentTreasuryValue :: Maybe L.Coin
  -- ^ Current treasury value
  , forall era. TxBodyContent era -> Maybe Coin
txTreasuryDonation :: Maybe L.Coin
  -- ^ Treasury donation to perform
  , forall era.
TxBodyContent era -> Map (SafeHash EraIndependentData) (Data era)
txSupplementalDatums :: 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.
  }

defaultTxBodyContent
  :: TxBodyContent era
defaultTxBodyContent :: forall era. TxBodyContent era
defaultTxBodyContent =
  TxBodyContent
    { txIns :: [(TxIn, AnyWitness era)]
txIns = []
    , txInsCollateral :: [TxIn]
txInsCollateral = []
    , txInsReference :: TxInsReference era
txInsReference = [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
    , txOuts :: [TxOut era]
txOuts = []
    , txTotalCollateral :: Maybe TxTotalCollateral
txTotalCollateral = Maybe TxTotalCollateral
forall a. Maybe a
Nothing
    , txReturnCollateral :: Maybe (TxReturnCollateral era)
txReturnCollateral = Maybe (TxReturnCollateral era)
forall a. Maybe a
Nothing
    , txFee :: Coin
txFee = Coin
0
    , txValidityLowerBound :: Maybe SlotNo
txValidityLowerBound = Maybe SlotNo
forall a. Maybe a
Nothing
    , txValidityUpperBound :: Maybe SlotNo
txValidityUpperBound = Maybe SlotNo
forall a. Maybe a
Nothing
    , txMetadata :: TxMetadata
txMetadata = Map Word64 TxMetadataValue -> TxMetadata
TxMetadata Map Word64 TxMetadataValue
forall a. Monoid a => a
mempty
    , txAuxScripts :: [SimpleScript era]
txAuxScripts = []
    , txExtraKeyWits :: TxExtraKeyWitnesses
txExtraKeyWits = [Hash PaymentKey] -> TxExtraKeyWitnesses
TxExtraKeyWitnesses []
    , txProtocolParams :: Maybe (PParams era)
txProtocolParams = Maybe (PParams era)
forall a. Maybe a
Nothing
    , txWithdrawals :: TxWithdrawals era
txWithdrawals = [(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
    , txCertificates :: TxCertificates era
txCertificates = OMap (Certificate era) (Maybe (StakeCredential, AnyWitness era))
-> TxCertificates era
forall era.
OMap (Certificate era) (Maybe (StakeCredential, AnyWitness era))
-> TxCertificates era
TxCertificates OMap (Certificate era) (Maybe (StakeCredential, AnyWitness era))
forall k v. OMap k v
OMap.empty
    , txMintValue :: TxMintValue era
txMintValue = 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
    , txScriptValidity :: ScriptValidity
txScriptValidity = ScriptValidity
ScriptValid
    , txProposalProcedures :: Maybe (TxProposalProcedures era)
txProposalProcedures = Maybe (TxProposalProcedures era)
forall a. Maybe a
Nothing
    , txVotingProcedures :: Maybe (TxVotingProcedures era)
txVotingProcedures = Maybe (TxVotingProcedures era)
forall a. Maybe a
Nothing
    , txCurrentTreasuryValue :: Maybe Coin
txCurrentTreasuryValue = Maybe Coin
forall a. Maybe a
Nothing
    , txTreasuryDonation :: Maybe Coin
txTreasuryDonation = Maybe Coin
forall a. Maybe a
Nothing
    , txSupplementalDatums :: Map (SafeHash EraIndependentData) (Data era)
txSupplementalDatums = Map (SafeHash EraIndependentData) (Data era)
forall a. Monoid a => a
mempty
    }

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]

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 (LedgerEra era)
txCerts =
  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)
-> StakeCredential -> Witnessable 'CertItem (LedgerEra era)
forall era.
(EraTxCert era, AlonzoEraScript era) =>
TxCert era -> StakeCredential -> Witnessable 'CertItem era
WitTxCert TxCert (LedgerEra era)
cert StakeCredential
stakeCred
        , AnyWitness (LedgerEra era)
wit
        )
      | (Exp.Certificate TxCert (LedgerEra era)
cert, Just (StakeCredential
stakeCred, AnyWitness (LedgerEra era)
wit)) <- TxCertificates (LedgerEra era)
-> [(Certificate (LedgerEra era),
     Maybe (StakeCredential, AnyWitness (LedgerEra era)))]
forall {era}.
TxCertificates era
-> [(Certificate era, Maybe (StakeCredential, AnyWitness era))]
getCertificates TxCertificates (LedgerEra era)
txCerts
      ]
 where
  getCertificates :: TxCertificates era
-> [Item
      (OMap (Certificate era) (Maybe (StakeCredential, AnyWitness era)))]
getCertificates (TxCertificates OMap (Certificate era) (Maybe (StakeCredential, AnyWitness era))
txcs) = OMap (Certificate era) (Maybe (StakeCredential, AnyWitness era))
-> [Item
      (OMap (Certificate era) (Maybe (StakeCredential, AnyWitness era)))]
forall l. IsList l => l -> [Item l]
toList OMap (Certificate era) (Maybe (StakeCredential, AnyWitness era))
txcs

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) =
  case forall era. IsEra era => Era era
useEra @era of
    Era era
DijkstraEra -> String
-> [(Witnessable 'VoterItem DijkstraEra, AnyWitness DijkstraEra)]
forall a. HasCallStack => String -> a
error String
"TODO Dijkstra: extractWitnessableVotes: era not supported"
    Era era
ConwayEra ->
      [(Witnessable 'VoterItem ConwayEra, AnyWitness ConwayEra)]
-> [(Witnessable 'VoterItem ConwayEra, AnyWitness ConwayEra)]
forall a. Eq a => [a] -> [a]
List.nub
        [ (Voter -> Witnessable 'VoterItem ConwayEra
forall era.
ConwayEraScript era =>
Voter -> Witnessable 'VoterItem era
WitVote Voter
vote, AnyWitness ConwayEra
wit)
        | (Voter
vote, AnyWitness ConwayEra
wit) <- TxVotingProcedures (LedgerEra era)
-> [(Voter, AnyWitness (LedgerEra era))]
getVotes TxVotingProcedures (LedgerEra era)
txVoteProc
        ]
 where
  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
    , AnyWitness (LedgerEra era)
wit <- [AnyWitness (LedgerEra era)]
-> (AnyWitness (LedgerEra era) -> [AnyWitness (LedgerEra era)])
-> Maybe (AnyWitness (LedgerEra era))
-> [AnyWitness (LedgerEra era)]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] AnyWitness (LedgerEra era) -> [AnyWitness (LedgerEra era)]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (Voter
-> Map Voter (AnyWitness (LedgerEra era))
-> Maybe (AnyWitness (LedgerEra era))
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup 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)

collectTxBodyScriptWitnessRequirements
  :: forall era
   . IsEra era
  => TxBodyContent (LedgerEra era)
  -> TxScriptWitnessRequirements (LedgerEra era)
collectTxBodyScriptWitnessRequirements :: forall era.
IsEra era =>
TxBodyContent (LedgerEra era)
-> TxScriptWitnessRequirements (LedgerEra era)
collectTxBodyScriptWitnessRequirements
  TxBodyContent
    { [(TxIn, AnyWitness (LedgerEra era))]
txIns :: forall era. TxBodyContent era -> [(TxIn, AnyWitness era)]
txIns :: [(TxIn, AnyWitness (LedgerEra era))]
txIns
    , TxInsReference (LedgerEra era)
txInsReference :: forall era. TxBodyContent era -> TxInsReference era
txInsReference :: TxInsReference (LedgerEra era)
txInsReference
    , TxCertificates (LedgerEra era)
txCertificates :: forall era. TxBodyContent era -> TxCertificates era
txCertificates :: TxCertificates (LedgerEra era)
txCertificates
    , TxMintValue (LedgerEra era)
txMintValue :: forall era. TxBodyContent era -> TxMintValue era
txMintValue :: TxMintValue (LedgerEra era)
txMintValue
    , TxWithdrawals (LedgerEra era)
txWithdrawals :: forall era. TxBodyContent era -> TxWithdrawals era
txWithdrawals :: TxWithdrawals (LedgerEra era)
txWithdrawals
    , Maybe (TxVotingProcedures (LedgerEra era))
txVotingProcedures :: forall era. TxBodyContent era -> Maybe (TxVotingProcedures era)
txVotingProcedures :: Maybe (TxVotingProcedures (LedgerEra era))
txVotingProcedures
    , Maybe (TxProposalProcedures (LedgerEra era))
txProposalProcedures :: forall era. TxBodyContent era -> Maybe (TxProposalProcedures era)
txProposalProcedures :: Maybe (TxProposalProcedures (LedgerEra era))
txProposalProcedures
    , Map (SafeHash EraIndependentData) (Data (LedgerEra era))
txSupplementalDatums :: forall era.
TxBodyContent era -> Map (SafeHash EraIndependentData) (Data era)
txSupplementalDatums :: Map (SafeHash EraIndependentData) (Data (LedgerEra era))
txSupplementalDatums
    } = 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)
txInsReference Map (SafeHash EraIndependentData) (Data (LedgerEra era))
txSupplementalDatums)
            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))]
txIns
        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)
txWithdrawals
        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)
txCertificates
        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)
txMintValue]
        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))
txVotingProcedures
        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))
txProposalProcedures

    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

setTxAuxScripts :: [SimpleScript era] -> TxBodyContent era -> TxBodyContent era
setTxAuxScripts :: forall era.
[SimpleScript era] -> TxBodyContent era -> TxBodyContent era
setTxAuxScripts [SimpleScript era]
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txAuxScripts = v}

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}

setTxIns :: [(TxIn, AnyWitness era)] -> TxBodyContent era -> TxBodyContent era
setTxIns :: forall era.
[(TxIn, AnyWitness era)] -> TxBodyContent era -> TxBodyContent era
setTxIns [(TxIn, AnyWitness era)]
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txIns = 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}

setTxInsReference :: TxInsReference era -> TxBodyContent era -> TxBodyContent era
setTxInsReference :: forall era.
TxInsReference era -> TxBodyContent era -> TxBodyContent era
setTxInsReference TxInsReference era
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txInsReference = v}

setTxProtocolParams :: L.PParams era -> TxBodyContent era -> TxBodyContent era
setTxProtocolParams :: forall era. PParams era -> TxBodyContent era -> TxBodyContent era
setTxProtocolParams PParams era
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txProtocolParams = Just 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}

setTxValidityLowerBound :: L.SlotNo -> TxBodyContent era -> TxBodyContent era
setTxValidityLowerBound :: forall era. SlotNo -> TxBodyContent era -> TxBodyContent era
setTxValidityLowerBound SlotNo
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txValidityLowerBound = Just v}

setTxValidityUpperBound :: L.SlotNo -> TxBodyContent era -> TxBodyContent era
setTxValidityUpperBound :: forall era. SlotNo -> TxBodyContent era -> TxBodyContent era
setTxValidityUpperBound SlotNo
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txValidityUpperBound = Just v}

setTxMetadata :: TxMetadata -> TxBodyContent era -> TxBodyContent era
setTxMetadata :: forall era. TxMetadata -> TxBodyContent era -> TxBodyContent era
setTxMetadata TxMetadata
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txMetadata = 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}

setTxOuts :: [TxOut era] -> TxBodyContent era -> TxBodyContent era
setTxOuts :: forall era. [TxOut era] -> TxBodyContent era -> TxBodyContent era
setTxOuts [TxOut era]
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txOuts = v}

setTxMintValue :: TxMintValue era -> TxBodyContent era -> TxBodyContent era
setTxMintValue :: forall era.
TxMintValue era -> TxBodyContent era -> TxBodyContent era
setTxMintValue TxMintValue era
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txMintValue = 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}

setTxCertificates :: TxCertificates era -> TxBodyContent era -> TxBodyContent era
setTxCertificates :: forall era.
TxCertificates era -> TxBodyContent era -> TxBodyContent era
setTxCertificates TxCertificates era
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txCertificates = v}

setTxWithdrawals :: TxWithdrawals era -> TxBodyContent era -> TxBodyContent era
setTxWithdrawals :: forall era.
TxWithdrawals era -> TxBodyContent era -> TxBodyContent era
setTxWithdrawals TxWithdrawals era
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txWithdrawals = v}

setTxVotingProcedures :: TxVotingProcedures era -> TxBodyContent era -> TxBodyContent era
setTxVotingProcedures :: forall era.
TxVotingProcedures era -> TxBodyContent era -> TxBodyContent era
setTxVotingProcedures TxVotingProcedures era
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txVotingProcedures = Just v}

setTxProposalProcedures :: TxProposalProcedures era -> TxBodyContent era -> TxBodyContent era
setTxProposalProcedures :: forall era.
TxProposalProcedures era -> TxBodyContent era -> TxBodyContent era
setTxProposalProcedures TxProposalProcedures era
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txProposalProcedures = Just v}

setTxCurrentTreasuryValue :: L.Coin -> TxBodyContent era -> TxBodyContent era
setTxCurrentTreasuryValue :: forall era. Coin -> TxBodyContent era -> TxBodyContent era
setTxCurrentTreasuryValue Coin
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txCurrentTreasuryValue = Just v}

setTxTreasuryDonation :: L.Coin -> TxBodyContent era -> TxBodyContent era
setTxTreasuryDonation :: forall era. Coin -> TxBodyContent era -> TxBodyContent era
setTxTreasuryDonation Coin
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txTreasuryDonation = Just v}

setTxSupplementalDatums :: Map L.DataHash (L.Data era) -> TxBodyContent era -> TxBodyContent era
setTxSupplementalDatums :: forall era.
Map (SafeHash EraIndependentData) (Data era)
-> TxBodyContent era -> TxBodyContent era
setTxSupplementalDatums Map (SafeHash EraIndependentData) (Data era)
v TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txSupplementalDatums = v}

modTxOuts
  :: ([TxOut era] -> [TxOut era]) -> TxBodyContent era -> TxBodyContent era
modTxOuts :: forall era.
([TxOut era] -> [TxOut era])
-> TxBodyContent era -> TxBodyContent era
modTxOuts [TxOut era] -> [TxOut era]
f TxBodyContent era
txBodyContent = TxBodyContent era
txBodyContent{txOuts = f (txOuts txBodyContent)}