-- | This module provides the description of a transaction skeleton. We have our
-- own representation of a transaction for many reasons. Here are some of them:
--
-- - our transaction skeletons are typed (datums, validators, outputs...)
--
-- - each transaction skeleton comes with its own set of generation options
--
-- - our transaction skeleton is by default anchored in the latest Cardano era
--
-- - each field in our transaction skeleton comes with a set of helpers and
-- - smart constructor to ease the transaction creation
--
-- - we can have default or automated behavior for the parts of the transactions
-- that are less relevant to testing, such as collaterals or fees
module Cooked.Skeleton
  ( module X,
    TxSkel (..),
    txSkelLabelL,
    txSkelOptsL,
    txSkelMintsL,
    txSkelValidityRangeL,
    txSkelProposalsL,
    txSkelSignersL,
    txSkelInsL,
    txSkelInsReferenceL,
    txSkelOutsL,
    txSkelWithdrawalsL,
    txSkelTemplate,
    txSkelKnownTxOutRefs,
    txSkelWithdrawnValue,
    txSkelWithdrawingScripts,
    txSkelValueInOutputs,
    txSkelInsReferenceInRedeemers,
    txSkelProposingScripts,
    txSkelMintingScripts,
  )
where

import Cooked.Skeleton.Datum as X
import Cooked.Skeleton.Label as X
import Cooked.Skeleton.Mint as X
import Cooked.Skeleton.Option as X
import Cooked.Skeleton.Output as X
import Cooked.Skeleton.Payable as X
import Cooked.Skeleton.Proposal as X
import Cooked.Skeleton.Redeemer as X
import Cooked.Skeleton.ReferenceScript as X
import Cooked.Skeleton.Value as X
import Cooked.Skeleton.Withdrawal as X
import Cooked.Wallet
import Data.Default
import Data.Either
import Data.Map (Map)
import Data.Map qualified as Map
import Data.Maybe
import Data.Set (Set)
import Data.Set qualified as Set
import Ledger.Slot qualified as Ledger
import Optics.Core
import Optics.TH
import Plutus.Script.Utils.Scripts qualified as Script
import Plutus.Script.Utils.Value qualified as Script
import PlutusLedgerApi.V3 qualified as Api

-- | A transaction skeleton. This is cooked-validators's variant of transaction
-- bodies, eventually translated to Cardano @TxBody@.
data TxSkel where
  TxSkel ::
    { -- | Labels do not influence the transaction generation at all; they are
      -- pretty-printed whenever cooked-validators prints a transaction, and can
      -- therefore make the output more informative (and greppable).
      TxSkel -> Set TxLabel
txSkelLabel :: Set TxLabel,
      -- | Some options that control transaction generation.
      TxSkel -> TxOpts
txSkelOpts :: TxOpts,
      -- | Any value minted or burned by the transaction. You'll probably want
      -- to use 'Cooked.Skeleton.Mint.txSkelMintsFromList' to construct this.
      TxSkel -> TxSkelMints
txSkelMints :: TxSkelMints,
      -- | The wallets signing the transaction. This list must contain at least
      -- one element. By default, the first signer will pay for fees and
      -- balancing. You can change that with
      -- 'Cooked.Skeleton.Option.txOptBalancingPolicy'.
      TxSkel -> [Wallet]
txSkelSigners :: [Wallet],
      TxSkel -> SlotRange
txSkelValidityRange :: Ledger.SlotRange,
      -- | To each 'Api.TxOutRef' the transaction should consume, add a redeemer
      -- specifying how to spend it. You must make sure that
      --
      -- - On 'Api.TxOutRef's referencing UTxOs belonging to public keys, use
      --   the 'Cooked.Skeleton.Redeemer.emptyTxSkelRedeemer' smart constructor.
      --
      -- - On 'Api.TxOutRef's referencing UTxOs belonging to scripts, use
      --   the 'Cooked.Skeleton.Redeemer.someTxSkelRedeemer' smart constructor.
      TxSkel -> Map TxOutRef TxSkelRedeemer
txSkelIns :: Map Api.TxOutRef TxSkelRedeemer,
      -- | All outputs directly referenced by the transaction. Each of them will
      -- be directly translated into a Cardano reference input. Additional
      -- reference inputs can be found within the various redeemers of the
      -- skeleton to host reference scripts. Function
      -- 'txSkelInsReferenceInRedeemers' collects those all.
      TxSkel -> Set TxOutRef
txSkelInsReference :: Set Api.TxOutRef,
      -- | The outputs of the transaction. These will occur in exactly this
      -- order on the transaction.
      TxSkel -> [TxSkelOut]
txSkelOuts :: [TxSkelOut],
      -- | Possible proposals issued in this transaction to be voted on and
      -- possible enacted later on.
      TxSkel -> [TxSkelProposal]
txSkelProposals :: [TxSkelProposal],
      -- | Withdrawals performed by the transaction
      TxSkel -> TxSkelWithdrawals
txSkelWithdrawals :: TxSkelWithdrawals
    } ->
    TxSkel
  deriving (Int -> TxSkel -> ShowS
[TxSkel] -> ShowS
TxSkel -> String
(Int -> TxSkel -> ShowS)
-> (TxSkel -> String) -> ([TxSkel] -> ShowS) -> Show TxSkel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TxSkel -> ShowS
showsPrec :: Int -> TxSkel -> ShowS
$cshow :: TxSkel -> String
show :: TxSkel -> String
$cshowList :: [TxSkel] -> ShowS
showList :: [TxSkel] -> ShowS
Show, TxSkel -> TxSkel -> Bool
(TxSkel -> TxSkel -> Bool)
-> (TxSkel -> TxSkel -> Bool) -> Eq TxSkel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TxSkel -> TxSkel -> Bool
== :: TxSkel -> TxSkel -> Bool
$c/= :: TxSkel -> TxSkel -> Bool
/= :: TxSkel -> TxSkel -> Bool
Eq)

