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

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

    -- * Legacy conversions
  , DatumDecodingError (..)
  , legacyDatumToDatum
  , fromLegacyTxOut
  , supplementalDatumFromLegacy
  )
where

import Cardano.Api.Address
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 (liftMaybe)
import Cardano.Api.Plutus.Internal.Script
  ( PlutusScript (..)
  , PlutusScriptVersion (..)
  , ScriptInAnyLang (..)
  , ScriptLanguage (..)
  , fromAllegraTimelock
  )
import Cardano.Api.Plutus.Internal.Script qualified as OldScript
import Cardano.Api.Plutus.Internal.ScriptData qualified as Api
import Cardano.Api.Pretty
import Cardano.Api.Serialise.Cbor (serialiseToCBOR)
import Cardano.Api.Tx.Internal.Body
  ( CtxTx
  , TxIn
  , asGuard
  , toShelleyTxIn
  , toShelleyWithdrawal
  )
import Cardano.Api.Tx.Internal.Output qualified as OldApi
import Cardano.Api.Tx.Internal.Sign
import Cardano.Api.Tx.Internal.TxMetadata
import Cardano.Api.Value.Internal
  ( PolicyAssets
  , PolicyId
  , Value
  , fromMaryValue
  , lovelaceToValue
  , policyAssetsToValue
  , toMaryValue
  )

import Cardano.Binary qualified as CBOR
import Cardano.Ledger.Alonzo.Scripts qualified as L
import Cardano.Ledger.Alonzo.Tx qualified as L
import Cardano.Ledger.Alonzo.TxBody qualified as L
import Cardano.Ledger.Alonzo.TxWits qualified as L
import Cardano.Ledger.Api qualified as L
import Cardano.Ledger.Core qualified as L
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 (ToJSON (..), (.=))
import Data.Aeson qualified as Aeson
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 Data.Typeable (cast)
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
"makeUnsignedTx: Dijkstra era not supported yet"
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

-- | Pre-Alonzo eras have no datums or reference scripts, so the JSON
-- output is just address and value.
instance ToJSON (TxOut L.ShelleyEra) where
  toJSON :: TxOut ShelleyEra -> Value
toJSON (TxOut TxOut ShelleyEra
o) = TxOut ShelleyEra -> Value
forall era. EraTxOut era => TxOut era -> Value
txOutBaseJson TxOut ShelleyEra
o

instance ToJSON (TxOut L.AllegraEra) where
  toJSON :: TxOut AllegraEra -> Value
toJSON (TxOut TxOut AllegraEra
o) = TxOut AllegraEra -> Value
forall era. EraTxOut era => TxOut era -> Value
txOutBaseJson TxOut AllegraEra
o

instance ToJSON (TxOut L.MaryEra) where
  toJSON :: TxOut MaryEra -> Value
toJSON (TxOut TxOut MaryEra
o) = TxOut MaryEra -> Value
forall era. EraTxOut era => TxOut era -> Value
txOutBaseJson TxOut MaryEra
o

-- | 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 = TxOut AlonzoEra -> Value
forall era.
(AnyEraTxOut era, AlonzoEraScript era) =>
TxOut era -> Value
alonzoOnwardsTxOutToJson

instance ToJSON (TxOut L.BabbageEra) where toJSON :: TxOut BabbageEra -> Value
toJSON = TxOut BabbageEra -> Value
forall era.
(AnyEraTxOut era, AlonzoEraScript era) =>
TxOut era -> Value
alonzoOnwardsTxOutToJson

instance ToJSON (TxOut L.ConwayEra) where toJSON :: TxOut ConwayEra -> Value
toJSON = TxOut ConwayEra -> Value
forall era.
(AnyEraTxOut era, AlonzoEraScript era) =>
TxOut era -> Value
alonzoOnwardsTxOutToJson

alonzoOnwardsTxOutToJson
  :: (L.AnyEraTxOut era, L.AlonzoEraScript era) => TxOut era -> Aeson.Value
