{-# LANGUAGE TemplateHaskell #-}

{- |
Module     : Agora.Stake
Maintainer : emi@haskell.fyi
Description: Vote-lockable stake UTXOs holding GT.

Vote-lockable stake UTXOs holding GT.
-}
module Agora.Stake (
  -- * Haskell-land
  StakeDatum (..),
  StakeRedeemer (..),
  Stake (..),
  ProposalLock (..),

  -- * Plutarch-land
  PStakeDatum (..),
  PStakeRedeemer (..),
  PProposalLock (..),
  PStakeUsage (..),

  -- * Utility functions
  stakeLocked,
  findStakeOwnedBy,
  pgetStakeUsage,
) where

import Agora.Plutarch.Orphans ()
import Agora.Proposal (PProposalId, PResultTag, ProposalId (..), ResultTag (..))
import Agora.SafeMoney (GTTag)
import Data.Tagged (Tagged (..))
import GHC.Generics qualified as GHC
import Generics.SOP (Generic, HasDatatypeInfo, I (I))
import Plutarch.Api.V1 (
  PDatum,
  PDatumHash,
  PMaybeData (PDJust, PDNothing),
  PPubKeyHash,
  PTuple,
  PTxInInfo (PTxInInfo),
  PTxOut (PTxOut),
 )
import Plutarch.Api.V1.AssetClass (PAssetClass, passetClassValueOf)
import Plutarch.Api.V1.ScriptContext (ptryFindDatum)
import Plutarch.DataRepr (
  DerivePConstantViaData (..),
  PDataFields,
  PIsDataReprInstances (PIsDataReprInstances),
 )
import Plutarch.Extra.List (pmapMaybe, pnotNull)
import Plutarch.Extra.TermCont (pletC, pletFieldsC, pmatchC)
import Plutarch.Internal (punsafeCoerce)
import Plutarch.Lift (PConstantDecl, PUnsafeLiftDecl (..))
import Plutarch.SafeMoney (PDiscrete)
import PlutusLedgerApi.V1 (PubKeyHash)
import PlutusLedgerApi.V1.Value (AssetClass)
import PlutusTx qualified
import Prelude hiding (Num (..))

--------------------------------------------------------------------------------

{- | Parameters for creating Stake scripts.

     @since 0.1.0
-}
data Stake = Stake
  { Stake -> Tagged @Type GTTag AssetClass
gtClassRef :: Tagged GTTag AssetClass
  -- ^ Used when inlining the AssetClass of a 'PDiscrete' in the script code.
  , Stake -> AssetClass
proposalSTClass :: AssetClass
  }
  deriving stock
    ( -- | @since 0.1.0
      (forall x. Stake -> Rep Stake x)
-> (forall x. Rep Stake x -> Stake) -> Generic Stake
forall x. Rep Stake x -> Stake
forall x. Stake -> Rep Stake x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Stake x -> Stake
$cfrom :: forall x. Stake -> Rep Stake x
GHC.Generic
    )

{- | A lock placed on a Stake datum in order to prevent
     depositing and withdrawing when votes are in place.

     NOTE: Due to retracting votes always being possible,
     this lock will only lock with contention on the proposal.

     FIXME: Contention on Proposals could create contention
     on voting which in turn creates contention on stakers.

     Vaguely this is the dependency graph for this locking
     interaction. Both the stake validator and the proposal
     validator are only able to check for one another through
     the datum belonging to the ST:

     @
     ┌─────────────────┐   ┌────────────────────┐
     │ Stake Validator ├─┐ │ Proposal Validator │
     └────────┬────────┘ │ └──────┬─────┬───────┘
              │          │        │     │
              │        ┌─┼────────┘     │
              ▼        │ │              ▼
     ┌──────────────┐  │ │ ┌─────────────────┐
     │ Stake Policy │◄─┘ └►│ Proposal Policy │
     └──────────────┘      └─────────────────┘
     @

     @since 0.1.0
-}
data ProposalLock = ProposalLock
  { ProposalLock -> ResultTag
vote :: ResultTag
  -- ^ What was voted on. This allows retracting votes to
  --   undo their vote.
  , ProposalLock -> ProposalId
proposalId :: ProposalId
  -- ^ Identifies the proposal. See 'ProposalId' for further
  -- comments on its significance.
  }
  deriving stock
    ( -- | @since 0.1.0
      Int -> ProposalLock -> ShowS
[ProposalLock] -> ShowS
ProposalLock -> String
(Int -> ProposalLock -> ShowS)
-> (ProposalLock -> String)
-> ([ProposalLock] -> ShowS)
-> Show ProposalLock
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProposalLock] -> ShowS
$cshowList :: [ProposalLock] -> ShowS
show :: ProposalLock -> String
$cshow :: ProposalLock -> String
showsPrec :: Int -> ProposalLock -> ShowS
$cshowsPrec :: Int -> ProposalLock -> ShowS
Show
    , -- | @since 0.1.0
      (forall x. ProposalLock -> Rep ProposalLock x)
-> (forall x. Rep ProposalLock x -> ProposalLock)
-> Generic ProposalLock
forall x. Rep ProposalLock x -> ProposalLock
forall x. ProposalLock -> Rep ProposalLock x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProposalLock x -> ProposalLock
$cfrom :: forall x. ProposalLock -> Rep ProposalLock x
GHC.Generic
    )