-- | A lens to set of get labels from a 'TxSkel'
makeLensesFor [("txSkelLabel", "txSkelLabelL")] ''TxSkel

-- | A lens to set of get options from a 'TxSkel'
makeLensesFor [("txSkelOpts", "txSkelOptsL")] ''TxSkel

-- | A lens to set of get the minted value of a 'TxSkel'
makeLensesFor [("txSkelMints", "txSkelMintsL")] ''TxSkel

-- | A lens to set of get the validity range of a 'TxSkel'
makeLensesFor [("txSkelValidityRange", "txSkelValidityRangeL")] ''TxSkel

-- | A lens to set of get signers from a 'TxSkel'
makeLensesFor [("txSkelSigners", "txSkelSignersL")] ''TxSkel

-- | A lens to set of get inputs from a 'TxSkel'
makeLensesFor [("txSkelIns", "txSkelInsL")] ''TxSkel

-- | A lens to set of get reference inputs from a 'TxSkel'
makeLensesFor [("txSkelInsReference", "txSkelInsReferenceL")] ''TxSkel

-- | A lens to set of get outputs from a 'TxSkel'
makeLensesFor [("txSkelOuts", "txSkelOutsL")] ''TxSkel

-- | A lens to set of get proposals from a 'TxSkel'
makeLensesFor [("txSkelProposals", "txSkelProposalsL")] ''TxSkel

-- | A lens to set of get withdrawals from a 'TxSkel'
makeLensesFor [("txSkelWithdrawals", "txSkelWithdrawalsL")] ''TxSkel

-- | A convenience template of an empty transaction skeleton.
txSkelTemplate :: TxSkel
txSkelTemplate :: TxSkel
txSkelTemplate =
  TxSkel
    { txSkelLabel :: Set TxLabel
txSkelLabel = Set TxLabel
forall a. Set a
Set.empty,
      txSkelOpts :: TxOpts
txSkelOpts = TxOpts
forall a. Default a => a
def,
      txSkelMints :: TxSkelMints
txSkelMints = TxSkelMints
forall k a. Map k a
Map.empty,
      txSkelValidityRange :: SlotRange
txSkelValidityRange = SlotRange
forall a. Interval a
Api.always,
      txSkelSigners :: [Wallet]
txSkelSigners = [],
      txSkelIns :: Map TxOutRef TxSkelRedeemer
txSkelIns = Map TxOutRef TxSkelRedeemer
forall k a. Map k a
Map.empty,
      txSkelInsReference :: Set TxOutRef
txSkelInsReference = Set TxOutRef
forall a. Set a
Set.empty,
      txSkelOuts :: [TxSkelOut]
txSkelOuts = [],
      txSkelProposals :: [TxSkelProposal]
txSkelProposals = [],
      txSkelWithdrawals :: TxSkelWithdrawals
txSkelWithdrawals = TxSkelWithdrawals
forall k a. Map k a
Map.empty
    }