alonzoOnwardsTxOutToJson :: forall era.
(AnyEraTxOut era, AlonzoEraScript era) =>
TxOut era -> Value
alonzoOnwardsTxOutToJson (TxOut TxOut era
o) =
  [Pair] -> Value
Aeson.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$
    [ 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 era
o TxOut era -> Getting Addr (TxOut era) Addr -> Addr
forall s a. s -> Getting a s a -> a
^. Getting Addr (TxOut era) Addr
forall era. EraTxOut era => Lens' (TxOut era) Addr
Lens' (TxOut 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
.= Value era -> Value
forall v. Val v => v -> Value
valueToJson (TxOut era
o TxOut era
-> Getting (Value era) (TxOut era) (Value era) -> Value era
forall s a. s -> Getting a s a -> a
^. Getting (Value era) (TxOut era) (Value era)
forall era. EraTxOut era => Lens' (TxOut era) (Value era)
Lens' (TxOut era) (Value era)
L.valueTxOutL)
    ]
      [Pair] -> [Pair] -> [Pair]
forall a. Semigroup a => a -> a -> a
<> Maybe (Datum era) -> [Pair]
forall {e} {a} {era}. KeyValue e a => Maybe (Datum era) -> [a]
datumFields Maybe (Datum era)
mDatum
      [Pair] -> [Pair] -> [Pair]
