-- | This module provides the description of a transaction skeleton. We have our
-- own representation of a transaction for three main reasons:
--
-- - our transaction skeletons are typed (datums, validators, outputs...)
--
-- - with our own wrapper, we are less affected by plutus updates
--
-- - 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,
    txSkelDataInOutputs,
    txSkelValidatorsInOutputs,
    txSkelKnownTxOutRefs,
    txSkelWithdrawnValue,
    txSkelWithdrawalsScripts,
    txSkelValueInOutputs,
    txSkelReferenceScripts,
    txSkelReferenceTxOutRefs,
  )
where

import Cooked.Conversion
import Cooked.Output
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.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 PlutusLedgerApi.V3 qualified as Api

-- * Transaction skeletons

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 '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 'txOptBalanceWallet'.
      TxSkel -> [Wallet]
txSkelSigners :: [Wallet],
      TxSkel -> SlotRange
txSkelValidityRange :: Ledger.SlotRange,
      -- | To each 'TxOutRef' the transaction should consume, add a redeemer
      -- specifying how to spend it. You must make sure that
      --
      -- - On 'TxOutRef's referencing UTxOs belonging to public keys, you use
      --   the 'emptyTxSkelRedeemer' smart constructor.
      --
      -- - On 'TxOutRef's referencing UTxOs belonging to scripts, you must make
      --   sure that the type of the redeemer is appropriate for the script.
      TxSkel -> Map TxOutRef TxSkelRedeemer
txSkelIns :: Map Api.TxOutRef TxSkelRedeemer,
      -- | All outputs referenced by the transaction.
      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)

makeLensesFor
  [ ("txSkelLabel", "txSkelLabelL"),
    ("txSkelOpts", "txSkelOptsL"),
    ("txSkelMints", "txSkelMintsL"),
    ("txSkelValidityRange", "txSkelValidityRangeL"),
    ("txSkelSigners", "txSkelSignersL"),
    ("txSkelIns", "txSkelInsL"),
    ("txSkelInsReference", "txSkelInsReferenceL"),
    ("txSkelOuts", "txSkelOutsL"),
    ("txSkelProposals", "txSkelProposalsL"),
    ("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)

-- | Return all data on transaction outputs. This can contain duplicates, which
-- is intended.
txSkelDataInOutputs :: TxSkel -> [(Api.DatumHash, TxSkelOutDatum)]
txSkelDataInOutputs :: TxSkel -> [(DatumHash, TxSkelOutDatum)]
txSkelDataInOutputs =
  Optic' A_Fold '[] TxSkel TxSkelOutDatum
-> (TxSkelOutDatum -> [(DatumHash, TxSkelOutDatum)])
-> TxSkel
-> [(DatumHash, TxSkelOutDatum)]
forall k m (is :: IxList) s a.
(Is k A_Fold, Monoid m) =>
Optic' k is s a -> (a -> m) -> s -> m
foldMapOf
    ( 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 TxSkelOutDatum TxSkelOutDatum
-> Optic' A_Fold '[] TxSkel TxSkelOutDatum
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 TxSkelOutDatum TxSkelOutDatum
txSkelOutDatumL
    )
    ( \TxSkelOutDatum
txSkelOutDatum ->
        [(DatumHash, TxSkelOutDatum)]
-> (Datum -> [(DatumHash, TxSkelOutDatum)])
-> Maybe Datum
-> [(DatumHash, TxSkelOutDatum)]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
          []
          (\Datum
datum -> [(Datum -> DatumHash
Script.datumHash Datum
datum, TxSkelOutDatum
txSkelOutDatum)])
          (TxSkelOutDatum -> Maybe Datum
txSkelOutUntypedDatum TxSkelOutDatum
txSkelOutDatum)
    )

-- | All validators which will receive transaction outputs
txSkelValidatorsInOutputs :: TxSkel -> Map Script.ValidatorHash (Script.Versioned Script.Validator)
txSkelValidatorsInOutputs :: TxSkel -> Map ValidatorHash (Versioned Validator)
txSkelValidatorsInOutputs =
  [(ValidatorHash, Versioned Validator)]
-> Map ValidatorHash (Versioned Validator)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
    ([(ValidatorHash, Versioned Validator)]
 -> Map ValidatorHash (Versioned Validator))
-> (TxSkel -> [(ValidatorHash, Versioned Validator)])
-> TxSkel
-> Map ValidatorHash (Versioned Validator)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxSkelOut -> Maybe (ValidatorHash, Versioned Validator))
-> [TxSkelOut] -> [(ValidatorHash, Versioned Validator)]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe ((Versioned Validator -> (ValidatorHash, Versioned Validator))
-> Maybe (Versioned Validator)
-> Maybe (ValidatorHash, Versioned Validator)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Versioned Validator
val -> (Versioned Validator -> ValidatorHash
Script.validatorHash Versioned Validator
val, Versioned Validator
val)) (Maybe (Versioned Validator)
 -> Maybe (ValidatorHash, Versioned Validator))
-> (TxSkelOut -> Maybe (Versioned Validator))
-> TxSkelOut
-> Maybe (ValidatorHash, Versioned Validator)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkelOut -> Maybe (Versioned Validator)
txSkelOutValidator)
    ([TxSkelOut] -> [(ValidatorHash, Versioned Validator)])
