{-# OPTIONS_GHC -Wno-orphans #-}

-- Mirrors the equivalent V3 module in plutus-ledger-api
module Plutarch.LedgerApi.V3.Contexts (
  PColdCommitteeCredential (..),
  PHotCommitteeCredential (..),
  PDRepCredential (..),
  PDRep (..),
  PDelegatee (..),
  PTxCert (..),
  PVoter (..),
  PVote (..),
  PGovernanceActionId (..),
  PCommittee (..),
  PConstitution (..),
  PProtocolVersion (..),
  PChangedParameters (..),
  PGovernanceAction (..),
  PProposalProcedure (..),
  PScriptPurpose (..),
  PScriptInfo (..),
  PTxInInfo (..),
  PTxInfo (..),
  PScriptContext (..),
  pfindOwnInput,
  pfindDatum,
  pfindDatumHash,
  pparseDatum,
  pfindTxInByTxOutRef,
  pfindContinuingOutputs,
  pgetContinuingOutputs,
  ptxSignedBy,
  ppubKeyOutputsAt,
  pvaluePaidTo,
  pvalueSpent,
  pvalueProduced,
  pownCurrencySymbol,
  pspendsOutput,
) where

import Data.Kind (Type)
import GHC.Generics (Generic)
import Generics.SOP qualified as SOP
import Plutarch.LedgerApi.AssocMap qualified as AssocMap
import Plutarch.LedgerApi.Interval qualified as Interval
import Plutarch.LedgerApi.Utils (PMaybeData, PRationalData)
import Plutarch.LedgerApi.V1.Address (PAddress (..))
import Plutarch.LedgerApi.V1.Credential (PCredential (PPubKeyCredential))
import Plutarch.LedgerApi.V1.Crypto (PPubKeyHash)
import Plutarch.LedgerApi.V1.Scripts (
  PDatum,
  PDatumHash,
  PRedeemer,
  PScriptHash,
 )
import Plutarch.LedgerApi.V1.Time (PPosixTime)
import Plutarch.LedgerApi.V2.Tx (PTxOut (..))
import Plutarch.LedgerApi.V3.MintValue qualified as MintValue
import Plutarch.LedgerApi.V3.Tx (PTxId, PTxOutRef (..))
import Plutarch.LedgerApi.Value (PLedgerValue, pemptyLedgerValue)
import Plutarch.LedgerApi.Value qualified as Value
import Plutarch.Maybe (pmapDropNothing, pmapMaybe)
import Plutarch.Prelude
import PlutusLedgerApi.V3 qualified as Plutus

-- | @since 3.1.0
newtype PColdCommitteeCredential (s :: S) = PColdCommitteeCredential (Term s PCredential)
  deriving stock
    ( -- | @since 3.1.0
      (forall x.
 PColdCommitteeCredential s -> Rep (PColdCommitteeCredential s) x)
-> (forall x.
    Rep (PColdCommitteeCredential s) x -> PColdCommitteeCredential s)
-> Generic (PColdCommitteeCredential s)
forall x.
Rep (PColdCommitteeCredential s) x -> PColdCommitteeCredential s
forall x.
PColdCommitteeCredential s -> Rep (PColdCommitteeCredential s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x.
Rep (PColdCommitteeCredential s) x -> PColdCommitteeCredential s
forall (s :: S) x.
PColdCommitteeCredential s -> Rep (PColdCommitteeCredential s) x
$cfrom :: forall (s :: S) x.
PColdCommitteeCredential s -> Rep (PColdCommitteeCredential s) x
from :: forall x.
PColdCommitteeCredential s -> Rep (PColdCommitteeCredential s) x
$cto :: forall (s :: S) x.
Rep (PColdCommitteeCredential s) x -> PColdCommitteeCredential s
to :: forall x.
Rep (PColdCommitteeCredential s) x -> PColdCommitteeCredential s
Generic
    )
  deriving anyclass
    ( -- | @since 3.3.0
      All SListI (Code (PColdCommitteeCredential s))
All SListI (Code (PColdCommitteeCredential s)) =>
(PColdCommitteeCredential s -> Rep (PColdCommitteeCredential s))
-> (Rep (PColdCommitteeCredential s) -> PColdCommitteeCredential s)
-> Generic (PColdCommitteeCredential s)
Rep (PColdCommitteeCredential s) -> PColdCommitteeCredential s
PColdCommitteeCredential s -> Rep (PColdCommitteeCredential s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PColdCommitteeCredential s))
forall (s :: S).
Rep (PColdCommitteeCredential s) -> PColdCommitteeCredential s
forall (s :: S).
PColdCommitteeCredential s -> Rep (PColdCommitteeCredential s)
$cfrom :: forall (s :: S).
PColdCommitteeCredential s -> Rep (PColdCommitteeCredential s)
from :: PColdCommitteeCredential s -> Rep (PColdCommitteeCredential s)
$cto :: forall (s :: S).
Rep (PColdCommitteeCredential s) -> PColdCommitteeCredential s
to :: Rep (PColdCommitteeCredential s) -> PColdCommitteeCredential s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s (PAsData PColdCommitteeCredential)
 -> Term s PColdCommitteeCredential)
-> (forall (s :: S).
    Term s PColdCommitteeCredential -> Term s PData)
-> PIsData PColdCommitteeCredential
forall (s :: S).
Term s (PAsData PColdCommitteeCredential)
-> Term s PColdCommitteeCredential
forall (s :: S). Term s PColdCommitteeCredential -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S).
Term s (PAsData PColdCommitteeCredential)
-> Term s PColdCommitteeCredential
pfromDataImpl :: forall (s :: S).
Term s (PAsData PColdCommitteeCredential)
-> Term s PColdCommitteeCredential
$cpdataImpl :: forall (s :: S). Term s PColdCommitteeCredential -> Term s PData
pdataImpl :: forall (s :: S). Term s PColdCommitteeCredential -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s PColdCommitteeCredential
 -> Term s PColdCommitteeCredential -> Term s PBool)
-> PEq PColdCommitteeCredential
forall (s :: S).
Term s PColdCommitteeCredential
-> Term s PColdCommitteeCredential -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PColdCommitteeCredential
-> Term s PColdCommitteeCredential -> Term s PBool
#== :: forall (s :: S).
Term s PColdCommitteeCredential
-> Term s PColdCommitteeCredential -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S).
 Bool -> Term s PColdCommitteeCredential -> Term s PString)
-> PShow PColdCommitteeCredential
forall (s :: S).
Bool -> Term s PColdCommitteeCredential -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S).
Bool -> Term s PColdCommitteeCredential -> Term s PString
pshow' :: forall (s :: S).
Bool -> Term s PColdCommitteeCredential -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S).
 PColdCommitteeCredential s
 -> Term s (PInner PColdCommitteeCredential))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PColdCommitteeCredential)
    -> (PColdCommitteeCredential s -> Term s b) -> Term s b)
-> PlutusType PColdCommitteeCredential
forall (s :: S).
PColdCommitteeCredential s
-> Term s (PInner PColdCommitteeCredential)
forall (s :: S) (b :: S -> Type).
Term s (PInner PColdCommitteeCredential)
-> (PColdCommitteeCredential s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S).
PColdCommitteeCredential s
-> Term s (PInner PColdCommitteeCredential)
pcon' :: forall (s :: S).
PColdCommitteeCredential s
-> Term s (PInner PColdCommitteeCredential)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PColdCommitteeCredential)
-> (PColdCommitteeCredential s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PColdCommitteeCredential)
-> (PColdCommitteeCredential s -> Term s b) -> Term s b
PlutusType
    )
    via (DeriveNewtypePlutusType PColdCommitteeCredential)
  deriving
    ( -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PColdCommitteeCredential
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveNewtypePValidateData PColdCommitteeCredential PCredential)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PColdCommitteeCredential Plutus.ColdCommitteeCredential
  instance
    PLiftable PColdCommitteeCredential

-- | @since 3.4.0
instance PTryFrom PData (PAsData PColdCommitteeCredential)

-- | @since 3.1.0
newtype PHotCommitteeCredential (s :: S) = PHotCommitteeCredential (Term s PCredential)
  deriving stock
    ( -- | @since 3.1.0
      (forall x.
 PHotCommitteeCredential s -> Rep (PHotCommitteeCredential s) x)
-> (forall x.
    Rep (PHotCommitteeCredential s) x -> PHotCommitteeCredential s)
-> Generic (PHotCommitteeCredential s)
forall x.
Rep (PHotCommitteeCredential s) x -> PHotCommitteeCredential s
forall x.
PHotCommitteeCredential s -> Rep (PHotCommitteeCredential s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x.
Rep (PHotCommitteeCredential s) x -> PHotCommitteeCredential s
forall (s :: S) x.
PHotCommitteeCredential s -> Rep (PHotCommitteeCredential s) x
$cfrom :: forall (s :: S) x.
PHotCommitteeCredential s -> Rep (PHotCommitteeCredential s) x
from :: forall x.
PHotCommitteeCredential s -> Rep (PHotCommitteeCredential s) x
$cto :: forall (s :: S) x.
Rep (PHotCommitteeCredential s) x -> PHotCommitteeCredential s
to :: forall x.
Rep (PHotCommitteeCredential s) x -> PHotCommitteeCredential s
Generic
    )
  deriving anyclass
    ( -- | @since
      All SListI (Code (PHotCommitteeCredential s))
All SListI (Code (PHotCommitteeCredential s)) =>
(PHotCommitteeCredential s -> Rep (PHotCommitteeCredential s))
-> (Rep (PHotCommitteeCredential s) -> PHotCommitteeCredential s)
-> Generic (PHotCommitteeCredential s)
Rep (PHotCommitteeCredential s) -> PHotCommitteeCredential s
PHotCommitteeCredential s -> Rep (PHotCommitteeCredential s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PHotCommitteeCredential s))
forall (s :: S).
Rep (PHotCommitteeCredential s) -> PHotCommitteeCredential s
forall (s :: S).
PHotCommitteeCredential s -> Rep (PHotCommitteeCredential s)
$cfrom :: forall (s :: S).
PHotCommitteeCredential s -> Rep (PHotCommitteeCredential s)
from :: PHotCommitteeCredential s -> Rep (PHotCommitteeCredential s)
$cto :: forall (s :: S).
Rep (PHotCommitteeCredential s) -> PHotCommitteeCredential s
to :: Rep (PHotCommitteeCredential s) -> PHotCommitteeCredential s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s (PAsData PHotCommitteeCredential)
 -> Term s PHotCommitteeCredential)
-> (forall (s :: S).
    Term s PHotCommitteeCredential -> Term s PData)
-> PIsData PHotCommitteeCredential
forall (s :: S).
Term s (PAsData PHotCommitteeCredential)
-> Term s PHotCommitteeCredential
forall (s :: S). Term s PHotCommitteeCredential -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S).
Term s (PAsData PHotCommitteeCredential)
-> Term s PHotCommitteeCredential
pfromDataImpl :: forall (s :: S).
Term s (PAsData PHotCommitteeCredential)
-> Term s PHotCommitteeCredential
$cpdataImpl :: forall (s :: S). Term s PHotCommitteeCredential -> Term s PData
pdataImpl :: forall (s :: S). Term s PHotCommitteeCredential -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s PHotCommitteeCredential
 -> Term s PHotCommitteeCredential -> Term s PBool)
-> PEq PHotCommitteeCredential
forall (s :: S).
Term s PHotCommitteeCredential
-> Term s PHotCommitteeCredential -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PHotCommitteeCredential
-> Term s PHotCommitteeCredential -> Term s PBool
#== :: forall (s :: S).
Term s PHotCommitteeCredential
-> Term s PHotCommitteeCredential -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S).
 Bool -> Term s PHotCommitteeCredential -> Term s PString)
-> PShow PHotCommitteeCredential
forall (s :: S).
Bool -> Term s PHotCommitteeCredential -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S).
Bool -> Term s PHotCommitteeCredential -> Term s PString
pshow' :: forall (s :: S).
Bool -> Term s PHotCommitteeCredential -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S).
 PHotCommitteeCredential s
 -> Term s (PInner PHotCommitteeCredential))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PHotCommitteeCredential)
    -> (PHotCommitteeCredential s -> Term s b) -> Term s b)
-> PlutusType PHotCommitteeCredential
forall (s :: S).
PHotCommitteeCredential s
-> Term s (PInner PHotCommitteeCredential)
forall (s :: S) (b :: S -> Type).
Term s (PInner PHotCommitteeCredential)
-> (PHotCommitteeCredential s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S).
PHotCommitteeCredential s
-> Term s (PInner PHotCommitteeCredential)
pcon' :: forall (s :: S).
PHotCommitteeCredential s
-> Term s (PInner PHotCommitteeCredential)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PHotCommitteeCredential)
-> (PHotCommitteeCredential s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PHotCommitteeCredential)
-> (PHotCommitteeCredential s -> Term s b) -> Term s b
PlutusType
    )
    via (DeriveNewtypePlutusType PHotCommitteeCredential)
  deriving
    ( -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PHotCommitteeCredential
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveNewtypePValidateData PHotCommitteeCredential PCredential)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PHotCommitteeCredential Plutus.HotCommitteeCredential
  instance
    PLiftable PHotCommitteeCredential

-- | @since 3.4.0
instance PTryFrom PData (PAsData PHotCommitteeCredential)

-- | @since 3.1.0
newtype PDRepCredential (s :: S) = PDRepCredential (Term s PCredential)
  deriving stock
    ( -- | @since 3.1.0
      (forall x. PDRepCredential s -> Rep (PDRepCredential s) x)
-> (forall x. Rep (PDRepCredential s) x -> PDRepCredential s)
-> Generic (PDRepCredential s)
forall x. Rep (PDRepCredential s) x -> PDRepCredential s
forall x. PDRepCredential s -> Rep (PDRepCredential s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PDRepCredential s) x -> PDRepCredential s
forall (s :: S) x. PDRepCredential s -> Rep (PDRepCredential s) x
$cfrom :: forall (s :: S) x. PDRepCredential s -> Rep (PDRepCredential s) x
from :: forall x. PDRepCredential s -> Rep (PDRepCredential s) x
$cto :: forall (s :: S) x. Rep (PDRepCredential s) x -> PDRepCredential s
to :: forall x. Rep (PDRepCredential s) x -> PDRepCredential s
Generic
    )
  deriving anyclass
    ( -- | @since 3.1.0
      All SListI (Code (PDRepCredential s))
All SListI (Code (PDRepCredential s)) =>
(PDRepCredential s -> Rep (PDRepCredential s))
-> (Rep (PDRepCredential s) -> PDRepCredential s)
-> Generic (PDRepCredential s)
Rep (PDRepCredential s) -> PDRepCredential s
PDRepCredential s -> Rep (PDRepCredential s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PDRepCredential s))
forall (s :: S). Rep (PDRepCredential s) -> PDRepCredential s
forall (s :: S). PDRepCredential s -> Rep (PDRepCredential s)
$cfrom :: forall (s :: S). PDRepCredential s -> Rep (PDRepCredential s)
from :: PDRepCredential s -> Rep (PDRepCredential s)
$cto :: forall (s :: S). Rep (PDRepCredential s) -> PDRepCredential s
to :: Rep (PDRepCredential s) -> PDRepCredential s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s (PAsData PDRepCredential) -> Term s PDRepCredential)
-> (forall (s :: S). Term s PDRepCredential -> Term s PData)
-> PIsData PDRepCredential
forall (s :: S).
Term s (PAsData PDRepCredential) -> Term s PDRepCredential
forall (s :: S). Term s PDRepCredential -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S).
Term s (PAsData PDRepCredential) -> Term s PDRepCredential
pfromDataImpl :: forall (s :: S).
Term s (PAsData PDRepCredential) -> Term s PDRepCredential
$cpdataImpl :: forall (s :: S). Term s PDRepCredential -> Term s PData
pdataImpl :: forall (s :: S). Term s PDRepCredential -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s PDRepCredential -> Term s PDRepCredential -> Term s PBool)
-> PEq PDRepCredential
forall (s :: S).
Term s PDRepCredential -> Term s PDRepCredential -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PDRepCredential -> Term s PDRepCredential -> Term s PBool
#== :: forall (s :: S).
Term s PDRepCredential -> Term s PDRepCredential -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S). Bool -> Term s PDRepCredential -> Term s PString)
-> PShow PDRepCredential
forall (s :: S). Bool -> Term s PDRepCredential -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PDRepCredential -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PDRepCredential -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S).
 PDRepCredential s -> Term s (PInner PDRepCredential))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PDRepCredential)
    -> (PDRepCredential s -> Term s b) -> Term s b)
-> PlutusType PDRepCredential
forall (s :: S).
PDRepCredential s -> Term s (PInner PDRepCredential)
forall (s :: S) (b :: S -> Type).
Term s (PInner PDRepCredential)
-> (PDRepCredential s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S).
PDRepCredential s -> Term s (PInner PDRepCredential)
pcon' :: forall (s :: S).
PDRepCredential s -> Term s (PInner PDRepCredential)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PDRepCredential)
-> (PDRepCredential s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PDRepCredential)
-> (PDRepCredential s -> Term s b) -> Term s b
PlutusType
    )
    via (DeriveNewtypePlutusType PDRepCredential)
  deriving
    ( -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PDRepCredential
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveNewtypePValidateData PDRepCredential PCredential)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PDRepCredential Plutus.DRepCredential
  instance
    PLiftable PDRepCredential

-- | @since 3.4.0
instance PTryFrom PData (PAsData PDRepCredential)

-- | @since 3.1.0
data PDRep (s :: S)
  = PDRep (Term s (PAsData PDRepCredential))
  | PDRepAlwaysAbstain
  | PDRepAlwaysNoConfidence
  deriving stock
    ( -- | @since 3.1.0
      (forall x. PDRep s -> Rep (PDRep s) x)
-> (forall x. Rep (PDRep s) x -> PDRep s) -> Generic (PDRep s)
forall x. Rep (PDRep s) x -> PDRep s
forall x. PDRep s -> Rep (PDRep s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PDRep s) x -> PDRep s
forall (s :: S) x. PDRep s -> Rep (PDRep s) x
$cfrom :: forall (s :: S) x. PDRep s -> Rep (PDRep s) x
from :: forall x. PDRep s -> Rep (PDRep s) x
$cto :: forall (s :: S) x. Rep (PDRep s) x -> PDRep s
to :: forall x. Rep (PDRep s) x -> PDRep s
Generic
    )
  deriving anyclass
    ( -- | @since 3.3.0
      All SListI (Code (PDRep s))
All SListI (Code (PDRep s)) =>
(PDRep s -> Rep (PDRep s))
-> (Rep (PDRep s) -> PDRep s) -> Generic (PDRep s)
Rep (PDRep s) -> PDRep s
PDRep s -> Rep (PDRep s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PDRep s))
forall (s :: S). Rep (PDRep s) -> PDRep s
forall (s :: S). PDRep s -> Rep (PDRep s)
$cfrom :: forall (s :: S). PDRep s -> Rep (PDRep s)
from :: PDRep s -> Rep (PDRep s)
$cto :: forall (s :: S). Rep (PDRep s) -> PDRep s
to :: Rep (PDRep s) -> PDRep s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S). Term s (PAsData PDRep) -> Term s PDRep)
-> (forall (s :: S). Term s PDRep -> Term s PData) -> PIsData PDRep
forall (s :: S). Term s (PAsData PDRep) -> Term s PDRep
forall (s :: S). Term s PDRep -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S). Term s (PAsData PDRep) -> Term s PDRep
pfromDataImpl :: forall (s :: S). Term s (PAsData PDRep) -> Term s PDRep
$cpdataImpl :: forall (s :: S). Term s PDRep -> Term s PData
pdataImpl :: forall (s :: S). Term s PDRep -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S). Term s PDRep -> Term s PDRep -> Term s PBool)
-> PEq PDRep
forall (s :: S). Term s PDRep -> Term s PDRep -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S). Term s PDRep -> Term s PDRep -> Term s PBool
#== :: forall (s :: S). Term s PDRep -> Term s PDRep -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S). Bool -> Term s PDRep -> Term s PString)
-> PShow PDRep
forall (s :: S). Bool -> Term s PDRep -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PDRep -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PDRep -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S). PDRep s -> Term s (PInner PDRep))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PDRep) -> (PDRep s -> Term s b) -> Term s b)
-> PlutusType PDRep
forall (s :: S). PDRep s -> Term s (PInner PDRep)
forall (s :: S) (b :: S -> Type).
Term s (PInner PDRep) -> (PDRep s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S). PDRep s -> Term s (PInner PDRep)
pcon' :: forall (s :: S). PDRep s -> Term s (PInner PDRep)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PDRep) -> (PDRep s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PDRep) -> (PDRep s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PDRep
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PDRep)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PDRep Plutus.DRep
  instance
    PLiftable PDRep

-- | @since 3.4.0
instance PTryFrom PData (PAsData PDRep)