forall a. Semigroup a => a -> a -> a
<> Bool -> Maybe (Datum era) -> [Pair]
forall {era} {e} {a}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat MinVersion (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat MinVersion (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Era era, KeyValue e a) =>
Bool -> Maybe (Datum era) -> [a]
inlineDatumFields Bool
isBabbagePlus Maybe (Datum era)
mDatum
      [Pair] -> [Pair] -> [Pair]
forall a. Semigroup a => a -> a -> a
<> Maybe (Maybe (Script era)) -> [Pair]
forall {era} {e} {a}.
(Assert
   (OrdCond
      (CmpNat (ProtVerLow era) (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat MinVersion (ProtVerLow era)) 'True 'True 'False)
   (TypeError ...),
 Assert
   (OrdCond (CmpNat MinVersion (ProtVerHigh era)) 'True 'True 'False)
   (TypeError ...),
 KeyValue e a, AlonzoEraScript era) =>
Maybe (Maybe (Script era)) -> [a]
refScriptFields Maybe (Maybe (Script era))
mRefScript
 where
  mDatum :: Maybe (Datum era)
mDatum = TxOut era
o TxOut era
-> Getting (Maybe (Datum era)) (TxOut era) (Maybe (Datum era))
-> Maybe (Datum era)
forall s a. s -> Getting a s a -> a
^. Getting (Maybe (Datum era)) (TxOut era) (Maybe (Datum era))
forall era.
AnyEraTxOut era =>
SimpleGetter (TxOut era) (Maybe (Datum era))
SimpleGetter (TxOut era) (Maybe (Datum era))
L.datumTxOutG
  mRefScript :: Maybe (Maybe (Script era))
mRefScript = TxOut era
o TxOut era
-> Getting
     (Maybe (Maybe (Script era)))
     (TxOut era)
     (Maybe (Maybe (Script era)))
-> Maybe (Maybe (Script era))
forall s a. s -> Getting a s a -> a
^. Getting
  (Maybe (Maybe (Script era)))
  (TxOut era)
  (Maybe (Maybe (Script era)))
forall era.
AnyEraTxOut era =>
SimpleGetter (TxOut era) (Maybe (Maybe (Script era)))
SimpleGetter (TxOut era) (Maybe (Maybe (Script era)))
L.referenceScriptTxOutG
  isBabbagePlus :: Bool
isBabbagePlus = Maybe (Maybe (Script era)) -> Bool
forall a. Maybe a -> Bool
isJust Maybe (Maybe (Script era))
mRefScript

  datumFields :: Maybe (Datum era) -> [a]
datumFields Maybe (Datum era)
Nothing = []
  datumFields (Just Datum era
L.NoDatum) =
    [Key
"datumhash" Key -> Value -> a
forall v. ToJSON v => Key -> v -> a
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value
Aeson.Null, Key
"datum" Key -> Value -> a
forall v. ToJSON v => Key -> v -> a
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value
Aeson.Null]
  datumFields (Just (L.DatumHash SafeHash EraIndependentData
dh)) =
    [Key
"datumhash" Key -> SafeHash EraIndependentData -> a
forall v. ToJSON v => Key -> v -> a
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= SafeHash EraIndependentData
dh, Key
"datum" Key -> Value -> a
forall v. ToJSON v => Key -> v -> a
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value
Aeson.Null]
  datumFields (Just (L.Datum BinaryData era
_)) =
    [Key
"datum" Key -> Value -> a
forall v. ToJSON v => Key -> v -> a
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value
Aeson.Null]

  inlineDatumFields :: Bool -> Maybe (Datum era) -> [a]
inlineDatumFields Bool
_ (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 -> a
forall v. ToJSON v => Key -> v -> a
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 -> a
forall v. ToJSON v => Key -> v -> a
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= HashableScriptData -> Value
Api.scriptDataToJsonDetailedSchema HashableScriptData
hsd
        , Key
"inlineDatumRaw"
            Key -> Value -> a
forall v. ToJSON v => Key -> v -> a
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
               )
        ]
  inlineDatumFields Bool
True Maybe (Datum era)
_ =
    [Key
"inlineDatum" Key -> Value -> a
forall v. ToJSON v => Key -> v -> a
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value
Aeson.Null, Key
"inlineDatumRaw" Key -> Value -> a
forall v. ToJSON v => Key -> v -> a
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value
Aeson.Null]
  inlineDatumFields Bool
_ Maybe (Datum era)
_ = []

  refScriptFields :: Maybe (Maybe (Script era)) -> [a]
refScriptFields Maybe (Maybe (Script era))
Nothing = []
  refScriptFields (Just Maybe (Script era)
Nothing) = [Key
"referenceScript" Key -> Value -> a
forall v. ToJSON v => Key -> v -> a
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value
Aeson.Null]
  refScriptFields (Just (Just Script era
script)) =
    [Key
"referenceScript" Key -> ScriptInAnyLang -> a
forall v. ToJSON v => Key -> v -> a
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.
txOutBaseJson :: L.EraTxOut era => L.TxOut era -> Aeson.Value
txOutBaseJson :: forall era. EraTxOut era => TxOut era -> Value
txOutBaseJson TxOut era
o =
  [Pair] -> Value
Aeson.object
    [ 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 era
o TxOut era -> Getting Addr (TxOut era) Addr -> Addr
forall s a. s -> Getting a s a -> a
^. Getting Addr (TxOut era) Addr
forall era. EraTxOut era => Lens' (TxOut era) Addr
Lens' (TxOut 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
.= Value era -> Value
forall v. Val v => v -> Value
valueToJson (TxOut era
o TxOut era
-> Getting (Value era) (TxOut era) (Value era) -> Value era
forall s a. s -> Getting a s a -> a
^. Getting (Value era) (TxOut era) (Value era)
forall era. EraTxOut era => Lens' (TxOut era) (Value era)
Lens' (TxOut era) (Value 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 value to JSON using the cardano-api 'Value' format.
-- Uses 'Typeable' to detect 'MaryValue' (multi-asset) vs 'Coin' (ada-only).
valueToJson :: L.Val v => v -> Aeson.Value
valueToJson :: forall v. Val v => v -> Value
valueToJson v
v = case v -> Maybe MaryValue
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast v
v of
  Just (MaryValue
mv :: L.MaryValue) -> Value -> Value
forall a. ToJSON a => a -> Value
toJSON (MaryValue -> Value
fromMaryValue MaryValue
mv)
  Maybe MaryValue
Nothing -> Value -> Value
forall a. ToJSON a => a -> Value
toJSON (Coin -> Value
lovelaceToValue (v -> Coin
forall t. Val t => t -> Coin
L.coin v
v))

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

deriving instance (Show (TxOut era))

deriving instance (Eq (TxOut era))

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)

hashableScriptDatumToDatumAndHash :: L.Era era => Api.HashableScriptData -> (L.DataHash, L.Data era)
hashableScriptDatumToDatumAndHash :: forall era.
Era era =>
HashableScriptData -> (SafeHash EraIndependentData, Data era)
hashableScriptDatumToDatumAndHash HashableScriptData
sd =
  (Hash ScriptData -> SafeHash EraIndependentData
Api.unScriptDataHash (Hash ScriptData -> SafeHash EraIndependentData)
-> Hash ScriptData -> SafeHash EraIndependentData
forall a b. (a -> b) -> a -> b
$ HashableScriptData -> Hash ScriptData
Api.hashScriptDataBytes HashableScriptData
sd, HashableScriptData -> Data era
forall ledgerera.
Era ledgerera =>
HashableScriptData -> Data ledgerera
Api.toAlonzoData HashableScriptData
sd)

legacyDatumToDatum
  :: forall era. IsEra era => OldApi.TxOutDatum CtxTx era -> Maybe (Datum CtxTx (LedgerEra era))
legacyDatumToDatum :: forall era.
IsEra era =>
TxOutDatum CtxTx era -> Maybe (Datum CtxTx (LedgerEra era))
legacyDatumToDatum (OldApi.TxOutDatumHash AlonzoEraOnwards era
_ Hash ScriptData
h) = Datum CtxTx (LedgerEra era) -> Maybe (Datum CtxTx (LedgerEra era))
forall a. a -> Maybe a
Just (SafeHash EraIndependentData -> Datum CtxTx (LedgerEra era)
forall ctx era. SafeHash EraIndependentData -> Datum ctx era
TxOutDatumHash (SafeHash EraIndependentData -> Datum CtxTx (LedgerEra era))
-> SafeHash EraIndependentData -> Datum CtxTx (LedgerEra era)
forall a b. (a -> b) -> a -> b
$ Hash ScriptData -> SafeHash EraIndependentData
Api.unScriptDataHash Hash ScriptData
h)
legacyDatumToDatum (OldApi.TxOutSupplementalDatum AlonzoEraOnwards era
_ HashableScriptData
hd) = do
  let (SafeHash EraIndependentData
hash, Data (LedgerEra era)
d) = Era era
-> (EraCommonConstraints era =>
    (SafeHash EraIndependentData, Data (LedgerEra era)))
-> (SafeHash EraIndependentData, Data (LedgerEra era))
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era =>
  (SafeHash EraIndependentData, Data (LedgerEra era)))
 -> (SafeHash EraIndependentData, Data (LedgerEra era)))
-> (EraCommonConstraints era =>
    (SafeHash EraIndependentData, Data (LedgerEra era)))
-> (SafeHash EraIndependentData, Data (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ HashableScriptData
-> (SafeHash EraIndependentData, Data (LedgerEra era))
forall era.
Era era =>
HashableScriptData -> (SafeHash EraIndependentData, Data era)
hashableScriptDatumToDatumAndHash HashableScriptData
hd
  Datum CtxTx (LedgerEra era) -> Maybe (Datum CtxTx (LedgerEra era))
forall a. a -> Maybe a
Just (SafeHash EraIndependentData
-> Data (LedgerEra era) -> Datum CtxTx (LedgerEra era)
forall era.
SafeHash EraIndependentData -> Data era -> Datum CtxTx era
TxOutSupplementalDatum SafeHash EraIndependentData
hash Data (LedgerEra era)
d)
legacyDatumToDatum (OldApi.TxOutDatumInline BabbageEraOnwards era
_ HashableScriptData
hd) = do
  let (SafeHash EraIndependentData
hash, Data (LedgerEra era)
d) = Era era
-> (EraCommonConstraints era =>
    (SafeHash EraIndependentData, Data (LedgerEra era)))
-> (SafeHash EraIndependentData, Data (LedgerEra era))
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era =>
  (SafeHash EraIndependentData, Data (LedgerEra era)))
 -> (SafeHash EraIndependentData, Data (LedgerEra era)))
-> (EraCommonConstraints era =>
    (SafeHash EraIndependentData, Data (LedgerEra era)))
-> (SafeHash EraIndependentData, Data (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ HashableScriptData
-> (SafeHash EraIndependentData, Data (LedgerEra era))
forall era.
Era era =>
HashableScriptData -> (SafeHash EraIndependentData, Data era)
hashableScriptDatumToDatumAndHash HashableScriptData
hd
  Datum CtxTx (LedgerEra era) -> Maybe (Datum CtxTx (LedgerEra era))
forall a. a -> Maybe a
Just (SafeHash EraIndependentData
-> Data (LedgerEra era) -> Datum CtxTx (LedgerEra era)
forall era ctx.
SafeHash EraIndependentData -> Data era -> Datum ctx era
TxOutDatumInline SafeHash EraIndependentData
hash Data (LedgerEra era)
d)
legacyDatumToDatum TxOutDatum CtxTx era
OldApi.TxOutDatumNone = Maybe (Datum CtxTx (LedgerEra era))
forall a. Maybe a
Nothing

fromLegacyTxOut
  :: forall era
   . IsEra era
  => OldApi.TxOut CtxTx era
  -> Either DatumDecodingError (TxOut (LedgerEra era), Map L.DataHash (L.Data (LedgerEra era)))
fromLegacyTxOut :: forall era.
IsEra era =>
TxOut CtxTx era
-> Either
     DatumDecodingError
     (TxOut (LedgerEra era),
      Map (SafeHash EraIndependentData) (Data (LedgerEra era)))
fromLegacyTxOut tOut :: TxOut CtxTx era
tOut@(OldApi.TxOut AddressInEra era
_ TxOutValue era
_ TxOutDatum CtxTx era
d ReferenceScript era
_) = do
  let o :: TxOut (ShelleyLedgerEra era)
o = ShelleyBasedEra era
-> TxOut CtxTx era -> TxOut (ShelleyLedgerEra era)
forall ctx era ledgerera.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera) =>
ShelleyBasedEra era -> TxOut ctx era -> TxOut ledgerera
OldApi.toShelleyTxOutAny (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 -> ShelleyBasedEra era) -> Era era -> ShelleyBasedEra era
forall a b. (a -> b) -> a -> b
$ forall era. IsEra era => Era era
useEra @era) TxOut CtxTx era
tOut
  newDatum :: L.Datum (LedgerEra era) <- Era era
-> (EraCommonConstraints era =>
    Either DatumDecodingError (Datum (LedgerEra era)))
-> Either DatumDecodingError (Datum (LedgerEra era))
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era =>
  Either DatumDecodingError (Datum (LedgerEra era)))
 -> Either DatumDecodingError (Datum (LedgerEra era)))
-> (EraCommonConstraints era =>
    Either DatumDecodingError (Datum (LedgerEra era)))
-> Either DatumDecodingError (Datum (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ TxOutDatum CtxTx era
-> Either DatumDecodingError (Datum (LedgerEra era))
forall era.
Era (LedgerEra era) =>
TxOutDatum CtxTx era
-> Either DatumDecodingError (Datum (LedgerEra era))
toLedgerDatum TxOutDatum CtxTx era
d
  let txOut = Era era
-> (EraCommonConstraints era => TxOut (LedgerEra era))
-> TxOut (LedgerEra era)
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era => TxOut (LedgerEra era))
 -> TxOut (LedgerEra era))
-> (EraCommonConstraints era => TxOut (LedgerEra era))
-> TxOut (LedgerEra era)
forall a b. (a -> b) -> a -> b
$ TxOut (LedgerEra era) -> TxOut (LedgerEra era)
forall era. EraTxOut era => TxOut era -> TxOut era
TxOut (TxOut (LedgerEra era) -> TxOut (LedgerEra era))
-> TxOut (LedgerEra era) -> TxOut (LedgerEra era)
forall a b. (a -> b) -> a -> b
$ TxOut (ShelleyLedgerEra era)
TxOut (LedgerEra era)
o TxOut (LedgerEra era)
-> (TxOut (LedgerEra era) -> TxOut (LedgerEra era))
-> TxOut (LedgerEra era)
forall a b. a -> (a -> b) -> b
& (Datum (LedgerEra era) -> Identity (Datum (LedgerEra era)))
-> TxOut (LedgerEra era) -> Identity (TxOut (LedgerEra era))
forall era. BabbageEraTxOut era => Lens' (TxOut era) (Datum era)
Lens' (TxOut (LedgerEra era)) (Datum (LedgerEra era))
L.datumTxOutL ((Datum (LedgerEra era) -> Identity (Datum (LedgerEra era)))
 -> TxOut (LedgerEra era) -> Identity (TxOut (LedgerEra era)))
-> Datum (LedgerEra era)
-> TxOut (LedgerEra era)
-> TxOut (LedgerEra era)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Datum (LedgerEra era)
newDatum
      suppDats = Era era
-> (EraCommonConstraints era =>
    Map (SafeHash EraIndependentData) (Data (LedgerEra era)))
-> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
forall era a. Era era -> (EraCommonConstraints era => a) -> a
obtainCommonConstraints (forall era. IsEra era => Era era
useEra @era) ((EraCommonConstraints era =>
  Map (SafeHash EraIndependentData) (Data (LedgerEra era)))
 -> Map (SafeHash EraIndependentData) (Data (LedgerEra era)))
-> (EraCommonConstraints era =>
    Map (SafeHash EraIndependentData) (Data (LedgerEra era)))
-> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ TxOutDatum CtxTx era
-> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
forall era.
Era (LedgerEra era) =>
TxOutDatum CtxTx era
-> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
supplementalDatumFromLegacy TxOutDatum CtxTx era
d
  return (txOut, suppDats)

-- | Extract supplemental datum data from a legacy 'TxOutDatum'.
-- Returns 'mempty' for non-supplemental datums.
supplementalDatumFromLegacy
  :: L.Era (LedgerEra era)
  => OldApi.TxOutDatum CtxTx era
  -> Map L.DataHash (L.Data (LedgerEra era))
supplementalDatumFromLegacy :: forall era.
Era (LedgerEra era) =>
TxOutDatum CtxTx era
-> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
supplementalDatumFromLegacy (OldApi.TxOutSupplementalDatum AlonzoEraOnwards era
_ HashableScriptData
h) =
  let ledgerData :: Data (LedgerEra era)
ledgerData = HashableScriptData -> Data (LedgerEra era)
forall ledgerera.
Era ledgerera =>
HashableScriptData -> Data ledgerera
Api.toAlonzoData HashableScriptData
h
   in [Item (Map (SafeHash EraIndependentData) (Data (LedgerEra era)))]
-> Map (SafeHash EraIndependentData) (Data (LedgerEra era))
forall l. IsList l => [Item l] -> l
fromList [(Data (LedgerEra era) -> SafeHash EraIndependentData
forall era. Data era -> SafeHash EraIndependentData
L.hashData Data (LedgerEra era)
ledgerData, Data (LedgerEra era)
ledgerData)]
supplementalDatumFromLegacy TxOutDatum CtxTx era
_ = Map (SafeHash EraIndependentData) (Data (LedgerEra era))
forall a. Monoid a => a
mempty

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

instance Error DatumDecodingError where
  prettyError :: forall ann. DatumDecodingError -> Doc ann
prettyError (DatumDecodingError String
msg) = Doc ann
"Datum decoding error: " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> String -> Doc ann
forall a ann. Show a => a -> Doc ann
pshow String
msg

toLedgerDatum
  :: L.Era (LedgerEra era)
  => OldApi.TxOutDatum CtxTx era -> Either DatumDecodingError (L.Datum (LedgerEra era))
toLedgerDatum :: forall era.
Era (LedgerEra era) =>
TxOutDatum CtxTx era
-> Either DatumDecodingError (Datum (LedgerEra era))
toLedgerDatum TxOutDatum CtxTx era
OldApi.TxOutDatumNone = Datum (LedgerEra era)
-> Either DatumDecodingError (Datum (LedgerEra era))
forall a b. b -> Either a b
Right Datum (LedgerEra era)
forall era. Datum era
L.NoDatum
toLedgerDatum (OldApi.TxOutDatumHash AlonzoEraOnwards era
_ (Api.ScriptDataHash SafeHash EraIndependentData
h)) = Datum (LedgerEra era)
-> Either DatumDecodingError (Datum (LedgerEra era))
forall a b. b -> Either a b
Right (Datum (LedgerEra era)
 -> Either DatumDecodingError (Datum (LedgerEra era)))
-> Datum (LedgerEra era)
-> Either DatumDecodingError (Datum (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ SafeHash EraIndependentData -> Datum (LedgerEra era)
forall era. SafeHash EraIndependentData -> Datum era
L.DatumHash SafeHash EraIndependentData
h
toLedgerDatum (OldApi.TxOutSupplementalDatum AlonzoEraOnwards era
_ HashableScriptData
h) =
  Datum (LedgerEra era)
-> Either DatumDecodingError (Datum (LedgerEra era))
forall a b. b -> Either a b
Right (Datum (LedgerEra era)
 -> Either DatumDecodingError (Datum (LedgerEra era)))
-> Datum (LedgerEra era)
-> Either DatumDecodingError (Datum (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ SafeHash EraIndependentData -> Datum (LedgerEra era)
forall era. SafeHash EraIndependentData -> Datum era
L.DatumHash (Hash ScriptData -> SafeHash EraIndependentData
Api.unScriptDataHash (Hash ScriptData -> SafeHash EraIndependentData)
-> Hash ScriptData -> SafeHash EraIndependentData
forall a b. (a -> b) -> a -> b
$ HashableScriptData -> Hash ScriptData
Api.hashScriptDataBytes HashableScriptData
h)
toLedgerDatum (OldApi.TxOutDatumInline BabbageEraOnwards era
_ HashableScriptData
h) =
  case ShortByteString -> Either String (BinaryData (LedgerEra era))
forall era.
Era era =>
ShortByteString -> Either String (BinaryData era)
L.makeBinaryData (ShortByteString -> Either String (BinaryData (LedgerEra era)))
-> ShortByteString -> Either String (BinaryData (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ ByteString -> ShortByteString
SBS.toShort (ByteString -> ShortByteString) -> ByteString -> ShortByteString
forall a b. (a -> b) -> a -> b
$ HashableScriptData -> ByteString
Api.getOriginalScriptDataBytes HashableScriptData
h of
    Left String
e -> DatumDecodingError
-> Either DatumDecodingError (Datum (LedgerEra era))
forall a b. a -> Either a b
Left (DatumDecodingError
 -> Either DatumDecodingError (Datum (LedgerEra era)))
-> DatumDecodingError
-> Either DatumDecodingError (Datum (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ String -> DatumDecodingError
DatumDecodingError String
e
    Right BinaryData (LedgerEra era)
bd -> Datum (LedgerEra era)
-> Either DatumDecodingError (Datum (LedgerEra era))
forall a b. b -> Either a b
Right (Datum (LedgerEra era)
 -> Either DatumDecodingError (Datum (LedgerEra era)))
-> Datum (LedgerEra era)
-> Either DatumDecodingError (Datum (LedgerEra era))
forall a b. (a -> b) -> a -> b
$ BinaryData (LedgerEra era) -> Datum (LedgerEra era)
forall era. BinaryData era -> Datum era
L.Datum BinaryData (LedgerEra era)
bd

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
"extractWitnessableVotes: Dijkstra 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)}