-> (TxSkel -> [TxSkelOut])
-> TxSkel
-> [(ValidatorHash, Versioned Validator)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkel -> [TxSkelOut]
txSkelOuts

-- | All validators in the reference script field of transaction outputs
txSkelReferenceScripts :: TxSkel -> Map Script.ValidatorHash (Script.Versioned Script.Validator)
txSkelReferenceScripts :: TxSkel -> Map ValidatorHash (Versioned Validator)
txSkelReferenceScripts =
  [Map ValidatorHash (Versioned Validator)]
-> Map ValidatorHash (Versioned Validator)
forall a. Monoid a => [a] -> a
mconcat
    ([Map ValidatorHash (Versioned Validator)]
 -> Map ValidatorHash (Versioned Validator))
-> (TxSkel -> [Map ValidatorHash (Versioned Validator)])
-> TxSkel
-> Map ValidatorHash (Versioned Validator)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxSkelOut -> Map ValidatorHash (Versioned Validator))
-> [TxSkelOut] -> [Map ValidatorHash (Versioned Validator)]
forall a b. (a -> b) -> [a] -> [b]
map
      ( \(Pays o
output) ->
          case o
output o
-> Optic' A_Lens '[] o (Maybe (ReferenceScriptType o))
-> Maybe (ReferenceScriptType o)
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens '[] o (Maybe (ReferenceScriptType o))
forall o.
IsAbstractOutput o =>
Lens' o (Maybe (ReferenceScriptType o))
outputReferenceScriptL of
            Maybe (ReferenceScriptType o)
Nothing -> Map ValidatorHash (Versioned Validator)
forall k a. Map k a
Map.empty
            Just ReferenceScriptType o
x ->
              let vScript :: Versioned Script
vScript@(Script.Versioned Script
script Language
version) = ReferenceScriptType o -> Versioned Script
forall a. ToVersionedScript a => a -> Versioned Script
toVersionedScript ReferenceScriptType o
x
                  Script.ScriptHash BuiltinByteString
hash = Versioned Script -> ScriptHash
forall a. ToScriptHash a => a -> ScriptHash
toScriptHash Versioned Script
vScript
               in ValidatorHash
-> Versioned Validator -> Map ValidatorHash (Versioned Validator)
forall k a. k -> a -> Map k a
Map.singleton (BuiltinByteString -> ValidatorHash
Script.ValidatorHash BuiltinByteString
hash) (Versioned Validator -> Map ValidatorHash (Versioned Validator))
-> Versioned Validator -> Map ValidatorHash (Versioned Validator)
forall a b. (a -> b) -> a -> b
$ Validator -> Language -> Versioned Validator
forall script. script -> Language -> Versioned script
Script.Versioned (Script -> Validator
Script.Validator Script
script) Language
version
      )
    ([TxSkelOut] -> [Map ValidatorHash (Versioned Validator)])
-> (TxSkel -> [TxSkelOut])
-> TxSkel
-> [Map ValidatorHash (Versioned Validator)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkel -> [TxSkelOut]
txSkelOuts

-- | All `TxOutRefs` in reference inputs
txSkelReferenceTxOutRefs :: TxSkel -> [Api.TxOutRef]
txSkelReferenceTxOutRefs :: TxSkel -> [TxOutRef]
txSkelReferenceTxOutRefs 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
..} =
  -- direct reference inputs
  Set TxOutRef -> [TxOutRef]
forall a. Set a -> [a]
Set.toList Set TxOutRef
txSkelInsReference
    -- reference inputs in inputs redeemers
    [TxOutRef] -> [TxOutRef] -> [TxOutRef]
forall a. Semigroup a => a -> a -> a
<> (TxSkelRedeemer -> Maybe TxOutRef)
-> [TxSkelRedeemer] -> [TxOutRef]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe TxSkelRedeemer -> Maybe TxOutRef
txSkelReferenceInput (Map TxOutRef TxSkelRedeemer -> [TxSkelRedeemer]
forall k a. Map k a -> [a]
Map.elems Map TxOutRef TxSkelRedeemer
txSkelIns)
    -- reference inputs in proposals redeemers
    [TxOutRef] -> [TxOutRef] -> [TxOutRef]