-- | Returns the full value contained in the skeleton outputs
txSkelValueInOutputs :: TxSkel -> Api.Value
txSkelValueInOutputs :: TxSkel -> Value
txSkelValueInOutputs = Optic' A_Fold '[] TxSkel Value -> TxSkel -> Value
forall k a (is :: IxList) s.
(Is k A_Fold, Monoid a) =>
Optic' k is s a -> s -> a
foldOf (Lens' TxSkel [TxSkelOut]
txSkelOutsL Lens' TxSkel [TxSkelOut]
-> Optic A_Fold '[] [TxSkelOut] [TxSkelOut] TxSkelOut TxSkelOut
-> Optic A_Fold '[] TxSkel TxSkel TxSkelOut TxSkelOut
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic A_Fold '[] [TxSkelOut] [TxSkelOut] TxSkelOut TxSkelOut
forall (f :: * -> *) a. Foldable f => Fold (f a) a
folded Optic A_Fold '[] TxSkel TxSkel TxSkelOut TxSkelOut
-> Optic
     A_Lens '[] TxSkelOut TxSkelOut TxSkelOutValue TxSkelOutValue
-> Optic A_Fold '[] TxSkel TxSkel TxSkelOutValue TxSkelOutValue
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic A_Lens '[] TxSkelOut TxSkelOut TxSkelOutValue TxSkelOutValue
txSkelOutValueL Optic A_Fold '[] TxSkel TxSkel TxSkelOutValue TxSkelOutValue
-> Optic A_Lens '[] TxSkelOutValue TxSkelOutValue Value Value
-> Optic' A_Fold '[] TxSkel Value
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic A_Lens '[] TxSkelOutValue TxSkelOutValue Value Value
txSkelOutValueContentL)

-- | All 'Api.TxOutRef's in reference inputs from redeemers
txSkelInsReferenceInRedeemers :: TxSkel -> Set Api.TxOutRef
txSkelInsReferenceInRedeemers :: TxSkel -> Set TxOutRef
txSkelInsReferenceInRedeemers TxSkel {[Wallet]
[TxSkelProposal]
[TxSkelOut]
Set TxOutRef
Set TxLabel
TxSkelWithdrawals
Map TxOutRef TxSkelRedeemer
TxSkelMints
SlotRange
TxOpts
txSkelLabel :: TxSkel -> Set TxLabel
txSkelOpts :: TxSkel -> TxOpts
txSkelMints :: TxSkel -> TxSkelMints
txSkelSigners :: TxSkel -> [Wallet]
txSkelValidityRange :: TxSkel -> SlotRange
txSkelIns :: TxSkel -> Map TxOutRef TxSkelRedeemer
txSkelInsReference :: TxSkel -> Set TxOutRef
txSkelOuts :: TxSkel -> [TxSkelOut]
txSkelProposals :: TxSkel -> [TxSkelProposal]
txSkelWithdrawals :: TxSkel -> TxSkelWithdrawals
txSkelLabel :: Set TxLabel
txSkelOpts :: TxOpts
txSkelMints :: TxSkelMints
txSkelSigners :: [Wallet]
txSkelValidityRange :: SlotRange
txSkelIns :: Map TxOutRef TxSkelRedeemer
txSkelInsReference :: Set TxOutRef
txSkelOuts :: [TxSkelOut]
txSkelProposals :: [TxSkelProposal]
txSkelWithdrawals :: TxSkelWithdrawals
..} =
  [TxOutRef] -> Set TxOutRef