PlutusTx.makeIsDataIndexed ''ProposalLock [('ProposalLock, 0)]

{- | Haskell-level redeemer for Stake scripts.

     @since 0.1.0
-}
data StakeRedeemer
  = -- | Deposit or withdraw a discrete amount of the staked governance token.
    --   Stake must be unlocked.
    DepositWithdraw (Tagged GTTag Integer)
  | -- | Destroy a stake, retrieving its LQ, the minimum ADA and any other assets.
    --   Stake must be unlocked.
    Destroy
  | -- | Permit a Vote to be added onto a 'Agora.Proposal.Proposal'.
    --   This also adds a lock to the 'lockedBy' field. See 'ProposalLock'.
    --   This needs to be done in sync with casting a vote, otherwise
    --   it's possible for a lock to be permanently placed on the stake,
    --   and then the funds are lost.
    PermitVote ProposalLock
  | -- | Retract a vote, removing it from the 'lockedBy' field. See 'ProposalLock'.
    --   This action checks for permission of the 'Agora.Proposal.Proposal'. Finished proposals are
    --   always allowed to have votes retracted and won't affect the Proposal datum,
    --   allowing 'Stake's to be unlocked.
    RetractVotes [ProposalLock]
  | -- | The owner can consume stake if nothing is changed about it.
    --   If the proposal token moves, this is equivalent to the owner consuming it.
    WitnessStake
  deriving stock (Int -> StakeRedeemer -> ShowS
[StakeRedeemer] -> ShowS
StakeRedeemer -> String
(Int -> StakeRedeemer -> ShowS)
-> (StakeRedeemer -> String)
-> ([StakeRedeemer] -> ShowS)
-> Show StakeRedeemer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StakeRedeemer] -> ShowS
$cshowList :: [StakeRedeemer] -> ShowS
show :: StakeRedeemer -> String
$cshow :: StakeRedeemer -> String
showsPrec :: Int -> StakeRedeemer -> ShowS
$cshowsPrec :: Int -> StakeRedeemer -> ShowS
Show, (forall x. StakeRedeemer -> Rep StakeRedeemer x)
-> (forall x. Rep StakeRedeemer x -> StakeRedeemer)
-> Generic StakeRedeemer
forall x. Rep StakeRedeemer x -> StakeRedeemer
forall x. StakeRedeemer -> Rep StakeRedeemer x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StakeRedeemer x -> StakeRedeemer
$cfrom :: forall x. StakeRedeemer -> Rep StakeRedeemer x
GHC.Generic)

PlutusTx.makeIsDataIndexed
  ''StakeRedeemer
  [ ('DepositWithdraw, 0)
  , ('Destroy, 1)
  , ('PermitVote, 2)
  , ('RetractVotes, 3)
  , ('WitnessStake, 4)
  ]

{- | Haskell-level datum for Stake scripts.

     @since 0.1.0
-}
data StakeDatum = StakeDatum
  { StakeDatum -> Tagged @Type GTTag BuiltinInteger
stakedAmount :: Tagged GTTag Integer
  -- ^ Tracks the amount of governance token staked in the datum.
  -- This also acts as the voting weight for 'Agora.Proposal.Proposal's.
  , StakeDatum -> PubKeyHash
owner :: PubKeyHash
  -- ^ The hash of the public key this stake belongs to.
  --
  -- TODO Support for MultiSig/Scripts is tracked here:
  --      https://github.com/Liqwid-Labs/agora/issues/45
  , StakeDatum -> [ProposalLock]
lockedBy :: [ProposalLock]
  -- ^ The current proposals locking this stake. This field must be empty
  -- for the stake to be usable for deposits and withdrawals.
  }
  deriving stock (Int -> StakeDatum -> ShowS
[StakeDatum] -> ShowS
StakeDatum -> String
(Int -> StakeDatum -> ShowS)
-> (StakeDatum -> String)
-> ([StakeDatum] -> ShowS)
-> Show StakeDatum
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StakeDatum] -> ShowS
$cshowList :: [StakeDatum] -> ShowS
show :: StakeDatum -> String
$cshow :: StakeDatum -> String
showsPrec :: Int -> StakeDatum -> ShowS
$cshowsPrec :: Int -> StakeDatum -> ShowS
Show, (forall x. StakeDatum -> Rep StakeDatum x)
-> (forall x. Rep StakeDatum x -> StakeDatum) -> Generic StakeDatum
forall x. Rep StakeDatum x -> StakeDatum
forall x. StakeDatum -> Rep StakeDatum x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StakeDatum x -> StakeDatum
$cfrom :: forall x. StakeDatum -> Rep StakeDatum x
GHC.Generic)

PlutusTx.makeIsDataIndexed ''StakeDatum [('StakeDatum, 0)]

--------------------------------------------------------------------------------

{- | Plutarch-level datum for Stake scripts.

     @since 0.1.0
-}
newtype PStakeDatum (s :: S) = PStakeDatum
  { forall (s :: S).
PStakeDatum s
-> Term
     s
     (PDataRecord
        ((':)
           @PLabeledType
           ("stakedAmount" ':= PDiscrete @Type GTTag)
           ((':)
              @PLabeledType
              ("owner" ':= PPubKeyHash)
              ((':)
                 @PLabeledType
                 ("lockedBy" ':= PBuiltinList (PAsData PProposalLock))
                 ('[] @PLabeledType)))))
getStakeDatum ::
      Term
        s
        ( PDataRecord
            '[ "stakedAmount" ':= PDiscrete GTTag
             , "owner" ':= PPubKeyHash
             , "lockedBy" ':= PBuiltinList (PAsData PProposalLock)
             ]
        )
  }
  deriving stock
    ( -- | @since 0.1.0
      (forall x. PStakeDatum s -> Rep (PStakeDatum s) x)
-> (forall x. Rep (PStakeDatum s) x -> PStakeDatum s)
-> Generic (PStakeDatum s)
forall x. Rep (PStakeDatum s) x -> PStakeDatum s
forall x. PStakeDatum s -> Rep (PStakeDatum s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PStakeDatum s) x -> PStakeDatum s
forall (s :: S) x. PStakeDatum s -> Rep (PStakeDatum s) x
$cto :: forall (s :: S) x. Rep (PStakeDatum s) x -> PStakeDatum s
$cfrom :: forall (s :: S) x. PStakeDatum s -> Rep (PStakeDatum s) x
GHC.Generic
    )
  deriving anyclass
    ( -- | @since 0.1.0
      All @[Type] (SListI @Type) (Code (PStakeDatum s))
All @[Type] (SListI @Type) (Code (PStakeDatum s))
-> (PStakeDatum s -> Rep (PStakeDatum s))
-> (Rep (PStakeDatum s) -> PStakeDatum s)
-> Generic (PStakeDatum s)
Rep (PStakeDatum s) -> PStakeDatum s
PStakeDatum s -> Rep (PStakeDatum s)
forall a.
All @[Type] (SListI @Type) (Code a)
-> (a -> Rep a) -> (Rep a -> a) -> Generic a
forall {s :: S}. All @[Type] (SListI @Type) (Code (PStakeDatum s))
forall (s :: S). Rep (PStakeDatum s) -> PStakeDatum s
forall (s :: S). PStakeDatum s -> Rep (PStakeDatum s)
to :: Rep (PStakeDatum s) -> PStakeDatum s
$cto :: forall (s :: S). Rep (PStakeDatum s) -> PStakeDatum s
from :: PStakeDatum s -> Rep (PStakeDatum s)
$cfrom :: forall (s :: S). PStakeDatum s -> Rep (PStakeDatum s)
Generic
    )
  deriving anyclass
    ( -- | @since 0.1.0
      PIsData PStakeDatum
PlutusType PStakeDatum
PlutusType PStakeDatum
-> PIsData PStakeDatum
-> (forall (s :: S).
    PStakeDatum s -> Term s (PDataSum (PIsDataReprRepr PStakeDatum)))
-> (forall (s :: S) (b :: PType).
    Term s (PDataSum (PIsDataReprRepr PStakeDatum))
    -> (PStakeDatum s -> Term s b) -> Term s b)
-> PIsDataRepr PStakeDatum
forall (s :: S).
PStakeDatum s -> Term s (PDataSum (PIsDataReprRepr PStakeDatum))
forall (s :: S) (b :: PType).
Term s (PDataSum (PIsDataReprRepr PStakeDatum))
-> (PStakeDatum s -> Term s b) -> Term s b
forall (a :: PType).
PlutusType a
-> PIsData a
-> (forall (s :: S). a s -> Term s (PDataSum (PIsDataReprRepr a)))
-> (forall (s :: S) (b :: PType).
    Term s (PDataSum (PIsDataReprRepr a))
    -> (a s -> Term s b) -> Term s b)
-> PIsDataRepr a
pmatchRepr :: forall (s :: S) (b :: PType).
Term s (PDataSum (PIsDataReprRepr PStakeDatum))
-> (PStakeDatum s -> Term s b) -> Term s b
$cpmatchRepr :: forall (s :: S) (b :: PType).
Term s (PDataSum (PIsDataReprRepr PStakeDatum))
-> (PStakeDatum s -> Term s b) -> Term s b
pconRepr :: forall (s :: S).
PStakeDatum s -> Term s (PDataSum (PIsDataReprRepr PStakeDatum))
$cpconRepr :: forall (s :: S).
PStakeDatum s -> Term s (PDataSum (PIsDataReprRepr PStakeDatum))
PIsDataRepr
    )
  deriving
    ( -- | @since 0.1.0
      PCon PStakeDatum
PMatch PStakeDatum
PCon PStakeDatum
-> PMatch PStakeDatum
-> (forall (s :: S) (b :: PType).
    PStakeDatum s -> Term s (PInner PStakeDatum b))
-> (forall (s :: S) (b :: PType).
    Term s (PInner PStakeDatum b)
    -> (PStakeDatum s -> Term s b) -> Term s b)
-> PlutusType PStakeDatum
forall (s :: S) (b :: PType).
Term s (PInner PStakeDatum b)
-> (PStakeDatum s -> Term s b) -> Term s b
forall (s :: S) (b :: PType).
PStakeDatum s -> Term s (PInner PStakeDatum b)
forall (a :: PType).
PCon a
-> PMatch a
-> (forall (s :: S) (b :: PType). a s -> Term s (PInner a b))
-> (forall (s :: S) (b :: PType).
    Term s (PInner a b) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
pmatch' :: forall (s :: S) (b :: PType).
Term s (PInner PStakeDatum b)
-> (PStakeDatum s -> Term s b) -> Term s b
$cpmatch' :: forall (s :: S) (b :: PType).
Term s (PInner PStakeDatum b)
-> (PStakeDatum s -> Term s b) -> Term s b
pcon' :: forall (s :: S) (b :: PType).
PStakeDatum s -> Term s (PInner PStakeDatum b)
$cpcon' :: forall (s :: S) (b :: PType).
PStakeDatum s -> Term s (PInner PStakeDatum b)
PlutusType
    , -- | @since 0.1.0
      (forall (s :: S).
 Term s (PAsData PStakeDatum) -> Term s PStakeDatum)
-> (forall (s :: S). Term s PStakeDatum -> Term s PData)
-> PIsData PStakeDatum
forall (s :: S). Term s (PAsData PStakeDatum) -> Term s PStakeDatum
forall (s :: S). Term s PStakeDatum -> Term s PData
forall (a :: PType).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
pdataImpl :: forall (s :: S). Term s PStakeDatum -> Term s PData
$cpdataImpl :: forall (s :: S). Term s PStakeDatum -> Term s PData
pfromDataImpl :: forall (s :: S). Term s (PAsData PStakeDatum) -> Term s PStakeDatum
$cpfromDataImpl :: forall (s :: S). Term s (PAsData PStakeDatum) -> Term s PStakeDatum
PIsData
    , -- | @since 0.1.0
      (forall (s :: S).
 Term s PStakeDatum -> Term s (PDataRecord (PFields PStakeDatum)))
-> PDataFields PStakeDatum
forall (s :: S).
Term s PStakeDatum -> Term s (PDataRecord (PFields PStakeDatum))
forall (a :: PType).
(forall (s :: S). Term s a -> Term s (PDataRecord (PFields a)))
-> PDataFields a
ptoFields :: forall (s :: S).
Term s PStakeDatum -> Term s (PDataRecord (PFields PStakeDatum))
$cptoFields :: forall (s :: S).
Term s PStakeDatum -> Term s (PDataRecord (PFields PStakeDatum))
PDataFields
    , -- | @since 0.1.0
      (forall (s :: S).
 Term s PStakeDatum -> Term s PStakeDatum -> Term s PBool)
-> PEq PStakeDatum
forall (s :: S).
Term s PStakeDatum -> Term s PStakeDatum -> Term s PBool
forall (t :: PType).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
#== :: forall (s :: S).
Term s PStakeDatum -> Term s PStakeDatum -> Term s PBool
$c#== :: forall (s :: S).
Term s PStakeDatum -> Term s PStakeDatum -> Term s PBool
PEq
    )
    via (PIsDataReprInstances PStakeDatum)

-- | @since 0.1.0
instance Plutarch.Lift.PUnsafeLiftDecl PStakeDatum where type PLifted PStakeDatum = StakeDatum

-- | @since 0.1.0
deriving via (DerivePConstantViaData StakeDatum PStakeDatum) instance (Plutarch.Lift.PConstantDecl StakeDatum)

-- | @since 0.1.0
deriving via PAsData (PIsDataReprInstances PStakeDatum) instance PTryFrom PData (PAsData PStakeDatum)

{- | Plutarch-level redeemer for Stake scripts.

     @since 0.1.0
-}
data PStakeRedeemer (s :: S)
  = -- | Deposit or withdraw a discrete amount of the staked governance token.
    PDepositWithdraw (Term s (PDataRecord '["delta" ':= PDiscrete GTTag]))
  | -- | Destroy a stake, retrieving its LQ, the minimum ADA and any other assets.
    PDestroy (Term s (PDataRecord '[]))
  | PPermitVote (Term s (PDataRecord '["lock" ':= PProposalLock]))
  | PRetractVotes (Term s (PDataRecord '["locks" ':= PBuiltinList (PAsData PProposalLock)]))
  | PWitnessStake (Term s (PDataRecord '[]))
  deriving stock
    ( -- | @since 0.1.0
      (forall x. PStakeRedeemer s -> Rep (PStakeRedeemer s) x)
-> (forall x. Rep (PStakeRedeemer s) x -> PStakeRedeemer s)
-> Generic (PStakeRedeemer s)
forall x. Rep (PStakeRedeemer s) x -> PStakeRedeemer s
forall x. PStakeRedeemer s -> Rep (PStakeRedeemer s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PStakeRedeemer s) x -> PStakeRedeemer s
forall (s :: S) x. PStakeRedeemer s -> Rep (PStakeRedeemer s) x
$cto :: forall (s :: S) x. Rep (PStakeRedeemer s) x -> PStakeRedeemer s
$cfrom :: forall (s :: S) x. PStakeRedeemer s -> Rep (PStakeRedeemer s) x
GHC.Generic
    )
  deriving anyclass
    ( -- | @since 0.1.0
      All @[Type] (SListI @Type) (Code (PStakeRedeemer s))
All @[Type] (SListI @Type) (Code (PStakeRedeemer s))
-> (PStakeRedeemer s -> Rep (PStakeRedeemer s))
-> (Rep (PStakeRedeemer s) -> PStakeRedeemer s)
-> Generic (PStakeRedeemer s)
Rep (PStakeRedeemer s) -> PStakeRedeemer s
PStakeRedeemer s -> Rep (PStakeRedeemer s)
forall a.
All @[Type] (SListI @Type) (Code a)
-> (a -> Rep a) -> (Rep a -> a) -> Generic a
forall {s :: S}.
All @[Type] (SListI @Type) (Code (PStakeRedeemer s))
forall (s :: S). Rep (PStakeRedeemer s) -> PStakeRedeemer s
forall (s :: S). PStakeRedeemer s -> Rep (PStakeRedeemer s)
to :: Rep (PStakeRedeemer s) -> PStakeRedeemer s
$cto :: forall (s :: S). Rep (PStakeRedeemer s) -> PStakeRedeemer s
from :: PStakeRedeemer s -> Rep (PStakeRedeemer s)
$cfrom :: forall (s :: S). PStakeRedeemer s -> Rep (PStakeRedeemer s)
Generic
    )
  deriving anyclass
    ( -- | @since 0.1.0
      PIsData PStakeRedeemer
PlutusType PStakeRedeemer
PlutusType PStakeRedeemer
-> PIsData PStakeRedeemer
-> (forall (s :: S).
    PStakeRedeemer s
    -> Term s (PDataSum (PIsDataReprRepr PStakeRedeemer)))
-> (forall (s :: S) (b :: PType).
    Term s (PDataSum (PIsDataReprRepr PStakeRedeemer))
    -> (PStakeRedeemer s -> Term s b) -> Term s b)
-> PIsDataRepr PStakeRedeemer
forall (s :: S).
PStakeRedeemer s
-> Term s (PDataSum (PIsDataReprRepr PStakeRedeemer))
forall (s :: S) (b :: PType).
Term s (PDataSum (PIsDataReprRepr PStakeRedeemer))
-> (PStakeRedeemer s -> Term s b) -> Term s b
forall (a :: PType).
PlutusType a
-> PIsData a
-> (forall (s :: S). a s -> Term s (PDataSum (PIsDataReprRepr a)))
-> (forall (s :: S) (b :: PType).
    Term s (PDataSum (PIsDataReprRepr a))
    -> (a s -> Term s b) -> Term s b)
-> PIsDataRepr a
pmatchRepr :: forall (s :: S) (b :: PType).
Term s (PDataSum (PIsDataReprRepr PStakeRedeemer))
-> (PStakeRedeemer s -> Term s b) -> Term s b
$cpmatchRepr :: forall (s :: S) (b :: PType).
Term s (PDataSum (PIsDataReprRepr PStakeRedeemer))
-> (PStakeRedeemer s -> Term s b) -> Term s b
pconRepr :: forall (s :: S).
PStakeRedeemer s
-> Term s (PDataSum (PIsDataReprRepr PStakeRedeemer))
$cpconRepr :: forall (s :: S).
PStakeRedeemer s
-> Term s (PDataSum (PIsDataReprRepr PStakeRedeemer))
PIsDataRepr
    )
  deriving
    ( -- | @since 0.1.0
      PCon PStakeRedeemer
PMatch PStakeRedeemer
PCon PStakeRedeemer
-> PMatch PStakeRedeemer
-> (forall (s :: S) (b :: PType).
    PStakeRedeemer s -> Term s (PInner PStakeRedeemer b))
-> (forall (s :: S) (b :: PType).
    Term s (PInner PStakeRedeemer b)
    -> (PStakeRedeemer s -> Term s b) -> Term s b)
-> PlutusType PStakeRedeemer
forall (s :: S) (b :: PType).
Term s (PInner PStakeRedeemer b)
-> (PStakeRedeemer s -> Term s b) -> Term s b
forall (s :: S) (b :: PType).
PStakeRedeemer s -> Term s (PInner PStakeRedeemer b)
forall (a :: PType).
PCon a
-> PMatch a
-> (forall (s :: S) (b :: PType). a s -> Term s (PInner a b))
-> (forall (s :: S) (b :: PType).
    Term s (PInner a b) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
pmatch' :: forall (s :: S) (b :: PType).
Term s (PInner PStakeRedeemer b)
-> (PStakeRedeemer s -> Term s b) -> Term s b
$cpmatch' :: forall (s :: S) (b :: PType).
Term s (PInner PStakeRedeemer b)
-> (PStakeRedeemer s -> Term s b) -> Term s b
pcon' :: forall (s :: S) (b :: PType).
PStakeRedeemer s -> Term s (PInner PStakeRedeemer b)
$cpcon' :: forall (s :: S) (b :: PType).
PStakeRedeemer s -> Term s (PInner PStakeRedeemer b)
PlutusType
    , -- | @since 0.1.0
      (forall (s :: S).
 Term s (PAsData PStakeRedeemer) -> Term s PStakeRedeemer)
-> (forall (s :: S). Term s PStakeRedeemer -> Term s PData)
-> PIsData PStakeRedeemer
forall (s :: S).
Term s (PAsData PStakeRedeemer) -> Term s PStakeRedeemer
forall (s :: S). Term s PStakeRedeemer -> Term s PData
forall (a :: PType).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
pdataImpl :: forall (s :: S). Term s PStakeRedeemer -> Term s PData
$cpdataImpl :: forall (s :: S). Term s PStakeRedeemer -> Term s PData
pfromDataImpl :: forall (s :: S).
Term s (PAsData PStakeRedeemer) -> Term s PStakeRedeemer
$cpfromDataImpl :: forall (s :: S).
Term s (PAsData PStakeRedeemer) -> Term s PStakeRedeemer
PIsData
    )
    via PIsDataReprInstances PStakeRedeemer

deriving via
  PAsData (PIsDataReprInstances PStakeRedeemer)
  instance
    PTryFrom PData (PAsData PStakeRedeemer)

instance Plutarch.Lift.PUnsafeLiftDecl PStakeRedeemer where type PLifted PStakeRedeemer = StakeRedeemer
deriving via (DerivePConstantViaData StakeRedeemer PStakeRedeemer) instance (Plutarch.Lift.PConstantDecl StakeRedeemer)

{- | Plutarch-level version of 'ProposalLock'.

     @since 0.1.0
-}
newtype PProposalLock (s :: S) = PProposalLock
  { forall (s :: S).
PProposalLock s
-> Term
     s
     (PDataRecord
        ((':)
           @PLabeledType
           ("vote" ':= PResultTag)
           ((':)
              @PLabeledType
              ("proposalTag" ':= PProposalId)
              ('[] @PLabeledType))))
getProposalLock ::
      Term
        s
        ( PDataRecord
            '[ "vote" ':= PResultTag
             , "proposalTag" ':= PProposalId
             ]
        )
  }
  deriving stock ((forall x. PProposalLock s -> Rep (PProposalLock s) x)
-> (forall x. Rep (PProposalLock s) x -> PProposalLock s)
-> Generic (PProposalLock s)
forall x. Rep (PProposalLock s) x -> PProposalLock s
forall x. PProposalLock s -> Rep (PProposalLock s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PProposalLock s) x -> PProposalLock s
forall (s :: S) x. PProposalLock s -> Rep (PProposalLock s) x
$cto :: forall (s :: S) x. Rep (PProposalLock s) x -> PProposalLock s
$cfrom :: forall (s :: S) x. PProposalLock s -> Rep (PProposalLock s) x
GHC.Generic)
  deriving anyclass (All @[Type] (SListI @Type) (Code (PProposalLock s))
All @[Type] (SListI @Type) (Code (PProposalLock s))
-> (PProposalLock s -> Rep (PProposalLock s))
-> (Rep (PProposalLock s) -> PProposalLock s)
-> Generic (PProposalLock s)
Rep (PProposalLock s) -> PProposalLock s
PProposalLock s -> Rep (PProposalLock s)
forall a.
All @[Type] (SListI @Type) (Code a)
-> (a -> Rep a) -> (Rep a -> a) -> Generic a
forall {s :: S}.
All @[Type] (SListI @Type) (Code (PProposalLock s))
forall (s :: S). Rep (PProposalLock s) -> PProposalLock s
forall (s :: S). PProposalLock s -> Rep (PProposalLock s)
to :: Rep (PProposalLock s) -> PProposalLock s
$cto :: forall (s :: S). Rep (PProposalLock s) -> PProposalLock s
from :: PProposalLock s -> Rep (PProposalLock s)
$cfrom :: forall (s :: S). PProposalLock s -> Rep (PProposalLock s)
Generic)
  deriving anyclass (PIsData PProposalLock
PlutusType PProposalLock
PlutusType PProposalLock
-> PIsData PProposalLock
-> (forall (s :: S).
    PProposalLock s
    -> Term s (PDataSum (PIsDataReprRepr PProposalLock)))
-> (forall (s :: S) (b :: PType).
    Term s (PDataSum (PIsDataReprRepr PProposalLock))
    -> (PProposalLock s -> Term s b) -> Term s b)
-> PIsDataRepr PProposalLock
forall (s :: S).
PProposalLock s
-> Term s (PDataSum (PIsDataReprRepr PProposalLock))
forall (s :: S) (b :: PType).
Term s (PDataSum (PIsDataReprRepr PProposalLock))
-> (PProposalLock s -> Term s b) -> Term s b
forall (a :: PType).
PlutusType a
-> PIsData a
-> (forall (s :: S). a s -> Term s (PDataSum (PIsDataReprRepr a)))
-> (forall (s :: S) (b :: PType).
    Term s (PDataSum (PIsDataReprRepr a))
    -> (a s -> Term s b) -> Term s b)
-> PIsDataRepr a
pmatchRepr :: forall (s :: S) (b :: PType).
Term s (PDataSum (PIsDataReprRepr PProposalLock))
-> (PProposalLock s -> Term s b) -> Term s b
$cpmatchRepr :: forall (s :: S) (b :: PType).
Term s (PDataSum (PIsDataReprRepr PProposalLock))
-> (PProposalLock s -> Term s b) -> Term s b
pconRepr :: forall (s :: S).
PProposalLock s
-> Term s (PDataSum (PIsDataReprRepr PProposalLock))
$cpconRepr :: forall (s :: S).
PProposalLock s
-> Term s (PDataSum (PIsDataReprRepr PProposalLock))
PIsDataRepr)
  deriving
    (PCon PProposalLock
PMatch PProposalLock
PCon PProposalLock
-> PMatch PProposalLock
-> (forall (s :: S) (b :: PType).
    PProposalLock s -> Term s (PInner PProposalLock b))
-> (forall (s :: S) (b :: PType).
    Term s (PInner PProposalLock b)
    -> (PProposalLock s -> Term s b) -> Term s b)
-> PlutusType PProposalLock
forall (s :: S) (b :: PType).
Term s (PInner PProposalLock b)
-> (PProposalLock s -> Term s b) -> Term s b
forall (s :: S) (b :: PType).
PProposalLock s -> Term s (PInner PProposalLock b)
forall (a :: PType).
PCon a
-> PMatch a
-> (forall (s :: S) (b :: PType). a s -> Term s (PInner a b))
-> (forall (s :: S) (b :: PType).
    Term s (PInner a b) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
pmatch' :: forall (s :: S) (b :: PType).
Term s (PInner PProposalLock b)
-> (PProposalLock s -> Term s b) -> Term s b
$cpmatch' :: forall (s :: S) (b :: PType).
Term s (PInner PProposalLock b)
-> (PProposalLock s -> Term s b) -> Term s b
pcon' :: forall (s :: S) (b :: PType).
PProposalLock s -> Term s (PInner PProposalLock b)
$cpcon' :: forall (s :: S) (b :: PType).
PProposalLock s -> Term s (PInner PProposalLock b)
PlutusType, (forall (s :: S).
 Term s (PAsData PProposalLock) -> Term s PProposalLock)
-> (forall (s :: S). Term s PProposalLock -> Term s PData)
-> PIsData PProposalLock
forall (s :: S).
Term s (PAsData PProposalLock) -> Term s PProposalLock
forall (s :: S). Term s PProposalLock -> Term s PData
forall (a :: PType).
(forall (s :: S). Term s (PAsData a) -> Term s a)
-> (forall (s :: S). Term s a -> Term s PData) -> PIsData a
pdataImpl :: forall (s :: S). Term s PProposalLock -> Term s PData
$cpdataImpl :: forall (s :: S). Term s PProposalLock -> Term s PData
pfromDataImpl :: forall (s :: S).
Term s (PAsData PProposalLock) -> Term s PProposalLock
$cpfromDataImpl :: forall (s :: S).
Term s (PAsData PProposalLock) -> Term s PProposalLock
PIsData, (forall (s :: S).
 Term s PProposalLock
 -> Term s (PDataRecord (PFields PProposalLock)))
-> PDataFields PProposalLock
forall (s :: S).
Term s PProposalLock
-> Term s (PDataRecord (PFields PProposalLock))
forall (a :: PType).
(forall (s :: S). Term s a -> Term s (PDataRecord (PFields a)))
-> PDataFields a
ptoFields :: forall (s :: S).
Term s PProposalLock
-> Term s (PDataRecord (PFields PProposalLock))
$cptoFields :: forall (s :: S).
Term s PProposalLock
-> Term s (PDataRecord (PFields PProposalLock))
PDataFields, (forall (s :: S).
 Term s PProposalLock -> Term s PProposalLock -> Term s PBool)
-> PEq PProposalLock
forall (s :: S).
Term s PProposalLock -> Term s PProposalLock -> Term s PBool
forall (t :: PType).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
#== :: forall (s :: S).
Term s PProposalLock -> Term s PProposalLock -> Term s PBool
$c#== :: forall (s :: S).
Term s PProposalLock -> Term s PProposalLock -> Term s PBool
PEq)
    via (PIsDataReprInstances PProposalLock)

deriving via
  PAsData (PIsDataReprInstances PProposalLock)
  instance
    PTryFrom PData (PAsData PProposalLock)

instance Plutarch.Lift.PUnsafeLiftDecl PProposalLock where type PLifted PProposalLock = ProposalLock
deriving via (DerivePConstantViaData ProposalLock PProposalLock) instance (Plutarch.Lift.PConstantDecl ProposalLock)

--------------------------------------------------------------------------------

{- | Check whether a Stake is locked. If it is locked, various actions are unavailable.

     @since 0.1.0
-}
stakeLocked :: forall (s :: S). Term s (PStakeDatum :--> PBool)
stakeLocked :: forall (s :: S). Term s (PStakeDatum :--> PBool)
stakeLocked = (forall (s :: S). Term s (PStakeDatum :--> PBool))
-> Term s (PStakeDatum :--> PBool)
forall (a :: PType) (s :: S).
HasCallStack =>
ClosedTerm a -> Term s a
phoistAcyclic ((forall (s :: S). Term s (PStakeDatum :--> PBool))
 -> Term s (PStakeDatum :--> PBool))
-> (forall (s :: S). Term s (PStakeDatum :--> PBool))
-> Term s (PStakeDatum :--> PBool)
forall a b. (a -> b) -> a -> b
$
  (Term s PStakeDatum -> Term s PBool)
-> Term s (PStakeDatum :--> PBool)
forall a (b :: PType) (s :: S) (c :: PType).
PLamN a b s =>
(Term s c -> a) -> Term s (c :--> b)
plam ((Term s PStakeDatum -> Term s PBool)
 -> Term s (PStakeDatum :--> PBool))
-> (Term s PStakeDatum -> Term s PBool)
-> Term s (PStakeDatum :--> PBool)
forall a b. (a -> b) -> a -> b
$ \Term s PStakeDatum
stakeDatum ->
    let locks :: Term _ (PBuiltinList (PAsData PProposalLock))
        locks :: Term s (PBuiltinList (PAsData PProposalLock))
locks = forall (name :: Symbol) (p :: PType) (s :: S) (a :: PType)
       (as :: [PLabeledType]) (n :: Nat) (b :: PType).
(PDataFields p,
 (as :: [PLabeledType]) ~ (PFields p :: [PLabeledType]),
 (n :: Nat) ~ (PLabelIndex name as :: Nat), KnownNat n,
 (a :: PType) ~ (PUnLabel (IndexList @PLabeledType n as) :: PType),
 PFromDataable a b) =>
Term s (p :--> b)
pfield @"lockedBy" Term s (PStakeDatum :--> PBuiltinList (PAsData PProposalLock))
-> Term s PStakeDatum
-> Term s (PBuiltinList (PAsData PProposalLock))
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s PStakeDatum
stakeDatum
     in Term s (PBuiltinList (PAsData PProposalLock) :--> PBool)
forall (a :: PType) (s :: S) (list :: PType -> PType).
PIsListLike list a =>
Term s (list a :--> PBool)
pnotNull Term s (PBuiltinList (PAsData PProposalLock) :--> PBool)
-> Term s (PBuiltinList (PAsData PProposalLock)) -> Term s PBool
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PBuiltinList (PAsData PProposalLock))
locks

{- | Find a stake owned by a particular PK.

     @since 0.1.0
-}
findStakeOwnedBy ::
  Term
    s
    ( PAssetClass
        :--> PPubKeyHash
        :--> PBuiltinList (PAsData (PTuple PDatumHash PDatum))
        :--> PBuiltinList (PAsData PTxInInfo)
        :--> PMaybe (PAsData PStakeDatum)
    )
findStakeOwnedBy :: forall (s :: S).
Term
  s
  (PAssetClass
   :--> (PPubKeyHash
         :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
               :--> (PBuiltinList (PAsData PTxInInfo)
                     :--> PMaybe (PAsData PStakeDatum)))))
findStakeOwnedBy = (forall (s :: S).
 Term
   s
   (PAssetClass
    :--> (PPubKeyHash
          :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
                :--> (PBuiltinList (PAsData PTxInInfo)
                      :--> PMaybe (PAsData PStakeDatum))))))
-> Term
     s
     (PAssetClass
      :--> (PPubKeyHash
            :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
                  :--> (PBuiltinList (PAsData PTxInInfo)
                        :--> PMaybe (PAsData PStakeDatum)))))
forall (a :: PType) (s :: S).
HasCallStack =>
ClosedTerm a -> Term s a
phoistAcyclic ((forall (s :: S).
  Term
    s
    (PAssetClass
     :--> (PPubKeyHash
           :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
                 :--> (PBuiltinList (PAsData PTxInInfo)
                       :--> PMaybe (PAsData PStakeDatum))))))
 -> Term
      s
      (PAssetClass
       :--> (PPubKeyHash
             :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
                   :--> (PBuiltinList (PAsData PTxInInfo)
                         :--> PMaybe (PAsData PStakeDatum))))))
-> (forall (s :: S).
    Term
      s
      (PAssetClass
       :--> (PPubKeyHash
             :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
                   :--> (PBuiltinList (PAsData PTxInInfo)
                         :--> PMaybe (PAsData PStakeDatum))))))
-> Term
     s
     (PAssetClass
      :--> (PPubKeyHash
            :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
                  :--> (PBuiltinList (PAsData PTxInInfo)
                        :--> PMaybe (PAsData PStakeDatum)))))
forall a b. (a -> b) -> a -> b
$
  (Term s PAssetClass
 -> Term s PPubKeyHash
 -> Term s (PBuiltinList (PAsData (PTuple PDatumHash PDatum)))
 -> Term s (PBuiltinList (PAsData PTxInInfo))
 -> Term s (PMaybe (PAsData PStakeDatum)))
-> Term
     s
     (PAssetClass
      :--> (PPubKeyHash
            :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
                  :--> (PBuiltinList (PAsData PTxInInfo)
                        :--> PMaybe (PAsData PStakeDatum)))))
forall a (b :: PType) (s :: S) (c :: PType).
PLamN a b s =>
(Term s c -> a) -> Term s (c :--> b)
plam ((Term s PAssetClass
  -> Term s PPubKeyHash
  -> Term s (PBuiltinList (PAsData (PTuple PDatumHash PDatum)))
  -> Term s (PBuiltinList (PAsData PTxInInfo))
  -> Term s (PMaybe (PAsData PStakeDatum)))
 -> Term
      s
      (PAssetClass
       :--> (PPubKeyHash
             :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
                   :--> (PBuiltinList (PAsData PTxInInfo)
                         :--> PMaybe (PAsData PStakeDatum))))))
-> (Term s PAssetClass
    -> Term s PPubKeyHash
    -> Term s (PBuiltinList (PAsData (PTuple PDatumHash PDatum)))
    -> Term s (PBuiltinList (PAsData PTxInInfo))
    -> Term s (PMaybe (PAsData PStakeDatum)))
-> Term
     s
     (PAssetClass
      :--> (PPubKeyHash
            :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
                  :--> (PBuiltinList (PAsData PTxInInfo)
                        :--> PMaybe (PAsData PStakeDatum)))))
forall a b. (a -> b) -> a -> b
$ \Term s PAssetClass
ac Term s PPubKeyHash
pk Term s (PBuiltinList (PAsData (PTuple PDatumHash PDatum)))
datums Term s (PBuiltinList (PAsData PTxInInfo))
inputs ->
    Term s (PMaybe (PAsData PTxInInfo))
-> (PMaybe (PAsData PTxInInfo) s
    -> Term s (PMaybe (PAsData PStakeDatum)))
-> Term s (PMaybe (PAsData PStakeDatum))
forall (a :: PType) (s :: S) (b :: PType).
PMatch a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (Term
  s
  ((PAsData PTxInInfo :--> PBool)
   :--> (PBuiltinList (PAsData PTxInInfo)
         :--> PMaybe (PAsData PTxInInfo)))
forall (l :: PType -> PType) (a :: PType) (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 :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# (Term
  s
  (PAssetClass
   :--> (PPubKeyHash
         :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
               :--> (PAsData PTxInInfo :--> PBool))))
forall {s :: S}.
Term
  s
  (PAssetClass
   :--> (PPubKeyHash
         :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
               :--> (PAsData PTxInInfo :--> PBool))))
isInputStakeOwnedBy Term
  s
  (PAssetClass
   :--> (PPubKeyHash
         :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
               :--> (PAsData PTxInInfo :--> PBool))))
-> Term s PAssetClass
-> Term
     s
     (PPubKeyHash
      :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
            :--> (PAsData PTxInInfo :--> PBool)))
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s PAssetClass
ac Term
  s
  (PPubKeyHash
   :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
         :--> (PAsData PTxInInfo :--> PBool)))
-> Term s PPubKeyHash
-> Term
     s
     (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
      :--> (PAsData PTxInInfo :--> PBool))
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s PPubKeyHash
pk Term
  s
  (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
   :--> (PAsData PTxInInfo :--> PBool))
-> Term s (PBuiltinList (PAsData (PTuple PDatumHash PDatum)))
-> Term s (PAsData PTxInInfo :--> PBool)
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PBuiltinList (PAsData (PTuple PDatumHash PDatum)))
datums) Term
  s
  (PBuiltinList (PAsData PTxInInfo) :--> PMaybe (PAsData PTxInInfo))
-> Term s (PBuiltinList (PAsData PTxInInfo))
-> Term s (PMaybe (PAsData PTxInInfo))
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PBuiltinList (PAsData PTxInInfo))
inputs) ((PMaybe (PAsData PTxInInfo) s
  -> Term s (PMaybe (PAsData PStakeDatum)))
 -> Term s (PMaybe (PAsData PStakeDatum)))
-> (PMaybe (PAsData PTxInInfo) s
    -> Term s (PMaybe (PAsData PStakeDatum)))
-> Term s (PMaybe (PAsData PStakeDatum))
forall a b. (a -> b) -> a -> b
$ \case
      PMaybe (PAsData PTxInInfo) s
PNothing -> PMaybe (PAsData PStakeDatum) s
-> Term s (PMaybe (PAsData PStakeDatum))
forall (a :: PType) (s :: S). PCon a => a s -> Term s a
pcon PMaybe (PAsData PStakeDatum) s
forall (a :: PType) (s :: S). PMaybe a s
PNothing
      PJust (Term s (PAsData PTxInInfo) -> Term s PTxInInfo
forall (a :: PType) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData -> Term s PTxInInfo
v) -> TermCont
  @(PMaybe (PAsData PStakeDatum))
  s
  (Term s (PMaybe (PAsData PStakeDatum)))
-> Term s (PMaybe (PAsData PStakeDatum))
forall (a :: PType) (s :: S). TermCont @a s (Term s a) -> Term s a
unTermCont (TermCont
   @(PMaybe (PAsData PStakeDatum))
   s
   (Term s (PMaybe (PAsData PStakeDatum)))
 -> Term s (PMaybe (PAsData PStakeDatum)))
-> TermCont
     @(PMaybe (PAsData PStakeDatum))
     s
     (Term s (PMaybe (PAsData PStakeDatum)))
-> Term s (PMaybe (PAsData PStakeDatum))
forall a b. (a -> b) -> a -> b
$ do
        let txOut :: Term s (PAsData PTxOut)
txOut = forall (name :: Symbol) (p :: PType) (s :: S) (a :: PType)
       (as :: [PLabeledType]) (n :: Nat) (b :: PType).
(PDataFields p,
 (as :: [PLabeledType]) ~ (PFields p :: [PLabeledType]),
 (n :: Nat) ~ (PLabelIndex name as :: Nat), KnownNat n,
 (a :: PType) ~ (PUnLabel (IndexList @PLabeledType n as) :: PType),
 PFromDataable a b) =>
Term s (p :--> b)
pfield @"resolved" Term
  s
  (PDataSum
     ((':)
        @[PLabeledType]
        ((':)
           @PLabeledType
           ("outRef" ':= PTxOutRef)
           ((':) @PLabeledType ("resolved" ':= PTxOut) ('[] @PLabeledType)))
        ('[] @[PLabeledType]))
   :--> PAsData PTxOut)
-> Term
     s
     (PDataSum
        ((':)
           @[PLabeledType]
           ((':)
              @PLabeledType
              ("outRef" ':= PTxOutRef)
              ((':) @PLabeledType ("resolved" ':= PTxOut) ('[] @PLabeledType)))
           ('[] @[PLabeledType])))
-> Term s (PAsData PTxOut)
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s PTxInInfo
-> forall (b :: PType). Term s (PInner PTxInInfo b)
forall (s :: S) (a :: PType).
Term s a -> forall (b :: PType). Term s (PInner a b)
pto Term s PTxInInfo
v
        HRec
  (BoundTerms
     (PFields (PAsData PTxOut))
     (Bindings
        (PFields (PAsData PTxOut))
        ((':) @Symbol "datumHash" ('[] @Symbol)))
     s)
txOutF <- ((HRec
    (BoundTerms
       (PFields (PAsData PTxOut))
       (Bindings
          (PFields (PAsData PTxOut))
          ((':) @Symbol "datumHash" ('[] @Symbol)))
       s)
  -> Term s (PMaybe (PAsData PStakeDatum)))
 -> Term s (PMaybe (PAsData PStakeDatum)))
-> TermCont
     @(PMaybe (PAsData PStakeDatum))
     s
     (HRec
        (BoundTerms
           (PFields (PAsData PTxOut))
           (Bindings
              (PFields (PAsData PTxOut))
              ((':) @Symbol "datumHash" ('[] @Symbol)))
           s))
forall a (s :: S) (r :: PType).
((a -> Term s r) -> Term s r) -> TermCont @r s a
tcont (((HRec
     (BoundTerms
        (PFields (PAsData PTxOut))
        (Bindings
           (PFields (PAsData PTxOut))
           ((':) @Symbol "datumHash" ('[] @Symbol)))
        s)
   -> Term s (PMaybe (PAsData PStakeDatum)))
  -> Term s (PMaybe (PAsData PStakeDatum)))
 -> TermCont
      @(PMaybe (PAsData PStakeDatum))
      s
      (HRec
         (BoundTerms
            (PFields (PAsData PTxOut))
            (Bindings
               (PFields (PAsData PTxOut))
               ((':) @Symbol "datumHash" ('[] @Symbol)))
            s)))
-> ((HRec
       (BoundTerms
          (PFields (PAsData PTxOut))
          (Bindings
             (PFields (PAsData PTxOut))
             ((':) @Symbol "datumHash" ('[] @Symbol)))
          s)
     -> Term s (PMaybe (PAsData PStakeDatum)))
    -> Term s (PMaybe (PAsData PStakeDatum)))
-> TermCont
     @(PMaybe (PAsData PStakeDatum))
     s
     (HRec
        (BoundTerms
           (PFields (PAsData PTxOut))
           (Bindings
              (PFields (PAsData PTxOut))
              ((':) @Symbol "datumHash" ('[] @Symbol)))
           s))
forall a b. (a -> b) -> a -> b
$ forall (fs :: [Symbol]) (a :: PType) (s :: S) (b :: PType)
       (ps :: [PLabeledType]) (bs :: [ToBind]).
(PDataFields a,
 (ps :: [PLabeledType]) ~ (PFields a :: [PLabeledType]),
 (bs :: [ToBind]) ~ (Bindings ps fs :: [ToBind]),
 BindFields ps bs) =>
Term s a -> (HRecOf a fs s -> Term s b) -> Term s b
pletFields @'["datumHash"] (Term s (PAsData PTxOut)
 -> (HRec
       (BoundTerms
          (PFields (PAsData PTxOut))
          (Bindings
             (PFields (PAsData PTxOut))
             ((':) @Symbol "datumHash" ('[] @Symbol)))
          s)
     -> Term s (PMaybe (PAsData PStakeDatum)))
 -> Term s (PMaybe (PAsData PStakeDatum)))
-> Term s (PAsData PTxOut)
-> (HRec
      (BoundTerms
         (PFields (PAsData PTxOut))
         (Bindings
            (PFields (PAsData PTxOut))
            ((':) @Symbol "datumHash" ('[] @Symbol)))
         s)
    -> Term s (PMaybe (PAsData PStakeDatum)))
-> Term s (PMaybe (PAsData PStakeDatum))
forall a b. (a -> b) -> a -> b
$ Term s (PAsData PTxOut)
txOut
        Term s (PMaybe (PAsData PStakeDatum))
-> TermCont
     @(PMaybe (PAsData PStakeDatum))
     s
     (Term s (PMaybe (PAsData PStakeDatum)))
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (Term s (PMaybe (PAsData PStakeDatum))
 -> TermCont
      @(PMaybe (PAsData PStakeDatum))
      s
      (Term s (PMaybe (PAsData PStakeDatum))))
-> Term s (PMaybe (PAsData PStakeDatum))
-> TermCont
     @(PMaybe (PAsData PStakeDatum))
     s
     (Term s (PMaybe (PAsData PStakeDatum)))
forall a b. (a -> b) -> a -> b
$
          Term s (PMaybeData PDatumHash)
-> (PMaybeData PDatumHash s
    -> Term s (PMaybe (PAsData PStakeDatum)))
-> Term s (PMaybe (PAsData PStakeDatum))
forall (a :: PType) (s :: S) (b :: PType).
PMatch a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch HRec
  (BoundTerms
     (PFields (PAsData PTxOut))
     (Bindings
        (PFields (PAsData PTxOut))
        ((':) @Symbol "datumHash" ('[] @Symbol)))
     s)
txOutF.datumHash ((PMaybeData PDatumHash s -> Term s (PMaybe (PAsData PStakeDatum)))
 -> Term s (PMaybe (PAsData PStakeDatum)))
-> (PMaybeData PDatumHash s
    -> Term s (PMaybe (PAsData PStakeDatum)))
-> Term s (PMaybe (PAsData PStakeDatum))
forall a b. (a -> b) -> a -> b
$ \case
            PDNothing Term s (PDataRecord ('[] @PLabeledType))
_ -> PMaybe (PAsData PStakeDatum) s
-> Term s (PMaybe (PAsData PStakeDatum))
forall (a :: PType) (s :: S). PCon a => a s -> Term s a
pcon PMaybe (PAsData PStakeDatum) s
forall (a :: PType) (s :: S). PMaybe a s
PNothing
            PDJust ((forall (name :: Symbol) (p :: PType) (s :: S) (a :: PType)
       (as :: [PLabeledType]) (n :: Nat) (b :: PType).
(PDataFields p,
 (as :: [PLabeledType]) ~ (PFields p :: [PLabeledType]),
 (n :: Nat) ~ (PLabelIndex name as :: Nat), KnownNat n,
 (a :: PType) ~ (PUnLabel (IndexList @PLabeledType n as) :: PType),
 PFromDataable a b) =>
Term s (p :--> b)
pfield @"_0" #) -> Term s PDatumHash
dh) ->
              forall (a :: PType) (s :: S).
PTryFrom PData a =>
Term
  s
  (PDatumHash
   :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
         :--> PMaybe a))
ptryFindDatum @(PAsData PStakeDatum) Term
  s
  (PDatumHash
   :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
         :--> PMaybe (PAsData PStakeDatum)))
-> Term s PDatumHash
-> Term
     s
     (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
      :--> PMaybe (PAsData PStakeDatum))
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s PDatumHash
dh Term
  s
  (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
   :--> PMaybe (PAsData PStakeDatum))
-> Term s (PBuiltinList (PAsData (PTuple PDatumHash PDatum)))
-> Term s (PMaybe (PAsData PStakeDatum))
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PBuiltinList (PAsData (PTuple PDatumHash PDatum)))
datums

{- | Check if a StakeDatum  is owned by a particular public key.

   @since 0.1.0
-}
stakeDatumOwnedBy :: Term _ (PPubKeyHash :--> PStakeDatum :--> PBool)
stakeDatumOwnedBy :: Term w (PPubKeyHash :--> (PStakeDatum :--> PBool))
stakeDatumOwnedBy =
  ClosedTerm (PPubKeyHash :--> (PStakeDatum :--> PBool))
-> Term w (PPubKeyHash :--> (PStakeDatum :--> PBool))
forall (a :: PType) (s :: S).
HasCallStack =>
ClosedTerm a -> Term s a
phoistAcyclic (ClosedTerm (PPubKeyHash :--> (PStakeDatum :--> PBool))
 -> Term w (PPubKeyHash :--> (PStakeDatum :--> PBool)))
-> ClosedTerm (PPubKeyHash :--> (PStakeDatum :--> PBool))
-> Term w (PPubKeyHash :--> (PStakeDatum :--> PBool))
forall a b. (a -> b) -> a -> b
$
    (Term s PPubKeyHash -> Term s PStakeDatum -> Term s PBool)
-> Term s (PPubKeyHash :--> (PStakeDatum :--> PBool))
forall a (b :: PType) (s :: S) (c :: PType).
PLamN a b s =>
(Term s c -> a) -> Term s (c :--> b)
plam ((Term s PPubKeyHash -> Term s PStakeDatum -> Term s PBool)
 -> Term s (PPubKeyHash :--> (PStakeDatum :--> PBool)))
-> (Term s PPubKeyHash -> Term s PStakeDatum -> Term s PBool)
-> Term s (PPubKeyHash :--> (PStakeDatum :--> PBool))
forall a b. (a -> b) -> a -> b
$ \Term s PPubKeyHash
pk Term s PStakeDatum
stakeDatum ->
      forall (fs :: [Symbol]) (a :: PType) (s :: S) (b :: PType)
       (ps :: [PLabeledType]) (bs :: [ToBind]).
(PDataFields a,
 (ps :: [PLabeledType]) ~ (PFields a :: [PLabeledType]),
 (bs :: [ToBind]) ~ (Bindings ps fs :: [ToBind]),
 BindFields ps bs) =>
Term s a -> (HRecOf a fs s -> Term s b) -> Term s b
pletFields @'["owner"] (Term s PStakeDatum
-> forall (b :: PType). Term s (PInner PStakeDatum b)
forall (s :: S) (a :: PType).
Term s a -> forall (b :: PType). Term s (PInner a b)
pto Term s PStakeDatum
stakeDatum) ((HRec
    (BoundTerms
       (PFields (PInner PStakeDatum (Any @PType)))
       (Bindings
          (PFields (PInner PStakeDatum (Any @PType)))
          ((':) @Symbol "owner" ('[] @Symbol)))
       s)
  -> Term s PBool)
 -> Term s PBool)
-> (HRec
      (BoundTerms
         (PFields (PInner PStakeDatum (Any @PType)))
         (Bindings
            (PFields (PInner PStakeDatum (Any @PType)))
            ((':) @Symbol "owner" ('[] @Symbol)))
         s)
    -> Term s PBool)
-> Term s PBool
forall a b. (a -> b) -> a -> b
$ \HRec
  (BoundTerms
     (PFields (PInner PStakeDatum (Any @PType)))
     (Bindings
        (PFields (PInner PStakeDatum (Any @PType)))
        ((':) @Symbol "owner" ('[] @Symbol)))
     s)
stakeDatumF ->
        HRec
  (BoundTerms
     (PFields (PInner PStakeDatum (Any @PType)))
     (Bindings
        (PFields (PInner PStakeDatum (Any @PType)))
        ((':) @Symbol "owner" ('[] @Symbol)))
     s)
stakeDatumF.owner Term s (PAsData PPubKeyHash)
-> Term s (PAsData PPubKeyHash) -> Term s PBool
forall (t :: PType) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== Term s PPubKeyHash -> Term s (PAsData PPubKeyHash)
forall (a :: PType) (s :: S).
PIsData a =>
Term s a -> Term s (PAsData a)
pdata Term s PPubKeyHash
pk

{- | Does the input have a `Stake` owned by a particular PK?

     @since 0.1.0
-}
isInputStakeOwnedBy ::
  Term
    _
    ( PAssetClass :--> PPubKeyHash
        :--> PBuiltinList (PAsData (PTuple PDatumHash PDatum))
        :--> PAsData PTxInInfo
        :--> PBool
    )
isInputStakeOwnedBy :: Term
  s
  (PAssetClass
   :--> (PPubKeyHash
         :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
               :--> (PAsData PTxInInfo :--> PBool))))
isInputStakeOwnedBy =
  (Term s PAssetClass
 -> Term s PPubKeyHash
 -> Term s (PBuiltinList (PAsData (PTuple PDatumHash PDatum)))
 -> Term s (PAsData PTxInInfo)
 -> Term s PBool)
-> Term
     s
     (PAssetClass
      :--> (PPubKeyHash
            :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
                  :--> (PAsData PTxInInfo :--> PBool))))
forall a (b :: PType) (s :: S) (c :: PType).
PLamN a b s =>
(Term s c -> a) -> Term s (c :--> b)
plam ((Term s PAssetClass
  -> Term s PPubKeyHash
  -> Term s (PBuiltinList (PAsData (PTuple PDatumHash PDatum)))
  -> Term s (PAsData PTxInInfo)
  -> Term s PBool)
 -> Term
      s
      (PAssetClass
       :--> (PPubKeyHash
             :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
                   :--> (PAsData PTxInInfo :--> PBool)))))
-> (Term s PAssetClass
    -> Term s PPubKeyHash
    -> Term s (PBuiltinList (PAsData (PTuple PDatumHash PDatum)))
    -> Term s (PAsData PTxInInfo)
    -> Term s PBool)
-> Term
     s
     (PAssetClass
      :--> (PPubKeyHash
            :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
                  :--> (PAsData PTxInInfo :--> PBool))))
forall a b. (a -> b) -> a -> b
$ \Term s PAssetClass
ac Term s PPubKeyHash
ss Term s (PBuiltinList (PAsData (PTuple PDatumHash PDatum)))
datums Term s (PAsData PTxInInfo)
txInInfo' -> TermCont @PBool s (Term s PBool) -> Term s PBool
forall (a :: PType) (s :: S). TermCont @a s (Term s a) -> Term s a
unTermCont (TermCont @PBool s (Term s PBool) -> Term s PBool)
-> TermCont @PBool s (Term s PBool) -> Term s PBool
forall a b. (a -> b) -> a -> b
$ do
    PTxInInfo ((forall (name :: Symbol) (p :: PType) (s :: S) (a :: PType)
       (as :: [PLabeledType]) (n :: Nat) (b :: PType).
(PDataFields p,
 (as :: [PLabeledType]) ~ (PFields p :: [PLabeledType]),
 (n :: Nat) ~ (PLabelIndex name as :: Nat), KnownNat n,
 (a :: PType) ~ (PUnLabel (IndexList @PLabeledType n as) :: PType),
 PFromDataable a b) =>
Term s (p :--> b)
pfield @"resolved" #) -> Term s PTxOut
txOut) <- Term s PTxInInfo -> TermCont @PBool s (PTxInInfo s)
forall {r :: PType} (a :: PType) (s :: S).
PMatch a =>
Term s a -> TermCont @r s (a s)
pmatchC (Term s PTxInInfo -> TermCont @PBool s (PTxInInfo s))
-> Term s PTxInInfo -> TermCont @PBool s (PTxInInfo s)
forall a b. (a -> b) -> a -> b
$ Term s (PAsData PTxInInfo) -> Term s PTxInInfo
forall (a :: PType) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData Term s (PAsData PTxInInfo)
txInInfo'
    PTxOut Term
  s
  (PDataRecord
     ((':)
        @PLabeledType
        ("address" ':= PAddress)
        ((':)
           @PLabeledType
           ("value" ':= PValue 'Sorted 'Positive)
           ((':)
              @PLabeledType
              ("datumHash" ':= PMaybeData PDatumHash)
              ('[] @PLabeledType)))))
txOut' <- Term s PTxOut -> TermCont @PBool s (PTxOut s)
forall {r :: PType} (a :: PType) (s :: S).
PMatch a =>
Term s a -> TermCont @r s (a s)
pmatchC Term s PTxOut
txOut
    HRec
  ((':)
     @(Symbol, Type)
     '("value", Term s (PAsData (PValue 'Sorted 'Positive)))
     ((':)
        @(Symbol, Type)
        '("datumHash", Term s (PAsData (PMaybeData PDatumHash)))
        ('[] @(Symbol, Type))))
txOutF <- forall (fs :: [Symbol]) (a :: PType) (s :: S) (b :: PType)
       (ps :: [PLabeledType]) (bs :: [ToBind]).
(PDataFields a,
 (ps :: [PLabeledType]) ~ (PFields a :: [PLabeledType]),
 (bs :: [ToBind]) ~ (Bindings ps fs :: [ToBind]),
 BindFields ps bs) =>
Term s a -> TermCont @b s (HRec (BoundTerms ps bs s))
pletFieldsC @'["value", "datumHash"] Term
  s
  (PDataRecord
     ((':)
        @PLabeledType
        ("address" ':= PAddress)
        ((':)
           @PLabeledType
           ("value" ':= PValue 'Sorted 'Positive)
           ((':)
              @PLabeledType
              ("datumHash" ':= PMaybeData PDatumHash)
              ('[] @PLabeledType)))))
txOut'
    Term s (PInteger @S)
outStakeST <- Term s (PInteger @S) -> TermCont @PBool s (Term s (PInteger @S))
forall {r :: PType} (s :: S) (a :: PType).
Term s a -> TermCont @r s (Term s a)
pletC (Term s (PInteger @S) -> TermCont @PBool s (Term s (PInteger @S)))
-> Term s (PInteger @S) -> TermCont @PBool s (Term s (PInteger @S))
forall a b. (a -> b) -> a -> b
$ Term
  s (PValue 'Sorted 'Positive :--> (PAssetClass :--> PInteger @S))
forall (s :: S) (keys :: KeyGuarantees)
       (amounts :: AmountGuarantees).
Term s (PValue keys amounts :--> (PAssetClass :--> PInteger @S))
passetClassValueOf Term
  s (PValue 'Sorted 'Positive :--> (PAssetClass :--> PInteger @S))
-> Term s (PValue 'Sorted 'Positive)
-> Term s (PAssetClass :--> PInteger @S)
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# HRec
  ((':)
     @(Symbol, Type)
     '("value", Term s (PAsData (PValue 'Sorted 'Positive)))
     ((':)
        @(Symbol, Type)
        '("datumHash", Term s (PAsData (PMaybeData PDatumHash)))
        ('[] @(Symbol, Type))))
txOutF.value Term s (PAssetClass :--> PInteger @S)
-> Term s PAssetClass -> Term s (PInteger @S)
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s PAssetClass
ac
    Term s PBool -> TermCont @PBool s (Term s PBool)
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (Term s PBool -> TermCont @PBool s (Term s PBool))
-> Term s PBool -> TermCont @PBool s (Term s PBool)
forall a b. (a -> b) -> a -> b
$
      Term s (PMaybeData PDatumHash)
-> (PMaybeData PDatumHash s -> Term s PBool) -> Term s PBool
forall (a :: PType) (s :: S) (b :: PType).
PMatch a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch HRec
  ((':)
     @(Symbol, Type)
     '("value", Term s (PAsData (PValue 'Sorted 'Positive)))
     ((':)
        @(Symbol, Type)
        '("datumHash", Term s (PAsData (PMaybeData PDatumHash)))
        ('[] @(Symbol, Type))))
txOutF.datumHash ((PMaybeData PDatumHash s -> Term s PBool) -> Term s PBool)
-> (PMaybeData PDatumHash s -> Term s PBool) -> Term s PBool
forall a b. (a -> b) -> a -> b
$ \case
        PDNothing Term s (PDataRecord ('[] @PLabeledType))
_ -> PBool s -> Term s PBool
forall (a :: PType) (s :: S). PCon a => a s -> Term s a
pcon PBool s
forall (s :: S). PBool s
PFalse
        PDJust ((forall (name :: Symbol) (p :: PType) (s :: S) (a :: PType)
       (as :: [PLabeledType]) (n :: Nat) (b :: PType).
(PDataFields p,
 (as :: [PLabeledType]) ~ (PFields p :: [PLabeledType]),
 (n :: Nat) ~ (PLabelIndex name as :: Nat), KnownNat n,
 (a :: PType) ~ (PUnLabel (IndexList @PLabeledType n as) :: PType),
 PFromDataable a b) =>
Term s (p :--> b)
pfield @"_0" #) -> Term s PDatumHash
datumHash) ->
          Term s PBool -> Term s PBool -> Term s PBool -> Term s PBool
forall (s :: S) (a :: PType).
Term s PBool -> Term s a -> Term s a -> Term s a
pif
            (Term s (PInteger @S)
outStakeST Term s (PInteger @S) -> Term s (PInteger @S) -> Term s PBool
forall (t :: PType) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== Term s (PInteger @S)
1)
            ( Term s (PMaybe (PAsData PStakeDatum))
-> (PMaybe (PAsData PStakeDatum) s -> Term s PBool) -> Term s PBool
forall (a :: PType) (s :: S) (b :: PType).
PMatch a =>
Term s a -> (a s -> Term s b) -> Term s b
pmatch (forall (a :: PType) (s :: S).
PTryFrom PData a =>
Term
  s
  (PDatumHash
   :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
         :--> PMaybe a))
ptryFindDatum @(PAsData PStakeDatum) Term
  s
  (PDatumHash
   :--> (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
         :--> PMaybe (PAsData PStakeDatum)))
-> Term s PDatumHash
-> Term
     s
     (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
      :--> PMaybe (PAsData PStakeDatum))
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s PDatumHash
datumHash Term
  s
  (PBuiltinList (PAsData (PTuple PDatumHash PDatum))
   :--> PMaybe (PAsData PStakeDatum))
-> Term s (PBuiltinList (PAsData (PTuple PDatumHash PDatum)))
-> Term s (PMaybe (PAsData PStakeDatum))
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PBuiltinList (PAsData (PTuple PDatumHash PDatum)))
datums) ((PMaybe (PAsData PStakeDatum) s -> Term s PBool) -> Term s PBool)
-> (PMaybe (PAsData PStakeDatum) s -> Term s PBool) -> Term s PBool
forall a b. (a -> b) -> a -> b
$ \case
                PMaybe (PAsData PStakeDatum) s
PNothing -> PBool s -> Term s PBool
forall (a :: PType) (s :: S). PCon a => a s -> Term s a
pcon PBool s
forall (s :: S). PBool s
PFalse
                PJust Term s (PAsData PStakeDatum)
v -> Term s (PPubKeyHash :--> (PStakeDatum :--> PBool))
ClosedTerm (PPubKeyHash :--> (PStakeDatum :--> PBool))
stakeDatumOwnedBy Term s (PPubKeyHash :--> (PStakeDatum :--> PBool))
-> Term s PPubKeyHash -> Term s (PStakeDatum :--> PBool)
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s PPubKeyHash
ss Term s (PStakeDatum :--> PBool)
-> Term s PStakeDatum -> Term s PBool
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PAsData PStakeDatum) -> Term s PStakeDatum
forall (a :: PType) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (Term s (PAsData PStakeDatum) -> Term s (PAsData PStakeDatum)
forall (s :: S) (a :: PType) (b :: PType). Term s a -> Term s b
punsafeCoerce Term s (PAsData PStakeDatum)
v)
            )
            (PBool s -> Term s PBool
forall (a :: PType) (s :: S). PCon a => a s -> Term s a
pcon PBool s
forall (s :: S). PBool s
PFalse)

{- | Represent the usage of a stake on a particular proposal.
     A stake can be used to either create or vote on a proposal.

     @since 0.1.0
-}
data PStakeUsage (s :: S)
  = PVotedFor (Term s PResultTag)
  | PCreated
  | PDidNothing
  deriving stock
    ( -- | @since 0.1.0
      (forall x. PStakeUsage s -> Rep (PStakeUsage s) x)
-> (forall x. Rep (PStakeUsage s) x -> PStakeUsage s)
-> Generic (PStakeUsage s)
forall x. Rep (PStakeUsage s) x -> PStakeUsage s
forall x. PStakeUsage s -> Rep (PStakeUsage s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: S) x. Rep (PStakeUsage s) x -> PStakeUsage s
forall (s :: S) x. PStakeUsage s -> Rep (PStakeUsage s) x
$cto :: forall (s :: S) x. Rep (PStakeUsage s) x -> PStakeUsage s
$cfrom :: forall (s :: S) x. PStakeUsage s -> Rep (PStakeUsage s) x
GHC.Generic
    )
  deriving anyclass
    ( -- | @since 0.1.0
      All @[Type] (SListI @Type) (Code (PStakeUsage s))
All @[Type] (SListI @Type) (Code (PStakeUsage s))
-> (PStakeUsage s -> Rep (PStakeUsage s))
-> (Rep (PStakeUsage s) -> PStakeUsage s)
-> Generic (PStakeUsage s)
Rep (PStakeUsage s) -> PStakeUsage s
PStakeUsage s -> Rep (PStakeUsage s)
forall a.
All @[Type] (SListI @Type) (Code a)
-> (a -> Rep a) -> (Rep a -> a) -> Generic a
forall {s :: S}. All @[Type] (SListI @Type) (Code (PStakeUsage s))
forall (s :: S). Rep (PStakeUsage s) -> PStakeUsage s
forall (s :: S). PStakeUsage s -> Rep (PStakeUsage s)
to :: Rep (PStakeUsage s) -> PStakeUsage s
$cto :: forall (s :: S). Rep (PStakeUsage s) -> PStakeUsage s
from :: PStakeUsage s -> Rep (PStakeUsage s)
$cfrom :: forall (s :: S). PStakeUsage s -> Rep (PStakeUsage s)
Generic
    , -- | @since 0.1.0
      PCon PStakeUsage
PMatch PStakeUsage
PCon PStakeUsage
-> PMatch PStakeUsage
-> (forall (s :: S) (b :: PType).
    PStakeUsage s -> Term s (PInner PStakeUsage b))
-> (forall (s :: S) (b :: PType).
    Term s (PInner PStakeUsage b)
    -> (PStakeUsage s -> Term s b) -> Term s b)
-> PlutusType PStakeUsage
forall (s :: S) (b :: PType).
Term s (PInner PStakeUsage b)
-> (PStakeUsage s -> Term s b) -> Term s b
forall (s :: S) (b :: PType).
PStakeUsage s -> Term s (PInner PStakeUsage b)
forall (a :: PType).
PCon a
-> PMatch a
-> (forall (s :: S) (b :: PType). a s -> Term s (PInner a b))
-> (forall (s :: S) (b :: PType).
    Term s (PInner a b) -> (a s -> Term s b) -> Term s b)
-> PlutusType a
pmatch' :: forall (s :: S) (b :: PType).
Term s (PInner PStakeUsage b)
-> (PStakeUsage s -> Term s b) -> Term s b
$cpmatch' :: forall (s :: S) (b :: PType).
Term s (PInner PStakeUsage b)
-> (PStakeUsage s -> Term s b) -> Term s b
pcon' :: forall (s :: S) (b :: PType).
PStakeUsage s -> Term s (PInner PStakeUsage b)
$cpcon' :: forall (s :: S) (b :: PType).
PStakeUsage s -> Term s (PInner PStakeUsage b)
PlutusType
    , -- | @since 0.1.0
      Generic (PStakeUsage s)
Generic (PStakeUsage s)
-> (forall (proxy :: Type -> Type).
    proxy (PStakeUsage s) -> DatatypeInfo (Code (PStakeUsage s)))
-> HasDatatypeInfo (PStakeUsage s)
forall a.
Generic a
-> (forall (proxy :: Type -> Type).
    proxy a -> DatatypeInfo (Code a))
-> HasDatatypeInfo a
forall (s :: S). Generic (PStakeUsage s)
forall (s :: S) (proxy :: Type -> Type).
proxy (PStakeUsage s) -> DatatypeInfo (Code (PStakeUsage s))
forall (proxy :: Type -> Type).
proxy (PStakeUsage s) -> DatatypeInfo (Code (PStakeUsage s))
datatypeInfo :: forall (proxy :: Type -> Type).
proxy (PStakeUsage s) -> DatatypeInfo (Code (PStakeUsage s))
$cdatatypeInfo :: forall (s :: S) (proxy :: Type -> Type).
proxy (PStakeUsage s) -> DatatypeInfo (Code (PStakeUsage s))
HasDatatypeInfo
    , -- | @since 0.1.0
      (forall (s :: S).
 Term s PStakeUsage -> Term s PStakeUsage -> Term s PBool)
-> PEq PStakeUsage
forall (s :: S).
Term s PStakeUsage -> Term s PStakeUsage -> Term s PBool
forall (t :: PType).
(forall (s :: S). Term s t -> Term s t -> Term s PBool) -> PEq t
#== :: forall (s :: S).
Term s PStakeUsage -> Term s PStakeUsage -> Term s PBool
$c#== :: forall (s :: S).
Term s PStakeUsage -> Term s PStakeUsage -> Term s PBool
PEq
    )

{- | / O(n) /.Return the usage of a stake on a particular proposal,
     given the 'lockedBy' field of a stake and the target proposal.

     @since 0.1.0
-}
pgetStakeUsage ::
  Term
    _
    ( PBuiltinList (PAsData PProposalLock)
        :--> PProposalId
        :--> PStakeUsage
    )
pgetStakeUsage :: Term
  w
  (PBuiltinList (PAsData PProposalLock)
   :--> (PProposalId :--> PStakeUsage))
pgetStakeUsage = ClosedTerm
  (PBuiltinList (PAsData PProposalLock)
   :--> (PProposalId :--> PStakeUsage))
-> Term
     w
     (PBuiltinList (PAsData PProposalLock)
      :--> (PProposalId :--> PStakeUsage))
forall (a :: PType) (s :: S).
HasCallStack =>
ClosedTerm a -> Term s a
phoistAcyclic (ClosedTerm
   (PBuiltinList (PAsData PProposalLock)
    :--> (PProposalId :--> PStakeUsage))
 -> Term
      w
      (PBuiltinList (PAsData PProposalLock)
       :--> (PProposalId :--> PStakeUsage)))
-> ClosedTerm
     (PBuiltinList (PAsData PProposalLock)
      :--> (PProposalId :--> PStakeUsage))
-> Term
     w
     (PBuiltinList (PAsData PProposalLock)
      :--> (PProposalId :--> PStakeUsage))
forall a b. (a -> b) -> a -> b
$
  (Term s (PBuiltinList (PAsData PProposalLock))
 -> Term s PProposalId -> Term s PStakeUsage)
-> Term
     s
     (PBuiltinList (PAsData PProposalLock)
      :--> (PProposalId :--> PStakeUsage))
forall a (b :: PType) (s :: S) (c :: PType).
PLamN a b s =>
(Term s c -> a) -> Term s (c :--> b)
plam ((Term s (PBuiltinList (PAsData PProposalLock))
  -> Term s PProposalId -> Term s PStakeUsage)
 -> Term
      s
      (PBuiltinList (PAsData PProposalLock)
       :--> (PProposalId :--> PStakeUsage)))
-> (Term s (PBuiltinList (PAsData PProposalLock))
    -> Term s PProposalId -> Term s PStakeUsage)
-> Term
     s
     (PBuiltinList (PAsData PProposalLock)
      :--> (PProposalId :--> PStakeUsage))
forall a b. (a -> b) -> a -> b
$ \Term s (PBuiltinList (PAsData PProposalLock))
locks Term s PProposalId
pid ->
    let -- All locks from the given proposal.
        filteredLocks :: Term s (PBuiltinList (PAsData PProposalLock))
filteredLocks =
          Term
  s
  ((PAsData PProposalLock :--> PMaybe (PAsData PProposalLock))
   :--> (PBuiltinList (PAsData PProposalLock)
         :--> PBuiltinList (PAsData PProposalLock)))
forall (a :: PType) (s :: S) (list :: PType -> PType).
PIsListLike list a =>
Term s ((a :--> PMaybe a) :--> (list a :--> list a))
pmapMaybe
            # plam
              ( \lock'@(pfromData -> lock) -> unTermCont $ do
                  lockF <- pletFieldsC @'["proposalTag"] lock

                  pure $
                    pif
                      (lockF.proposalTag #== pid)
                      (pcon $ PJust lock')
                      (pcon PNothing)
              )
            # locks

        lockCount' :: Term s (PInteger @S)
lockCount' = Term s (PBuiltinList (PAsData PProposalLock) :--> PInteger @S)
forall (list :: PType -> PType) (a :: PType) (s :: S).
PIsListLike list a =>
Term s (list a :--> PInteger @S)
plength Term s (PBuiltinList (PAsData PProposalLock) :--> PInteger @S)
-> Term s (PBuiltinList (PAsData PProposalLock))
-> Term s (PInteger @S)
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PBuiltinList (PAsData PProposalLock))
filteredLocks
     in Term s (PInteger @S)
-> (Term s (PInteger @S) -> Term s PStakeUsage)
-> Term s PStakeUsage
forall (s :: S) (a :: PType) (b :: PType).
Term s a -> (Term s a -> Term s b) -> Term s b
plet Term s (PInteger @S)
lockCount' ((Term s (PInteger @S) -> Term s PStakeUsage)
 -> Term s PStakeUsage)
-> (Term s (PInteger @S) -> Term s PStakeUsage)
-> Term s PStakeUsage
forall a b. (a -> b) -> a -> b
$ \Term s (PInteger @S)
lockCount ->
          Term s PBool
-> Term s PStakeUsage -> Term s PStakeUsage -> Term s PStakeUsage
forall (s :: S) (a :: PType).
Term s PBool -> Term s a -> Term s a -> Term s a
pif (Term s (PInteger @S)
lockCount Term s (PInteger @S) -> Term s (PInteger @S) -> Term s PBool
forall (t :: PType) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== Term s (PInteger @S)
0) (PStakeUsage s -> Term s PStakeUsage
forall (a :: PType) (s :: S). PCon a => a s -> Term s a
pcon PStakeUsage s
forall (s :: S). PStakeUsage s
PDidNothing) (Term s PStakeUsage -> Term s PStakeUsage)
-> Term s PStakeUsage -> Term s PStakeUsage
forall a b. (a -> b) -> a -> b
$
            Term s PBool
-> Term s PStakeUsage -> Term s PStakeUsage -> Term s PStakeUsage
forall (s :: S) (a :: PType).
Term s PBool -> Term s a -> Term s a -> Term s a
pif
              (Term s (PInteger @S)
lockCount Term s (PInteger @S) -> Term s (PInteger @S) -> Term s PBool
forall (t :: PType) (s :: S).
PEq t =>
Term s t -> Term s t -> Term s PBool
#== Term s (PInteger @S)
1)
              ( PStakeUsage s -> Term s PStakeUsage
forall (a :: PType) (s :: S). PCon a => a s -> Term s a
pcon (PStakeUsage s -> Term s PStakeUsage)
-> PStakeUsage s -> Term s PStakeUsage
forall a b. (a -> b) -> a -> b
$
                  Term s PResultTag -> PStakeUsage s
forall (s :: S). Term s PResultTag -> PStakeUsage s
PVotedFor (Term s PResultTag -> PStakeUsage s)
-> Term s PResultTag -> PStakeUsage s
forall a b. (a -> b) -> a -> b
$
                    Term s (PAsData PResultTag) -> Term s PResultTag
forall (a :: PType) (s :: S).
PIsData a =>
Term s (PAsData a) -> Term s a
pfromData (Term s (PAsData PResultTag) -> Term s PResultTag)
-> Term s (PAsData PResultTag) -> Term s PResultTag
forall a b. (a -> b) -> a -> b
$
                      forall (name :: Symbol) (p :: PType) (s :: S) (a :: PType)
       (as :: [PLabeledType]) (n :: Nat) (b :: PType).
(PDataFields p,
 (as :: [PLabeledType]) ~ (PFields p :: [PLabeledType]),
 (n :: Nat) ~ (PLabelIndex name as :: Nat), KnownNat n,
 (a :: PType) ~ (PUnLabel (IndexList @PLabeledType n as) :: PType),
 PFromDataable a b) =>
Term s (p :--> b)
pfield @"vote" Term s (PAsData PProposalLock :--> PAsData PResultTag)
-> Term s (PAsData PProposalLock) -> Term s (PAsData PResultTag)
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
#$ Term
  s (PBuiltinList (PAsData PProposalLock) :--> PAsData PProposalLock)
forall (list :: PType -> PType) (a :: PType) (s :: S).
(PListLike list, PElemConstraint list a) =>
Term s (list a :--> a)
phead Term
  s (PBuiltinList (PAsData PProposalLock) :--> PAsData PProposalLock)
-> Term s (PBuiltinList (PAsData PProposalLock))
-> Term s (PAsData PProposalLock)
forall (s :: S) (a :: PType) (b :: PType).
Term s (a :--> b) -> Term s a -> Term s b
# Term s (PBuiltinList (PAsData PProposalLock))
filteredLocks
              )
              -- Note: see the implementation of the governor.
              (PStakeUsage s -> Term s PStakeUsage
forall (a :: PType) (s :: S). PCon a => a s -> Term s a
pcon PStakeUsage s
forall (s :: S). PStakeUsage s
PCreated)