-- | @since 3.1.0
data PDelegatee (s :: S)
  = PDelegStake (Term s (PAsData PPubKeyHash))
  | PDelegVote (Term s PDRep)
  | PDelegStakeVote (Term s (PAsData PPubKeyHash)) (Term s PDRep)
  deriving stock
    ( -- | @since 3.1.0
      (forall x. PDelegatee s -> Rep (PDelegatee s) x)
-> (forall x. Rep (PDelegatee s) x -> PDelegatee s)
-> Generic (PDelegatee s)
forall x. Rep (PDelegatee s) x -> PDelegatee s
forall x. PDelegatee s -> Rep (PDelegatee s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PDelegatee s) x -> PDelegatee s
forall (s :: S) x. PDelegatee s -> Rep (PDelegatee s) x
$cfrom :: forall (s :: S) x. PDelegatee s -> Rep (PDelegatee s) x
from :: forall x. PDelegatee s -> Rep (PDelegatee s) x
$cto :: forall (s :: S) x. Rep (PDelegatee s) x -> PDelegatee s
to :: forall x. Rep (PDelegatee s) x -> PDelegatee s
Generic
    )
  deriving anyclass
    ( -- | @since 3.3.0
      All SListI (Code (PDelegatee s))
All SListI (Code (PDelegatee s)) =>
(PDelegatee s -> Rep (PDelegatee s))
-> (Rep (PDelegatee s) -> PDelegatee s) -> Generic (PDelegatee s)
Rep (PDelegatee s) -> PDelegatee s
PDelegatee s -> Rep (PDelegatee s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PDelegatee s))
forall (s :: S). Rep (PDelegatee s) -> PDelegatee s
forall (s :: S). PDelegatee s -> Rep (PDelegatee s)
$cfrom :: forall (s :: S). PDelegatee s -> Rep (PDelegatee s)
from :: PDelegatee s -> Rep (PDelegatee s)
$cto :: forall (s :: S). Rep (PDelegatee s) -> PDelegatee s
to :: Rep (PDelegatee s) -> PDelegatee s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S). Term s (PAsData PDelegatee) -> Term s PDelegatee)
-> (forall (s :: S). Term s PDelegatee -> Term s PData)
-> PIsData PDelegatee
forall (s :: S). Term s (PAsData PDelegatee) -> Term s PDelegatee
forall (s :: S). Term s PDelegatee -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S). Term s (PAsData PDelegatee) -> Term s PDelegatee
pfromDataImpl :: forall (s :: S). Term s (PAsData PDelegatee) -> Term s PDelegatee
$cpdataImpl :: forall (s :: S). Term s PDelegatee -> Term s PData
pdataImpl :: forall (s :: S). Term s PDelegatee -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s PDelegatee -> Term s PDelegatee -> Term s PBool)
-> PEq PDelegatee
forall (s :: S).
Term s PDelegatee -> Term s PDelegatee -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PDelegatee -> Term s PDelegatee -> Term s PBool
#== :: forall (s :: S).
Term s PDelegatee -> Term s PDelegatee -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S). Bool -> Term s PDelegatee -> Term s PString)
-> PShow PDelegatee
forall (s :: S). Bool -> Term s PDelegatee -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PDelegatee -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PDelegatee -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S). PDelegatee s -> Term s (PInner PDelegatee))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PDelegatee)
    -> (PDelegatee s -> Term s b) -> Term s b)
-> PlutusType PDelegatee
forall (s :: S). PDelegatee s -> Term s (PInner PDelegatee)
forall (s :: S) (b :: S -> Type).
Term s (PInner PDelegatee)
-> (PDelegatee s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S). PDelegatee s -> Term s (PInner PDelegatee)
pcon' :: forall (s :: S). PDelegatee s -> Term s (PInner PDelegatee)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PDelegatee)
-> (PDelegatee s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PDelegatee)
-> (PDelegatee s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PDelegatee
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PDelegatee)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PDelegatee Plutus.Delegatee
  instance
    PLiftable PDelegatee

-- | @since 3.4.0
instance PTryFrom PData (PAsData PDelegatee)

-- | @since 3.1.0
data PTxCert (s :: S)
  = PTxCertRegStaking (Term s PCredential) (Term s (PMaybeData Value.PLovelace))
  | PTxCertUnRegStaking (Term s PCredential) (Term s (PMaybeData Value.PLovelace))
  | PTxCertDelegStaking (Term s PCredential) (Term s PDelegatee)
  | PTxCertRegDeleg (Term s PCredential) (Term s PDelegatee) (Term s (PAsData Value.PLovelace))
  | PTxCertRegDRep (Term s PDRepCredential) (Term s (PAsData Value.PLovelace))
  | PTxCertUpdateDRep (Term s PDRepCredential)
  | PTxCertUnRegDRep (Term s PDRepCredential) (Term s (PAsData Value.PLovelace))
  | PTxCertPoolRegister (Term s (PAsData PPubKeyHash)) (Term s (PAsData PPubKeyHash))
  | PTxCertPoolRetire (Term s (PAsData PPubKeyHash)) (Term s (PAsData PInteger))
  | PTxCertAuthHotCommittee (Term s PColdCommitteeCredential) (Term s PHotCommitteeCredential)
  | PTxCertResignColdCommittee (Term s PColdCommitteeCredential)
  deriving stock
    ( -- | @since 3.1.0
      (forall x. PTxCert s -> Rep (PTxCert s) x)
-> (forall x. Rep (PTxCert s) x -> PTxCert s)
-> Generic (PTxCert s)
forall x. Rep (PTxCert s) x -> PTxCert s
forall x. PTxCert s -> Rep (PTxCert s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PTxCert s) x -> PTxCert s
forall (s :: S) x. PTxCert s -> Rep (PTxCert s) x
$cfrom :: forall (s :: S) x. PTxCert s -> Rep (PTxCert s) x
from :: forall x. PTxCert s -> Rep (PTxCert s) x
$cto :: forall (s :: S) x. Rep (PTxCert s) x -> PTxCert s
to :: forall x. Rep (PTxCert s) x -> PTxCert s
Generic
    )
  deriving anyclass
    ( -- | @since 3.3.0
      All SListI (Code (PTxCert s))
All SListI (Code (PTxCert s)) =>
(PTxCert s -> Rep (PTxCert s))
-> (Rep (PTxCert s) -> PTxCert s) -> Generic (PTxCert s)
Rep (PTxCert s) -> PTxCert s
PTxCert s -> Rep (PTxCert s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PTxCert s))
forall (s :: S). Rep (PTxCert s) -> PTxCert s
forall (s :: S). PTxCert s -> Rep (PTxCert s)
$cfrom :: forall (s :: S). PTxCert s -> Rep (PTxCert s)
from :: PTxCert s -> Rep (PTxCert s)
$cto :: forall (s :: S). Rep (PTxCert s) -> PTxCert s
to :: Rep (PTxCert s) -> PTxCert s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S). Term s (PAsData PTxCert) -> Term s PTxCert)
-> (forall (s :: S). Term s PTxCert -> Term s PData)
-> PIsData PTxCert
forall (s :: S). Term s (PAsData PTxCert) -> Term s PTxCert
forall (s :: S). Term s PTxCert -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S). Term s (PAsData PTxCert) -> Term s PTxCert
pfromDataImpl :: forall (s :: S). Term s (PAsData PTxCert) -> Term s PTxCert
$cpdataImpl :: forall (s :: S). Term s PTxCert -> Term s PData
pdataImpl :: forall (s :: S). Term s PTxCert -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S). Term s PTxCert -> Term s PTxCert -> Term s PBool)
-> PEq PTxCert
forall (s :: S). Term s PTxCert -> Term s PTxCert -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S). Term s PTxCert -> Term s PTxCert -> Term s PBool
#== :: forall (s :: S). Term s PTxCert -> Term s PTxCert -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S). Bool -> Term s PTxCert -> Term s PString)
-> PShow PTxCert
forall (s :: S). Bool -> Term s PTxCert -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PTxCert -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PTxCert -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S). PTxCert s -> Term s (PInner PTxCert))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PTxCert) -> (PTxCert s -> Term s b) -> Term s b)
-> PlutusType PTxCert
forall (s :: S). PTxCert s -> Term s (PInner PTxCert)
forall (s :: S) (b :: S -> Type).
Term s (PInner PTxCert) -> (PTxCert s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S). PTxCert s -> Term s (PInner PTxCert)
pcon' :: forall (s :: S). PTxCert s -> Term s (PInner PTxCert)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PTxCert) -> (PTxCert s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PTxCert) -> (PTxCert s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PTxCert
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PTxCert)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PTxCert Plutus.TxCert
  instance
    PLiftable PTxCert

-- | @since 3.4.0
instance PTryFrom PData (PAsData PTxCert)

-- | @since 3.1.0
data PVoter (s :: S)
  = PCommitteeVoter (Term s PHotCommitteeCredential)
  | PDRepVoter (Term s PDRepCredential)
  | PStakePoolVoter (Term s (PAsData PPubKeyHash))
  deriving stock
    ( -- | @since 3.1.0
      (forall x. PVoter s -> Rep (PVoter s) x)
-> (forall x. Rep (PVoter s) x -> PVoter s) -> Generic (PVoter s)
forall x. Rep (PVoter s) x -> PVoter s
forall x. PVoter s -> Rep (PVoter s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PVoter s) x -> PVoter s
forall (s :: S) x. PVoter s -> Rep (PVoter s) x
$cfrom :: forall (s :: S) x. PVoter s -> Rep (PVoter s) x
from :: forall x. PVoter s -> Rep (PVoter s) x
$cto :: forall (s :: S) x. Rep (PVoter s) x -> PVoter s
to :: forall x. Rep (PVoter s) x -> PVoter s
Generic
    )
  deriving anyclass
    ( -- | @since 3.3.0
      All SListI (Code (PVoter s))
All SListI (Code (PVoter s)) =>
(PVoter s -> Rep (PVoter s))
-> (Rep (PVoter s) -> PVoter s) -> Generic (PVoter s)
Rep (PVoter s) -> PVoter s
PVoter s -> Rep (PVoter s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PVoter s))
forall (s :: S). Rep (PVoter s) -> PVoter s
forall (s :: S). PVoter s -> Rep (PVoter s)
$cfrom :: forall (s :: S). PVoter s -> Rep (PVoter s)
from :: PVoter s -> Rep (PVoter s)
$cto :: forall (s :: S). Rep (PVoter s) -> PVoter s
to :: Rep (PVoter s) -> PVoter s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S). Term s (PAsData PVoter) -> Term s PVoter)
-> (forall (s :: S). Term s PVoter -> Term s PData)
-> PIsData PVoter
forall (s :: S). Term s (PAsData PVoter) -> Term s PVoter
forall (s :: S). Term s PVoter -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S). Term s (PAsData PVoter) -> Term s PVoter
pfromDataImpl :: forall (s :: S). Term s (PAsData PVoter) -> Term s PVoter
$cpdataImpl :: forall (s :: S). Term s PVoter -> Term s PData
pdataImpl :: forall (s :: S). Term s PVoter -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S). Term s PVoter -> Term s PVoter -> Term s PBool)
-> PEq PVoter
forall (s :: S). Term s PVoter -> Term s PVoter -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S). Term s PVoter -> Term s PVoter -> Term s PBool
#== :: forall (s :: S). Term s PVoter -> Term s PVoter -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S). Bool -> Term s PVoter -> Term s PString)
-> PShow PVoter
forall (s :: S). Bool -> Term s PVoter -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PVoter -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PVoter -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S). PVoter s -> Term s (PInner PVoter))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PVoter) -> (PVoter s -> Term s b) -> Term s b)
-> PlutusType PVoter
forall (s :: S). PVoter s -> Term s (PInner PVoter)
forall (s :: S) (b :: S -> Type).
Term s (PInner PVoter) -> (PVoter s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S). PVoter s -> Term s (PInner PVoter)
pcon' :: forall (s :: S). PVoter s -> Term s (PInner PVoter)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PVoter) -> (PVoter s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PVoter) -> (PVoter s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PVoter
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PVoter)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PVoter Plutus.Voter
  instance
    PLiftable PVoter

-- | @since 3.4.0
instance PTryFrom PData (PAsData PVoter)

-- | @since 3.1.0
data PVote (s :: S)
  = PVoteYes
  | PVoteNo
  | PAbstain
  deriving stock
    ( -- | @since 3.1.0
      (forall x. PVote s -> Rep (PVote s) x)
-> (forall x. Rep (PVote s) x -> PVote s) -> Generic (PVote s)
forall x. Rep (PVote s) x -> PVote s
forall x. PVote s -> Rep (PVote s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PVote s) x -> PVote s
forall (s :: S) x. PVote s -> Rep (PVote s) x
$cfrom :: forall (s :: S) x. PVote s -> Rep (PVote s) x
from :: forall x. PVote s -> Rep (PVote s) x
$cto :: forall (s :: S) x. Rep (PVote s) x -> PVote s
to :: forall x. Rep (PVote s) x -> PVote s
Generic
    )
  deriving anyclass
    ( -- | @since 3.1.0
      All SListI (Code (PVote s))
All SListI (Code (PVote s)) =>
(PVote s -> Rep (PVote s))
-> (Rep (PVote s) -> PVote s) -> Generic (PVote s)
Rep (PVote s) -> PVote s
PVote s -> Rep (PVote s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PVote s))
forall (s :: S). Rep (PVote s) -> PVote s
forall (s :: S). PVote s -> Rep (PVote s)
$cfrom :: forall (s :: S). PVote s -> Rep (PVote s)
from :: PVote s -> Rep (PVote s)
$cto :: forall (s :: S). Rep (PVote s) -> PVote s
to :: Rep (PVote s) -> PVote s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S). Term s (PAsData PVote) -> Term s PVote)
-> (forall (s :: S). Term s PVote -> Term s PData) -> PIsData PVote
forall (s :: S). Term s (PAsData PVote) -> Term s PVote
forall (s :: S). Term s PVote -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S). Term s (PAsData PVote) -> Term s PVote
pfromDataImpl :: forall (s :: S). Term s (PAsData PVote) -> Term s PVote
$cpdataImpl :: forall (s :: S). Term s PVote -> Term s PData
pdataImpl :: forall (s :: S). Term s PVote -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S). Term s PVote -> Term s PVote -> Term s PBool)
-> PEq PVote
forall (s :: S). Term s PVote -> Term s PVote -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S). Term s PVote -> Term s PVote -> Term s PBool
#== :: forall (s :: S). Term s PVote -> Term s PVote -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S). Bool -> Term s PVote -> Term s PString)
-> PShow PVote
forall (s :: S). Bool -> Term s PVote -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PVote -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PVote -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S). PVote s -> Term s (PInner PVote))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PVote) -> (PVote s -> Term s b) -> Term s b)
-> PlutusType PVote
forall (s :: S). PVote s -> Term s (PInner PVote)
forall (s :: S) (b :: S -> Type).
Term s (PInner PVote) -> (PVote s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S). PVote s -> Term s (PInner PVote)
pcon' :: forall (s :: S). PVote s -> Term s (PInner PVote)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PVote) -> (PVote s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PVote) -> (PVote s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PVote
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PVote)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PVote Plutus.Vote
  instance
    PLiftable PVote

-- | @since 3.4.0
instance PTryFrom PData (PAsData PVote)

-- | @since 3.1.0
data PGovernanceActionId (s :: S)
  = PGovernanceActionId (Term s (PAsData PTxId)) (Term s (PAsData PInteger))
  deriving stock
    ( -- | @since 3.1.0
      (forall x. PGovernanceActionId s -> Rep (PGovernanceActionId s) x)
-> (forall x.
    Rep (PGovernanceActionId s) x -> PGovernanceActionId s)
-> Generic (PGovernanceActionId s)
forall x. Rep (PGovernanceActionId s) x -> PGovernanceActionId s
forall x. PGovernanceActionId s -> Rep (PGovernanceActionId s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x.
Rep (PGovernanceActionId s) x -> PGovernanceActionId s
forall (s :: S) x.
PGovernanceActionId s -> Rep (PGovernanceActionId s) x
$cfrom :: forall (s :: S) x.
PGovernanceActionId s -> Rep (PGovernanceActionId s) x
from :: forall x. PGovernanceActionId s -> Rep (PGovernanceActionId s) x
$cto :: forall (s :: S) x.
Rep (PGovernanceActionId s) x -> PGovernanceActionId s
to :: forall x. Rep (PGovernanceActionId s) x -> PGovernanceActionId s
Generic
    )
  deriving anyclass
    ( -- | @since 3.1.0
      All SListI (Code (PGovernanceActionId s))
All SListI (Code (PGovernanceActionId s)) =>
(PGovernanceActionId s -> Rep (PGovernanceActionId s))
-> (Rep (PGovernanceActionId s) -> PGovernanceActionId s)
-> Generic (PGovernanceActionId s)
Rep (PGovernanceActionId s) -> PGovernanceActionId s
PGovernanceActionId s -> Rep (PGovernanceActionId s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PGovernanceActionId s))
forall (s :: S).
Rep (PGovernanceActionId s) -> PGovernanceActionId s
forall (s :: S).
PGovernanceActionId s -> Rep (PGovernanceActionId s)
$cfrom :: forall (s :: S).
PGovernanceActionId s -> Rep (PGovernanceActionId s)
from :: PGovernanceActionId s -> Rep (PGovernanceActionId s)
$cto :: forall (s :: S).
Rep (PGovernanceActionId s) -> PGovernanceActionId s
to :: Rep (PGovernanceActionId s) -> PGovernanceActionId s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s (PAsData PGovernanceActionId) -> Term s PGovernanceActionId)
-> (forall (s :: S). Term s PGovernanceActionId -> Term s PData)
-> PIsData PGovernanceActionId
forall (s :: S).
Term s (PAsData PGovernanceActionId) -> Term s PGovernanceActionId
forall (s :: S). Term s PGovernanceActionId -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S).
Term s (PAsData PGovernanceActionId) -> Term s PGovernanceActionId
pfromDataImpl :: forall (s :: S).
Term s (PAsData PGovernanceActionId) -> Term s PGovernanceActionId
$cpdataImpl :: forall (s :: S). Term s PGovernanceActionId -> Term s PData
pdataImpl :: forall (s :: S). Term s PGovernanceActionId -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s PGovernanceActionId
 -> Term s PGovernanceActionId -> Term s PBool)
-> PEq PGovernanceActionId
forall (s :: S).
Term s PGovernanceActionId
-> Term s PGovernanceActionId -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PGovernanceActionId
-> Term s PGovernanceActionId -> Term s PBool
#== :: forall (s :: S).
Term s PGovernanceActionId
-> Term s PGovernanceActionId -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S).
 Bool -> Term s PGovernanceActionId -> Term s PString)
-> PShow PGovernanceActionId
forall (s :: S).
Bool -> Term s PGovernanceActionId -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S).
Bool -> Term s PGovernanceActionId -> Term s PString
pshow' :: forall (s :: S).
Bool -> Term s PGovernanceActionId -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S).
 PGovernanceActionId s -> Term s (PInner PGovernanceActionId))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PGovernanceActionId)
    -> (PGovernanceActionId s -> Term s b) -> Term s b)
-> PlutusType PGovernanceActionId
forall (s :: S).
PGovernanceActionId s -> Term s (PInner PGovernanceActionId)
forall (s :: S) (b :: S -> Type).
Term s (PInner PGovernanceActionId)
-> (PGovernanceActionId s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S).
PGovernanceActionId s -> Term s (PInner PGovernanceActionId)
pcon' :: forall (s :: S).
PGovernanceActionId s -> Term s (PInner PGovernanceActionId)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PGovernanceActionId)
-> (PGovernanceActionId s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PGovernanceActionId)
-> (PGovernanceActionId s -> Term s b) -> Term s b
PlutusType
    )
    via (DeriveAsDataStruct PGovernanceActionId)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PGovernanceActionId Plutus.GovernanceActionId
  instance
    PLiftable PGovernanceActionId

-- | @since 3.4.0
instance PTryFrom PData (PAsData PGovernanceActionId)

{- | Checks that we have a valid 'PGovernanceActionId'. The underlying 'PTxId'
must be exactly 32 bytes, as Cardano transactions are hashed with BLAKE2b-256,
and the action index must be a non-negative 'PInteger'.

@since 3.6.0
-}
instance PValidateData PGovernanceActionId where
  pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated Term s PData
opq Term s r
x =
    Term s (PBuiltinPair PInteger (PBuiltinList PData))
-> (PBuiltinPair PInteger (PBuiltinList PData) s -> Term s r)
-> Term s r
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term s (PData :--> PBuiltinPair PInteger (PBuiltinList PData))
forall (s :: S).
Term s (PData :--> PBuiltinPair PInteger (PBuiltinList PData))
pasConstr Term s (PData :--> PBuiltinPair PInteger (PBuiltinList PData))
-> Term s PData
-> Term s (PBuiltinPair PInteger (PBuiltinList PData))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s PData
opq) ((PBuiltinPair PInteger (PBuiltinList PData) s -> Term s r)
 -> Term s r)
-> (PBuiltinPair PInteger (PBuiltinList PData) s -> Term s r)
-> Term s r
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s PInteger
constrIdx Term s (PBuiltinList PData)
fields) ->
      Term s PBool -> Term s r -> Term s r -> Term s r
forall (a :: S -> Type) (s :: S).
Term s PBool -> Term s a -> Term s a -> Term s a
pif
        ((Term s PInteger
constrIdx Term s PInteger -> Term s PInteger -> Term s PBool
forall (s :: S). Term s PInteger -> Term s PInteger -> Term s PBool
forall (t :: S -> Type) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== Term s PInteger
0) Term s PBool -> Term s PBool -> Term s PBool
forall (s :: S). Term s PBool -> Term s PBool -> Term s PBool
#&& ((Term s (PBuiltinList PData :--> PInteger)
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
PIsListLike list a =>
Term s (list a :--> PInteger)
plength Term s (PBuiltinList PData :--> PInteger)
-> Term s (PBuiltinList PData) -> Term s PInteger
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PBuiltinList PData)
fields) Term s PInteger -> Term s PInteger -> Term s PBool
forall (s :: S). Term s PInteger -> Term s PInteger -> Term s PBool
forall (t :: S -> Type) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== Term s PInteger
2))
        ( forall (a :: S -> Type) (s :: S).
PValidateData a =>
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated @PTxId (Natural -> Term s (PBuiltinList PData) -> Term s PData
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
PIsListLike list a =>
Natural -> Term s (list a) -> Term s a
ptryIndex Natural
0 Term s (PBuiltinList PData)
fields) (Term s r -> Term s r) -> Term s r -> Term s r
forall a b. (a -> b) -> a -> b
$
            Term s PInteger -> (Term s PInteger -> Term s r) -> Term s r
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term s (PData :--> PInteger)
forall (s :: S). Term s (PData :--> PInteger)
pasInt Term s (PData :--> PInteger) -> Term s PData -> Term s PInteger
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Natural -> Term s (PBuiltinList PData) -> Term s PData
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
PIsListLike list a =>
Natural -> Term s (list a) -> Term s a
ptryIndex Natural
1 Term s (PBuiltinList PData)
fields) ((Term s PInteger -> Term s r) -> Term s r)
-> (Term s PInteger -> Term s r) -> Term s r
forall a b. (a -> b) -> a -> b
$ \Term s PInteger
outIdx ->
              Term s PBool -> Term s r -> Term s r -> Term s r
forall (a :: S -> Type) (s :: S).
Term s PBool -> Term s a -> Term s a -> Term s a
pif
                (Term s PInteger
outIdx Term s PInteger -> Term s PInteger -> Term s PBool
forall (s :: S). Term s PInteger -> Term s PInteger -> Term s PBool
forall (t :: S -> Type) (s :: S).
POrd t =>
Term s t -> Term s t -> Term s PBool
#< Term s PInteger
0)
                Term s r
forall (s :: S) (a :: S -> Type). Term s a
perror
                Term s r
x
        )
        Term s r
forall (s :: S) (a :: S -> Type). Term s a
perror

-- TODO: Investigate what guarantees this provides on the Map, if any