forall a. Ord a => [a] -> Set a
Set.fromList ([TxOutRef] -> Set TxOutRef) -> [TxOutRef] -> Set TxOutRef
forall a b. (a -> b) -> a -> b
$
    (TxSkelRedeemer -> Maybe TxOutRef)
-> [TxSkelRedeemer] -> [TxOutRef]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe TxSkelRedeemer -> Maybe TxOutRef
txSkelRedeemerReferenceInput ([TxSkelRedeemer] -> [TxOutRef]) -> [TxSkelRedeemer] -> [TxOutRef]
forall a b. (a -> b) -> a -> b
$
      Map TxOutRef TxSkelRedeemer -> [TxSkelRedeemer]
forall k a. Map k a -> [a]
Map.elems Map TxOutRef TxSkelRedeemer
txSkelIns
        [TxSkelRedeemer] -> [TxSkelRedeemer] -> [TxSkelRedeemer]
forall a. Semigroup a => a -> a -> a
<> ((Versioned Script, TxSkelRedeemer) -> TxSkelRedeemer
forall a b. (a, b) -> b
snd ((Versioned Script, TxSkelRedeemer) -> TxSkelRedeemer)
-> [(Versioned Script, TxSkelRedeemer)] -> [TxSkelRedeemer]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TxSkelProposal -> Maybe (Versioned Script, TxSkelRedeemer))
-> [TxSkelProposal] -> [(Versioned Script, TxSkelRedeemer)]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe TxSkelProposal -> Maybe (Versioned Script, TxSkelRedeemer)
txSkelProposalWitness [TxSkelProposal]
txSkelProposals)
        [TxSkelRedeemer] -> [TxSkelRedeemer] -> [TxSkelRedeemer]