forall a. Semigroup a => a -> a -> a
<> ((Versioned Script, TxSkelRedeemer) -> Maybe TxOutRef)
-> [(Versioned Script, TxSkelRedeemer)] -> [TxOutRef]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (TxSkelRedeemer -> Maybe TxOutRef
txSkelReferenceInput (TxSkelRedeemer -> Maybe TxOutRef)
-> ((Versioned Script, TxSkelRedeemer) -> TxSkelRedeemer)
-> (Versioned Script, TxSkelRedeemer)
-> Maybe TxOutRef
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Versioned Script, TxSkelRedeemer) -> TxSkelRedeemer
forall a b. (a, b) -> b
snd) ((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)
    -- reference inputs in mints redeemers
    [TxOutRef] -> [TxOutRef] -> [TxOutRef]
forall a. Semigroup a => a -> a -> a
<> ((Versioned MintingPolicy,
  (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))
 -> Maybe TxOutRef)
-> [(Versioned MintingPolicy,
     (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))]
-> [TxOutRef]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (TxSkelRedeemer -> Maybe TxOutRef
txSkelReferenceInput (TxSkelRedeemer -> Maybe TxOutRef)
-> ((Versioned MintingPolicy,
     (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))
    -> TxSkelRedeemer)
-> (Versioned MintingPolicy,
    (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))
-> Maybe TxOutRef
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> TxSkelRedeemer
forall a b. (a, b) -> a
fst ((TxSkelRedeemer, NEMap TokenName (NonZero Integer))
 -> TxSkelRedeemer)
-> ((Versioned MintingPolicy,
     (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))
    -> (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))
-> (Versioned MintingPolicy,
    (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))
-> TxSkelRedeemer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Versioned MintingPolicy,
 (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))
-> (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
forall a b. (a, b) -> b
snd) (TxSkelMints
-> [(Versioned MintingPolicy,
     (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))]
forall k a. Map k a -> [(k, a)]
Map.toList TxSkelMints
txSkelMints)

-- | All `TxOutRefs` known by a given transaction skeleton. This includes
-- TxOutRef`s used as inputs of the skeleton and `TxOutRef`s used as reference
-- inputs of the skeleton.  This does not include additional possible
-- `TxOutRef`s used for balancing and additional `TxOutRef`s used as collateral
-- inputs, as they are not part of the skeleton.
txSkelKnownTxOutRefs :: TxSkel -> [Api.TxOutRef]
txSkelKnownTxOutRefs :: TxSkel -> [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 -> [TxOutRef]
txSkelReferenceTxOutRefs TxSkel
skel [TxOutRef] -> [TxOutRef] -> [TxOutRef]
forall a. Semigroup a => a -> a -> a
<> Map TxOutRef TxSkelRedeemer -> [TxOutRef]
forall k a. Map k a -> [k]
Map.keys Map TxOutRef TxSkelRedeemer
txSkelIns

-- * Various Optics on 'TxSkels' and all the other types defined here

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
. (Ada -> Value
forall a. ToValue a => a -> Value
toValue (Ada -> Value)
-> ((Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))
    -> Ada)
-> (Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))
-> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxSkelRedeemer, Ada) -> Ada
forall a b. (a, b) -> b
snd ((TxSkelRedeemer, Ada) -> Ada)
-> ((Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))
    -> (TxSkelRedeemer, Ada))
-> (Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))
-> Ada
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))
-> (TxSkelRedeemer, Ada)
forall a b. (a, b) -> b
snd ((Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))
 -> Value)
-> [(Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))]
-> [Value]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) ([(Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))]
 -> [Value])
-> (TxSkel
    -> [(Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))])
-> TxSkel
-> [Value]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkelWithdrawals
-> [(Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))]
forall k a. Map k a -> [(k, a)]
Map.toList (TxSkelWithdrawals
 -> [(Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))])
-> (TxSkel -> TxSkelWithdrawals)
-> TxSkel
-> [(Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkel -> TxSkelWithdrawals
txSkelWithdrawals

txSkelWithdrawalsScripts :: TxSkel -> [Script.Versioned Script.Script]
txSkelWithdrawalsScripts :: TxSkel -> [Versioned Script]
txSkelWithdrawalsScripts = ([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, Ada))
-> Either (Versioned Script) PubKeyHash
forall a b. (a, b) -> a
fst ((Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))
 -> Either (Versioned Script) PubKeyHash)
-> [(Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))]
-> [Either (Versioned Script) PubKeyHash]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) ([(Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))]
 -> [Either (Versioned Script) PubKeyHash])
-> (TxSkel
    -> [(Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))])
-> TxSkel
-> [Either (Versioned Script) PubKeyHash]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkelWithdrawals
-> [(Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))]
forall k a. Map k a -> [(k, a)]
Map.toList (TxSkelWithdrawals
 -> [(Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))])
-> (TxSkel -> TxSkelWithdrawals)
-> TxSkel
-> [(Either (Versioned Script) PubKeyHash, (TxSkelRedeemer, Ada))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkel -> TxSkelWithdrawals
txSkelWithdrawals