-- | @since 3.1.0
data PCommittee (s :: S) = PCommittee
  { forall (s :: S).
PCommittee s
-> Term
     s (PAsData (PUnsortedMap PColdCommitteeCredential PInteger))
pcommittee'members :: Term s (PAsData (AssocMap.PUnsortedMap PColdCommitteeCredential PInteger))
  , forall (s :: S). PCommittee s -> Term s PRationalData
pcommittee'quorum :: Term s PRationalData
  }
  deriving stock
    ( -- | @since 3.1.0
      (forall x. PCommittee s -> Rep (PCommittee s) x)
-> (forall x. Rep (PCommittee s) x -> PCommittee s)
-> Generic (PCommittee s)
forall x. Rep (PCommittee s) x -> PCommittee s
forall x. PCommittee s -> Rep (PCommittee s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PCommittee s) x -> PCommittee s
forall (s :: S) x. PCommittee s -> Rep (PCommittee s) x
$cfrom :: forall (s :: S) x. PCommittee s -> Rep (PCommittee s) x
from :: forall x. PCommittee s -> Rep (PCommittee s) x
$cto :: forall (s :: S) x. Rep (PCommittee s) x -> PCommittee s
to :: forall x. Rep (PCommittee s) x -> PCommittee s
Generic
    )
  deriving anyclass
    ( -- | @since 3.3.0
      All SListI (Code (PCommittee s))
All SListI (Code (PCommittee s)) =>
(PCommittee s -> Rep (PCommittee s))
-> (Rep (PCommittee s) -> PCommittee s) -> Generic (PCommittee s)
Rep (PCommittee s) -> PCommittee s
PCommittee s -> Rep (PCommittee s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PCommittee s))
forall (s :: S). Rep (PCommittee s) -> PCommittee s
forall (s :: S). PCommittee s -> Rep (PCommittee s)
$cfrom :: forall (s :: S). PCommittee s -> Rep (PCommittee s)
from :: PCommittee s -> Rep (PCommittee s)
$cto :: forall (s :: S). Rep (PCommittee s) -> PCommittee s
to :: Rep (PCommittee s) -> PCommittee s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S). Term s (PAsData PCommittee) -> Term s PCommittee)
-> (forall (s :: S). Term s PCommittee -> Term s PData)
-> PIsData PCommittee
forall (s :: S). Term s (PAsData PCommittee) -> Term s PCommittee
forall (s :: S). Term s PCommittee -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S). Term s (PAsData PCommittee) -> Term s PCommittee
pfromDataImpl :: forall (s :: S). Term s (PAsData PCommittee) -> Term s PCommittee
$cpdataImpl :: forall (s :: S). Term s PCommittee -> Term s PData
pdataImpl :: forall (s :: S). Term s PCommittee -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s PCommittee -> Term s PCommittee -> Term s PBool)
-> PEq PCommittee
forall (s :: S).
Term s PCommittee -> Term s PCommittee -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PCommittee -> Term s PCommittee -> Term s PBool
#== :: forall (s :: S).
Term s PCommittee -> Term s PCommittee -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S). Bool -> Term s PCommittee -> Term s PString)
-> PShow PCommittee
forall (s :: S). Bool -> Term s PCommittee -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PCommittee -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PCommittee -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S). PCommittee s -> Term s (PInner PCommittee))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PCommittee)
    -> (PCommittee s -> Term s b) -> Term s b)
-> PlutusType PCommittee
forall (s :: S). PCommittee s -> Term s (PInner PCommittee)
forall (s :: S) (b :: S -> Type).
Term s (PInner PCommittee)
-> (PCommittee s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S). PCommittee s -> Term s (PInner PCommittee)
pcon' :: forall (s :: S). PCommittee s -> Term s (PInner PCommittee)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PCommittee)
-> (PCommittee s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PCommittee)
-> (PCommittee s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PCommittee
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PCommittee)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PCommittee Plutus.Committee
  instance
    PLiftable PCommittee

-- | @since 3.4.0
instance PTryFrom PData (PAsData PCommittee)

{- | A constitution, omitting the optional anchor.

@since 3.1.0
-}
newtype PConstitution (s :: S) = PConstitution (Term s (PMaybeData PScriptHash))
  deriving stock
    ( -- | @since 3.1.0
      (forall x. PConstitution s -> Rep (PConstitution s) x)
-> (forall x. Rep (PConstitution s) x -> PConstitution s)
-> Generic (PConstitution s)
forall x. Rep (PConstitution s) x -> PConstitution s
forall x. PConstitution s -> Rep (PConstitution s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PConstitution s) x -> PConstitution s
forall (s :: S) x. PConstitution s -> Rep (PConstitution s) x
$cfrom :: forall (s :: S) x. PConstitution s -> Rep (PConstitution s) x
from :: forall x. PConstitution s -> Rep (PConstitution s) x
$cto :: forall (s :: S) x. Rep (PConstitution s) x -> PConstitution s
to :: forall x. Rep (PConstitution s) x -> PConstitution s
Generic
    )
  deriving anyclass
    ( -- | @since 3.3.0
      All SListI (Code (PConstitution s))
All SListI (Code (PConstitution s)) =>
(PConstitution s -> Rep (PConstitution s))
-> (Rep (PConstitution s) -> PConstitution s)
-> Generic (PConstitution s)
Rep (PConstitution s) -> PConstitution s
PConstitution s -> Rep (PConstitution s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PConstitution s))
forall (s :: S). Rep (PConstitution s) -> PConstitution s
forall (s :: S). PConstitution s -> Rep (PConstitution s)
$cfrom :: forall (s :: S). PConstitution s -> Rep (PConstitution s)
from :: PConstitution s -> Rep (PConstitution s)
$cto :: forall (s :: S). Rep (PConstitution s) -> PConstitution s
to :: Rep (PConstitution s) -> PConstitution s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s (PAsData PConstitution) -> Term s PConstitution)
-> (forall (s :: S). Term s PConstitution -> Term s PData)
-> PIsData PConstitution
forall (s :: S).
Term s (PAsData PConstitution) -> Term s PConstitution
forall (s :: S). Term s PConstitution -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S).
Term s (PAsData PConstitution) -> Term s PConstitution
pfromDataImpl :: forall (s :: S).
Term s (PAsData PConstitution) -> Term s PConstitution
$cpdataImpl :: forall (s :: S). Term s PConstitution -> Term s PData
pdataImpl :: forall (s :: S). Term s PConstitution -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s PConstitution -> Term s PConstitution -> Term s PBool)
-> PEq PConstitution
forall (s :: S).
Term s PConstitution -> Term s PConstitution -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PConstitution -> Term s PConstitution -> Term s PBool
#== :: forall (s :: S).
Term s PConstitution -> Term s PConstitution -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S). Bool -> Term s PConstitution -> Term s PString)
-> PShow PConstitution
forall (s :: S). Bool -> Term s PConstitution -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PConstitution -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PConstitution -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S). PConstitution s -> Term s (PInner PConstitution))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PConstitution)
    -> (PConstitution s -> Term s b) -> Term s b)
-> PlutusType PConstitution
forall (s :: S). PConstitution s -> Term s (PInner PConstitution)
forall (s :: S) (b :: S -> Type).
Term s (PInner PConstitution)
-> (PConstitution s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S). PConstitution s -> Term s (PInner PConstitution)
pcon' :: forall (s :: S). PConstitution s -> Term s (PInner PConstitution)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PConstitution)
-> (PConstitution s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PConstitution)
-> (PConstitution s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PConstitution
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PConstitution)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PConstitution Plutus.Constitution
  instance
    PLiftable PConstitution

-- | @since 3.4.0
instance PTryFrom PData (PAsData PConstitution)

-- | @since 3.1.0
data PProtocolVersion (s :: S) = PProtocolVersion
  { forall (s :: S). PProtocolVersion s -> Term s (PAsData PInteger)
pprotocolVersion'major :: Term s (PAsData PInteger)
  , forall (s :: S). PProtocolVersion s -> Term s (PAsData PInteger)
pprotocolVersion'minor :: Term s (PAsData PInteger)
  }
  deriving stock
    ( -- | @since 3.1.0
      (forall x. PProtocolVersion s -> Rep (PProtocolVersion s) x)
-> (forall x. Rep (PProtocolVersion s) x -> PProtocolVersion s)
-> Generic (PProtocolVersion s)
forall x. Rep (PProtocolVersion s) x -> PProtocolVersion s
forall x. PProtocolVersion s -> Rep (PProtocolVersion s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PProtocolVersion s) x -> PProtocolVersion s
forall (s :: S) x. PProtocolVersion s -> Rep (PProtocolVersion s) x
$cfrom :: forall (s :: S) x. PProtocolVersion s -> Rep (PProtocolVersion s) x
from :: forall x. PProtocolVersion s -> Rep (PProtocolVersion s) x
$cto :: forall (s :: S) x. Rep (PProtocolVersion s) x -> PProtocolVersion s
to :: forall x. Rep (PProtocolVersion s) x -> PProtocolVersion s
Generic
    )
  deriving anyclass
    ( -- | @since 3.3.0
      All SListI (Code (PProtocolVersion s))
All SListI (Code (PProtocolVersion s)) =>
(PProtocolVersion s -> Rep (PProtocolVersion s))
-> (Rep (PProtocolVersion s) -> PProtocolVersion s)
-> Generic (PProtocolVersion s)
Rep (PProtocolVersion s) -> PProtocolVersion s
PProtocolVersion s -> Rep (PProtocolVersion s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PProtocolVersion s))
forall (s :: S). Rep (PProtocolVersion s) -> PProtocolVersion s
forall (s :: S). PProtocolVersion s -> Rep (PProtocolVersion s)
$cfrom :: forall (s :: S). PProtocolVersion s -> Rep (PProtocolVersion s)
from :: PProtocolVersion s -> Rep (PProtocolVersion s)
$cto :: forall (s :: S). Rep (PProtocolVersion s) -> PProtocolVersion s
to :: Rep (PProtocolVersion s) -> PProtocolVersion s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s (PAsData PProtocolVersion) -> Term s PProtocolVersion)
-> (forall (s :: S). Term s PProtocolVersion -> Term s PData)
-> PIsData PProtocolVersion
forall (s :: S).
Term s (PAsData PProtocolVersion) -> Term s PProtocolVersion
forall (s :: S). Term s PProtocolVersion -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S).
Term s (PAsData PProtocolVersion) -> Term s PProtocolVersion
pfromDataImpl :: forall (s :: S).
Term s (PAsData PProtocolVersion) -> Term s PProtocolVersion
$cpdataImpl :: forall (s :: S). Term s PProtocolVersion -> Term s PData
pdataImpl :: forall (s :: S). Term s PProtocolVersion -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s PProtocolVersion -> Term s PProtocolVersion -> Term s PBool)
-> PEq PProtocolVersion
forall (s :: S).
Term s PProtocolVersion -> Term s PProtocolVersion -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PProtocolVersion -> Term s PProtocolVersion -> Term s PBool
#== :: forall (s :: S).
Term s PProtocolVersion -> Term s PProtocolVersion -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S).
 Bool -> Term s PProtocolVersion -> Term s PString)
-> PShow PProtocolVersion
forall (s :: S). Bool -> Term s PProtocolVersion -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PProtocolVersion -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PProtocolVersion -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S).
 PProtocolVersion s -> Term s (PInner PProtocolVersion))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PProtocolVersion)
    -> (PProtocolVersion s -> Term s b) -> Term s b)
-> PlutusType PProtocolVersion
forall (s :: S).
PProtocolVersion s -> Term s (PInner PProtocolVersion)
forall (s :: S) (b :: S -> Type).
Term s (PInner PProtocolVersion)
-> (PProtocolVersion s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S).
PProtocolVersion s -> Term s (PInner PProtocolVersion)
pcon' :: forall (s :: S).
PProtocolVersion s -> Term s (PInner PProtocolVersion)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PProtocolVersion)
-> (PProtocolVersion s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PProtocolVersion)
-> (PProtocolVersion s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PProtocolVersion
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PProtocolVersion)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PProtocolVersion Plutus.ProtocolVersion
  instance
    PLiftable PProtocolVersion

-- | @since 3.4.0
instance PTryFrom PData (PAsData PProtocolVersion)

-- | @since 3.1.0
newtype PChangedParameters (s :: S)
  = PChangedParameters (Term s PData)
  deriving stock
    ( -- | @since 3.1.0
      (forall x. PChangedParameters s -> Rep (PChangedParameters s) x)
-> (forall x. Rep (PChangedParameters s) x -> PChangedParameters s)
-> Generic (PChangedParameters s)
forall x. Rep (PChangedParameters s) x -> PChangedParameters s
forall x. PChangedParameters s -> Rep (PChangedParameters s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x.
Rep (PChangedParameters s) x -> PChangedParameters s
forall (s :: S) x.
PChangedParameters s -> Rep (PChangedParameters s) x
$cfrom :: forall (s :: S) x.
PChangedParameters s -> Rep (PChangedParameters s) x
from :: forall x. PChangedParameters s -> Rep (PChangedParameters s) x
$cto :: forall (s :: S) x.
Rep (PChangedParameters s) x -> PChangedParameters s
to :: forall x. Rep (PChangedParameters s) x -> PChangedParameters s
Generic
    )
  deriving anyclass
    ( -- | @since 3.3.0
      All SListI (Code (PChangedParameters s))
All SListI (Code (PChangedParameters s)) =>
(PChangedParameters s -> Rep (PChangedParameters s))
-> (Rep (PChangedParameters s) -> PChangedParameters s)
-> Generic (PChangedParameters s)
Rep (PChangedParameters s) -> PChangedParameters s
PChangedParameters s -> Rep (PChangedParameters s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PChangedParameters s))
forall (s :: S). Rep (PChangedParameters s) -> PChangedParameters s
forall (s :: S). PChangedParameters s -> Rep (PChangedParameters s)
$cfrom :: forall (s :: S). PChangedParameters s -> Rep (PChangedParameters s)
from :: PChangedParameters s -> Rep (PChangedParameters s)
$cto :: forall (s :: S). Rep (PChangedParameters s) -> PChangedParameters s
to :: Rep (PChangedParameters s) -> PChangedParameters s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s (PAsData PChangedParameters) -> Term s PChangedParameters)
-> (forall (s :: S). Term s PChangedParameters -> Term s PData)
-> PIsData PChangedParameters
forall (s :: S).
Term s (PAsData PChangedParameters) -> Term s PChangedParameters
forall (s :: S). Term s PChangedParameters -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S).
Term s (PAsData PChangedParameters) -> Term s PChangedParameters
pfromDataImpl :: forall (s :: S).
Term s (PAsData PChangedParameters) -> Term s PChangedParameters
$cpdataImpl :: forall (s :: S). Term s PChangedParameters -> Term s PData
pdataImpl :: forall (s :: S). Term s PChangedParameters -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s PChangedParameters
 -> Term s PChangedParameters -> Term s PBool)
-> PEq PChangedParameters
forall (s :: S).
Term s PChangedParameters
-> Term s PChangedParameters -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PChangedParameters
-> Term s PChangedParameters -> Term s PBool
#== :: forall (s :: S).
Term s PChangedParameters
-> Term s PChangedParameters -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S).
 Bool -> Term s PChangedParameters -> Term s PString)
-> PShow PChangedParameters
forall (s :: S).
Bool -> Term s PChangedParameters -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S).
Bool -> Term s PChangedParameters -> Term s PString
pshow' :: forall (s :: S).
Bool -> Term s PChangedParameters -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S).
 PChangedParameters s -> Term s (PInner PChangedParameters))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PChangedParameters)
    -> (PChangedParameters s -> Term s b) -> Term s b)
-> PlutusType PChangedParameters
forall (s :: S).
PChangedParameters s -> Term s (PInner PChangedParameters)
forall (s :: S) (b :: S -> Type).
Term s (PInner PChangedParameters)
-> (PChangedParameters s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S).
PChangedParameters s -> Term s (PInner PChangedParameters)
pcon' :: forall (s :: S).
PChangedParameters s -> Term s (PInner PChangedParameters)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PChangedParameters)
-> (PChangedParameters s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PChangedParameters)
-> (PChangedParameters s -> Term s b) -> Term s b
PlutusType
    )
    via (DeriveNewtypePlutusType PChangedParameters)
  deriving
    ( -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PChangedParameters
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveNewtypePValidateData PChangedParameters PData)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PChangedParameters Plutus.ChangedParameters
  instance
    PLiftable PChangedParameters

-- | @since 3.4.0
instance PTryFrom PData (PAsData PChangedParameters)

-- | @since 3.1.0
data PGovernanceAction (s :: S)
  = PParameterChange (Term s (PMaybeData PGovernanceActionId)) (Term s PChangedParameters) (Term s (PMaybeData PScriptHash))
  | PHardForkInitiation (Term s (PMaybeData PGovernanceActionId)) (Term s PProtocolVersion)
  | PTreasuryWithdrawals
      (Term s (PAsData (AssocMap.PUnsortedMap PCredential Value.PLovelace)))
      (Term s (PMaybeData PScriptHash))
  | PNoConfidence (Term s (PMaybeData PGovernanceActionId))
  | PUpdateCommittee
      (Term s (PMaybeData PGovernanceActionId))
      (Term s (PAsData (PBuiltinList (PAsData PColdCommitteeCredential))))
      (Term s (PAsData (AssocMap.PUnsortedMap PColdCommitteeCredential PInteger)))
      (Term s PRationalData)
  | PNewConstitution (Term s (PMaybeData PGovernanceActionId)) (Term s PConstitution)
  | PInfoAction
  deriving stock
    ( -- | @since 3.1.0
      (forall x. PGovernanceAction s -> Rep (PGovernanceAction s) x)
-> (forall x. Rep (PGovernanceAction s) x -> PGovernanceAction s)
-> Generic (PGovernanceAction s)
forall x. Rep (PGovernanceAction s) x -> PGovernanceAction s
forall x. PGovernanceAction s -> Rep (PGovernanceAction s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x.
Rep (PGovernanceAction s) x -> PGovernanceAction s
forall (s :: S) x.
PGovernanceAction s -> Rep (PGovernanceAction s) x
$cfrom :: forall (s :: S) x.
PGovernanceAction s -> Rep (PGovernanceAction s) x
from :: forall x. PGovernanceAction s -> Rep (PGovernanceAction s) x
$cto :: forall (s :: S) x.
Rep (PGovernanceAction s) x -> PGovernanceAction s
to :: forall x. Rep (PGovernanceAction s) x -> PGovernanceAction s
Generic
    )
  deriving anyclass
    ( -- | @since 3.3.0
      All SListI (Code (PGovernanceAction s))
All SListI (Code (PGovernanceAction s)) =>
(PGovernanceAction s -> Rep (PGovernanceAction s))
-> (Rep (PGovernanceAction s) -> PGovernanceAction s)
-> Generic (PGovernanceAction s)
Rep (PGovernanceAction s) -> PGovernanceAction s
PGovernanceAction s -> Rep (PGovernanceAction s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PGovernanceAction s))
forall (s :: S). Rep (PGovernanceAction s) -> PGovernanceAction s
forall (s :: S). PGovernanceAction s -> Rep (PGovernanceAction s)
$cfrom :: forall (s :: S). PGovernanceAction s -> Rep (PGovernanceAction s)
from :: PGovernanceAction s -> Rep (PGovernanceAction s)
$cto :: forall (s :: S). Rep (PGovernanceAction s) -> PGovernanceAction s
to :: Rep (PGovernanceAction s) -> PGovernanceAction s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s (PAsData PGovernanceAction) -> Term s PGovernanceAction)
-> (forall (s :: S). Term s PGovernanceAction -> Term s PData)
-> PIsData PGovernanceAction
forall (s :: S).
Term s (PAsData PGovernanceAction) -> Term s PGovernanceAction
forall (s :: S). Term s PGovernanceAction -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S).
Term s (PAsData PGovernanceAction) -> Term s PGovernanceAction
pfromDataImpl :: forall (s :: S).
Term s (PAsData PGovernanceAction) -> Term s PGovernanceAction
$cpdataImpl :: forall (s :: S). Term s PGovernanceAction -> Term s PData
pdataImpl :: forall (s :: S). Term s PGovernanceAction -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s PGovernanceAction
 -> Term s PGovernanceAction -> Term s PBool)
-> PEq PGovernanceAction
forall (s :: S).
Term s PGovernanceAction
-> Term s PGovernanceAction -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PGovernanceAction
-> Term s PGovernanceAction -> Term s PBool
#== :: forall (s :: S).
Term s PGovernanceAction
-> Term s PGovernanceAction -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S).
 Bool -> Term s PGovernanceAction -> Term s PString)
-> PShow PGovernanceAction
forall (s :: S). Bool -> Term s PGovernanceAction -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PGovernanceAction -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PGovernanceAction -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S).
 PGovernanceAction s -> Term s (PInner PGovernanceAction))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PGovernanceAction)
    -> (PGovernanceAction s -> Term s b) -> Term s b)
-> PlutusType PGovernanceAction
forall (s :: S).
PGovernanceAction s -> Term s (PInner PGovernanceAction)
forall (s :: S) (b :: S -> Type).
Term s (PInner PGovernanceAction)
-> (PGovernanceAction s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S).
PGovernanceAction s -> Term s (PInner PGovernanceAction)
pcon' :: forall (s :: S).
PGovernanceAction s -> Term s (PInner PGovernanceAction)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PGovernanceAction)
-> (PGovernanceAction s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PGovernanceAction)
-> (PGovernanceAction s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PGovernanceAction
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PGovernanceAction)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PGovernanceAction Plutus.GovernanceAction
  instance
    PLiftable PGovernanceAction

-- | @since 3.4.0
instance PTryFrom PData (PAsData PGovernanceAction)