forall a. Semigroup a => a -> a -> a
<> ((TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> TxSkelRedeemer
forall a b. (a, b) -> a
fst ((TxSkelRedeemer, NEMap TokenName (NonZero Integer))
 -> TxSkelRedeemer)
-> [(TxSkelRedeemer, NEMap TokenName (NonZero Integer))]
-> [TxSkelRedeemer]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TxSkelMints
-> [(TxSkelRedeemer, NEMap TokenName (NonZero Integer))]
forall k a. Map k a -> [a]
Map.elems TxSkelMints
txSkelMints)
        [TxSkelRedeemer] -> [TxSkelRedeemer] -> [TxSkelRedeemer]
forall a. Semigroup a => a -> a -> a
<> ((TxSkelRedeemer, Lovelace) -> TxSkelRedeemer
forall a b. (a, b) -> a
fst ((TxSkelRedeemer, Lovelace) -> TxSkelRedeemer)
-> [(TxSkelRedeemer, Lovelace)] -> [TxSkelRedeemer]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TxSkelWithdrawals -> [(TxSkelRedeemer, Lovelace)]
forall k a. Map k a -> [a]
Map.elems TxSkelWithdrawals
txSkelWithdrawals)

-- | All `Api.TxOutRef`s known by a given transaction skeleton. This includes
-- TxOutRef`s used as inputs of the skeleton and 'Api.TxOutRef's used as reference
-- inputs of the skeleton.  This does not include additional possible
-- 'Api.TxOutRef's used for balancing and additional 'Api.TxOutRef's used as collateral
-- inputs, as they are not part of the skeleton.
txSkelKnownTxOutRefs :: TxSkel -> Set Api.TxOutRef
txSkelKnownTxOutRefs :: TxSkel -> Set TxOutRef
txSkelKnownTxOutRefs skel :: TxSkel
skel@TxSkel {[Wallet]
[TxSkelProposal]
[TxSkelOut]
Set TxOutRef
Set TxLabel
TxSkelWithdrawals
Map TxOutRef TxSkelRedeemer
TxSkelMints
SlotRange
TxOpts
txSkelLabel :: TxSkel -> Set TxLabel
txSkelOpts :: TxSkel -> TxOpts
txSkelMints :: TxSkel -> TxSkelMints
txSkelSigners :: TxSkel -> [Wallet]
txSkelValidityRange :: TxSkel -> SlotRange
txSkelIns :: TxSkel -> Map TxOutRef TxSkelRedeemer
txSkelInsReference :: TxSkel -> Set TxOutRef
txSkelOuts :: TxSkel -> [TxSkelOut]
txSkelProposals :: TxSkel -> [TxSkelProposal]
txSkelWithdrawals :: TxSkel -> TxSkelWithdrawals
txSkelLabel :: Set TxLabel
txSkelOpts :: TxOpts
txSkelMints :: TxSkelMints
txSkelSigners :: [Wallet]
txSkelValidityRange :: SlotRange
txSkelIns :: Map TxOutRef TxSkelRedeemer
txSkelInsReference :: Set TxOutRef
txSkelOuts :: [TxSkelOut]
txSkelProposals :: [TxSkelProposal]
txSkelWithdrawals :: TxSkelWithdrawals
..} =
  TxSkel -> Set TxOutRef
txSkelInsReferenceInRedeemers TxSkel
skel
    Set TxOutRef -> Set TxOutRef -> Set TxOutRef
forall a. Semigroup a => a -> a -> a
<> Map TxOutRef TxSkelRedeemer -> Set TxOutRef
forall k a. Map k a -> Set k
Map.keysSet Map TxOutRef TxSkelRedeemer
txSkelIns
    Set TxOutRef -> Set TxOutRef -> Set TxOutRef
forall a. Semigroup a => a -> a -> a
<> Set TxOutRef
txSkelInsReference

-- | Returns the total value withdrawn in this 'TxSkel'
txSkelWithdrawnValue :: TxSkel -> Api.Value
txSkelWithdrawnValue :: TxSkel -> Value
txSkelWithdrawnValue = [Value] -> Value
forall a. Monoid a => [a] -> a
mconcat ([Value] -> Value) -> (TxSkel -> [Value]) -> TxSkel -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Lovelace -> Value
forall a. ToValue a => a -> Value
Script.toValue (Lovelace -> Value)
-> ((Either (Versioned Script) PubKeyHash,
     (TxSkelRedeemer, Lovelace))
    -> Lovelace)
-> (Either (Versioned Script) PubKeyHash,
    (TxSkelRedeemer, Lovelace))
-> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxSkelRedeemer, Lovelace) -> Lovelace
forall a b. (a, b) -> b
snd ((TxSkelRedeemer, Lovelace) -> Lovelace)
-> ((Either (Versioned Script) PubKeyHash,
     (TxSkelRedeemer, Lovelace))
    -> (TxSkelRedeemer, Lovelace))
-> (Either (Versioned Script) PubKeyHash,
    (TxSkelRedeemer, Lovelace))
-> Lovelace
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Lovelace))
-> (TxSkelRedeemer, Lovelace)
forall a b. (a, b) -> b
snd ((Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Lovelace))
 -> Value)
-> [(Either (Versioned Script) PubKeyHash,
     (TxSkelRedeemer, Lovelace))]
-> [Value]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) ([(Either (Versioned Script) PubKeyHash,
   (TxSkelRedeemer, Lovelace))]
 -> [Value])
-> (TxSkel
    -> [(Either (Versioned Script) PubKeyHash,
         (TxSkelRedeemer, Lovelace))])
-> TxSkel
-> [Value]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkelWithdrawals
-> [(Either (Versioned Script) PubKeyHash,
     (TxSkelRedeemer, Lovelace))]
forall k a. Map k a -> [(k, a)]
Map.toList (TxSkelWithdrawals
 -> [(Either (Versioned Script) PubKeyHash,
      (TxSkelRedeemer, Lovelace))])
-> (TxSkel -> TxSkelWithdrawals)
-> TxSkel
-> [(Either (Versioned Script) PubKeyHash,
     (TxSkelRedeemer, Lovelace))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkel -> TxSkelWithdrawals
txSkelWithdrawals

-- | Returns all the scripts involved in withdrawals in this 'TxSkel'
txSkelWithdrawingScripts :: TxSkel -> [Script.Versioned Script.Script]
txSkelWithdrawingScripts :: TxSkel -> [Versioned Script]
txSkelWithdrawingScripts = ([Versioned Script], [PubKeyHash]) -> [Versioned Script]
forall a b. (a, b) -> a
fst (([Versioned Script], [PubKeyHash]) -> [Versioned Script])
-> (TxSkel -> ([Versioned Script], [PubKeyHash]))
-> TxSkel
-> [Versioned Script]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Either (Versioned Script) PubKeyHash]
-> ([Versioned Script], [PubKeyHash])
forall a b. [Either a b] -> ([a], [b])
partitionEithers ([Either (Versioned Script) PubKeyHash]
 -> ([Versioned Script], [PubKeyHash]))
-> (TxSkel -> [Either (Versioned Script) PubKeyHash])
-> TxSkel
-> ([Versioned Script], [PubKeyHash])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Lovelace))
-> Either (Versioned Script) PubKeyHash
forall a b. (a, b) -> a
fst ((Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Lovelace))
 -> Either (Versioned Script) PubKeyHash)
-> [(Either (Versioned Script) PubKeyHash,
     (TxSkelRedeemer, Lovelace))]
-> [Either (Versioned Script) PubKeyHash]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) ([(Either (Versioned Script) PubKeyHash,
   (TxSkelRedeemer, Lovelace))]
 -> [Either (Versioned Script) PubKeyHash])
-> (TxSkel
    -> [(Either (Versioned Script) PubKeyHash,
         (TxSkelRedeemer, Lovelace))])
-> TxSkel
-> [Either (Versioned Script) PubKeyHash]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkelWithdrawals
-> [(Either (Versioned Script) PubKeyHash,
     (TxSkelRedeemer, Lovelace))]
forall k a. Map k a -> [(k, a)]
Map.toList (TxSkelWithdrawals
 -> [(Either (Versioned Script) PubKeyHash,
      (TxSkelRedeemer, Lovelace))])
-> (TxSkel -> TxSkelWithdrawals)
-> TxSkel
-> [(Either (Versioned Script) PubKeyHash,
     (TxSkelRedeemer, Lovelace))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkel -> TxSkelWithdrawals
txSkelWithdrawals

-- | Returns all the scripts involved in proposals in this 'TxSkel'
txSkelProposingScripts :: TxSkel -> [Script.Versioned Script.Script]
txSkelProposingScripts :: TxSkel -> [Versioned Script]
txSkelProposingScripts = (TxSkelProposal -> Maybe (Versioned Script))
-> [TxSkelProposal] -> [Versioned Script]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (((Versioned Script, TxSkelRedeemer) -> Versioned Script)
-> Maybe (Versioned Script, TxSkelRedeemer)
-> Maybe (Versioned Script)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Versioned Script, TxSkelRedeemer) -> Versioned Script
forall a b. (a, b) -> a
fst (Maybe (Versioned Script, TxSkelRedeemer)
 -> Maybe (Versioned Script))
-> (TxSkelProposal -> Maybe (Versioned Script, TxSkelRedeemer))
-> TxSkelProposal
-> Maybe (Versioned Script)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkelProposal -> Maybe (Versioned Script, TxSkelRedeemer)
txSkelProposalWitness) ([TxSkelProposal] -> [Versioned Script])
-> (TxSkel -> [TxSkelProposal]) -> TxSkel -> [Versioned Script]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkel -> [TxSkelProposal]
txSkelProposals

-- | Returns all the scripts involved in minting in this 'TxSkel'
txSkelMintingScripts :: TxSkel -> [Script.Versioned Script.Script]
txSkelMintingScripts :: TxSkel -> [Versioned Script]
txSkelMintingScripts = (Mint -> Versioned Script) -> [Mint] -> [Versioned Script]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Mint -> Versioned Script
txSkelMintVersionedScript ([Mint] -> [Versioned Script])
-> (TxSkel -> [Mint]) -> TxSkel -> [Versioned Script]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkelMints -> [Mint]
txSkelMintsToList (TxSkelMints -> [Mint])
-> (TxSkel -> TxSkelMints) -> TxSkel -> [Mint]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkel -> TxSkelMints
txSkelMints