-- | @since 3.1.0
data PProposalProcedure (s :: S) = PProposalProcedure
  { forall (s :: S). PProposalProcedure s -> Term s (PAsData PLovelace)
pproposalProcedure'deposit :: Term s (PAsData Value.PLovelace)
  , forall (s :: S). PProposalProcedure s -> Term s PCredential
pproposalProcedure'returnAddr :: Term s PCredential
  , forall (s :: S). PProposalProcedure s -> Term s PGovernanceAction
pproposalProcedure'governanceAction :: Term s PGovernanceAction
  }
  deriving stock
    ( -- | @since 3.1.0
      (forall x. PProposalProcedure s -> Rep (PProposalProcedure s) x)
-> (forall x. Rep (PProposalProcedure s) x -> PProposalProcedure s)
-> Generic (PProposalProcedure s)
forall x. Rep (PProposalProcedure s) x -> PProposalProcedure s
forall x. PProposalProcedure s -> Rep (PProposalProcedure s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x.
Rep (PProposalProcedure s) x -> PProposalProcedure s
forall (s :: S) x.
PProposalProcedure s -> Rep (PProposalProcedure s) x
$cfrom :: forall (s :: S) x.
PProposalProcedure s -> Rep (PProposalProcedure s) x
from :: forall x. PProposalProcedure s -> Rep (PProposalProcedure s) x
$cto :: forall (s :: S) x.
Rep (PProposalProcedure s) x -> PProposalProcedure s
to :: forall x. Rep (PProposalProcedure s) x -> PProposalProcedure s
Generic
    )
  deriving anyclass
    ( -- | @since 3.1.0
      All SListI (Code (PProposalProcedure s))
All SListI (Code (PProposalProcedure s)) =>
(PProposalProcedure s -> Rep (PProposalProcedure s))
-> (Rep (PProposalProcedure s) -> PProposalProcedure s)
-> Generic (PProposalProcedure s)
Rep (PProposalProcedure s) -> PProposalProcedure s
PProposalProcedure s -> Rep (PProposalProcedure s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PProposalProcedure s))
forall (s :: S). Rep (PProposalProcedure s) -> PProposalProcedure s
forall (s :: S). PProposalProcedure s -> Rep (PProposalProcedure s)
$cfrom :: forall (s :: S). PProposalProcedure s -> Rep (PProposalProcedure s)
from :: PProposalProcedure s -> Rep (PProposalProcedure s)
$cto :: forall (s :: S). Rep (PProposalProcedure s) -> PProposalProcedure s
to :: Rep (PProposalProcedure s) -> PProposalProcedure s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s (PAsData PProposalProcedure) -> Term s PProposalProcedure)
-> (forall (s :: S). Term s PProposalProcedure -> Term s PData)
-> PIsData PProposalProcedure
forall (s :: S).
Term s (PAsData PProposalProcedure) -> Term s PProposalProcedure
forall (s :: S). Term s PProposalProcedure -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S).
Term s (PAsData PProposalProcedure) -> Term s PProposalProcedure
pfromDataImpl :: forall (s :: S).
Term s (PAsData PProposalProcedure) -> Term s PProposalProcedure
$cpdataImpl :: forall (s :: S). Term s PProposalProcedure -> Term s PData
pdataImpl :: forall (s :: S). Term s PProposalProcedure -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s PProposalProcedure
 -> Term s PProposalProcedure -> Term s PBool)
-> PEq PProposalProcedure
forall (s :: S).
Term s PProposalProcedure
-> Term s PProposalProcedure -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PProposalProcedure
-> Term s PProposalProcedure -> Term s PBool
#== :: forall (s :: S).
Term s PProposalProcedure
-> Term s PProposalProcedure -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S).
 Bool -> Term s PProposalProcedure -> Term s PString)
-> PShow PProposalProcedure
forall (s :: S).
Bool -> Term s PProposalProcedure -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S).
Bool -> Term s PProposalProcedure -> Term s PString
pshow' :: forall (s :: S).
Bool -> Term s PProposalProcedure -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S).
 PProposalProcedure s -> Term s (PInner PProposalProcedure))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PProposalProcedure)
    -> (PProposalProcedure s -> Term s b) -> Term s b)
-> PlutusType PProposalProcedure
forall (s :: S).
PProposalProcedure s -> Term s (PInner PProposalProcedure)
forall (s :: S) (b :: S -> Type).
Term s (PInner PProposalProcedure)
-> (PProposalProcedure s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S).
PProposalProcedure s -> Term s (PInner PProposalProcedure)
pcon' :: forall (s :: S).
PProposalProcedure s -> Term s (PInner PProposalProcedure)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PProposalProcedure)
-> (PProposalProcedure s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PProposalProcedure)
-> (PProposalProcedure s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PProposalProcedure
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PProposalProcedure)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PProposalProcedure Plutus.ProposalProcedure
  instance
    PLiftable PProposalProcedure

-- | @since 3.4.0
instance PTryFrom PData (PAsData PProposalProcedure)

-- | @since 2.0.0
data PScriptPurpose (s :: S)
  = PMinting (Term s (PAsData Value.PCurrencySymbol))
  | PSpending (Term s PTxOutRef)
  | -- | @since 3.1.0
    PRewarding (Term s PCredential)
  | PCertifying (Term s (PAsData PInteger)) (Term s PTxCert)
  | -- | @since 3.1.0
    PVoting (Term s PVoter)
  | -- | @since 3.1.0
    PProposing (Term s (PAsData PInteger)) (Term s PProposalProcedure)
  deriving stock
    ( -- | @since 2.0.0
      (forall x. PScriptPurpose s -> Rep (PScriptPurpose s) x)
-> (forall x. Rep (PScriptPurpose s) x -> PScriptPurpose s)
-> Generic (PScriptPurpose s)
forall x. Rep (PScriptPurpose s) x -> PScriptPurpose s
forall x. PScriptPurpose s -> Rep (PScriptPurpose s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PScriptPurpose s) x -> PScriptPurpose s
forall (s :: S) x. PScriptPurpose s -> Rep (PScriptPurpose s) x
$cfrom :: forall (s :: S) x. PScriptPurpose s -> Rep (PScriptPurpose s) x
from :: forall x. PScriptPurpose s -> Rep (PScriptPurpose s) x
$cto :: forall (s :: S) x. Rep (PScriptPurpose s) x -> PScriptPurpose s
to :: forall x. Rep (PScriptPurpose s) x -> PScriptPurpose s
Generic
    )
  deriving anyclass
    ( -- | @since 2.0.0
      All SListI (Code (PScriptPurpose s))
All SListI (Code (PScriptPurpose s)) =>
(PScriptPurpose s -> Rep (PScriptPurpose s))
-> (Rep (PScriptPurpose s) -> PScriptPurpose s)
-> Generic (PScriptPurpose s)
Rep (PScriptPurpose s) -> PScriptPurpose s
PScriptPurpose s -> Rep (PScriptPurpose s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PScriptPurpose s))
forall (s :: S). Rep (PScriptPurpose s) -> PScriptPurpose s
forall (s :: S). PScriptPurpose s -> Rep (PScriptPurpose s)
$cfrom :: forall (s :: S). PScriptPurpose s -> Rep (PScriptPurpose s)
from :: PScriptPurpose s -> Rep (PScriptPurpose s)
$cto :: forall (s :: S). Rep (PScriptPurpose s) -> PScriptPurpose s
to :: Rep (PScriptPurpose s) -> PScriptPurpose s
SOP.Generic
    , -- | @since 2.0.0
      (forall (s :: S).
 Term s (PAsData PScriptPurpose) -> Term s PScriptPurpose)
-> (forall (s :: S). Term s PScriptPurpose -> Term s PData)
-> PIsData PScriptPurpose
forall (s :: S).
Term s (PAsData PScriptPurpose) -> Term s PScriptPurpose
forall (s :: S). Term s PScriptPurpose -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S).
Term s (PAsData PScriptPurpose) -> Term s PScriptPurpose
pfromDataImpl :: forall (s :: S).
Term s (PAsData PScriptPurpose) -> Term s PScriptPurpose
$cpdataImpl :: forall (s :: S). Term s PScriptPurpose -> Term s PData
pdataImpl :: forall (s :: S). Term s PScriptPurpose -> Term s PData
PIsData
    , -- | @since 2.0.0
      (forall (s :: S).
 Term s PScriptPurpose -> Term s PScriptPurpose -> Term s PBool)
-> PEq PScriptPurpose
forall (s :: S).
Term s PScriptPurpose -> Term s PScriptPurpose -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PScriptPurpose -> Term s PScriptPurpose -> Term s PBool
#== :: forall (s :: S).
Term s PScriptPurpose -> Term s PScriptPurpose -> Term s PBool
PEq
    , -- | @since 2.0.0
      (forall (s :: S). Bool -> Term s PScriptPurpose -> Term s PString)
-> PShow PScriptPurpose
forall (s :: S). Bool -> Term s PScriptPurpose -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PScriptPurpose -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PScriptPurpose -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S).
 PScriptPurpose s -> Term s (PInner PScriptPurpose))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PScriptPurpose)
    -> (PScriptPurpose s -> Term s b) -> Term s b)
-> PlutusType PScriptPurpose
forall (s :: S). PScriptPurpose s -> Term s (PInner PScriptPurpose)
forall (s :: S) (b :: S -> Type).
Term s (PInner PScriptPurpose)
-> (PScriptPurpose s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S). PScriptPurpose s -> Term s (PInner PScriptPurpose)
pcon' :: forall (s :: S). PScriptPurpose s -> Term s (PInner PScriptPurpose)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PScriptPurpose)
-> (PScriptPurpose s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PScriptPurpose)
-> (PScriptPurpose s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PScriptPurpose
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PScriptPurpose)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PScriptPurpose Plutus.ScriptPurpose
  instance
    PLiftable PScriptPurpose

-- | @since 3.4.0
instance PTryFrom PData (PAsData PScriptPurpose)

-- | @since 3.1.0
data PScriptInfo (s :: S)
  = PMintingScript (Term s (PAsData Value.PCurrencySymbol))
  | PSpendingScript (Term s PTxOutRef) (Term s (PMaybeData PDatum))
  | PRewardingScript (Term s PCredential)
  | PCertifyingScript (Term s (PAsData PInteger)) (Term s PTxCert)
  | PVotingScript (Term s PVoter)
  | PProposingScript (Term s (PAsData PInteger)) (Term s PProposalProcedure)
  deriving stock
    ( -- | @since 3.1.0
      (forall x. PScriptInfo s -> Rep (PScriptInfo s) x)
-> (forall x. Rep (PScriptInfo s) x -> PScriptInfo s)
-> Generic (PScriptInfo s)
forall x. Rep (PScriptInfo s) x -> PScriptInfo s
forall x. PScriptInfo s -> Rep (PScriptInfo s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PScriptInfo s) x -> PScriptInfo s
forall (s :: S) x. PScriptInfo s -> Rep (PScriptInfo s) x
$cfrom :: forall (s :: S) x. PScriptInfo s -> Rep (PScriptInfo s) x
from :: forall x. PScriptInfo s -> Rep (PScriptInfo s) x
$cto :: forall (s :: S) x. Rep (PScriptInfo s) x -> PScriptInfo s
to :: forall x. Rep (PScriptInfo s) x -> PScriptInfo s
Generic
    )
  deriving anyclass
    ( -- | @since 3.3.0
      All SListI (Code (PScriptInfo s))
All SListI (Code (PScriptInfo s)) =>
(PScriptInfo s -> Rep (PScriptInfo s))
-> (Rep (PScriptInfo s) -> PScriptInfo s)
-> Generic (PScriptInfo s)
Rep (PScriptInfo s) -> PScriptInfo s
PScriptInfo s -> Rep (PScriptInfo s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PScriptInfo s))
forall (s :: S). Rep (PScriptInfo s) -> PScriptInfo s
forall (s :: S). PScriptInfo s -> Rep (PScriptInfo s)
$cfrom :: forall (s :: S). PScriptInfo s -> Rep (PScriptInfo s)
from :: PScriptInfo s -> Rep (PScriptInfo s)
$cto :: forall (s :: S). Rep (PScriptInfo s) -> PScriptInfo s
to :: Rep (PScriptInfo s) -> PScriptInfo s
SOP.Generic
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s (PAsData PScriptInfo) -> Term s PScriptInfo)
-> (forall (s :: S). Term s PScriptInfo -> Term s PData)
-> PIsData PScriptInfo
forall (s :: S). Term s (PAsData PScriptInfo) -> Term s PScriptInfo
forall (s :: S). Term s PScriptInfo -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S). Term s (PAsData PScriptInfo) -> Term s PScriptInfo
pfromDataImpl :: forall (s :: S). Term s (PAsData PScriptInfo) -> Term s PScriptInfo
$cpdataImpl :: forall (s :: S). Term s PScriptInfo -> Term s PData
pdataImpl :: forall (s :: S). Term s PScriptInfo -> Term s PData
PIsData
    , -- | @since 3.1.0
      (forall (s :: S).
 Term s PScriptInfo -> Term s PScriptInfo -> Term s PBool)
-> PEq PScriptInfo
forall (s :: S).
Term s PScriptInfo -> Term s PScriptInfo -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PScriptInfo -> Term s PScriptInfo -> Term s PBool
#== :: forall (s :: S).
Term s PScriptInfo -> Term s PScriptInfo -> Term s PBool
PEq
    , -- | @since 3.1.0
      (forall (s :: S). Bool -> Term s PScriptInfo -> Term s PString)
-> PShow PScriptInfo
forall (s :: S). Bool -> Term s PScriptInfo -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PScriptInfo -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PScriptInfo -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S). PScriptInfo s -> Term s (PInner PScriptInfo))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PScriptInfo)
    -> (PScriptInfo s -> Term s b) -> Term s b)
-> PlutusType PScriptInfo
forall (s :: S). PScriptInfo s -> Term s (PInner PScriptInfo)
forall (s :: S) (b :: S -> Type).
Term s (PInner PScriptInfo)
-> (PScriptInfo s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S). PScriptInfo s -> Term s (PInner PScriptInfo)
pcon' :: forall (s :: S). PScriptInfo s -> Term s (PInner PScriptInfo)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PScriptInfo)
-> (PScriptInfo s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PScriptInfo)
-> (PScriptInfo s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PScriptInfo
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PScriptInfo)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PScriptInfo Plutus.ScriptInfo
  instance
    PLiftable PScriptInfo

-- | @since 3.4.0
instance PTryFrom PData (PAsData PScriptInfo)

{- | An input of the transaction.

@since 2.0.0
-}
data PTxInInfo (s :: S) = PTxInInfo
  { forall (s :: S). PTxInInfo s -> Term s PTxOutRef
ptxInInfo'outRef :: Term s PTxOutRef
  , forall (s :: S). PTxInInfo s -> Term s PTxOut
ptxInInfo'resolved :: Term s PTxOut
  }
  deriving stock
    ( -- | @since 2.0.0
      (forall x. PTxInInfo s -> Rep (PTxInInfo s) x)
-> (forall x. Rep (PTxInInfo s) x -> PTxInInfo s)
-> Generic (PTxInInfo s)
forall x. Rep (PTxInInfo s) x -> PTxInInfo s
forall x. PTxInInfo s -> Rep (PTxInInfo s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PTxInInfo s) x -> PTxInInfo s
forall (s :: S) x. PTxInInfo s -> Rep (PTxInInfo s) x
$cfrom :: forall (s :: S) x. PTxInInfo s -> Rep (PTxInInfo s) x
from :: forall x. PTxInInfo s -> Rep (PTxInInfo s) x
$cto :: forall (s :: S) x. Rep (PTxInInfo s) x -> PTxInInfo s
to :: forall x. Rep (PTxInInfo s) x -> PTxInInfo s
Generic
    )
  deriving anyclass
    ( -- | @since 3.3.0
      All SListI (Code (PTxInInfo s))
All SListI (Code (PTxInInfo s)) =>
(PTxInInfo s -> Rep (PTxInInfo s))
-> (Rep (PTxInInfo s) -> PTxInInfo s) -> Generic (PTxInInfo s)
Rep (PTxInInfo s) -> PTxInInfo s
PTxInInfo s -> Rep (PTxInInfo s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PTxInInfo s))
forall (s :: S). Rep (PTxInInfo s) -> PTxInInfo s
forall (s :: S). PTxInInfo s -> Rep (PTxInInfo s)
$cfrom :: forall (s :: S). PTxInInfo s -> Rep (PTxInInfo s)
from :: PTxInInfo s -> Rep (PTxInInfo s)
$cto :: forall (s :: S). Rep (PTxInInfo s) -> PTxInInfo s
to :: Rep (PTxInInfo s) -> PTxInInfo s
SOP.Generic
    , -- | @since 2.0.0
      (forall (s :: S). Term s (PAsData PTxInInfo) -> Term s PTxInInfo)
-> (forall (s :: S). Term s PTxInInfo -> Term s PData)
-> PIsData PTxInInfo
forall (s :: S). Term s (PAsData PTxInInfo) -> Term s PTxInInfo
forall (s :: S). Term s PTxInInfo -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S). Term s (PAsData PTxInInfo) -> Term s PTxInInfo
pfromDataImpl :: forall (s :: S). Term s (PAsData PTxInInfo) -> Term s PTxInInfo
$cpdataImpl :: forall (s :: S). Term s PTxInInfo -> Term s PData
pdataImpl :: forall (s :: S). Term s PTxInInfo -> Term s PData
PIsData
    , -- | @since 2.0.0
      (forall (s :: S).
 Term s PTxInInfo -> Term s PTxInInfo -> Term s PBool)
-> PEq PTxInInfo
forall (s :: S).
Term s PTxInInfo -> Term s PTxInInfo -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PTxInInfo -> Term s PTxInInfo -> Term s PBool
#== :: forall (s :: S).
Term s PTxInInfo -> Term s PTxInInfo -> Term s PBool
PEq
    , -- | @since 2.0.0
      (forall (s :: S). Bool -> Term s PTxInInfo -> Term s PString)
-> PShow PTxInInfo
forall (s :: S). Bool -> Term s PTxInInfo -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PTxInInfo -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PTxInInfo -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S). PTxInInfo s -> Term s (PInner PTxInInfo))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PTxInInfo) -> (PTxInInfo s -> Term s b) -> Term s b)
-> PlutusType PTxInInfo
forall (s :: S). PTxInInfo s -> Term s (PInner PTxInInfo)
forall (s :: S) (b :: S -> Type).
Term s (PInner PTxInInfo) -> (PTxInInfo s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S). PTxInInfo s -> Term s (PInner PTxInInfo)
pcon' :: forall (s :: S). PTxInInfo s -> Term s (PInner PTxInInfo)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PTxInInfo) -> (PTxInInfo s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PTxInInfo) -> (PTxInInfo s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PTxInInfo
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PTxInInfo)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PTxInInfo Plutus.TxInInfo
  instance
    PLiftable PTxInInfo

-- | @since 3.4.0
instance PTryFrom PData (PAsData PTxInInfo)

-- A pending transaction. This is the view as seen by a validator script.
--
-- @since 3.3.0
data PTxInfo (s :: S) = PTxInfo
  { forall (s :: S).
PTxInfo s -> Term s (PAsData (PBuiltinList (PAsData PTxInInfo)))
ptxInfo'inputs :: Term s (PAsData (PBuiltinList (PAsData PTxInInfo)))
  , forall (s :: S).
PTxInfo s -> Term s (PAsData (PBuiltinList (PAsData PTxInInfo)))
ptxInfo'referenceInputs :: Term s (PAsData (PBuiltinList (PAsData PTxInInfo)))
  , forall (s :: S).
PTxInfo s -> Term s (PAsData (PBuiltinList (PAsData PTxOut)))
ptxInfo'outputs :: Term s (PAsData (PBuiltinList (PAsData PTxOut)))
  , forall (s :: S). PTxInfo s -> Term s (PAsData PLovelace)
ptxInfo'fee :: Term s (PAsData Value.PLovelace)
  , forall (s :: S). PTxInfo s -> Term s (PAsData PMintValue)
ptxInfo'mint :: Term s (PAsData MintValue.PMintValue) -- value minted by transaction
  , forall (s :: S).
PTxInfo s -> Term s (PAsData (PBuiltinList (PAsData PTxCert)))
ptxInfo'txCerts :: Term s (PAsData (PBuiltinList (PAsData PTxCert)))
  , forall (s :: S).
PTxInfo s -> Term s (PAsData (PUnsortedMap PCredential PLovelace))
ptxInfo'wdrl :: Term s (PAsData (AssocMap.PUnsortedMap PCredential Value.PLovelace)) -- Staking withdrawals
  , forall (s :: S). PTxInfo s -> Term s (PInterval PPosixTime)
ptxInfo'validRange :: Term s (Interval.PInterval PPosixTime)
  , forall (s :: S).
PTxInfo s -> Term s (PAsData (PBuiltinList (PAsData PPubKeyHash)))
ptxInfo'signatories :: Term s (PAsData (PBuiltinList (PAsData PPubKeyHash)))
  , forall (s :: S).
PTxInfo s
-> Term s (PAsData (PUnsortedMap PScriptPurpose PRedeemer))
ptxInfo'redeemers :: Term s (PAsData (AssocMap.PUnsortedMap PScriptPurpose PRedeemer))
  , forall (s :: S).
PTxInfo s -> Term s (PAsData (PUnsortedMap PDatumHash PDatum))
ptxInfo'data :: Term s (PAsData (AssocMap.PUnsortedMap PDatumHash PDatum))
  , forall (s :: S). PTxInfo s -> Term s (PAsData PTxId)
ptxInfo'id :: Term s (PAsData PTxId) -- hash of the pending transaction
  , forall (s :: S).
PTxInfo s
-> Term
     s
     (PAsData
        (PUnsortedMap PVoter (PUnsortedMap PGovernanceActionId PVote)))
ptxInfo'votes :: Term s (PAsData (AssocMap.PUnsortedMap PVoter (AssocMap.PUnsortedMap PGovernanceActionId PVote)))
  , forall (s :: S).
PTxInfo s
-> Term s (PAsData (PBuiltinList (PAsData PProposalProcedure)))
ptxInfo'proposalProcedures :: Term s (PAsData (PBuiltinList (PAsData PProposalProcedure)))
  , forall (s :: S). PTxInfo s -> Term s (PMaybeData PLovelace)
ptxInfo'currentTreasuryAmount :: Term s (PMaybeData Value.PLovelace)
  , forall (s :: S). PTxInfo s -> Term s (PMaybeData PLovelace)
ptxInfo'treasuryDonation :: Term s (PMaybeData Value.PLovelace)
  }
  deriving stock
    ( -- | @since 2.0.0
      (forall x. PTxInfo s -> Rep (PTxInfo s) x)
-> (forall x. Rep (PTxInfo s) x -> PTxInfo s)
-> Generic (PTxInfo s)
forall x. Rep (PTxInfo s) x -> PTxInfo s
forall x. PTxInfo s -> Rep (PTxInfo s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PTxInfo s) x -> PTxInfo s
forall (s :: S) x. PTxInfo s -> Rep (PTxInfo s) x
$cfrom :: forall (s :: S) x. PTxInfo s -> Rep (PTxInfo s) x
from :: forall x. PTxInfo s -> Rep (PTxInfo s) x
$cto :: forall (s :: S) x. Rep (PTxInfo s) x -> PTxInfo s
to :: forall x. Rep (PTxInfo s) x -> PTxInfo s
Generic
    )
  deriving anyclass
    ( -- | @since 2.0.0
      All SListI (Code (PTxInfo s))
All SListI (Code (PTxInfo s)) =>
(PTxInfo s -> Rep (PTxInfo s))
-> (Rep (PTxInfo s) -> PTxInfo s) -> Generic (PTxInfo s)
Rep (PTxInfo s) -> PTxInfo s
PTxInfo s -> Rep (PTxInfo s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PTxInfo s))
forall (s :: S). Rep (PTxInfo s) -> PTxInfo s
forall (s :: S). PTxInfo s -> Rep (PTxInfo s)
$cfrom :: forall (s :: S). PTxInfo s -> Rep (PTxInfo s)
from :: PTxInfo s -> Rep (PTxInfo s)
$cto :: forall (s :: S). Rep (PTxInfo s) -> PTxInfo s
to :: Rep (PTxInfo s) -> PTxInfo s
SOP.Generic
    , -- | @since 2.0.0
      (forall (s :: S). Term s (PAsData PTxInfo) -> Term s PTxInfo)
-> (forall (s :: S). Term s PTxInfo -> Term s PData)
-> PIsData PTxInfo
forall (s :: S). Term s (PAsData PTxInfo) -> Term s PTxInfo
forall (s :: S). Term s PTxInfo -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S). Term s (PAsData PTxInfo) -> Term s PTxInfo
pfromDataImpl :: forall (s :: S). Term s (PAsData PTxInfo) -> Term s PTxInfo
$cpdataImpl :: forall (s :: S). Term s PTxInfo -> Term s PData
pdataImpl :: forall (s :: S). Term s PTxInfo -> Term s PData
PIsData
    , -- | @since 2.0.0
      (forall (s :: S). Term s PTxInfo -> Term s PTxInfo -> Term s PBool)
-> PEq PTxInfo
forall (s :: S). Term s PTxInfo -> Term s PTxInfo -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S). Term s PTxInfo -> Term s PTxInfo -> Term s PBool
#== :: forall (s :: S). Term s PTxInfo -> Term s PTxInfo -> Term s PBool
PEq
    , -- | @since 2.0.0
      (forall (s :: S). Bool -> Term s PTxInfo -> Term s PString)
-> PShow PTxInfo
forall (s :: S). Bool -> Term s PTxInfo -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PTxInfo -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PTxInfo -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S). PTxInfo s -> Term s (PInner PTxInfo))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PTxInfo) -> (PTxInfo s -> Term s b) -> Term s b)
-> PlutusType PTxInfo
forall (s :: S). PTxInfo s -> Term s (PInner PTxInfo)
forall (s :: S) (b :: S -> Type).
Term s (PInner PTxInfo) -> (PTxInfo s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S). PTxInfo s -> Term s (PInner PTxInfo)
pcon' :: forall (s :: S). PTxInfo s -> Term s (PInner PTxInfo)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PTxInfo) -> (PTxInfo s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PTxInfo) -> (PTxInfo s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PTxInfo
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PTxInfo)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PTxInfo Plutus.TxInfo
  instance
    PLiftable PTxInfo

-- | @since 3.4.0
instance PTryFrom PData (PAsData PTxInfo)

-- | @since 3.1.0
data PScriptContext (s :: S) = PScriptContext
  { forall (s :: S). PScriptContext s -> Term s PTxInfo
pscriptContext'txInfo :: Term s PTxInfo
  , forall (s :: S). PScriptContext s -> Term s PRedeemer
pscriptContext'redeemer :: Term s PRedeemer
  , forall (s :: S). PScriptContext s -> Term s PScriptInfo
pscriptContext'scriptInfo :: Term s PScriptInfo
  }
  deriving stock
    ( -- | @since 2.0.0
      (forall x. PScriptContext s -> Rep (PScriptContext s) x)
-> (forall x. Rep (PScriptContext s) x -> PScriptContext s)
-> Generic (PScriptContext s)
forall x. Rep (PScriptContext s) x -> PScriptContext s
forall x. PScriptContext s -> Rep (PScriptContext s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PScriptContext s) x -> PScriptContext s
forall (s :: S) x. PScriptContext s -> Rep (PScriptContext s) x
$cfrom :: forall (s :: S) x. PScriptContext s -> Rep (PScriptContext s) x
from :: forall x. PScriptContext s -> Rep (PScriptContext s) x
$cto :: forall (s :: S) x. Rep (PScriptContext s) x -> PScriptContext s
to :: forall x. Rep (PScriptContext s) x -> PScriptContext s
Generic
    )
  deriving anyclass
    ( -- | @since 3.3.0
      All SListI (Code (PScriptContext s))
All SListI (Code (PScriptContext s)) =>
(PScriptContext s -> Rep (PScriptContext s))
-> (Rep (PScriptContext s) -> PScriptContext s)
-> Generic (PScriptContext s)
Rep (PScriptContext s) -> PScriptContext s
PScriptContext s -> Rep (PScriptContext s)
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
forall (s :: S). All SListI (Code (PScriptContext s))
forall (s :: S). Rep (PScriptContext s) -> PScriptContext s
forall (s :: S). PScriptContext s -> Rep (PScriptContext s)
$cfrom :: forall (s :: S). PScriptContext s -> Rep (PScriptContext s)
from :: PScriptContext s -> Rep (PScriptContext s)
$cto :: forall (s :: S). Rep (PScriptContext s) -> PScriptContext s
to :: Rep (PScriptContext s) -> PScriptContext s
SOP.Generic
    , -- | @since 2.0.0
      (forall (s :: S).
 Term s (PAsData PScriptContext) -> Term s PScriptContext)
-> (forall (s :: S). Term s PScriptContext -> Term s PData)
-> PIsData PScriptContext
forall (s :: S).
Term s (PAsData PScriptContext) -> Term s PScriptContext
forall (s :: S). Term s PScriptContext -> Term s PData
forall (a :: S -> Type).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
$cpfromDataImpl :: forall (s :: S).
Term s (PAsData PScriptContext) -> Term s PScriptContext
pfromDataImpl :: forall (s :: S).
Term s (PAsData PScriptContext) -> Term s PScriptContext
$cpdataImpl :: forall (s :: S). Term s PScriptContext -> Term s PData
pdataImpl :: forall (s :: S). Term s PScriptContext -> Term s PData
PIsData
    , -- | @since 2.0.0
      (forall (s :: S).
 Term s PScriptContext -> Term s PScriptContext -> Term s PBool)
-> PEq PScriptContext
forall (s :: S).
Term s PScriptContext -> Term s PScriptContext -> Term s PBool
forall (t :: S -> Type).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
$c#== :: forall (s :: S).
Term s PScriptContext -> Term s PScriptContext -> Term s PBool
#== :: forall (s :: S).
Term s PScriptContext -> Term s PScriptContext -> Term s PBool
PEq
    , -- | @since 2.0.0
      (forall (s :: S). Bool -> Term s PScriptContext -> Term s PString)
-> PShow PScriptContext
forall (s :: S). Bool -> Term s PScriptContext -> Term s PString
forall (t :: S -> Type).
(forall (s :: S). Bool -> Term s t -> Term s PString) -> PShow t
$cpshow' :: forall (s :: S). Bool -> Term s PScriptContext -> Term s PString
pshow' :: forall (s :: S). Bool -> Term s PScriptContext -> Term s PString
PShow
    )
  deriving
    ( -- | @since 3.3.0
      (forall (s :: S).
 PScriptContext s -> Term s (PInner PScriptContext))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner PScriptContext)
    -> (PScriptContext s -> Term s b) -> Term s b)
-> PlutusType PScriptContext
forall (s :: S). PScriptContext s -> Term s (PInner PScriptContext)
forall (s :: S) (b :: S -> Type).
Term s (PInner PScriptContext)
-> (PScriptContext s -> Term s b) -> Term s b
forall (a :: S -> Type).
(forall (s :: S). a s -> Term s (PInner a))
-> (forall (s :: S) (b :: S -> Type).
    Term s (PInner a) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
$cpcon' :: forall (s :: S). PScriptContext s -> Term s (PInner PScriptContext)
pcon' :: forall (s :: S). PScriptContext s -> Term s (PInner PScriptContext)
$cpmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PScriptContext)
-> (PScriptContext s -> Term s b) -> Term s b
pmatch' :: forall (s :: S) (b :: S -> Type).
Term s (PInner PScriptContext)
-> (PScriptContext s -> Term s b) -> Term s b
PlutusType
    , -- | @since 3.6.0
      (forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData PScriptContext
forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
forall (a :: S -> Type).
(forall (s :: S).
 Term s PData -> forall (r :: S -> Type). Term s r -> Term s r)
-> PValidateData a
$cpwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
pwithValidated :: forall (s :: S).
Term s PData -> forall (r :: S -> Type). Term s r -> Term s r
PValidateData
    )
    via (DeriveAsDataStruct PScriptContext)

-- | @since 3.3.0
deriving via
  DeriveDataPLiftable PScriptContext Plutus.ScriptContext
  instance
    PLiftable PScriptContext

-- | @since 3.4.0
instance PTryFrom PData (PAsData PScriptContext)

{- | Find the input currently being validated.

@since 3.6.0
-}
pfindOwnInput :: forall (s :: S). Term s (PScriptContext :--> PMaybe PTxInInfo)
pfindOwnInput :: forall (s :: S). Term s (PScriptContext :--> PMaybe PTxInInfo)
pfindOwnInput =
  (forall (s :: S). Term s (PScriptContext :--> PMaybe PTxInInfo))
-> Term s (PScriptContext :--> PMaybe PTxInInfo)
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s :: S). Term s (PScriptContext :--> PMaybe PTxInInfo))
 -> Term s (PScriptContext :--> PMaybe PTxInInfo))
-> (forall (s :: S). Term s (PScriptContext :--> PMaybe PTxInInfo))
-> Term s (PScriptContext :--> PMaybe PTxInInfo)
forall a b. (a -> b) -> a -> b
$
    (Term s' PScriptContext -> Term s' (PMaybe PTxInInfo))
-> Term s' (PScriptContext :--> PMaybe PTxInInfo)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PMaybe PTxInInfo))
-> Term s' (c :--> PMaybe PTxInInfo)
plam ((Term s' PScriptContext -> Term s' (PMaybe PTxInInfo))
 -> Term s' (PScriptContext :--> PMaybe PTxInInfo))
-> (Term s' PScriptContext -> Term s' (PMaybe PTxInInfo))
-> Term s' (PScriptContext :--> PMaybe PTxInInfo)
forall a b. (a -> b) -> a -> b
$ \Term s' PScriptContext
scriptCtx ->
      Term s' PScriptContext
-> (PScriptContext s' -> Term s' (PMaybe PTxInInfo))
-> Term s' (PMaybe PTxInInfo)
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' PScriptContext
scriptCtx ((PScriptContext s' -> Term s' (PMaybe PTxInInfo))
 -> Term s' (PMaybe PTxInInfo))
-> (PScriptContext s' -> Term s' (PMaybe PTxInInfo))
-> Term s' (PMaybe PTxInInfo)
forall a b. (a -> b) -> a -> b
$ \PScriptContext s'
ctx ->
        Term s' PScriptInfo
-> (Term s' PScriptInfo -> Term s' (PMaybe PTxInInfo))
-> Term s' (PMaybe PTxInInfo)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (PScriptContext s' -> Term s' PScriptInfo
forall (s :: S). PScriptContext s -> Term s PScriptInfo
pscriptContext'scriptInfo PScriptContext s'
ctx) ((Term s' PScriptInfo -> Term s' (PMaybe PTxInInfo))
 -> Term s' (PMaybe PTxInInfo))
-> (Term s' PScriptInfo -> Term s' (PMaybe PTxInInfo))
-> Term s' (PMaybe PTxInInfo)
forall a b. (a -> b) -> a -> b
$ \Term s' PScriptInfo
scriptInfo ->
          Term s' PScriptInfo
-> (PScriptInfo s' -> Term s' (PMaybe PTxInInfo))
-> Term s' (PMaybe PTxInInfo)
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' PScriptInfo
scriptInfo ((PScriptInfo s' -> Term s' (PMaybe PTxInInfo))
 -> Term s' (PMaybe PTxInInfo))
-> (PScriptInfo s' -> Term s' (PMaybe PTxInInfo))
-> Term s' (PMaybe PTxInInfo)
forall a b. (a -> b) -> a -> b
$ \case
            PSpendingScript Term s' PTxOutRef
outRef Term s' (PMaybeData PDatum)
_ ->
              Term s' (PTxOutRef :--> (PTxInfo :--> PMaybe PTxInInfo))
forall (s :: S).
Term s (PTxOutRef :--> (PTxInfo :--> PMaybe PTxInInfo))
pfindTxInByTxOutRef Term s' (PTxOutRef :--> (PTxInfo :--> PMaybe PTxInInfo))
-> Term s' PTxOutRef -> Term s' (PTxInfo :--> PMaybe PTxInInfo)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' PTxOutRef
outRef Term s' (PTxInfo :--> PMaybe PTxInInfo)
-> Term s' PTxInfo -> Term s' (PMaybe PTxInInfo)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# PScriptContext s' -> Term s' PTxInfo
forall (s :: S). PScriptContext s -> Term s PTxInfo
pscriptContext'txInfo PScriptContext s'
ctx
            PScriptInfo s'
_ ->
              PMaybe PTxInInfo s' -> Term s' (PMaybe PTxInInfo)
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PMaybe PTxInInfo s'
forall (a :: S -> Type) (s :: S). PMaybe a s
PNothing

{- | Find the datum corresponding to a datum hash, if there is one.

@since 3.1.0
-}
pfindDatum :: forall (s :: S). Term s (PDatumHash :--> PTxInfo :--> PMaybe PDatum)
pfindDatum :: forall (s :: S).
Term s (PDatumHash :--> (PTxInfo :--> PMaybe PDatum))
pfindDatum = (forall (s :: S).
 Term s (PDatumHash :--> (PTxInfo :--> PMaybe PDatum)))
-> Term s (PDatumHash :--> (PTxInfo :--> PMaybe PDatum))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s :: S).
  Term s (PDatumHash :--> (PTxInfo :--> PMaybe PDatum)))
 -> Term s (PDatumHash :--> (PTxInfo :--> PMaybe PDatum)))
-> (forall (s :: S).
    Term s (PDatumHash :--> (PTxInfo :--> PMaybe PDatum)))
-> Term s (PDatumHash :--> (PTxInfo :--> PMaybe PDatum))
forall a b. (a -> b) -> a -> b
$ (Term s' PDatumHash -> Term s' PTxInfo -> Term s' (PMaybe PDatum))
-> Term s' (PDatumHash :--> (PTxInfo :--> PMaybe PDatum))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' PTxInfo -> Term s' (PMaybe PDatum))
-> Term s' (c :--> (PTxInfo :--> PMaybe PDatum))
plam ((Term s' PDatumHash -> Term s' PTxInfo -> Term s' (PMaybe PDatum))
 -> Term s' (PDatumHash :--> (PTxInfo :--> PMaybe PDatum)))
-> (Term s' PDatumHash
    -> Term s' PTxInfo -> Term s' (PMaybe PDatum))
-> Term s' (PDatumHash :--> (PTxInfo :--> PMaybe PDatum))
forall a b. (a -> b) -> a -> b
$ \Term s' PDatumHash
dh Term s' PTxInfo
txI ->
  Term s' PTxInfo
-> (PTxInfo s' -> Term s' (PMaybe PDatum))
-> Term s' (PMaybe PDatum)
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' PTxInfo
txI ((PTxInfo s' -> Term s' (PMaybe PDatum))
 -> Term s' (PMaybe PDatum))
-> (PTxInfo s' -> Term s' (PMaybe PDatum))
-> Term s' (PMaybe PDatum)
forall a b. (a -> b) -> a -> b
$ \PTxInfo s'
tx ->
    Term
  s'
  (PDatumHash :--> (PSortedMap PDatumHash PDatum :--> PMaybe PDatum))
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v) =>
Term s (k :--> (PSortedMap k v :--> PMaybe v))
AssocMap.plookup Term
  s'
  (PDatumHash :--> (PSortedMap PDatumHash PDatum :--> PMaybe PDatum))
-> Term s' PDatumHash
-> Term s' (PSortedMap PDatumHash PDatum :--> PMaybe PDatum)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' PDatumHash
dh Term s' (PSortedMap PDatumHash PDatum :--> PMaybe PDatum)
-> Term s' (PSortedMap PDatumHash PDatum)
-> Term s' (PMaybe PDatum)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap PDatumHash PDatum)
-> Term s' (PSortedMap PDatumHash PDatum)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PUnsortedMap k v) -> Term s (PSortedMap k v)
AssocMap.punsafeCoerceToSortedMap (Term s' (PAsData (PUnsortedMap PDatumHash PDatum))
-> Term s' (PUnsortedMap PDatumHash PDatum)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (PTxInfo s' -> Term s' (PAsData (PUnsortedMap PDatumHash PDatum))
forall (s :: S).
PTxInfo s -> Term s (PAsData (PUnsortedMap PDatumHash PDatum))
ptxInfo'data PTxInfo s'
tx))

{- | Find the hash of a datum if it's part of the pending transaction's hashes.

@since 3.1.0
-}
pfindDatumHash :: forall (s :: S). Term s (PDatum :--> PTxInfo :--> PMaybe PDatumHash)
pfindDatumHash :: forall (s :: S).
Term s (PDatum :--> (PTxInfo :--> PMaybe PDatumHash))
pfindDatumHash = (forall (s :: S).
 Term s (PDatum :--> (PTxInfo :--> PMaybe PDatumHash)))
-> Term s (PDatum :--> (PTxInfo :--> PMaybe PDatumHash))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s :: S).
  Term s (PDatum :--> (PTxInfo :--> PMaybe PDatumHash)))
 -> Term s (PDatum :--> (PTxInfo :--> PMaybe PDatumHash)))
-> (forall (s :: S).
    Term s (PDatum :--> (PTxInfo :--> PMaybe PDatumHash)))
-> Term s (PDatum :--> (PTxInfo :--> PMaybe PDatumHash))
forall a b. (a -> b) -> a -> b
$ (Term s' PDatum -> Term s' PTxInfo -> Term s' (PMaybe PDatumHash))
-> Term s' (PDatum :--> (PTxInfo :--> PMaybe PDatumHash))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' PTxInfo -> Term s' (PMaybe PDatumHash))
-> Term s' (c :--> (PTxInfo :--> PMaybe PDatumHash))
plam ((Term s' PDatum -> Term s' PTxInfo -> Term s' (PMaybe PDatumHash))
 -> Term s' (PDatum :--> (PTxInfo :--> PMaybe PDatumHash)))
-> (Term s' PDatum
    -> Term s' PTxInfo -> Term s' (PMaybe PDatumHash))
-> Term s' (PDatum :--> (PTxInfo :--> PMaybe PDatumHash))
forall a b. (a -> b) -> a -> b
$ \Term s' PDatum
d Term s' PTxInfo
txI ->
  Term s' PTxInfo
-> (PTxInfo s' -> Term s' (PMaybe PDatumHash))
-> Term s' (PMaybe PDatumHash)
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' PTxInfo
txI ((PTxInfo s' -> Term s' (PMaybe PDatumHash))
 -> Term s' (PMaybe PDatumHash))
-> (PTxInfo s' -> Term s' (PMaybe PDatumHash))
-> Term s' (PMaybe PDatumHash)
forall a b. (a -> b) -> a -> b
$ \PTxInfo s'
tx ->
    Term s' (PUnsortedMap PDatumHash PDatum)
-> (PUnsortedMap PDatumHash PDatum s'
    -> Term s' (PMaybe PDatumHash))
-> Term s' (PMaybe PDatumHash)
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term s' (PAsData (PUnsortedMap PDatumHash PDatum))
-> Term s' (PUnsortedMap PDatumHash PDatum)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (PTxInfo s' -> Term s' (PAsData (PUnsortedMap PDatumHash PDatum))
forall (s :: S).
PTxInfo s -> Term s (PAsData (PUnsortedMap PDatumHash PDatum))
ptxInfo'data PTxInfo s'
tx)) ((PUnsortedMap PDatumHash PDatum s' -> Term s' (PMaybe PDatumHash))
 -> Term s' (PMaybe PDatumHash))
-> (PUnsortedMap PDatumHash PDatum s'
    -> Term s' (PMaybe PDatumHash))
-> Term s' (PMaybe PDatumHash)
forall a b. (a -> b) -> a -> b
$ \(AssocMap.PUnsortedMap Term s' (PAssocMap PDatumHash PDatum)
ell) ->
      Term
  s' (PMaybe (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)))
-> (PMaybe (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)) s'
    -> Term s' (PMaybe PDatumHash))
-> Term s' (PMaybe PDatumHash)
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term
  s'
  ((PBuiltinPair (PAsData PDatumHash) (PAsData PDatum) :--> PBool)
   :--> (PBuiltinList
           (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))
         :--> PMaybe (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))))
forall (l :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S).
PIsListLike l a =>
Term s ((a :--> PBool) :--> (l a :--> PMaybe a))
pfind Term
  s'
  ((PBuiltinPair (PAsData PDatumHash) (PAsData PDatum) :--> PBool)
   :--> (PBuiltinList
           (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))
         :--> PMaybe (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))))
-> Term
     s' (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum) :--> PBool)
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))
      :--> PMaybe (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term
  s'
  (PDatum
   :--> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
         :--> PBool))
forall (s' :: S).
Term
  s'
  (PDatum
   :--> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
         :--> PBool))
matches Term
  s'
  (PDatum
   :--> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
         :--> PBool))
-> Term s' PDatum
-> Term
     s' (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum) :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' PDatum
d) Term
  s'
  (PBuiltinList (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))
   :--> PMaybe (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)))
-> Term
     s'
     (PBuiltinList (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)))
-> Term
     s' (PMaybe (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAssocMap PDatumHash PDatum)
-> Term s' (PInner (PAssocMap PDatumHash PDatum))
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto Term s' (PAssocMap PDatumHash PDatum)
ell) ((PMaybe (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)) s'
  -> Term s' (PMaybe PDatumHash))
 -> Term s' (PMaybe PDatumHash))
-> (PMaybe (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)) s'
    -> Term s' (PMaybe PDatumHash))
-> Term s' (PMaybe PDatumHash)
forall a b. (a -> b) -> a -> b
$ \case
        PMaybe (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)) s'
PNothing -> PMaybe PDatumHash s' -> Term s' (PMaybe PDatumHash)
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PMaybe PDatumHash s'
forall (a :: S -> Type) (s :: S). PMaybe a s
PNothing
        PJust Term s' (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))
p -> Term s' (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))
-> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum) s'
    -> Term s' (PMaybe PDatumHash))
-> Term s' (PMaybe PDatumHash)
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))
p ((PBuiltinPair (PAsData PDatumHash) (PAsData PDatum) s'
  -> Term s' (PMaybe PDatumHash))
 -> Term s' (PMaybe PDatumHash))
-> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum) s'
    -> Term s' (PMaybe PDatumHash))
-> Term s' (PMaybe PDatumHash)
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData PDatumHash)
pFst Term s' (PAsData PDatum)
_) ->
          PMaybe PDatumHash s' -> Term s' (PMaybe PDatumHash)
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PMaybe PDatumHash s' -> Term s' (PMaybe PDatumHash))
-> (Term s' (PAsData PDatumHash) -> PMaybe PDatumHash s')
-> Term s' (PAsData PDatumHash)
-> Term s' (PMaybe PDatumHash)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' PDatumHash -> PMaybe PDatumHash s'
forall (a :: S -> Type) (s :: S). Term s a -> PMaybe a s
PJust (Term s' PDatumHash -> PMaybe PDatumHash s')
-> (Term s' (PAsData PDatumHash) -> Term s' PDatumHash)
-> Term s' (PAsData PDatumHash)
-> PMaybe PDatumHash s'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PAsData PDatumHash) -> Term s' PDatumHash
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (Term s' (PAsData PDatumHash) -> Term s' (PMaybe PDatumHash))
-> Term s' (PAsData PDatumHash) -> Term s' (PMaybe PDatumHash)
forall a b. (a -> b) -> a -> b
$ Term s' (PAsData PDatumHash)
pFst
  where
    matches ::
      forall (s' :: S).
      Term
        s'
        ( PDatum
            :--> PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
            :--> PBool
        )
    matches :: forall (s' :: S).
Term
  s'
  (PDatum
   :--> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
         :--> PBool))
matches = (forall (s' :: S).
 Term
   s'
   (PDatum
    :--> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
          :--> PBool)))
-> Term
     s'
     (PDatum
      :--> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
            :--> PBool))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    (PDatum
     :--> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
           :--> PBool)))
 -> Term
      s'
      (PDatum
       :--> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
             :--> PBool)))
-> (forall (s' :: S).
    Term
      s'
      (PDatum
       :--> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
             :--> PBool)))
-> Term
     s'
     (PDatum
      :--> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
            :--> PBool))
forall a b. (a -> b) -> a -> b
$ (Term s' PDatum
 -> Term s' (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))
 -> Term s' PBool)
-> Term
     s'
     (PDatum
      :--> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
            :--> PBool))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term s' (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))
 -> Term s' PBool)
-> Term
     s'
     (c
      :--> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
            :--> PBool))
plam ((Term s' PDatum
  -> Term s' (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))
  -> Term s' PBool)
 -> Term
      s'
      (PDatum
       :--> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
             :--> PBool)))
-> (Term s' PDatum
    -> Term s' (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))
    -> Term s' PBool)
-> Term
     s'
     (PDatum
      :--> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum)
            :--> PBool))
forall a b. (a -> b) -> a -> b
$ \Term s' PDatum
needle Term s' (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))
p ->
      Term s' (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))
-> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum) s'
    -> Term s' PBool)
-> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum))
p ((PBuiltinPair (PAsData PDatumHash) (PAsData PDatum) s'
  -> Term s' PBool)
 -> Term s' PBool)
-> (PBuiltinPair (PAsData PDatumHash) (PAsData PDatum) s'
    -> Term s' PBool)
-> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \(PBuiltinPair Term s' (PAsData PDatumHash)
_ Term s' (PAsData PDatum)
thing) ->
        Term s' PDatum
needle Term s' PDatum -> Term s' PDatum -> Term s' PBool
forall (s :: S). Term s PDatum -> Term s PDatum -> Term s PBool
forall (t :: S -> Type) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== Term s' (PAsData PDatum) -> Term s' PDatum
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData PDatum)
thing

{- | Lookup up the datum given the datum hash.

  Takes as argument the datum assoc list from a `PTxInfo`. Validates the datum
  using `PTryFrom`.

  __Example:__

  @
  pparseDatum @MyType # datumHash #$ pfield @"datums" # txinfo
  @

  @since 2.1.2
-}
pparseDatum ::
  forall (a :: S -> Type) (s :: S).
  PTryFrom PData (PAsData a) =>
  Term s (PDatumHash :--> AssocMap.PUnsortedMap PDatumHash PDatum :--> PMaybe (PAsData a))
pparseDatum :: forall (a :: S -> Type) (s :: S).
PTryFrom PData (PAsData a) =>
Term
  s
  (PDatumHash
   :--> (PUnsortedMap PDatumHash PDatum :--> PMaybe (PAsData a)))
pparseDatum = (forall (s' :: S).
 Term
   s'
   (PDatumHash
    :--> (PUnsortedMap PDatumHash PDatum :--> PMaybe (PAsData a))))
-> Term
     s
     (PDatumHash
      :--> (PUnsortedMap PDatumHash PDatum :--> PMaybe (PAsData a)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term
    s'
    (PDatumHash
     :--> (PUnsortedMap PDatumHash PDatum :--> PMaybe (PAsData a))))
 -> Term
      s
      (PDatumHash
       :--> (PUnsortedMap PDatumHash PDatum :--> PMaybe (PAsData a))))
-> (forall (s' :: S).
    Term
      s'
      (PDatumHash
       :--> (PUnsortedMap PDatumHash PDatum :--> PMaybe (PAsData a))))
-> Term
     s
     (PDatumHash
      :--> (PUnsortedMap PDatumHash PDatum :--> PMaybe (PAsData a)))
forall a b. (a -> b) -> a -> b
$ (Term s' PDatumHash
 -> Term s' (PUnsortedMap PDatumHash PDatum)
 -> Term s' (PMaybe (PAsData a)))
-> Term
     s'
     (PDatumHash
      :--> (PUnsortedMap PDatumHash PDatum :--> PMaybe (PAsData a)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term s' (PUnsortedMap PDatumHash PDatum)
 -> Term s' (PMaybe (PAsData a)))
-> Term
     s'
     (c :--> (PUnsortedMap PDatumHash PDatum :--> PMaybe (PAsData a)))
plam ((Term s' PDatumHash
  -> Term s' (PUnsortedMap PDatumHash PDatum)
  -> Term s' (PMaybe (PAsData a)))
 -> Term
      s'
      (PDatumHash
       :--> (PUnsortedMap PDatumHash PDatum :--> PMaybe (PAsData a))))
-> (Term s' PDatumHash
    -> Term s' (PUnsortedMap PDatumHash PDatum)
    -> Term s' (PMaybe (PAsData a)))
-> Term
     s'
     (PDatumHash
      :--> (PUnsortedMap PDatumHash PDatum :--> PMaybe (PAsData a)))
forall a b. (a -> b) -> a -> b
$ \Term s' PDatumHash
dh Term s' (PUnsortedMap PDatumHash PDatum)
datums ->
  Term s' (PMaybe PDatum)
-> (PMaybe PDatum s' -> Term s' (PMaybe (PAsData a)))
-> Term s' (PMaybe (PAsData a))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term
  s'
  (PDatumHash :--> (PSortedMap PDatumHash PDatum :--> PMaybe PDatum))
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
(PIsData k, PIsData v) =>
Term s (k :--> (PSortedMap k v :--> PMaybe v))
AssocMap.plookup Term
  s'
  (PDatumHash :--> (PSortedMap PDatumHash PDatum :--> PMaybe PDatum))
-> Term s' PDatumHash
-> Term s' (PSortedMap PDatumHash PDatum :--> PMaybe PDatum)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' PDatumHash
dh Term s' (PSortedMap PDatumHash PDatum :--> PMaybe PDatum)
-> Term s' (PSortedMap PDatumHash PDatum)
-> Term s' (PMaybe PDatum)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PUnsortedMap PDatumHash PDatum)
-> Term s' (PSortedMap PDatumHash PDatum)
forall (k :: S -> Type) (v :: S -> Type) (s :: S).
Term s (PUnsortedMap k v) -> Term s (PSortedMap k v)
AssocMap.punsafeCoerceToSortedMap Term s' (PUnsortedMap PDatumHash PDatum)
datums) ((PMaybe PDatum s' -> Term s' (PMaybe (PAsData a)))
 -> Term s' (PMaybe (PAsData a)))
-> (PMaybe PDatum s' -> Term s' (PMaybe (PAsData a)))
-> Term s' (PMaybe (PAsData a))
forall a b. (a -> b) -> a -> b
$ \case
    PMaybe PDatum s'
PNothing -> PMaybe (PAsData a) s' -> Term s' (PMaybe (PAsData a))
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PMaybe (PAsData a) s'
forall (a :: S -> Type) (s :: S). PMaybe a s
PNothing
    PJust Term s' PDatum
datum -> PMaybe (PAsData a) s' -> Term s' (PMaybe (PAsData a))
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PMaybe (PAsData a) s' -> Term s' (PMaybe (PAsData a)))
-> (Term s' (PAsData a) -> PMaybe (PAsData a) s')
-> Term s' (PAsData a)
-> Term s' (PMaybe (PAsData a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term s' (PAsData a) -> PMaybe (PAsData a) s'
forall (a :: S -> Type) (s :: S). Term s a -> PMaybe a s
PJust (Term s' (PAsData a) -> Term s' (PMaybe (PAsData a)))
-> Term s' (PAsData a) -> Term s' (PMaybe (PAsData a))
forall a b. (a -> b) -> a -> b
$ Term s' (PInner PDatum)
-> ((Term s' (PAsData a),
     Reduce (PTryFromExcess (PInner PDatum) (PAsData a) s'))
    -> Term s' (PAsData a))
-> Term s' (PAsData a)
forall (b :: S -> Type) (a :: S -> Type) (s :: S) (r :: S -> Type).
PTryFrom a b =>
Term s a
-> ((Term s b, Reduce (PTryFromExcess a b s)) -> Term s r)
-> Term s r
ptryFrom (Term s' PDatum -> Term s' (PInner PDatum)
forall (a :: S -> Type) (s :: S). Term s a -> Term s (PInner a)
pto Term s' PDatum
datum) (Term s' (PAsData a),
 Reduce (PTryFromExcess (PInner PDatum) (PAsData a) s'))
-> Term s' (PAsData a)
(Term s' (PAsData a),
 GReduce
   (PTryFromExcess (PInner PDatum) (PAsData a) s')
   (Rep (PTryFromExcess (PInner PDatum) (PAsData a) s')))
-> Term s' (PAsData a)
forall a b. (a, b) -> a
fst

{- | Given a UTXO reference and a transaction ('PTxInfo'), resolve it to one of
the transaction's inputs ('PTxInInfo'). If no matching input exists, the result
is 'PNothing'.

= NOTE

This only searches the true transaction inputs and not the referenced
transaction inputs.

@since 3.6.0
-}
pfindTxInByTxOutRef ::
  forall (s :: S).
  Term
    s
    ( PTxOutRef
        :--> PTxInfo
        :--> PMaybe PTxInInfo
    )
pfindTxInByTxOutRef :: forall (s :: S).
Term s (PTxOutRef :--> (PTxInfo :--> PMaybe PTxInInfo))
pfindTxInByTxOutRef = (forall (s :: S).
 Term s (PTxOutRef :--> (PTxInfo :--> PMaybe PTxInInfo)))
-> Term s (PTxOutRef :--> (PTxInfo :--> PMaybe PTxInInfo))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s :: S).
  Term s (PTxOutRef :--> (PTxInfo :--> PMaybe PTxInInfo)))
 -> Term s (PTxOutRef :--> (PTxInfo :--> PMaybe PTxInInfo)))
-> (forall (s :: S).
    Term s (PTxOutRef :--> (PTxInfo :--> PMaybe PTxInInfo)))
-> Term s (PTxOutRef :--> (PTxInfo :--> PMaybe PTxInInfo))
forall a b. (a -> b) -> a -> b
$
  (Term s' PTxOutRef
 -> Term s' PTxInfo -> Term s' (PMaybe PTxInInfo))
-> Term s' (PTxOutRef :--> (PTxInfo :--> PMaybe PTxInInfo))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' PTxInfo -> Term s' (PMaybe PTxInInfo))
-> Term s' (c :--> (PTxInfo :--> PMaybe PTxInInfo))
plam ((Term s' PTxOutRef
  -> Term s' PTxInfo -> Term s' (PMaybe PTxInInfo))
 -> Term s' (PTxOutRef :--> (PTxInfo :--> PMaybe PTxInInfo)))
-> (Term s' PTxOutRef
    -> Term s' PTxInfo -> Term s' (PMaybe PTxInInfo))
-> Term s' (PTxOutRef :--> (PTxInfo :--> PMaybe PTxInInfo))
forall a b. (a -> b) -> a -> b
$ \Term s' PTxOutRef
outRef Term s' PTxInfo
txInfo ->
    Term s' PTxInfo
-> (PTxInfo s' -> Term s' (PMaybe PTxInInfo))
-> Term s' (PMaybe PTxInInfo)
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' PTxInfo
txInfo ((PTxInfo s' -> Term s' (PMaybe PTxInInfo))
 -> Term s' (PMaybe PTxInInfo))
-> (PTxInfo s' -> Term s' (PMaybe PTxInInfo))
-> Term s' (PMaybe PTxInInfo)
forall a b. (a -> b) -> a -> b
$ \PTxInfo s'
tx ->
      Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
-> (Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
    -> Term s' (PMaybe PTxInInfo))
-> Term s' (PMaybe PTxInInfo)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (PTxInfo s' -> Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
forall (s :: S).
PTxInfo s -> Term s (PAsData (PBuiltinList (PAsData PTxInInfo)))
ptxInfo'inputs PTxInfo s'
tx) ((Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
  -> Term s' (PMaybe PTxInInfo))
 -> Term s' (PMaybe PTxInInfo))
-> (Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
    -> Term s' (PMaybe PTxInInfo))
-> Term s' (PMaybe PTxInInfo)
forall a b. (a -> b) -> a -> b
$ \Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
inputs ->
        Term
  s'
  ((PAsData PTxInInfo :--> PTxInInfo)
   :--> (PMaybe (PAsData PTxInInfo) :--> PMaybe PTxInInfo))
forall (a :: S -> Type) (b :: S -> Type) (s :: S).
Term s ((a :--> b) :--> (PMaybe a :--> PMaybe b))
pmapMaybe Term
  s'
  ((PAsData PTxInInfo :--> PTxInInfo)
   :--> (PMaybe (PAsData PTxInInfo) :--> PMaybe PTxInInfo))
-> Term s' (PAsData PTxInInfo :--> PTxInInfo)
-> Term s' (PMaybe (PAsData PTxInInfo) :--> PMaybe PTxInInfo)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term s' (PAsData PTxInInfo) -> Term s' PTxInInfo)
-> Term s' (PAsData PTxInInfo :--> PTxInInfo)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' PTxInInfo) -> Term s' (c :--> PTxInInfo)
plam Term s' (PAsData PTxInInfo) -> Term s' PTxInInfo
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PMaybe (PAsData PTxInInfo) :--> PMaybe PTxInInfo)
-> Term s' (PMaybe (PAsData PTxInInfo))
-> Term s' (PMaybe PTxInInfo)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
#$ Term
  s'
  ((PAsData PTxInInfo :--> PBool)
   :--> (PBuiltinList (PAsData PTxInInfo)
         :--> PMaybe (PAsData PTxInInfo)))
forall (l :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S).
PIsListLike l a =>
Term s ((a :--> PBool) :--> (l a :--> PMaybe a))
pfind Term
  s'
  ((PAsData PTxInInfo :--> PBool)
   :--> (PBuiltinList (PAsData PTxInInfo)
         :--> PMaybe (PAsData PTxInInfo)))
-> Term s' (PAsData PTxInInfo :--> PBool)
-> Term
     s'
     (PBuiltinList (PAsData PTxInInfo) :--> PMaybe (PAsData PTxInInfo))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# (Term s' (PTxOutRef :--> (PAsData PTxInInfo :--> PBool))
forall (s' :: S).
Term s' (PTxOutRef :--> (PAsData PTxInInfo :--> PBool))
matches Term s' (PTxOutRef :--> (PAsData PTxInInfo :--> PBool))
-> Term s' PTxOutRef -> Term s' (PAsData PTxInInfo :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' PTxOutRef
outRef) Term
  s'
  (PBuiltinList (PAsData PTxInInfo) :--> PMaybe (PAsData PTxInInfo))
-> Term s' (PBuiltinList (PAsData PTxInInfo))
-> Term s' (PMaybe (PAsData PTxInInfo))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
-> Term s' (PBuiltinList (PAsData PTxInInfo))
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
inputs
  where
    matches ::
      forall (s' :: S).
      Term s' (PTxOutRef :--> PAsData PTxInInfo :--> PBool)
    matches :: forall (s' :: S).
Term s' (PTxOutRef :--> (PAsData PTxInInfo :--> PBool))
matches = (forall (s' :: S).
 Term s' (PTxOutRef :--> (PAsData PTxInInfo :--> PBool)))
-> Term s' (PTxOutRef :--> (PAsData PTxInInfo :--> PBool))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s' :: S).
  Term s' (PTxOutRef :--> (PAsData PTxInInfo :--> PBool)))
 -> Term s' (PTxOutRef :--> (PAsData PTxInInfo :--> PBool)))
-> (forall (s' :: S).
    Term s' (PTxOutRef :--> (PAsData PTxInInfo :--> PBool)))
-> Term s' (PTxOutRef :--> (PAsData PTxInInfo :--> PBool))
forall a b. (a -> b) -> a -> b
$
      (Term s' PTxOutRef -> Term s' (PAsData PTxInInfo) -> Term s' PBool)
-> Term s' (PTxOutRef :--> (PAsData PTxInInfo :--> PBool))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PAsData PTxInInfo) -> Term s' PBool)
-> Term s' (c :--> (PAsData PTxInInfo :--> PBool))
plam ((Term s' PTxOutRef
  -> Term s' (PAsData PTxInInfo) -> Term s' PBool)
 -> Term s' (PTxOutRef :--> (PAsData PTxInInfo :--> PBool)))
-> (Term s' PTxOutRef
    -> Term s' (PAsData PTxInInfo) -> Term s' PBool)
-> Term s' (PTxOutRef :--> (PAsData PTxInInfo :--> PBool))
forall a b. (a -> b) -> a -> b
$ \Term s' PTxOutRef
outRef Term s' (PAsData PTxInInfo)
txininfo ->
        Term s' PTxInInfo
-> (PTxInInfo s' -> Term s' PBool) -> Term s' PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term s' (PAsData PTxInInfo) -> Term s' PTxInInfo
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData PTxInInfo)
txininfo) ((PTxInInfo s' -> Term s' PBool) -> Term s' PBool)
-> (PTxInInfo s' -> Term s' PBool) -> Term s' PBool
forall a b. (a -> b) -> a -> b
$ \PTxInInfo s'
ininfo ->
          Term s' PTxOutRef
outRef Term s' PTxOutRef -> Term s' PTxOutRef -> Term s' PBool
forall (s :: S).
Term s PTxOutRef -> Term s PTxOutRef -> Term s PBool
forall (t :: S -> Type) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== PTxInInfo s' -> Term s' PTxOutRef
forall (s :: S). PTxInInfo s -> Term s PTxOutRef
ptxInInfo'outRef PTxInInfo s'
ininfo

{- | Find the indices of all the outputs that pay to the same script address we
are currently spending from, if any.

@since 3.6.0
-}
pfindContinuingOutputs :: forall (s :: S). Term s (PScriptContext :--> PBuiltinList PInteger)
pfindContinuingOutputs :: forall (s :: S). Term s (PScriptContext :--> PBuiltinList PInteger)
pfindContinuingOutputs =
  (forall (s :: S).
 Term s (PScriptContext :--> PBuiltinList PInteger))
-> Term s (PScriptContext :--> PBuiltinList PInteger)
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s :: S).
  Term s (PScriptContext :--> PBuiltinList PInteger))
 -> Term s (PScriptContext :--> PBuiltinList PInteger))
-> (forall (s :: S).
    Term s (PScriptContext :--> PBuiltinList PInteger))
-> Term s (PScriptContext :--> PBuiltinList PInteger)
forall a b. (a -> b) -> a -> b
$
    (Term s' PScriptContext -> Term s' (PBuiltinList PInteger))
-> Term s' (PScriptContext :--> PBuiltinList PInteger)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PBuiltinList PInteger))
-> Term s' (c :--> PBuiltinList PInteger)
plam ((Term s' PScriptContext -> Term s' (PBuiltinList PInteger))
 -> Term s' (PScriptContext :--> PBuiltinList PInteger))
-> (Term s' PScriptContext -> Term s' (PBuiltinList PInteger))
-> Term s' (PScriptContext :--> PBuiltinList PInteger)
forall a b. (a -> b) -> a -> b
$ \Term s' PScriptContext
scriptCtx ->
      Term s' (PMaybe PTxInInfo)
-> (PMaybe PTxInInfo s' -> Term s' (PBuiltinList PInteger))
-> Term s' (PBuiltinList PInteger)
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term s' (PScriptContext :--> PMaybe PTxInInfo)
forall (s :: S). Term s (PScriptContext :--> PMaybe PTxInInfo)
pfindOwnInput Term s' (PScriptContext :--> PMaybe PTxInInfo)
-> Term s' PScriptContext -> Term s' (PMaybe PTxInInfo)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' PScriptContext
scriptCtx) ((PMaybe PTxInInfo s' -> Term s' (PBuiltinList PInteger))
 -> Term s' (PBuiltinList PInteger))
-> (PMaybe PTxInInfo s' -> Term s' (PBuiltinList PInteger))
-> Term s' (PBuiltinList PInteger)
forall a b. (a -> b) -> a -> b
$ \case
        PMaybe PTxInInfo s'
PNothing ->
          Term s' PString -> Term s' (PBuiltinList PInteger)
forall (a :: S -> Type) (s :: S). Term s PString -> Term s a
ptraceInfoError Term s' PString
"can't find any continuing outputs: invalid script purpose"
        PJust Term s' PTxInInfo
ownInput ->
          TermCont s' (Term s' (PBuiltinList PInteger))
-> Term s' (PBuiltinList PInteger)
forall (a :: S -> Type) (s :: S). TermCont s (Term s a) -> Term s a
unTermCont (TermCont s' (Term s' (PBuiltinList PInteger))
 -> Term s' (PBuiltinList PInteger))
-> TermCont s' (Term s' (PBuiltinList PInteger))
-> Term s' (PBuiltinList PInteger)
forall a b. (a -> b) -> a -> b
$ do
            PScriptContext s'
ctx <- Term s' PScriptContext -> TermCont s' (PScriptContext s')
forall {r :: S -> Type} (a :: S -> Type) (s :: S).
PlutusType a =>
Term s a -> TermCont s (a s)
pmatchC Term s' PScriptContext
scriptCtx
            PTxInfo s'
txInfo <- Term s' PTxInfo -> TermCont s' (PTxInfo s')
forall {r :: S -> Type} (a :: S -> Type) (s :: S).
PlutusType a =>
Term s a -> TermCont s (a s)
pmatchC (Term s' PTxInfo -> TermCont s' (PTxInfo s'))
-> Term s' PTxInfo -> TermCont s' (PTxInfo s')
forall a b. (a -> b) -> a -> b
$ PScriptContext s' -> Term s' PTxInfo
forall (s :: S). PScriptContext s -> Term s PTxInfo
pscriptContext'txInfo PScriptContext s'
ctx
            Term s' (PBuiltinList (PAsData PTxOut))
outputs <- Term s' (PBuiltinList (PAsData PTxOut))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut)))
forall {r :: S -> Type} (s :: S) (a :: S -> Type).
Term s a -> TermCont s (Term s a)
pletC (Term s' (PBuiltinList (PAsData PTxOut))
 -> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut))))
-> Term s' (PBuiltinList (PAsData PTxOut))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut)))
forall a b. (a -> b) -> a -> b
$ Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
-> Term s' (PBuiltinList (PAsData PTxOut))
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
 -> Term s' (PBuiltinList (PAsData PTxOut)))
-> Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
-> Term s' (PBuiltinList (PAsData PTxOut))
forall a b. (a -> b) -> a -> b
$ PTxInfo s' -> Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
forall (s :: S).
PTxInfo s -> Term s (PAsData (PBuiltinList (PAsData PTxOut)))
ptxInfo'outputs PTxInfo s'
txInfo
            PTxInInfo s'
txInInfo <- Term s' PTxInInfo -> TermCont s' (PTxInInfo s')
forall {r :: S -> Type} (a :: S -> Type) (s :: S).
PlutusType a =>
Term s a -> TermCont s (a s)
pmatchC Term s' PTxInInfo
ownInput
            PTxOut s'
resolved <- Term s' PTxOut -> TermCont s' (PTxOut s')
forall {r :: S -> Type} (a :: S -> Type) (s :: S).
PlutusType a =>
Term s a -> TermCont s (a s)
pmatchC (Term s' PTxOut -> TermCont s' (PTxOut s'))
-> Term s' PTxOut -> TermCont s' (PTxOut s')
forall a b. (a -> b) -> a -> b
$ PTxInInfo s' -> Term s' PTxOut
forall (s :: S). PTxInInfo s -> Term s PTxOut
ptxInInfo'resolved PTxInInfo s'
txInInfo
            Term s' PAddress
addr <- Term s' PAddress -> TermCont s' (Term s' PAddress)
forall {r :: S -> Type} (s :: S) (a :: S -> Type).
Term s a -> TermCont s (Term s a)
pletC (Term s' PAddress -> TermCont s' (Term s' PAddress))
-> Term s' PAddress -> TermCont s' (Term s' PAddress)
forall a b. (a -> b) -> a -> b
$ PTxOut s' -> Term s' PAddress
forall (s :: S). PTxOut s -> Term s PAddress
ptxOut'address PTxOut s'
resolved
            PPair Term s' (PBuiltinList PInteger)
indices Term s' PInteger
_ <-
              Term s' (PPair (PBuiltinList PInteger) PInteger)
-> TermCont s' (PPair (PBuiltinList PInteger) PInteger s')
forall {r :: S -> Type} (a :: S -> Type) (s :: S).
PlutusType a =>
Term s a -> TermCont s (a s)
pmatchC (Term s' (PPair (PBuiltinList PInteger) PInteger)
 -> TermCont s' (PPair (PBuiltinList PInteger) PInteger s'))
-> Term s' (PPair (PBuiltinList PInteger) PInteger)
-> TermCont s' (PPair (PBuiltinList PInteger) PInteger s')
forall a b. (a -> b) -> a -> b
$
                Term
  s'
  ((PAsData PTxOut
    :--> (PPair (PBuiltinList PInteger) PInteger
          :--> PPair (PBuiltinList PInteger) PInteger))
   :--> (PPair (PBuiltinList PInteger) PInteger
         :--> (PBuiltinList (PAsData PTxOut)
               :--> PPair (PBuiltinList PInteger) PInteger)))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (b :: S -> Type).
PIsListLike list a =>
Term s ((a :--> (b :--> b)) :--> (b :--> (list a :--> b)))
pfoldr
                  # plam
                    ( \out acc ->
                        pmatch acc $ \(PPair indices currentIdx) ->
                          pmatch (pfromData out) $ \txOut ->
                            pif
                              (ptxOut'address txOut #== addr)
                              (pcon $ PPair (pcons # currentIdx # indices) (currentIdx #- 1))
                              (pcon $ PPair indices (currentIdx #- 1))
                    )
                  # pcon (PPair pnil $ (plength # outputs) #- 1)
                  # outputs
            Term s' (PBuiltinList PInteger)
-> TermCont s' (Term s' (PBuiltinList PInteger))
forall a. a -> TermCont s' a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure Term s' (PBuiltinList PInteger)
indices

{- | Get all the outputs that pay to the same script address we are currently
spending from, if any.

@since 3.6.0
-}
pgetContinuingOutputs :: forall (s :: S). Term s (PScriptContext :--> PBuiltinList (PAsData PTxOut))
pgetContinuingOutputs :: forall (s :: S).
Term s (PScriptContext :--> PBuiltinList (PAsData PTxOut))
pgetContinuingOutputs =
  (forall (s :: S).
 Term s (PScriptContext :--> PBuiltinList (PAsData PTxOut)))
-> Term s (PScriptContext :--> PBuiltinList (PAsData PTxOut))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s :: S).
  Term s (PScriptContext :--> PBuiltinList (PAsData PTxOut)))
 -> Term s (PScriptContext :--> PBuiltinList (PAsData PTxOut)))
-> (forall (s :: S).
    Term s (PScriptContext :--> PBuiltinList (PAsData PTxOut)))
-> Term s (PScriptContext :--> PBuiltinList (PAsData PTxOut))
forall a b. (a -> b) -> a -> b
$
    (Term s' PScriptContext -> Term s' (PBuiltinList (PAsData PTxOut)))
-> Term s' (PScriptContext :--> PBuiltinList (PAsData PTxOut))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PBuiltinList (PAsData PTxOut)))
-> Term s' (c :--> PBuiltinList (PAsData PTxOut))
plam ((Term s' PScriptContext
  -> Term s' (PBuiltinList (PAsData PTxOut)))
 -> Term s' (PScriptContext :--> PBuiltinList (PAsData PTxOut)))
-> (Term s' PScriptContext
    -> Term s' (PBuiltinList (PAsData PTxOut)))
-> Term s' (PScriptContext :--> PBuiltinList (PAsData PTxOut))
forall a b. (a -> b) -> a -> b
$ \Term s' PScriptContext
scriptCtx ->
      Term s' (PMaybe PTxInInfo)
-> (PMaybe PTxInInfo s' -> Term s' (PBuiltinList (PAsData PTxOut)))
-> Term s' (PBuiltinList (PAsData PTxOut))
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term s' (PScriptContext :--> PMaybe PTxInInfo)
forall (s :: S). Term s (PScriptContext :--> PMaybe PTxInInfo)
pfindOwnInput Term s' (PScriptContext :--> PMaybe PTxInInfo)
-> Term s' PScriptContext -> Term s' (PMaybe PTxInInfo)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' PScriptContext
scriptCtx) ((PMaybe PTxInInfo s' -> Term s' (PBuiltinList (PAsData PTxOut)))
 -> Term s' (PBuiltinList (PAsData PTxOut)))
-> (PMaybe PTxInInfo s' -> Term s' (PBuiltinList (PAsData PTxOut)))
-> Term s' (PBuiltinList (PAsData PTxOut))
forall a b. (a -> b) -> a -> b
$ \case
        PMaybe PTxInInfo s'
PNothing ->
          Term s' PString -> Term s' (PBuiltinList (PAsData PTxOut))
forall (a :: S -> Type) (s :: S). Term s PString -> Term s a
ptraceInfoError Term s' PString
"can't get any continuing outputs: invalid script purpose"
        PJust Term s' PTxInInfo
ownInput ->
          TermCont s' (Term s' (PBuiltinList (PAsData PTxOut)))
-> Term s' (PBuiltinList (PAsData PTxOut))
forall (a :: S -> Type) (s :: S). TermCont s (Term s a) -> Term s a
unTermCont (TermCont s' (Term s' (PBuiltinList (PAsData PTxOut)))
 -> Term s' (PBuiltinList (PAsData PTxOut)))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut)))
-> Term s' (PBuiltinList (PAsData PTxOut))
forall a b. (a -> b) -> a -> b
$ do
            PScriptContext s'
ctx <- Term s' PScriptContext -> TermCont s' (PScriptContext s')
forall {r :: S -> Type} (a :: S -> Type) (s :: S).
PlutusType a =>
Term s a -> TermCont s (a s)
pmatchC Term s' PScriptContext
scriptCtx
            PTxInfo s'
txInfo <- Term s' PTxInfo -> TermCont s' (PTxInfo s')
forall {r :: S -> Type} (a :: S -> Type) (s :: S).
PlutusType a =>
Term s a -> TermCont s (a s)
pmatchC (Term s' PTxInfo -> TermCont s' (PTxInfo s'))
-> Term s' PTxInfo -> TermCont s' (PTxInfo s')
forall a b. (a -> b) -> a -> b
$ PScriptContext s' -> Term s' PTxInfo
forall (s :: S). PScriptContext s -> Term s PTxInfo
pscriptContext'txInfo PScriptContext s'
ctx
            Term s' (PBuiltinList (PAsData PTxOut))
outputs <- Term s' (PBuiltinList (PAsData PTxOut))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut)))
forall {r :: S -> Type} (s :: S) (a :: S -> Type).
Term s a -> TermCont s (Term s a)
pletC (Term s' (PBuiltinList (PAsData PTxOut))
 -> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut))))
-> Term s' (PBuiltinList (PAsData PTxOut))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut)))
forall a b. (a -> b) -> a -> b
$ Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
-> Term s' (PBuiltinList (PAsData PTxOut))
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
 -> Term s' (PBuiltinList (PAsData PTxOut)))
-> Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
-> Term s' (PBuiltinList (PAsData PTxOut))
forall a b. (a -> b) -> a -> b
$ PTxInfo s' -> Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
forall (s :: S).
PTxInfo s -> Term s (PAsData (PBuiltinList (PAsData PTxOut)))
ptxInfo'outputs PTxInfo s'
txInfo
            PTxInInfo s'
txInInfo <- Term s' PTxInInfo -> TermCont s' (PTxInInfo s')
forall {r :: S -> Type} (a :: S -> Type) (s :: S).
PlutusType a =>
Term s a -> TermCont s (a s)
pmatchC Term s' PTxInInfo
ownInput
            PTxOut s'
resolved <- Term s' PTxOut -> TermCont s' (PTxOut s')
forall {r :: S -> Type} (a :: S -> Type) (s :: S).
PlutusType a =>
Term s a -> TermCont s (a s)
pmatchC (Term s' PTxOut -> TermCont s' (PTxOut s'))
-> Term s' PTxOut -> TermCont s' (PTxOut s')
forall a b. (a -> b) -> a -> b
$ PTxInInfo s' -> Term s' PTxOut
forall (s :: S). PTxInInfo s -> Term s PTxOut
ptxInInfo'resolved PTxInInfo s'
txInInfo
            Term s' PAddress
addr <- Term s' PAddress -> TermCont s' (Term s' PAddress)
forall {r :: S -> Type} (s :: S) (a :: S -> Type).
Term s a -> TermCont s (Term s a)
pletC (Term s' PAddress -> TermCont s' (Term s' PAddress))
-> Term s' PAddress -> TermCont s' (Term s' PAddress)
forall a b. (a -> b) -> a -> b
$ PTxOut s' -> Term s' PAddress
forall (s :: S). PTxOut s -> Term s PAddress
ptxOut'address PTxOut s'
resolved
            Term s' (PBuiltinList (PAsData PTxOut))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut)))
forall a. a -> TermCont s' a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (Term s' (PBuiltinList (PAsData PTxOut))
 -> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut))))
-> Term s' (PBuiltinList (PAsData PTxOut))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut)))
forall a b. (a -> b) -> a -> b
$
              Term
  s'
  ((PAsData PTxOut :--> PBool)
   :--> (PBuiltinList (PAsData PTxOut)
         :--> PBuiltinList (PAsData PTxOut)))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
PIsListLike list a =>
Term s ((a :--> PBool) :--> (list a :--> list a))
pfilter
                # plam
                  ( \out ->
                      pmatch (pfromData out) $ \txOut ->
                        ptxOut'address txOut #== addr
                  )
                # outputs

{- | Check if a transaction was signed by the given public key.

@since 3.6.0
-}
ptxSignedBy :: forall (s :: S). Term s (PTxInfo :--> PPubKeyHash :--> PBool)
ptxSignedBy :: forall (s :: S). Term s (PTxInfo :--> (PPubKeyHash :--> PBool))
ptxSignedBy =
  (Term s PTxInfo -> Term s PPubKeyHash -> Term s PBool)
-> Term s (PTxInfo :--> (PPubKeyHash :--> PBool))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s c -> Term s PPubKeyHash -> Term s PBool)
-> Term s (c :--> (PPubKeyHash :--> PBool))
plam ((Term s PTxInfo -> Term s PPubKeyHash -> Term s PBool)
 -> Term s (PTxInfo :--> (PPubKeyHash :--> PBool)))
-> (Term s PTxInfo -> Term s PPubKeyHash -> Term s PBool)
-> Term s (PTxInfo :--> (PPubKeyHash :--> PBool))
forall a b. (a -> b) -> a -> b
$ \Term s PTxInfo
txInfo Term s PPubKeyHash
pkh ->
    Term s PTxInfo -> (PTxInfo s -> Term s PBool) -> Term s PBool
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s PTxInfo
txInfo ((PTxInfo s -> Term s PBool) -> Term s PBool)
-> (PTxInfo s -> Term s PBool) -> Term s PBool
forall a b. (a -> b) -> a -> b
$ \PTxInfo s
tx ->
      Term s (PAsData PPubKeyHash)
-> (Term s (PAsData PPubKeyHash) -> Term s PBool) -> Term s PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term s PPubKeyHash -> Term s (PAsData PPubKeyHash)
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s PPubKeyHash
pkh) ((Term s (PAsData PPubKeyHash) -> Term s PBool) -> Term s PBool)
-> (Term s (PAsData PPubKeyHash) -> Term s PBool) -> Term s PBool
forall a b. (a -> b) -> a -> b
$ \Term s (PAsData PPubKeyHash)
pkhData ->
        Term
  s
  (PAsData PPubKeyHash
   :--> (PBuiltinList (PAsData PPubKeyHash) :--> PBool))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
(PIsListLike list a, PEq a) =>
Term s (a :--> (list a :--> PBool))
pelem Term
  s
  (PAsData PPubKeyHash
   :--> (PBuiltinList (PAsData PPubKeyHash) :--> PBool))
-> Term s (PAsData PPubKeyHash)
-> Term s (PBuiltinList (PAsData PPubKeyHash) :--> PBool)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PAsData PPubKeyHash)
pkhData Term s (PBuiltinList (PAsData PPubKeyHash) :--> PBool)
-> Term s (PBuiltinList (PAsData PPubKeyHash)) -> Term s PBool
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PAsData (PBuiltinList (PAsData PPubKeyHash)))
-> Term s (PBuiltinList (PAsData PPubKeyHash))
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (PTxInfo s -> Term s (PAsData (PBuiltinList (PAsData PPubKeyHash)))
forall (s :: S).
PTxInfo s -> Term s (PAsData (PBuiltinList (PAsData PPubKeyHash)))
ptxInfo'signatories PTxInfo s
tx)

{- | Get the Values paid to a public key address by a pending transaction.

@since 3.6.0
-}
ppubKeyOutputsAt ::
  forall (s :: S).
  Term
    s
    ( PPubKeyHash
        :--> PTxInfo
        :--> PBuiltinList (PAsData PLedgerValue)
    )
ppubKeyOutputsAt :: forall (s :: S).
Term
  s
  (PPubKeyHash
   :--> (PTxInfo :--> PBuiltinList (PAsData PLedgerValue)))
ppubKeyOutputsAt =
  (forall (s :: S).
 Term
   s
   (PPubKeyHash
    :--> (PTxInfo :--> PBuiltinList (PAsData PLedgerValue))))
-> Term
     s
     (PPubKeyHash
      :--> (PTxInfo :--> PBuiltinList (PAsData PLedgerValue)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s :: S).
  Term
    s
    (PPubKeyHash
     :--> (PTxInfo :--> PBuiltinList (PAsData PLedgerValue))))
 -> Term
      s
      (PPubKeyHash
       :--> (PTxInfo :--> PBuiltinList (PAsData PLedgerValue))))
-> (forall (s :: S).
    Term
      s
      (PPubKeyHash
       :--> (PTxInfo :--> PBuiltinList (PAsData PLedgerValue))))
-> Term
     s
     (PPubKeyHash
      :--> (PTxInfo :--> PBuiltinList (PAsData PLedgerValue)))
forall a b. (a -> b) -> a -> b
$
    (Term s' PPubKeyHash
 -> Term s' PTxInfo
 -> Term s' (PBuiltinList (PAsData PLedgerValue)))
-> Term
     s'
     (PPubKeyHash
      :--> (PTxInfo :--> PBuiltinList (PAsData PLedgerValue)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c
 -> Term s' PTxInfo
 -> Term s' (PBuiltinList (PAsData PLedgerValue)))
-> Term
     s' (c :--> (PTxInfo :--> PBuiltinList (PAsData PLedgerValue)))
plam ((Term s' PPubKeyHash
  -> Term s' PTxInfo
  -> Term s' (PBuiltinList (PAsData PLedgerValue)))
 -> Term
      s'
      (PPubKeyHash
       :--> (PTxInfo :--> PBuiltinList (PAsData PLedgerValue))))
-> (Term s' PPubKeyHash
    -> Term s' PTxInfo
    -> Term s' (PBuiltinList (PAsData PLedgerValue)))
-> Term
     s'
     (PPubKeyHash
      :--> (PTxInfo :--> PBuiltinList (PAsData PLedgerValue)))
forall a b. (a -> b) -> a -> b
$ \Term s' PPubKeyHash
targetPkh Term s' PTxInfo
txInfo ->
      TermCont s' (Term s' (PBuiltinList (PAsData PLedgerValue)))
-> Term s' (PBuiltinList (PAsData PLedgerValue))
forall (a :: S -> Type) (s :: S). TermCont s (Term s a) -> Term s a
unTermCont (TermCont s' (Term s' (PBuiltinList (PAsData PLedgerValue)))
 -> Term s' (PBuiltinList (PAsData PLedgerValue)))
-> TermCont s' (Term s' (PBuiltinList (PAsData PLedgerValue)))
-> Term s' (PBuiltinList (PAsData PLedgerValue))
forall a b. (a -> b) -> a -> b
$ do
        PTxInfo s'
tx <- Term s' PTxInfo -> TermCont s' (PTxInfo s')
forall {r :: S -> Type} (a :: S -> Type) (s :: S).
PlutusType a =>
Term s a -> TermCont s (a s)
pmatchC Term s' PTxInfo
txInfo
        Term s' (PBuiltinList (PAsData PTxOut))
outputs <- Term s' (PBuiltinList (PAsData PTxOut))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut)))
forall {r :: S -> Type} (s :: S) (a :: S -> Type).
Term s a -> TermCont s (Term s a)
pletC (Term s' (PBuiltinList (PAsData PTxOut))
 -> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut))))
-> Term s' (PBuiltinList (PAsData PTxOut))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut)))
forall a b. (a -> b) -> a -> b
$ Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
-> Term s' (PBuiltinList (PAsData PTxOut))
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
 -> Term s' (PBuiltinList (PAsData PTxOut)))
-> Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
-> Term s' (PBuiltinList (PAsData PTxOut))
forall a b. (a -> b) -> a -> b
$ PTxInfo s' -> Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
forall (s :: S).
PTxInfo s -> Term s (PAsData (PBuiltinList (PAsData PTxOut)))
ptxInfo'outputs PTxInfo s'
tx
        Term s' (PBuiltinList (PAsData PLedgerValue))
-> TermCont s' (Term s' (PBuiltinList (PAsData PLedgerValue)))
forall a. a -> TermCont s' a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (Term s' (PBuiltinList (PAsData PLedgerValue))
 -> TermCont s' (Term s' (PBuiltinList (PAsData PLedgerValue))))
-> Term s' (PBuiltinList (PAsData PLedgerValue))
-> TermCont s' (Term s' (PBuiltinList (PAsData PLedgerValue)))
forall a b. (a -> b) -> a -> b
$
          Term
  s'
  ((PAsData PTxOut :--> PMaybe (PAsData PLedgerValue))
   :--> (PBuiltinList (PAsData PTxOut)
         :--> PBuiltinList (PAsData PLedgerValue)))
forall (b :: S -> Type) (a :: S -> Type)
       (list :: (S -> Type) -> S -> Type) (s :: S).
(PListLike list, PElemConstraint list a, PElemConstraint list b) =>
Term s ((a :--> PMaybe b) :--> (list a :--> list b))
pmapDropNothing
            # plam
              ( \out ->
                  unTermCont $ do
                    txOut <- pmatchC $ pfromData out
                    addr <- pmatchC $ ptxOut'address txOut
                    payCred <- pmatchC $ paddress'credential addr
                    pure $ case payCred of
                      PPubKeyCredential pkh ->
                        pif
                          (pfromData pkh #== targetPkh)
                          (pcon $ PJust $ ptxOut'value txOut)
                          (pcon PNothing)
                      _ ->
                        pcon PNothing
              )
            # outputs

{- | Get the total value paid to a public key address by a pending transaction.

@since 3.6.0
-}
pvaluePaidTo :: forall (s :: S). Term s (PTxInfo :--> PPubKeyHash :--> PLedgerValue)
pvaluePaidTo :: forall (s :: S).
Term s (PTxInfo :--> (PPubKeyHash :--> PLedgerValue))
pvaluePaidTo =
  (forall (s :: S).
 Term s (PTxInfo :--> (PPubKeyHash :--> PLedgerValue)))
-> Term s (PTxInfo :--> (PPubKeyHash :--> PLedgerValue))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s :: S).
  Term s (PTxInfo :--> (PPubKeyHash :--> PLedgerValue)))
 -> Term s (PTxInfo :--> (PPubKeyHash :--> PLedgerValue)))
-> (forall (s :: S).
    Term s (PTxInfo :--> (PPubKeyHash :--> PLedgerValue)))
-> Term s (PTxInfo :--> (PPubKeyHash :--> PLedgerValue))
forall a b. (a -> b) -> a -> b
$
    (Term s' PTxInfo -> Term s' PPubKeyHash -> Term s' PLedgerValue)
-> Term s' (PTxInfo :--> (PPubKeyHash :--> PLedgerValue))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' PPubKeyHash -> Term s' PLedgerValue)
-> Term s' (c :--> (PPubKeyHash :--> PLedgerValue))
plam ((Term s' PTxInfo -> Term s' PPubKeyHash -> Term s' PLedgerValue)
 -> Term s' (PTxInfo :--> (PPubKeyHash :--> PLedgerValue)))
-> (Term s' PTxInfo -> Term s' PPubKeyHash -> Term s' PLedgerValue)
-> Term s' (PTxInfo :--> (PPubKeyHash :--> PLedgerValue))
forall a b. (a -> b) -> a -> b
$ \Term s' PTxInfo
txInfo Term s' PPubKeyHash
pkh ->
      Term s' (PBuiltinList (PAsData PLedgerValue))
-> (Term s' (PBuiltinList (PAsData PLedgerValue))
    -> Term s' PLedgerValue)
-> Term s' PLedgerValue
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (Term
  s'
  (PPubKeyHash
   :--> (PTxInfo :--> PBuiltinList (PAsData PLedgerValue)))
forall (s :: S).
Term
  s
  (PPubKeyHash
   :--> (PTxInfo :--> PBuiltinList (PAsData PLedgerValue)))
ppubKeyOutputsAt Term
  s'
  (PPubKeyHash
   :--> (PTxInfo :--> PBuiltinList (PAsData PLedgerValue)))
-> Term s' PPubKeyHash
-> Term s' (PTxInfo :--> PBuiltinList (PAsData PLedgerValue))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' PPubKeyHash
pkh Term s' (PTxInfo :--> PBuiltinList (PAsData PLedgerValue))
-> Term s' PTxInfo -> Term s' (PBuiltinList (PAsData PLedgerValue))
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s (a :--> b) -> Term s a -> Term s b
# Term s' PTxInfo
txInfo) ((Term s' (PBuiltinList (PAsData PLedgerValue))
  -> Term s' PLedgerValue)
 -> Term s' PLedgerValue)
-> (Term s' (PBuiltinList (PAsData PLedgerValue))
    -> Term s' PLedgerValue)
-> Term s' PLedgerValue
forall a b. (a -> b) -> a -> b
$ \Term s' (PBuiltinList (PAsData PLedgerValue))
vals ->
        Term
  s'
  ((PLedgerValue :--> (PAsData PLedgerValue :--> PLedgerValue))
   :--> (PLedgerValue
         :--> (PBuiltinList (PAsData PLedgerValue) :--> PLedgerValue)))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (b :: S -> Type).
PIsListLike list a =>
Term s ((b :--> (a :--> b)) :--> (b :--> (list a :--> b)))
pfoldl
          # plam (\x y -> x <> pfromData y)
          # pemptyLedgerValue
          # vals

{- Get the total value of inputs spent by this transaction.

@since 3.6.0
-}
pvalueSpent :: forall (s :: S). Term s (PTxInfo :--> PLedgerValue)
pvalueSpent :: forall (s :: S). Term s (PTxInfo :--> PLedgerValue)
pvalueSpent =
  (forall (s :: S). Term s (PTxInfo :--> PLedgerValue))
-> Term s (PTxInfo :--> PLedgerValue)
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s :: S). Term s (PTxInfo :--> PLedgerValue))
 -> Term s (PTxInfo :--> PLedgerValue))
-> (forall (s :: S). Term s (PTxInfo :--> PLedgerValue))
-> Term s (PTxInfo :--> PLedgerValue)
forall a b. (a -> b) -> a -> b
$
    (Term s' PTxInfo -> Term s' PLedgerValue)
-> Term s' (PTxInfo :--> PLedgerValue)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' PLedgerValue)
-> Term s' (c :--> PLedgerValue)
plam ((Term s' PTxInfo -> Term s' PLedgerValue)
 -> Term s' (PTxInfo :--> PLedgerValue))
-> (Term s' PTxInfo -> Term s' PLedgerValue)
-> Term s' (PTxInfo :--> PLedgerValue)
forall a b. (a -> b) -> a -> b
$ \Term s' PTxInfo
txInfo ->
      TermCont s' (Term s' PLedgerValue) -> Term s' PLedgerValue
forall (a :: S -> Type) (s :: S). TermCont s (Term s a) -> Term s a
unTermCont (TermCont s' (Term s' PLedgerValue) -> Term s' PLedgerValue)
-> TermCont s' (Term s' PLedgerValue) -> Term s' PLedgerValue
forall a b. (a -> b) -> a -> b
$ do
        PTxInfo s'
tx <- Term s' PTxInfo -> TermCont s' (PTxInfo s')
forall {r :: S -> Type} (a :: S -> Type) (s :: S).
PlutusType a =>
Term s a -> TermCont s (a s)
pmatchC Term s' PTxInfo
txInfo
        Term s' (PBuiltinList (PAsData PTxInInfo))
inputs <- Term s' (PBuiltinList (PAsData PTxInInfo))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxInInfo)))
forall {r :: S -> Type} (s :: S) (a :: S -> Type).
Term s a -> TermCont s (Term s a)
pletC (Term s' (PBuiltinList (PAsData PTxInInfo))
 -> TermCont s' (Term s' (PBuiltinList (PAsData PTxInInfo))))
-> Term s' (PBuiltinList (PAsData PTxInInfo))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxInInfo)))
forall a b. (a -> b) -> a -> b
$ Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
-> Term s' (PBuiltinList (PAsData PTxInInfo))
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
 -> Term s' (PBuiltinList (PAsData PTxInInfo)))
-> Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
-> Term s' (PBuiltinList (PAsData PTxInInfo))
forall a b. (a -> b) -> a -> b
$ PTxInfo s' -> Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
forall (s :: S).
PTxInfo s -> Term s (PAsData (PBuiltinList (PAsData PTxInInfo)))
ptxInfo'inputs PTxInfo s'
tx
        Term s' PLedgerValue -> TermCont s' (Term s' PLedgerValue)
forall a. a -> TermCont s' a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (Term s' PLedgerValue -> TermCont s' (Term s' PLedgerValue))
-> Term s' PLedgerValue -> TermCont s' (Term s' PLedgerValue)
forall a b. (a -> b) -> a -> b
$
          Term
  s'
  ((PLedgerValue :--> (PAsData PTxInInfo :--> PLedgerValue))
   :--> (PLedgerValue
         :--> (PBuiltinList (PAsData PTxInInfo) :--> PLedgerValue)))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (b :: S -> Type).
PIsListLike list a =>
Term s ((b :--> (a :--> b)) :--> (b :--> (list a :--> b)))
pfoldl
            # plam
              ( \acc inp ->
                  unTermCont $ do
                    txInInfo <- pmatchC $ pfromData inp
                    resolved <- pmatchC $ ptxInInfo'resolved txInInfo
                    val <- pletC $ pfromData $ ptxOut'value resolved
                    pure $ acc <> val
              )
            # pemptyLedgerValue
            # inputs

{- Get the total value of outputs produced by this transaction.

@since 3.6.0
-}
pvalueProduced :: forall (s :: S). Term s (PTxInfo :--> PLedgerValue)
pvalueProduced :: forall (s :: S). Term s (PTxInfo :--> PLedgerValue)
pvalueProduced =
  (forall (s :: S). Term s (PTxInfo :--> PLedgerValue))
-> Term s (PTxInfo :--> PLedgerValue)
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s :: S). Term s (PTxInfo :--> PLedgerValue))
 -> Term s (PTxInfo :--> PLedgerValue))
-> (forall (s :: S). Term s (PTxInfo :--> PLedgerValue))
-> Term s (PTxInfo :--> PLedgerValue)
forall a b. (a -> b) -> a -> b
$
    (Term s' PTxInfo -> Term s' PLedgerValue)
-> Term s' (PTxInfo :--> PLedgerValue)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' PLedgerValue)
-> Term s' (c :--> PLedgerValue)
plam ((Term s' PTxInfo -> Term s' PLedgerValue)
 -> Term s' (PTxInfo :--> PLedgerValue))
-> (Term s' PTxInfo -> Term s' PLedgerValue)
-> Term s' (PTxInfo :--> PLedgerValue)
forall a b. (a -> b) -> a -> b
$ \Term s' PTxInfo
txInfo ->
      TermCont s' (Term s' PLedgerValue) -> Term s' PLedgerValue
forall (a :: S -> Type) (s :: S). TermCont s (Term s a) -> Term s a
unTermCont (TermCont s' (Term s' PLedgerValue) -> Term s' PLedgerValue)
-> TermCont s' (Term s' PLedgerValue) -> Term s' PLedgerValue
forall a b. (a -> b) -> a -> b
$ do
        PTxInfo s'
tx <- Term s' PTxInfo -> TermCont s' (PTxInfo s')
forall {r :: S -> Type} (a :: S -> Type) (s :: S).
PlutusType a =>
Term s a -> TermCont s (a s)
pmatchC Term s' PTxInfo
txInfo
        Term s' (PBuiltinList (PAsData PTxOut))
outputs <- Term s' (PBuiltinList (PAsData PTxOut))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut)))
forall {r :: S -> Type} (s :: S) (a :: S -> Type).
Term s a -> TermCont s (Term s a)
pletC (Term s' (PBuiltinList (PAsData PTxOut))
 -> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut))))
-> Term s' (PBuiltinList (PAsData PTxOut))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxOut)))
forall a b. (a -> b) -> a -> b
$ Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
-> Term s' (PBuiltinList (PAsData PTxOut))
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
 -> Term s' (PBuiltinList (PAsData PTxOut)))
-> Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
-> Term s' (PBuiltinList (PAsData PTxOut))
forall a b. (a -> b) -> a -> b
$ PTxInfo s' -> Term s' (PAsData (PBuiltinList (PAsData PTxOut)))
forall (s :: S).
PTxInfo s -> Term s (PAsData (PBuiltinList (PAsData PTxOut)))
ptxInfo'outputs PTxInfo s'
tx
        Term s' PLedgerValue -> TermCont s' (Term s' PLedgerValue)
forall a. a -> TermCont s' a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (Term s' PLedgerValue -> TermCont s' (Term s' PLedgerValue))
-> Term s' PLedgerValue -> TermCont s' (Term s' PLedgerValue)
forall a b. (a -> b) -> a -> b
$
          Term
  s'
  ((PLedgerValue :--> (PAsData PTxOut :--> PLedgerValue))
   :--> (PLedgerValue
         :--> (PBuiltinList (PAsData PTxOut) :--> PLedgerValue)))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S)
       (b :: S -> Type).
PIsListLike list a =>
Term s ((b :--> (a :--> b)) :--> (b :--> (list a :--> b)))
pfoldl
            # plam
              ( \acc out ->
                  unTermCont $ do
                    txOut <- pmatchC $ pfromData out
                    val <- pletC $ pfromData $ ptxOut'value txOut
                    pure $ acc <> val
              )
            # pemptyLedgerValue
            # outputs

{- | Get the 'PCurrencySymbol' of the current minting policy script.

@since 3.6.0
-}
pownCurrencySymbol :: forall (s :: S). Term s (PScriptContext :--> PMaybe Value.PCurrencySymbol)
pownCurrencySymbol :: forall (s :: S).
Term s (PScriptContext :--> PMaybe PCurrencySymbol)
pownCurrencySymbol =
  (forall (s :: S).
 Term s (PScriptContext :--> PMaybe PCurrencySymbol))
-> Term s (PScriptContext :--> PMaybe PCurrencySymbol)
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s :: S).
  Term s (PScriptContext :--> PMaybe PCurrencySymbol))
 -> Term s (PScriptContext :--> PMaybe PCurrencySymbol))
-> (forall (s :: S).
    Term s (PScriptContext :--> PMaybe PCurrencySymbol))
-> Term s (PScriptContext :--> PMaybe PCurrencySymbol)
forall a b. (a -> b) -> a -> b
$
    (Term s' PScriptContext -> Term s' (PMaybe PCurrencySymbol))
-> Term s' (PScriptContext :--> PMaybe PCurrencySymbol)
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' (PMaybe PCurrencySymbol))
-> Term s' (c :--> PMaybe PCurrencySymbol)
plam ((Term s' PScriptContext -> Term s' (PMaybe PCurrencySymbol))
 -> Term s' (PScriptContext :--> PMaybe PCurrencySymbol))
-> (Term s' PScriptContext -> Term s' (PMaybe PCurrencySymbol))
-> Term s' (PScriptContext :--> PMaybe PCurrencySymbol)
forall a b. (a -> b) -> a -> b
$ \Term s' PScriptContext
scriptCtx ->
      Term s' PScriptContext
-> (PScriptContext s' -> Term s' (PMaybe PCurrencySymbol))
-> Term s' (PMaybe PCurrencySymbol)
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' PScriptContext
scriptCtx ((PScriptContext s' -> Term s' (PMaybe PCurrencySymbol))
 -> Term s' (PMaybe PCurrencySymbol))
-> (PScriptContext s' -> Term s' (PMaybe PCurrencySymbol))
-> Term s' (PMaybe PCurrencySymbol)
forall a b. (a -> b) -> a -> b
$ \PScriptContext s'
ctx ->
        Term s' PScriptInfo
-> (Term s' PScriptInfo -> Term s' (PMaybe PCurrencySymbol))
-> Term s' (PMaybe PCurrencySymbol)
forall (s :: S) (a :: S -> Type) (b :: S -> Type).
Term s a -> (Term s a -> Term s b) -> Term s b
plet (PScriptContext s' -> Term s' PScriptInfo
forall (s :: S). PScriptContext s -> Term s PScriptInfo
pscriptContext'scriptInfo PScriptContext s'
ctx) ((Term s' PScriptInfo -> Term s' (PMaybe PCurrencySymbol))
 -> Term s' (PMaybe PCurrencySymbol))
-> (Term s' PScriptInfo -> Term s' (PMaybe PCurrencySymbol))
-> Term s' (PMaybe PCurrencySymbol)
forall a b. (a -> b) -> a -> b
$ \Term s' PScriptInfo
scriptInfo ->
          Term s' PScriptInfo
-> (PScriptInfo s' -> Term s' (PMaybe PCurrencySymbol))
-> Term s' (PMaybe PCurrencySymbol)
forall (a :: S -> Type) (s :: S) (b :: S -> Type).
PlutusType a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch Term s' PScriptInfo
scriptInfo ((PScriptInfo s' -> Term s' (PMaybe PCurrencySymbol))
 -> Term s' (PMaybe PCurrencySymbol))
-> (PScriptInfo s' -> Term s' (PMaybe PCurrencySymbol))
-> Term s' (PMaybe PCurrencySymbol)
forall a b. (a -> b) -> a -> b
$ \case
            PMintingScript Term s' (PAsData PCurrencySymbol)
cs ->
              PMaybe PCurrencySymbol s' -> Term s' (PMaybe PCurrencySymbol)
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon (PMaybe PCurrencySymbol s' -> Term s' (PMaybe PCurrencySymbol))
-> PMaybe PCurrencySymbol s' -> Term s' (PMaybe PCurrencySymbol)
forall a b. (a -> b) -> a -> b
$ Term s' PCurrencySymbol -> PMaybe PCurrencySymbol s'
forall (a :: S -> Type) (s :: S). Term s a -> PMaybe a s
PJust (Term s' PCurrencySymbol -> PMaybe PCurrencySymbol s')
-> Term s' PCurrencySymbol -> PMaybe PCurrencySymbol s'
forall a b. (a -> b) -> a -> b
$ Term s' (PAsData PCurrencySymbol) -> Term s' PCurrencySymbol
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s' (PAsData PCurrencySymbol)
cs
            PScriptInfo s'
_ ->
              PMaybe PCurrencySymbol s' -> Term s' (PMaybe PCurrencySymbol)
forall (a :: S -> Type) (s :: S). PlutusType a => a s -> Term s a
pcon PMaybe PCurrencySymbol s'
forall (a :: S -> Type) (s :: S). PMaybe a s
PNothing

{- | Check if the pending transaction spends a specific transaction output
(identified by the hash of a transaction and an index into that
transactions' outputs)

@since 3.6.0
-}
pspendsOutput :: forall (s :: S). Term s (PTxInfo :--> PTxId :--> PInteger :--> PBool)
pspendsOutput :: forall (s :: S).
Term s (PTxInfo :--> (PTxId :--> (PInteger :--> PBool)))
pspendsOutput =
  (forall (s :: S).
 Term s (PTxInfo :--> (PTxId :--> (PInteger :--> PBool))))
-> Term s (PTxInfo :--> (PTxId :--> (PInteger :--> PBool)))
forall (a :: S -> Type) (s :: S).
HasCallStack =>
(forall (s' :: S). Term s' a) -> Term s a
phoistAcyclic ((forall (s :: S).
  Term s (PTxInfo :--> (PTxId :--> (PInteger :--> PBool))))
 -> Term s (PTxInfo :--> (PTxId :--> (PInteger :--> PBool))))
-> (forall (s :: S).
    Term s (PTxInfo :--> (PTxId :--> (PInteger :--> PBool))))
-> Term s (PTxInfo :--> (PTxId :--> (PInteger :--> PBool)))
forall a b. (a -> b) -> a -> b
$
    (Term s' PTxInfo
 -> Term s' PTxId -> Term s' PInteger -> Term s' PBool)
-> Term s' (PTxInfo :--> (PTxId :--> (PInteger :--> PBool)))
forall a (b :: S -> Type) (s :: S) (c :: S -> Type).
(PLamN a b s, HasCallStack) =>
(Term s c -> a) -> Term s (c :--> b)
forall (c :: S -> Type).
HasCallStack =>
(Term s' c -> Term s' PTxId -> Term s' PInteger -> Term s' PBool)
-> Term s' (c :--> (PTxId :--> (PInteger :--> PBool)))
plam ((Term s' PTxInfo
  -> Term s' PTxId -> Term s' PInteger -> Term s' PBool)
 -> Term s' (PTxInfo :--> (PTxId :--> (PInteger :--> PBool))))
-> (Term s' PTxInfo
    -> Term s' PTxId -> Term s' PInteger -> Term s' PBool)
-> Term s' (PTxInfo :--> (PTxId :--> (PInteger :--> PBool)))
forall a b. (a -> b) -> a -> b
$ \Term s' PTxInfo
txInfo Term s' PTxId
txHash Term s' PInteger
outIdx ->
      TermCont s' (Term s' PBool) -> Term s' PBool
forall (a :: S -> Type) (s :: S). TermCont s (Term s a) -> Term s a
unTermCont (TermCont s' (Term s' PBool) -> Term s' PBool)
-> TermCont s' (Term s' PBool) -> Term s' PBool
forall a b. (a -> b) -> a -> b
$ do
        PTxInfo s'
tx <- Term s' PTxInfo -> TermCont s' (PTxInfo s')
forall {r :: S -> Type} (a :: S -> Type) (s :: S).
PlutusType a =>
Term s a -> TermCont s (a s)
pmatchC Term s' PTxInfo
txInfo
        Term s' (PBuiltinList (PAsData PTxInInfo))
inputs <- Term s' (PBuiltinList (PAsData PTxInInfo))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxInInfo)))
forall {r :: S -> Type} (s :: S) (a :: S -> Type).
Term s a -> TermCont s (Term s a)
pletC (Term s' (PBuiltinList (PAsData PTxInInfo))
 -> TermCont s' (Term s' (PBuiltinList (PAsData PTxInInfo))))
-> Term s' (PBuiltinList (PAsData PTxInInfo))
-> TermCont s' (Term s' (PBuiltinList (PAsData PTxInInfo)))
forall a b. (a -> b) -> a -> b
$ Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
-> Term s' (PBuiltinList (PAsData PTxInInfo))
forall (a :: S -> Type) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
 -> Term s' (PBuiltinList (PAsData PTxInInfo)))
-> Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
-> Term s' (PBuiltinList (PAsData PTxInInfo))
forall a b. (a -> b) -> a -> b
$ PTxInfo s' -> Term s' (PAsData (PBuiltinList (PAsData PTxInInfo)))
forall (s :: S).
PTxInfo s -> Term s (PAsData (PBuiltinList (PAsData PTxInInfo)))
ptxInfo'inputs PTxInfo s'
tx
        Term s' PBool -> TermCont s' (Term s' PBool)
forall a. a -> TermCont s' a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (Term s' PBool -> TermCont s' (Term s' PBool))
-> Term s' PBool -> TermCont s' (Term s' PBool)
forall a b. (a -> b) -> a -> b
$
          Term
  s'
  ((PAsData PTxInInfo :--> PBool)
   :--> (PBuiltinList (PAsData PTxInInfo) :--> PBool))
forall (list :: (S -> Type) -> S -> Type) (a :: S -> Type)
       (s :: S).
PIsListLike list a =>
Term s ((a :--> PBool) :--> (list a :--> PBool))
pany
            # plam
              ( \inp ->
                  unTermCont $ do
                    txInInfo <- pmatchC $ pfromData inp
                    outRef <- pmatchC $ ptxInInfo'outRef txInInfo
                    pure $
                      (pfromData (ptxOutRef'id outRef) #== txHash)
                        #&& (pfromData (ptxOutRef'idx outRef) #== outIdx)
              )
            # inputs