-- editorconfig-checker-disable-file
{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE ViewPatterns #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -Wno-simplifiable-class-constraints #-}
{-# OPTIONS_GHC -fno-omit-interface-pragmas #-}
{-# OPTIONS_GHC -fno-specialise #-}
{-# OPTIONS_GHC -fno-strictness #-}

module PlutusLedgerApi.V4.Contexts
  ( AccountId (..)
  , AccountBalanceInterval (..)
  , AccountBalanceIntervals (..)
  , ColdCommitteeCredential (..)
  , HotCommitteeCredential (..)
  , DRepCredential (..)
  , DRep (..)
  , Delegatee (..)
  , TxCert (..)
  , Voter (..)
  , Vote (..)
  , GovernanceActionId (GovernanceActionId, gaidTxId, gaidGovActionIx)
  , Committee (Committee, committeeMembers, committeeQuorum)
  , Constitution (..)
  , ProtocolVersion (ProtocolVersion, pvMajor, pvMinor)
  , ChangedParameters (..)
  , GovernanceAction (..)
  , ProposalProcedure (ProposalProcedure, ppDeposit, ppReturnAddr, ppGovernanceAction)
  , ScriptPurpose (..)
  , ScriptInfo (..)
  , TxInInfo (..)
  , TxInfo (..)
  , TopTxInfoSimplified (..)
  , TopTxInfo (..)
  , ScriptContext (..)
  , findOwnInput
  , findDatum
  , findDatumHash
  , findTxInByTxOutRef
  , findContinuingOutputs
  , getContinuingOutputs
  , txSignedBy
  , pubKeyOutputsAt
  , valuePaidTo
  , valueSpent
  , valueProduced
  , ownCurrencySymbol
  , spendsOutput
  ) where

import Data.Function ((&))
import GHC.Generics (Generic)
import PlutusLedgerApi.V2 qualified as V2
import PlutusLedgerApi.V3.Contexts
  ( ChangedParameters (..)
  , ColdCommitteeCredential (..)
  , DRep (..)
  , DRepCredential (..)
  , Delegatee (..)
  , HotCommitteeCredential (..)
  , Vote (..)
  , Voter (..)
  )
import PlutusLedgerApi.V3.Contexts qualified as V3
import PlutusLedgerApi.V3.MintValue qualified as V3
import PlutusLedgerApi.V3.Tx qualified as V3
import PlutusLedgerApi.V4.Address (AccountId (..), Address (..))
import PlutusLedgerApi.V4.Internal (ListEncoded (..))
import PlutusLedgerApi.V4.Ratio (Rational)
import PlutusLedgerApi.V4.Time (POSIXTimeRange)
import PlutusLedgerApi.V4.Tx (TxOut (..), TxOutRef (..))
import PlutusTx (makeIsDataSchemaAsList, makeIsDataSchemaIndexed)
import PlutusTx qualified
import PlutusTx.AssocMap (Map, lookup, toList)
import PlutusTx.Blueprint
  ( HasBlueprintSchema
  , SchemaInfo (..)
  )
import PlutusTx.Blueprint.Class (HasBlueprintSchema (..))
import PlutusTx.Blueprint.Definition (HasBlueprintDefinition (..), UnrollAll)
import PlutusTx.Blueprint.Definition.Derive (definitionRef)
import PlutusTx.Blueprint.Schema (withSchemaInfo)
import PlutusTx.Foldable qualified as F
import PlutusTx.Lift (makeLift)
import PlutusTx.List qualified as List
import PlutusTx.Prelude qualified as PlutusTx
import Prettyprinter (nest, vsep, (<+>))
import Prettyprinter.Extras (Pretty (pretty), PrettyShow (PrettyShow))
import Prelude qualified as Haskell

newtype GovernanceActionId = GovernanceActionIdValue V3.GovernanceActionId
  deriving stock ((forall x. GovernanceActionId -> Rep GovernanceActionId x)
-> (forall x. Rep GovernanceActionId x -> GovernanceActionId)
-> Generic GovernanceActionId
forall x. Rep GovernanceActionId x -> GovernanceActionId
forall x. GovernanceActionId -> Rep GovernanceActionId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GovernanceActionId -> Rep GovernanceActionId x
from :: forall x. GovernanceActionId -> Rep GovernanceActionId x
$cto :: forall x. Rep GovernanceActionId x -> GovernanceActionId
to :: forall x. Rep GovernanceActionId x -> GovernanceActionId
Generic)
  deriving newtype (Int -> GovernanceActionId -> ShowS
[GovernanceActionId] -> ShowS
GovernanceActionId -> String
(Int -> GovernanceActionId -> ShowS)
-> (GovernanceActionId -> String)
-> ([GovernanceActionId] -> ShowS)
-> Show GovernanceActionId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GovernanceActionId -> ShowS
showsPrec :: Int -> GovernanceActionId -> ShowS
$cshow :: GovernanceActionId -> String
show :: GovernanceActionId -> String
$cshowList :: [GovernanceActionId] -> ShowS
showList :: [GovernanceActionId] -> ShowS
Haskell.Show, GovernanceActionId -> GovernanceActionId -> Bool
(GovernanceActionId -> GovernanceActionId -> Bool)
-> (GovernanceActionId -> GovernanceActionId -> Bool)
-> Eq GovernanceActionId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GovernanceActionId -> GovernanceActionId -> Bool
== :: GovernanceActionId -> GovernanceActionId -> Bool
$c/= :: GovernanceActionId -> GovernanceActionId -> Bool
/= :: GovernanceActionId -> GovernanceActionId -> Bool
Haskell.Eq, Eq GovernanceActionId
Eq GovernanceActionId =>
(GovernanceActionId -> GovernanceActionId -> Ordering)
-> (GovernanceActionId -> GovernanceActionId -> Bool)
-> (GovernanceActionId -> GovernanceActionId -> Bool)
-> (GovernanceActionId -> GovernanceActionId -> Bool)
-> (GovernanceActionId -> GovernanceActionId -> Bool)
-> (GovernanceActionId -> GovernanceActionId -> GovernanceActionId)
-> (GovernanceActionId -> GovernanceActionId -> GovernanceActionId)
-> Ord GovernanceActionId
GovernanceActionId -> GovernanceActionId -> Bool
GovernanceActionId -> GovernanceActionId -> Ordering
GovernanceActionId -> GovernanceActionId -> GovernanceActionId
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: GovernanceActionId -> GovernanceActionId -> Ordering
compare :: GovernanceActionId -> GovernanceActionId -> Ordering
$c< :: GovernanceActionId -> GovernanceActionId -> Bool
< :: GovernanceActionId -> GovernanceActionId -> Bool
$c<= :: GovernanceActionId -> GovernanceActionId -> Bool
<= :: GovernanceActionId -> GovernanceActionId -> Bool
$c> :: GovernanceActionId -> GovernanceActionId -> Bool
> :: GovernanceActionId -> GovernanceActionId -> Bool
$c>= :: GovernanceActionId -> GovernanceActionId -> Bool
>= :: GovernanceActionId -> GovernanceActionId -> Bool
$cmax :: GovernanceActionId -> GovernanceActionId -> GovernanceActionId
max :: GovernanceActionId -> GovernanceActionId -> GovernanceActionId
$cmin :: GovernanceActionId -> GovernanceActionId -> GovernanceActionId
min :: GovernanceActionId -> GovernanceActionId -> GovernanceActionId
Haskell.Ord, (forall ann. GovernanceActionId -> Doc ann)
-> (forall ann. [GovernanceActionId] -> Doc ann)
-> Pretty GovernanceActionId
forall ann. [GovernanceActionId] -> Doc ann
forall ann. GovernanceActionId -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
$cpretty :: forall ann. GovernanceActionId -> Doc ann
pretty :: forall ann. GovernanceActionId -> Doc ann
$cprettyList :: forall ann. [GovernanceActionId] -> Doc ann
prettyList :: forall ann. [GovernanceActionId] -> Doc ann
Pretty, GovernanceActionId -> GovernanceActionId -> Bool
(GovernanceActionId -> GovernanceActionId -> Bool)
-> Eq GovernanceActionId
forall a. (a -> a -> Bool) -> Eq a
$c== :: GovernanceActionId -> GovernanceActionId -> Bool
== :: GovernanceActionId -> GovernanceActionId -> Bool
PlutusTx.Eq)
  deriving
    (GovernanceActionId -> BuiltinData
(GovernanceActionId -> BuiltinData) -> ToData GovernanceActionId
forall a. (a -> BuiltinData) -> ToData a
$ctoBuiltinData :: GovernanceActionId -> BuiltinData
toBuiltinData :: GovernanceActionId -> BuiltinData
PlutusTx.ToData, BuiltinData -> Maybe GovernanceActionId
(BuiltinData -> Maybe GovernanceActionId)
-> FromData GovernanceActionId
forall a. (BuiltinData -> Maybe a) -> FromData a
$cfromBuiltinData :: BuiltinData -> Maybe GovernanceActionId
fromBuiltinData :: BuiltinData -> Maybe GovernanceActionId
PlutusTx.FromData, BuiltinData -> GovernanceActionId
(BuiltinData -> GovernanceActionId)
-> UnsafeFromData GovernanceActionId
forall a. (BuiltinData -> a) -> UnsafeFromData a
$cunsafeFromBuiltinData :: BuiltinData -> GovernanceActionId
unsafeFromBuiltinData :: BuiltinData -> GovernanceActionId
PlutusTx.UnsafeFromData)
    via ListEncoded V3.GovernanceActionId

pattern GovernanceActionId :: V3.TxId -> Haskell.Integer -> GovernanceActionId
pattern $mGovernanceActionId :: forall {r}.
GovernanceActionId -> (TxId -> Integer -> r) -> ((# #) -> r) -> r
$bGovernanceActionId :: TxId -> Integer -> GovernanceActionId
GovernanceActionId {GovernanceActionId -> TxId
gaidTxId, GovernanceActionId -> Integer
gaidGovActionIx} =
  GovernanceActionIdValue (V3.GovernanceActionId gaidTxId gaidGovActionIx)
{-# COMPLETE GovernanceActionId #-}

instance HasBlueprintDefinition GovernanceActionId where
  type Unroll GovernanceActionId = GovernanceActionId ': UnrollAll '[V3.TxId, Haskell.Integer]

instance
  HasBlueprintSchema V3.GovernanceActionId referencedTypes
  => HasBlueprintSchema GovernanceActionId referencedTypes
  where
  schema :: Schema referencedTypes
schema = forall t (referencedTypes :: [*]).
HasBlueprintSchema t referencedTypes =>
Schema referencedTypes
schema @(ListEncoded V3.GovernanceActionId) @referencedTypes

PlutusTx.makeLift ''GovernanceActionId

newtype ProtocolVersion = ProtocolVersionValue V3.ProtocolVersion
  deriving stock ((forall x. ProtocolVersion -> Rep ProtocolVersion x)
-> (forall x. Rep ProtocolVersion x -> ProtocolVersion)
-> Generic ProtocolVersion
forall x. Rep ProtocolVersion x -> ProtocolVersion
forall x. ProtocolVersion -> Rep ProtocolVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ProtocolVersion -> Rep ProtocolVersion x
from :: forall x. ProtocolVersion -> Rep ProtocolVersion x
$cto :: forall x. Rep ProtocolVersion x -> ProtocolVersion
to :: forall x. Rep ProtocolVersion x -> ProtocolVersion
Generic)
  deriving newtype (Int -> ProtocolVersion -> ShowS
[ProtocolVersion] -> ShowS
ProtocolVersion -> String
(Int -> ProtocolVersion -> ShowS)
-> (ProtocolVersion -> String)
-> ([ProtocolVersion] -> ShowS)
-> Show ProtocolVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProtocolVersion -> ShowS
showsPrec :: Int -> ProtocolVersion -> ShowS
$cshow :: ProtocolVersion -> String
show :: ProtocolVersion -> String
$cshowList :: [ProtocolVersion] -> ShowS
showList :: [ProtocolVersion] -> ShowS
Haskell.Show, ProtocolVersion -> ProtocolVersion -> Bool
(ProtocolVersion -> ProtocolVersion -> Bool)
-> (ProtocolVersion -> ProtocolVersion -> Bool)
-> Eq ProtocolVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProtocolVersion -> ProtocolVersion -> Bool
== :: ProtocolVersion -> ProtocolVersion -> Bool
$c/= :: ProtocolVersion -> ProtocolVersion -> Bool
/= :: ProtocolVersion -> ProtocolVersion -> Bool
Haskell.Eq, Eq ProtocolVersion
Eq ProtocolVersion =>
(ProtocolVersion -> ProtocolVersion -> Ordering)
-> (ProtocolVersion -> ProtocolVersion -> Bool)
-> (ProtocolVersion -> ProtocolVersion -> Bool)
-> (ProtocolVersion -> ProtocolVersion -> Bool)
-> (ProtocolVersion -> ProtocolVersion -> Bool)
-> (ProtocolVersion -> ProtocolVersion -> ProtocolVersion)
-> (ProtocolVersion -> ProtocolVersion -> ProtocolVersion)
-> Ord ProtocolVersion
ProtocolVersion -> ProtocolVersion -> Bool
ProtocolVersion -> ProtocolVersion -> Ordering
ProtocolVersion -> ProtocolVersion -> ProtocolVersion
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ProtocolVersion -> ProtocolVersion -> Ordering
compare :: ProtocolVersion -> ProtocolVersion -> Ordering
$c< :: ProtocolVersion -> ProtocolVersion -> Bool
< :: ProtocolVersion -> ProtocolVersion -> Bool
$c<= :: ProtocolVersion -> ProtocolVersion -> Bool
<= :: ProtocolVersion -> ProtocolVersion -> Bool
$c> :: ProtocolVersion -> ProtocolVersion -> Bool
> :: ProtocolVersion -> ProtocolVersion -> Bool
$c>= :: ProtocolVersion -> ProtocolVersion -> Bool
>= :: ProtocolVersion -> ProtocolVersion -> Bool
$cmax :: ProtocolVersion -> ProtocolVersion -> ProtocolVersion
max :: ProtocolVersion -> ProtocolVersion -> ProtocolVersion
$cmin :: ProtocolVersion -> ProtocolVersion -> ProtocolVersion
min :: ProtocolVersion -> ProtocolVersion -> ProtocolVersion
Haskell.Ord, (forall ann. ProtocolVersion -> Doc ann)
-> (forall ann. [ProtocolVersion] -> Doc ann)
-> Pretty ProtocolVersion
forall ann. [ProtocolVersion] -> Doc ann
forall ann. ProtocolVersion -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
$cpretty :: forall ann. ProtocolVersion -> Doc ann
pretty :: forall ann. ProtocolVersion -> Doc ann
$cprettyList :: forall ann. [ProtocolVersion] -> Doc ann
prettyList :: forall ann. [ProtocolVersion] -> Doc ann
Pretty, ProtocolVersion -> ProtocolVersion -> Bool
(ProtocolVersion -> ProtocolVersion -> Bool) -> Eq ProtocolVersion
forall a. (a -> a -> Bool) -> Eq a
$c== :: ProtocolVersion -> ProtocolVersion -> Bool
== :: ProtocolVersion -> ProtocolVersion -> Bool
PlutusTx.Eq, Eq ProtocolVersion
Eq ProtocolVersion =>
(ProtocolVersion -> ProtocolVersion -> Ordering)
-> (ProtocolVersion -> ProtocolVersion -> Bool)
-> (ProtocolVersion -> ProtocolVersion -> Bool)
-> (ProtocolVersion -> ProtocolVersion -> Bool)
-> (ProtocolVersion -> ProtocolVersion -> Bool)
-> (ProtocolVersion -> ProtocolVersion -> ProtocolVersion)
-> (ProtocolVersion -> ProtocolVersion -> ProtocolVersion)
-> Ord ProtocolVersion
ProtocolVersion -> ProtocolVersion -> Bool
ProtocolVersion -> ProtocolVersion -> Ordering
ProtocolVersion -> ProtocolVersion -> ProtocolVersion
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ProtocolVersion -> ProtocolVersion -> Ordering
compare :: ProtocolVersion -> ProtocolVersion -> Ordering
$c< :: ProtocolVersion -> ProtocolVersion -> Bool
< :: ProtocolVersion -> ProtocolVersion -> Bool
$c<= :: ProtocolVersion -> ProtocolVersion -> Bool
<= :: ProtocolVersion -> ProtocolVersion -> Bool
$c> :: ProtocolVersion -> ProtocolVersion -> Bool
> :: ProtocolVersion -> ProtocolVersion -> Bool
$c>= :: ProtocolVersion -> ProtocolVersion -> Bool
>= :: ProtocolVersion -> ProtocolVersion -> Bool
$cmax :: ProtocolVersion -> ProtocolVersion -> ProtocolVersion
max :: ProtocolVersion -> ProtocolVersion -> ProtocolVersion
$cmin :: ProtocolVersion -> ProtocolVersion -> ProtocolVersion
min :: ProtocolVersion -> ProtocolVersion -> ProtocolVersion
PlutusTx.Ord)
  deriving
    (ProtocolVersion -> BuiltinData
(ProtocolVersion -> BuiltinData) -> ToData ProtocolVersion
forall a. (a -> BuiltinData) -> ToData a
$ctoBuiltinData :: ProtocolVersion -> BuiltinData
toBuiltinData :: ProtocolVersion -> BuiltinData
PlutusTx.ToData, BuiltinData -> Maybe ProtocolVersion
(BuiltinData -> Maybe ProtocolVersion) -> FromData ProtocolVersion
forall a. (BuiltinData -> Maybe a) -> FromData a
$cfromBuiltinData :: BuiltinData -> Maybe ProtocolVersion
fromBuiltinData :: BuiltinData -> Maybe ProtocolVersion
PlutusTx.FromData, BuiltinData -> ProtocolVersion
(BuiltinData -> ProtocolVersion) -> UnsafeFromData ProtocolVersion
forall a. (BuiltinData -> a) -> UnsafeFromData a
$cunsafeFromBuiltinData :: BuiltinData -> ProtocolVersion
unsafeFromBuiltinData :: BuiltinData -> ProtocolVersion
PlutusTx.UnsafeFromData)
    via ListEncoded V3.ProtocolVersion

pattern ProtocolVersion :: Haskell.Integer -> Haskell.Integer -> ProtocolVersion
pattern $mProtocolVersion :: forall {r}.
ProtocolVersion -> (Integer -> Integer -> r) -> ((# #) -> r) -> r
$bProtocolVersion :: Integer -> Integer -> ProtocolVersion
ProtocolVersion {ProtocolVersion -> Integer
pvMajor, ProtocolVersion -> Integer
pvMinor} = ProtocolVersionValue (V3.ProtocolVersion pvMajor pvMinor)
{-# COMPLETE ProtocolVersion #-}

instance HasBlueprintDefinition ProtocolVersion where
  type Unroll ProtocolVersion = '[ProtocolVersion, Haskell.Integer]

instance
  HasBlueprintSchema V3.ProtocolVersion referencedTypes
  => HasBlueprintSchema ProtocolVersion referencedTypes
  where
  schema :: Schema referencedTypes
schema = forall t (referencedTypes :: [*]).
HasBlueprintSchema t referencedTypes =>
Schema referencedTypes
schema @(ListEncoded V3.ProtocolVersion) @referencedTypes

PlutusTx.makeLift ''ProtocolVersion

newtype Constitution = Constitution {Constitution -> Maybe ScriptHash
constitutionScript :: Haskell.Maybe V2.ScriptHash}
  deriving stock ((forall x. Constitution -> Rep Constitution x)
-> (forall x. Rep Constitution x -> Constitution)
-> Generic Constitution
forall x. Rep Constitution x -> Constitution
forall x. Constitution -> Rep Constitution x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Constitution -> Rep Constitution x
from :: forall x. Constitution -> Rep Constitution x
$cto :: forall x. Rep Constitution x -> Constitution
to :: forall x. Rep Constitution x -> Constitution
Generic)
  deriving newtype (Int -> Constitution -> ShowS
[Constitution] -> ShowS
Constitution -> String
(Int -> Constitution -> ShowS)
-> (Constitution -> String)
-> ([Constitution] -> ShowS)
-> Show Constitution
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Constitution -> ShowS
showsPrec :: Int -> Constitution -> ShowS
$cshow :: Constitution -> String
show :: Constitution -> String
$cshowList :: [Constitution] -> ShowS
showList :: [Constitution] -> ShowS
Haskell.Show, Constitution -> Constitution -> Bool
(Constitution -> Constitution -> Bool)
-> (Constitution -> Constitution -> Bool) -> Eq Constitution
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Constitution -> Constitution -> Bool
== :: Constitution -> Constitution -> Bool
$c/= :: Constitution -> Constitution -> Bool
/= :: Constitution -> Constitution -> Bool
Haskell.Eq, Eq Constitution
Eq Constitution =>
(Constitution -> Constitution -> Ordering)
-> (Constitution -> Constitution -> Bool)
-> (Constitution -> Constitution -> Bool)
-> (Constitution -> Constitution -> Bool)
-> (Constitution -> Constitution -> Bool)
-> (Constitution -> Constitution -> Constitution)
-> (Constitution -> Constitution -> Constitution)
-> Ord Constitution
Constitution -> Constitution -> Bool
Constitution -> Constitution -> Ordering
Constitution -> Constitution -> Constitution
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Constitution -> Constitution -> Ordering
compare :: Constitution -> Constitution -> Ordering
$c< :: Constitution -> Constitution -> Bool
< :: Constitution -> Constitution -> Bool
$c<= :: Constitution -> Constitution -> Bool
<= :: Constitution -> Constitution -> Bool
$c> :: Constitution -> Constitution -> Bool
> :: Constitution -> Constitution -> Bool
$c>= :: Constitution -> Constitution -> Bool
>= :: Constitution -> Constitution -> Bool
$cmax :: Constitution -> Constitution -> Constitution
max :: Constitution -> Constitution -> Constitution
$cmin :: Constitution -> Constitution -> Constitution
min :: Constitution -> Constitution -> Constitution
Haskell.Ord, Constitution -> Constitution -> Bool
(Constitution -> Constitution -> Bool) -> Eq Constitution
forall a. (a -> a -> Bool) -> Eq a
$c== :: Constitution -> Constitution -> Bool
== :: Constitution -> Constitution -> Bool
PlutusTx.Eq)
  deriving anyclass (DefinitionId
DefinitionId -> HasBlueprintDefinition Constitution
forall t. DefinitionId -> HasBlueprintDefinition t
$cdefinitionId :: DefinitionId
definitionId :: DefinitionId
HasBlueprintDefinition)
  deriving
    (Constitution -> BuiltinData
(Constitution -> BuiltinData) -> ToData Constitution
forall a. (a -> BuiltinData) -> ToData a
$ctoBuiltinData :: Constitution -> BuiltinData
toBuiltinData :: Constitution -> BuiltinData
PlutusTx.ToData, BuiltinData -> Maybe Constitution
(BuiltinData -> Maybe Constitution) -> FromData Constitution
forall a. (BuiltinData -> Maybe a) -> FromData a
$cfromBuiltinData :: BuiltinData -> Maybe Constitution
fromBuiltinData :: BuiltinData -> Maybe Constitution
PlutusTx.FromData, BuiltinData -> Constitution
(BuiltinData -> Constitution) -> UnsafeFromData Constitution
forall a. (BuiltinData -> a) -> UnsafeFromData a
$cunsafeFromBuiltinData :: BuiltinData -> Constitution
unsafeFromBuiltinData :: BuiltinData -> Constitution
PlutusTx.UnsafeFromData)
    via ListEncoded V3.Constitution

instance
  HasBlueprintSchema V3.Constitution referencedTypes
  => HasBlueprintSchema Constitution referencedTypes
  where
  schema :: Schema referencedTypes
schema = forall t (referencedTypes :: [*]).
HasBlueprintSchema t referencedTypes =>
Schema referencedTypes
schema @(ListEncoded V3.Constitution) @referencedTypes

instance Pretty Constitution where
  pretty :: forall ann. Constitution -> Doc ann
pretty (Constitution Maybe ScriptHash
script) = Doc ann
"constitutionScript:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Maybe ScriptHash -> Doc ann
forall ann. Maybe ScriptHash -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Maybe ScriptHash
script

PlutusTx.makeLift ''Constitution

newtype Committee = CommitteeValue (Map ColdCommitteeCredential Haskell.Integer, Rational)
  deriving stock ((forall x. Committee -> Rep Committee x)
-> (forall x. Rep Committee x -> Committee) -> Generic Committee
forall x. Rep Committee x -> Committee
forall x. Committee -> Rep Committee x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Committee -> Rep Committee x
from :: forall x. Committee -> Rep Committee x
$cto :: forall x. Rep Committee x -> Committee
to :: forall x. Rep Committee x -> Committee
Generic)
  deriving newtype (Int -> Committee -> ShowS
[Committee] -> ShowS
Committee -> String
(Int -> Committee -> ShowS)
-> (Committee -> String)
-> ([Committee] -> ShowS)
-> Show Committee
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Committee -> ShowS
showsPrec :: Int -> Committee -> ShowS
$cshow :: Committee -> String
show :: Committee -> String
$cshowList :: [Committee] -> ShowS
showList :: [Committee] -> ShowS
Haskell.Show, Committee -> Committee -> Bool
(Committee -> Committee -> Bool)
-> (Committee -> Committee -> Bool) -> Eq Committee
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Committee -> Committee -> Bool
== :: Committee -> Committee -> Bool
$c/= :: Committee -> Committee -> Bool
/= :: Committee -> Committee -> Bool
Haskell.Eq, Eq Committee
Eq Committee =>
(Committee -> Committee -> Ordering)
-> (Committee -> Committee -> Bool)
-> (Committee -> Committee -> Bool)
-> (Committee -> Committee -> Bool)
-> (Committee -> Committee -> Bool)
-> (Committee -> Committee -> Committee)
-> (Committee -> Committee -> Committee)
-> Ord Committee
Committee -> Committee -> Bool
Committee -> Committee -> Ordering
Committee -> Committee -> Committee
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Committee -> Committee -> Ordering
compare :: Committee -> Committee -> Ordering
$c< :: Committee -> Committee -> Bool
< :: Committee -> Committee -> Bool
$c<= :: Committee -> Committee -> Bool
<= :: Committee -> Committee -> Bool
$c> :: Committee -> Committee -> Bool
> :: Committee -> Committee -> Bool
$c>= :: Committee -> Committee -> Bool
>= :: Committee -> Committee -> Bool
$cmax :: Committee -> Committee -> Committee
max :: Committee -> Committee -> Committee
$cmin :: Committee -> Committee -> Committee
min :: Committee -> Committee -> Committee
Haskell.Ord)
  deriving
    (Committee -> BuiltinData
(Committee -> BuiltinData) -> ToData Committee
forall a. (a -> BuiltinData) -> ToData a
$ctoBuiltinData :: Committee -> BuiltinData
toBuiltinData :: Committee -> BuiltinData
PlutusTx.ToData, BuiltinData -> Maybe Committee
(BuiltinData -> Maybe Committee) -> FromData Committee
forall a. (BuiltinData -> Maybe a) -> FromData a
$cfromBuiltinData :: BuiltinData -> Maybe Committee
fromBuiltinData :: BuiltinData -> Maybe Committee
PlutusTx.FromData, BuiltinData -> Committee
(BuiltinData -> Committee) -> UnsafeFromData Committee
forall a. (BuiltinData -> a) -> UnsafeFromData a
$cunsafeFromBuiltinData :: BuiltinData -> Committee
unsafeFromBuiltinData :: BuiltinData -> Committee
PlutusTx.UnsafeFromData)
    via ListEncoded (Map ColdCommitteeCredential Haskell.Integer, Rational)

pattern Committee :: Map ColdCommitteeCredential Haskell.Integer -> Rational -> Committee
pattern $mCommittee :: forall {r}.
Committee
-> (Map ColdCommitteeCredential Integer -> Rational -> r)
-> ((# #) -> r)
-> r
$bCommittee :: Map ColdCommitteeCredential Integer -> Rational -> Committee
Committee {Committee -> Map ColdCommitteeCredential Integer
committeeMembers, Committee -> Rational
committeeQuorum} = CommitteeValue (committeeMembers, committeeQuorum)
{-# COMPLETE Committee #-}

instance HasBlueprintDefinition Committee where
  type
    Unroll Committee =
      Committee ': UnrollAll '[Map ColdCommitteeCredential Haskell.Integer, Rational]

instance
  HasBlueprintSchema (Map ColdCommitteeCredential Haskell.Integer, Rational) referencedTypes
  => HasBlueprintSchema Committee referencedTypes
  where
  schema :: Schema referencedTypes
schema = forall t (referencedTypes :: [*]).
HasBlueprintSchema t referencedTypes =>
Schema referencedTypes
schema @(ListEncoded (Map ColdCommitteeCredential Haskell.Integer, Rational)) @referencedTypes

instance Pretty Committee where
  pretty :: forall ann. Committee -> Doc ann
pretty Committee {Map ColdCommitteeCredential Integer
Rational
committeeMembers :: Committee -> Map ColdCommitteeCredential Integer
committeeQuorum :: Committee -> Rational
committeeMembers :: Map ColdCommitteeCredential Integer
committeeQuorum :: Rational
..} =
    [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep
      [Doc ann
"committeeMembers:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Map ColdCommitteeCredential Integer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Map ColdCommitteeCredential Integer -> Doc ann
pretty Map ColdCommitteeCredential Integer
committeeMembers, Doc ann
"committeeQuorum:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Rational -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Rational -> Doc ann
pretty Rational
committeeQuorum]

PlutusTx.makeLift ''Committee

data GovernanceAction
  = ParameterChange (Haskell.Maybe GovernanceActionId) ChangedParameters (Haskell.Maybe V2.ScriptHash)
  | HardForkInitiation (Haskell.Maybe GovernanceActionId) ProtocolVersion
  | TreasuryWithdrawals (Map V2.Credential V2.Lovelace) (Haskell.Maybe V2.ScriptHash)
  | NoConfidence (Haskell.Maybe GovernanceActionId)
  | UpdateCommittee
      (Haskell.Maybe GovernanceActionId)
      [ColdCommitteeCredential]
      (Map ColdCommitteeCredential Haskell.Integer)
      Rational
  | NewConstitution (Haskell.Maybe GovernanceActionId) Constitution
  | InfoAction
  deriving stock ((forall x. GovernanceAction -> Rep GovernanceAction x)
-> (forall x. Rep GovernanceAction x -> GovernanceAction)
-> Generic GovernanceAction
forall x. Rep GovernanceAction x -> GovernanceAction
forall x. GovernanceAction -> Rep GovernanceAction x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GovernanceAction -> Rep GovernanceAction x
from :: forall x. GovernanceAction -> Rep GovernanceAction x
$cto :: forall x. Rep GovernanceAction x -> GovernanceAction
to :: forall x. Rep GovernanceAction x -> GovernanceAction
Generic, Int -> GovernanceAction -> ShowS
[GovernanceAction] -> ShowS
GovernanceAction -> String
(Int -> GovernanceAction -> ShowS)
-> (GovernanceAction -> String)
-> ([GovernanceAction] -> ShowS)
-> Show GovernanceAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GovernanceAction -> ShowS
showsPrec :: Int -> GovernanceAction -> ShowS
$cshow :: GovernanceAction -> String
show :: GovernanceAction -> String
$cshowList :: [GovernanceAction] -> ShowS
showList :: [GovernanceAction] -> ShowS
Haskell.Show, GovernanceAction -> GovernanceAction -> Bool
(GovernanceAction -> GovernanceAction -> Bool)
-> (GovernanceAction -> GovernanceAction -> Bool)
-> Eq GovernanceAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GovernanceAction -> GovernanceAction -> Bool
== :: GovernanceAction -> GovernanceAction -> Bool
$c/= :: GovernanceAction -> GovernanceAction -> Bool
/= :: GovernanceAction -> GovernanceAction -> Bool
Haskell.Eq, Eq GovernanceAction
Eq GovernanceAction =>
(GovernanceAction -> GovernanceAction -> Ordering)
-> (GovernanceAction -> GovernanceAction -> Bool)
-> (GovernanceAction -> GovernanceAction -> Bool)
-> (GovernanceAction -> GovernanceAction -> Bool)
-> (GovernanceAction -> GovernanceAction -> Bool)
-> (GovernanceAction -> GovernanceAction -> GovernanceAction)
-> (GovernanceAction -> GovernanceAction -> GovernanceAction)
-> Ord GovernanceAction
GovernanceAction -> GovernanceAction -> Bool
GovernanceAction -> GovernanceAction -> Ordering
GovernanceAction -> GovernanceAction -> GovernanceAction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: GovernanceAction -> GovernanceAction -> Ordering
compare :: GovernanceAction -> GovernanceAction -> Ordering
$c< :: GovernanceAction -> GovernanceAction -> Bool
< :: GovernanceAction -> GovernanceAction -> Bool
$c<= :: GovernanceAction -> GovernanceAction -> Bool
<= :: GovernanceAction -> GovernanceAction -> Bool
$c> :: GovernanceAction -> GovernanceAction -> Bool
> :: GovernanceAction -> GovernanceAction -> Bool
$c>= :: GovernanceAction -> GovernanceAction -> Bool
>= :: GovernanceAction -> GovernanceAction -> Bool
$cmax :: GovernanceAction -> GovernanceAction -> GovernanceAction
max :: GovernanceAction -> GovernanceAction -> GovernanceAction
$cmin :: GovernanceAction -> GovernanceAction -> GovernanceAction
min :: GovernanceAction -> GovernanceAction -> GovernanceAction
Haskell.Ord)
  deriving anyclass (DefinitionId
DefinitionId -> HasBlueprintDefinition GovernanceAction
forall t. DefinitionId -> HasBlueprintDefinition t
$cdefinitionId :: DefinitionId
definitionId :: DefinitionId
HasBlueprintDefinition)
  deriving ((forall ann. GovernanceAction -> Doc ann)
-> (forall ann. [GovernanceAction] -> Doc ann)
-> Pretty GovernanceAction
forall ann. [GovernanceAction] -> Doc ann
forall ann. GovernanceAction -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
$cpretty :: forall ann. GovernanceAction -> Doc ann
pretty :: forall ann. GovernanceAction -> Doc ann
$cprettyList :: forall ann. [GovernanceAction] -> Doc ann
prettyList :: forall ann. [GovernanceAction] -> Doc ann
Pretty) via (PrettyShow GovernanceAction)

PlutusTx.makeLift ''GovernanceAction
PlutusTx.makeIsDataSchemaIndexed
  ''GovernanceAction
  [ ('ParameterChange, 0)
  , ('HardForkInitiation, 1)
  , ('TreasuryWithdrawals, 2)
  , ('NoConfidence, 3)
  , ('UpdateCommittee, 4)
  , ('NewConstitution, 5)
  , ('InfoAction, 6)
  ]

newtype ProposalProcedure = ProposalProcedureValue (V2.Lovelace, V2.Credential, GovernanceAction)
  deriving stock ((forall x. ProposalProcedure -> Rep ProposalProcedure x)
-> (forall x. Rep ProposalProcedure x -> ProposalProcedure)
-> Generic ProposalProcedure
forall x. Rep ProposalProcedure x -> ProposalProcedure
forall x. ProposalProcedure -> Rep ProposalProcedure x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ProposalProcedure -> Rep ProposalProcedure x
from :: forall x. ProposalProcedure -> Rep ProposalProcedure x
$cto :: forall x. Rep ProposalProcedure x -> ProposalProcedure
to :: forall x. Rep ProposalProcedure x -> ProposalProcedure
Generic)
  deriving newtype (Int -> ProposalProcedure -> ShowS
[ProposalProcedure] -> ShowS
ProposalProcedure -> String
(Int -> ProposalProcedure -> ShowS)
-> (ProposalProcedure -> String)
-> ([ProposalProcedure] -> ShowS)
-> Show ProposalProcedure
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProposalProcedure -> ShowS
showsPrec :: Int -> ProposalProcedure -> ShowS
$cshow :: ProposalProcedure -> String
show :: ProposalProcedure -> String
$cshowList :: [ProposalProcedure] -> ShowS
showList :: [ProposalProcedure] -> ShowS
Haskell.Show, ProposalProcedure -> ProposalProcedure -> Bool
(ProposalProcedure -> ProposalProcedure -> Bool)
-> (ProposalProcedure -> ProposalProcedure -> Bool)
-> Eq ProposalProcedure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProposalProcedure -> ProposalProcedure -> Bool
== :: ProposalProcedure -> ProposalProcedure -> Bool
$c/= :: ProposalProcedure -> ProposalProcedure -> Bool
/= :: ProposalProcedure -> ProposalProcedure -> Bool
Haskell.Eq, Eq ProposalProcedure
Eq ProposalProcedure =>
(ProposalProcedure -> ProposalProcedure -> Ordering)
-> (ProposalProcedure -> ProposalProcedure -> Bool)
-> (ProposalProcedure -> ProposalProcedure -> Bool)
-> (ProposalProcedure -> ProposalProcedure -> Bool)
-> (ProposalProcedure -> ProposalProcedure -> Bool)
-> (ProposalProcedure -> ProposalProcedure -> ProposalProcedure)
-> (ProposalProcedure -> ProposalProcedure -> ProposalProcedure)
-> Ord ProposalProcedure
ProposalProcedure -> ProposalProcedure -> Bool
ProposalProcedure -> ProposalProcedure -> Ordering
ProposalProcedure -> ProposalProcedure -> ProposalProcedure
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ProposalProcedure -> ProposalProcedure -> Ordering
compare :: ProposalProcedure -> ProposalProcedure -> Ordering
$c< :: ProposalProcedure -> ProposalProcedure -> Bool
< :: ProposalProcedure -> ProposalProcedure -> Bool
$c<= :: ProposalProcedure -> ProposalProcedure -> Bool
<= :: ProposalProcedure -> ProposalProcedure -> Bool
$c> :: ProposalProcedure -> ProposalProcedure -> Bool
> :: ProposalProcedure -> ProposalProcedure -> Bool
$c>= :: ProposalProcedure -> ProposalProcedure -> Bool
>= :: ProposalProcedure -> ProposalProcedure -> Bool
$cmax :: ProposalProcedure -> ProposalProcedure -> ProposalProcedure
max :: ProposalProcedure -> ProposalProcedure -> ProposalProcedure
$cmin :: ProposalProcedure -> ProposalProcedure -> ProposalProcedure
min :: ProposalProcedure -> ProposalProcedure -> ProposalProcedure
Haskell.Ord)
  deriving
    (ProposalProcedure -> BuiltinData
(ProposalProcedure -> BuiltinData) -> ToData ProposalProcedure
forall a. (a -> BuiltinData) -> ToData a
$ctoBuiltinData :: ProposalProcedure -> BuiltinData
toBuiltinData :: ProposalProcedure -> BuiltinData
PlutusTx.ToData, BuiltinData -> Maybe ProposalProcedure
(BuiltinData -> Maybe ProposalProcedure)
-> FromData ProposalProcedure
forall a. (BuiltinData -> Maybe a) -> FromData a
$cfromBuiltinData :: BuiltinData -> Maybe ProposalProcedure
fromBuiltinData :: BuiltinData -> Maybe ProposalProcedure
PlutusTx.FromData, BuiltinData -> ProposalProcedure
(BuiltinData -> ProposalProcedure)
-> UnsafeFromData ProposalProcedure
forall a. (BuiltinData -> a) -> UnsafeFromData a
$cunsafeFromBuiltinData :: BuiltinData -> ProposalProcedure
unsafeFromBuiltinData :: BuiltinData -> ProposalProcedure
PlutusTx.UnsafeFromData)
    via ListEncoded (V2.Lovelace, V2.Credential, GovernanceAction)

pattern ProposalProcedure :: V2.Lovelace -> V2.Credential -> GovernanceAction -> ProposalProcedure
pattern $mProposalProcedure :: forall {r}.
ProposalProcedure
-> (Lovelace -> Credential -> GovernanceAction -> r)
-> ((# #) -> r)
-> r
$bProposalProcedure :: Lovelace -> Credential -> GovernanceAction -> ProposalProcedure
ProposalProcedure {ProposalProcedure -> Lovelace
ppDeposit, ProposalProcedure -> Credential
ppReturnAddr, ProposalProcedure -> GovernanceAction
ppGovernanceAction} =
  ProposalProcedureValue (ppDeposit, ppReturnAddr, ppGovernanceAction)
{-# COMPLETE ProposalProcedure #-}

instance HasBlueprintDefinition ProposalProcedure where
  type
    Unroll ProposalProcedure =
      ProposalProcedure ': UnrollAll '[V2.Lovelace, V2.Credential, GovernanceAction]

instance
  HasBlueprintSchema (V2.Lovelace, V2.Credential, GovernanceAction) referencedTypes
  => HasBlueprintSchema ProposalProcedure referencedTypes
  where
  schema :: Schema referencedTypes
schema = forall t (referencedTypes :: [*]).
HasBlueprintSchema t referencedTypes =>
Schema referencedTypes
schema @(ListEncoded (V2.Lovelace, V2.Credential, GovernanceAction)) @referencedTypes

instance Pretty ProposalProcedure where
  pretty :: forall ann. ProposalProcedure -> Doc ann
pretty ProposalProcedure {Lovelace
Credential
GovernanceAction
ppDeposit :: ProposalProcedure -> Lovelace
ppReturnAddr :: ProposalProcedure -> Credential
ppGovernanceAction :: ProposalProcedure -> GovernanceAction
ppDeposit :: Lovelace
ppReturnAddr :: Credential
ppGovernanceAction :: GovernanceAction
..} =
    [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep
      [ Doc ann
"ppDeposit:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Lovelace -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Lovelace -> Doc ann
pretty Lovelace
ppDeposit
      , Doc ann
"ppReturnAddr:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Credential -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Credential -> Doc ann
pretty Credential
ppReturnAddr
      , Doc ann
"ppGovernanceAction:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> GovernanceAction -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. GovernanceAction -> Doc ann
pretty GovernanceAction
ppGovernanceAction
      ]

PlutusTx.makeLift ''ProposalProcedure

data AccountBalanceInterval
  = AccountBalanceLowerBound V2.Lovelace
  | AccountBalanceUpperBound V2.Lovelace
  | AccountBalanceBothBounds V2.Lovelace V2.Lovelace
  | AccountBalanceExact V2.Lovelace
  deriving stock ((forall x. AccountBalanceInterval -> Rep AccountBalanceInterval x)
-> (forall x.
    Rep AccountBalanceInterval x -> AccountBalanceInterval)
-> Generic AccountBalanceInterval
forall x. Rep AccountBalanceInterval x -> AccountBalanceInterval
forall x. AccountBalanceInterval -> Rep AccountBalanceInterval x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AccountBalanceInterval -> Rep AccountBalanceInterval x
from :: forall x. AccountBalanceInterval -> Rep AccountBalanceInterval x
$cto :: forall x. Rep AccountBalanceInterval x -> AccountBalanceInterval
to :: forall x. Rep AccountBalanceInterval x -> AccountBalanceInterval
Generic, Int -> AccountBalanceInterval -> ShowS
[AccountBalanceInterval] -> ShowS
AccountBalanceInterval -> String
(Int -> AccountBalanceInterval -> ShowS)
-> (AccountBalanceInterval -> String)
-> ([AccountBalanceInterval] -> ShowS)
-> Show AccountBalanceInterval
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AccountBalanceInterval -> ShowS
showsPrec :: Int -> AccountBalanceInterval -> ShowS
$cshow :: AccountBalanceInterval -> String
show :: AccountBalanceInterval -> String
$cshowList :: [AccountBalanceInterval] -> ShowS
showList :: [AccountBalanceInterval] -> ShowS
Haskell.Show, AccountBalanceInterval -> AccountBalanceInterval -> Bool
(AccountBalanceInterval -> AccountBalanceInterval -> Bool)
-> (AccountBalanceInterval -> AccountBalanceInterval -> Bool)
-> Eq AccountBalanceInterval
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AccountBalanceInterval -> AccountBalanceInterval -> Bool
== :: AccountBalanceInterval -> AccountBalanceInterval -> Bool
$c/= :: AccountBalanceInterval -> AccountBalanceInterval -> Bool
/= :: AccountBalanceInterval -> AccountBalanceInterval -> Bool
Haskell.Eq, Eq AccountBalanceInterval
Eq AccountBalanceInterval =>
(AccountBalanceInterval -> AccountBalanceInterval -> Ordering)
-> (AccountBalanceInterval -> AccountBalanceInterval -> Bool)
-> (AccountBalanceInterval -> AccountBalanceInterval -> Bool)
-> (AccountBalanceInterval -> AccountBalanceInterval -> Bool)
-> (AccountBalanceInterval -> AccountBalanceInterval -> Bool)
-> (AccountBalanceInterval
    -> AccountBalanceInterval -> AccountBalanceInterval)
-> (AccountBalanceInterval
    -> AccountBalanceInterval -> AccountBalanceInterval)
-> Ord AccountBalanceInterval
AccountBalanceInterval -> AccountBalanceInterval -> Bool
AccountBalanceInterval -> AccountBalanceInterval -> Ordering
AccountBalanceInterval
-> AccountBalanceInterval -> AccountBalanceInterval
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AccountBalanceInterval -> AccountBalanceInterval -> Ordering
compare :: AccountBalanceInterval -> AccountBalanceInterval -> Ordering
$c< :: AccountBalanceInterval -> AccountBalanceInterval -> Bool
< :: AccountBalanceInterval -> AccountBalanceInterval -> Bool
$c<= :: AccountBalanceInterval -> AccountBalanceInterval -> Bool
<= :: AccountBalanceInterval -> AccountBalanceInterval -> Bool
$c> :: AccountBalanceInterval -> AccountBalanceInterval -> Bool
> :: AccountBalanceInterval -> AccountBalanceInterval -> Bool
$c>= :: AccountBalanceInterval -> AccountBalanceInterval -> Bool
>= :: AccountBalanceInterval -> AccountBalanceInterval -> Bool
$cmax :: AccountBalanceInterval
-> AccountBalanceInterval -> AccountBalanceInterval
max :: AccountBalanceInterval
-> AccountBalanceInterval -> AccountBalanceInterval
$cmin :: AccountBalanceInterval
-> AccountBalanceInterval -> AccountBalanceInterval
min :: AccountBalanceInterval
-> AccountBalanceInterval -> AccountBalanceInterval
Haskell.Ord)
  deriving anyclass (DefinitionId
DefinitionId -> HasBlueprintDefinition AccountBalanceInterval
forall t. DefinitionId -> HasBlueprintDefinition t
$cdefinitionId :: DefinitionId
definitionId :: DefinitionId
HasBlueprintDefinition)
  deriving ((forall ann. AccountBalanceInterval -> Doc ann)
-> (forall ann. [AccountBalanceInterval] -> Doc ann)
-> Pretty AccountBalanceInterval
forall ann. [AccountBalanceInterval] -> Doc ann
forall ann. AccountBalanceInterval -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
$cpretty :: forall ann. AccountBalanceInterval -> Doc ann
pretty :: forall ann. AccountBalanceInterval -> Doc ann
$cprettyList :: forall ann. [AccountBalanceInterval] -> Doc ann
prettyList :: forall ann. [AccountBalanceInterval] -> Doc ann
Pretty) via (PrettyShow AccountBalanceInterval)

PlutusTx.deriveEq ''AccountBalanceInterval

$(makeLift ''AccountBalanceInterval)
$( makeIsDataSchemaIndexed
     ''AccountBalanceInterval
     [ ('AccountBalanceLowerBound, 0)
     , ('AccountBalanceUpperBound, 1)
     , ('AccountBalanceBothBounds, 2)
     , ('AccountBalanceExact, 3)
     ]
 )

newtype AccountBalanceIntervals = AccountBalanceIntervals (Map AccountId AccountBalanceInterval)
  deriving stock ((forall x.
 AccountBalanceIntervals -> Rep AccountBalanceIntervals x)
-> (forall x.
    Rep AccountBalanceIntervals x -> AccountBalanceIntervals)
-> Generic AccountBalanceIntervals
forall x. Rep AccountBalanceIntervals x -> AccountBalanceIntervals
forall x. AccountBalanceIntervals -> Rep AccountBalanceIntervals x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AccountBalanceIntervals -> Rep AccountBalanceIntervals x
from :: forall x. AccountBalanceIntervals -> Rep AccountBalanceIntervals x
$cto :: forall x. Rep AccountBalanceIntervals x -> AccountBalanceIntervals
to :: forall x. Rep AccountBalanceIntervals x -> AccountBalanceIntervals
Generic)
  deriving anyclass (DefinitionId
DefinitionId -> HasBlueprintDefinition AccountBalanceIntervals
forall t. DefinitionId -> HasBlueprintDefinition t
$cdefinitionId :: DefinitionId
definitionId :: DefinitionId
HasBlueprintDefinition)
  deriving ((forall ann. AccountBalanceIntervals -> Doc ann)
-> (forall ann. [AccountBalanceIntervals] -> Doc ann)
-> Pretty AccountBalanceIntervals
forall ann. [AccountBalanceIntervals] -> Doc ann
forall ann. AccountBalanceIntervals -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
$cpretty :: forall ann. AccountBalanceIntervals -> Doc ann
pretty :: forall ann. AccountBalanceIntervals -> Doc ann
$cprettyList :: forall ann. [AccountBalanceIntervals] -> Doc ann
prettyList :: forall ann. [AccountBalanceIntervals] -> Doc ann
Pretty) via (PrettyShow AccountBalanceIntervals)
  deriving newtype
    ( AccountBalanceIntervals -> AccountBalanceIntervals -> Bool
(AccountBalanceIntervals -> AccountBalanceIntervals -> Bool)
-> (AccountBalanceIntervals -> AccountBalanceIntervals -> Bool)
-> Eq AccountBalanceIntervals
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AccountBalanceIntervals -> AccountBalanceIntervals -> Bool
== :: AccountBalanceIntervals -> AccountBalanceIntervals -> Bool
$c/= :: AccountBalanceIntervals -> AccountBalanceIntervals -> Bool
/= :: AccountBalanceIntervals -> AccountBalanceIntervals -> Bool
Haskell.Eq
    , Eq AccountBalanceIntervals
Eq AccountBalanceIntervals =>
(AccountBalanceIntervals -> AccountBalanceIntervals -> Ordering)
-> (AccountBalanceIntervals -> AccountBalanceIntervals -> Bool)
-> (AccountBalanceIntervals -> AccountBalanceIntervals -> Bool)
-> (AccountBalanceIntervals -> AccountBalanceIntervals -> Bool)
-> (AccountBalanceIntervals -> AccountBalanceIntervals -> Bool)
-> (AccountBalanceIntervals
    -> AccountBalanceIntervals -> AccountBalanceIntervals)
-> (AccountBalanceIntervals
    -> AccountBalanceIntervals -> AccountBalanceIntervals)
-> Ord AccountBalanceIntervals
AccountBalanceIntervals -> AccountBalanceIntervals -> Bool
AccountBalanceIntervals -> AccountBalanceIntervals -> Ordering
AccountBalanceIntervals
-> AccountBalanceIntervals -> AccountBalanceIntervals
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AccountBalanceIntervals -> AccountBalanceIntervals -> Ordering
compare :: AccountBalanceIntervals -> AccountBalanceIntervals -> Ordering
$c< :: AccountBalanceIntervals -> AccountBalanceIntervals -> Bool
< :: AccountBalanceIntervals -> AccountBalanceIntervals -> Bool
$c<= :: AccountBalanceIntervals -> AccountBalanceIntervals -> Bool
<= :: AccountBalanceIntervals -> AccountBalanceIntervals -> Bool
$c> :: AccountBalanceIntervals -> AccountBalanceIntervals -> Bool
> :: AccountBalanceIntervals -> AccountBalanceIntervals -> Bool
$c>= :: AccountBalanceIntervals -> AccountBalanceIntervals -> Bool
>= :: AccountBalanceIntervals -> AccountBalanceIntervals -> Bool
$cmax :: AccountBalanceIntervals
-> AccountBalanceIntervals -> AccountBalanceIntervals
max :: AccountBalanceIntervals
-> AccountBalanceIntervals -> AccountBalanceIntervals
$cmin :: AccountBalanceIntervals
-> AccountBalanceIntervals -> AccountBalanceIntervals
min :: AccountBalanceIntervals
-> AccountBalanceIntervals -> AccountBalanceIntervals
Haskell.Ord
    , Int -> AccountBalanceIntervals -> ShowS
[AccountBalanceIntervals] -> ShowS
AccountBalanceIntervals -> String
(Int -> AccountBalanceIntervals -> ShowS)
-> (AccountBalanceIntervals -> String)
-> ([AccountBalanceIntervals] -> ShowS)
-> Show AccountBalanceIntervals
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AccountBalanceIntervals -> ShowS
showsPrec :: Int -> AccountBalanceIntervals -> ShowS
$cshow :: AccountBalanceIntervals -> String
show :: AccountBalanceIntervals -> String
$cshowList :: [AccountBalanceIntervals] -> ShowS
showList :: [AccountBalanceIntervals] -> ShowS
Haskell.Show
    , AccountBalanceIntervals -> BuiltinData
(AccountBalanceIntervals -> BuiltinData)
-> ToData AccountBalanceIntervals
forall a. (a -> BuiltinData) -> ToData a
$ctoBuiltinData :: AccountBalanceIntervals -> BuiltinData
toBuiltinData :: AccountBalanceIntervals -> BuiltinData
PlutusTx.ToData
    , BuiltinData -> Maybe AccountBalanceIntervals
(BuiltinData -> Maybe AccountBalanceIntervals)
-> FromData AccountBalanceIntervals
forall a. (BuiltinData -> Maybe a) -> FromData a
$cfromBuiltinData :: BuiltinData -> Maybe AccountBalanceIntervals
fromBuiltinData :: BuiltinData -> Maybe AccountBalanceIntervals
PlutusTx.FromData
    , BuiltinData -> AccountBalanceIntervals
(BuiltinData -> AccountBalanceIntervals)
-> UnsafeFromData AccountBalanceIntervals
forall a. (BuiltinData -> a) -> UnsafeFromData a
$cunsafeFromBuiltinData :: BuiltinData -> AccountBalanceIntervals
unsafeFromBuiltinData :: BuiltinData -> AccountBalanceIntervals
PlutusTx.UnsafeFromData
    )

instance
  ( HasBlueprintSchema AccountId referencedTypes
  , HasBlueprintSchema AccountBalanceInterval referencedTypes
  )
  => HasBlueprintSchema AccountBalanceIntervals referencedTypes
  where
  schema :: Schema referencedTypes
schema =
    forall t (referencedTypes :: [*]).
HasBlueprintSchema t referencedTypes =>
Schema referencedTypes
schema @(Map AccountId AccountBalanceInterval) @referencedTypes
      Schema referencedTypes
-> (Schema referencedTypes -> Schema referencedTypes)
-> Schema referencedTypes
forall a b. a -> (a -> b) -> b
& (SchemaInfo -> SchemaInfo)
-> Schema referencedTypes -> Schema referencedTypes
forall (referencedTypes :: [*]).
(SchemaInfo -> SchemaInfo)
-> Schema referencedTypes -> Schema referencedTypes
withSchemaInfo \SchemaInfo
info -> SchemaInfo
info {title = Haskell.Just "AccountBalanceIntervals"}

data TxCert
  = TxCertRegAccount AccountId V2.Lovelace
  | TxCertUnRegAccount AccountId V2.Lovelace
  | TxCertDelegAccount AccountId Delegatee
  | TxCertRegAccountDeleg AccountId Delegatee V2.Lovelace
  | TxCertRegDRep DRepCredential V2.Lovelace
  | TxCertUpdateDRep DRepCredential
  | TxCertUnRegDRep DRepCredential V2.Lovelace
  | TxCertPoolRegister V2.PubKeyHash V2.PubKeyHash
  | TxCertPoolRetire V2.PubKeyHash Haskell.Integer
  | TxCertAuthHotCommittee ColdCommitteeCredential HotCommitteeCredential
  | TxCertResignColdCommittee ColdCommitteeCredential
  deriving stock ((forall x. TxCert -> Rep TxCert x)
-> (forall x. Rep TxCert x -> TxCert) -> Generic TxCert
forall x. Rep TxCert x -> TxCert
forall x. TxCert -> Rep TxCert x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TxCert -> Rep TxCert x
from :: forall x. TxCert -> Rep TxCert x
$cto :: forall x. Rep TxCert x -> TxCert
to :: forall x. Rep TxCert x -> TxCert
Generic, Int -> TxCert -> ShowS
[TxCert] -> ShowS
TxCert -> String
(Int -> TxCert -> ShowS)
-> (TxCert -> String) -> ([TxCert] -> ShowS) -> Show TxCert
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TxCert -> ShowS
showsPrec :: Int -> TxCert -> ShowS
$cshow :: TxCert -> String
show :: TxCert -> String
$cshowList :: [TxCert] -> ShowS
showList :: [TxCert] -> ShowS
Haskell.Show, TxCert -> TxCert -> Bool
(TxCert -> TxCert -> Bool)
-> (TxCert -> TxCert -> Bool) -> Eq TxCert
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TxCert -> TxCert -> Bool
== :: TxCert -> TxCert -> Bool
$c/= :: TxCert -> TxCert -> Bool
/= :: TxCert -> TxCert -> Bool
Haskell.Eq, Eq TxCert
Eq TxCert =>
(TxCert -> TxCert -> Ordering)
-> (TxCert -> TxCert -> Bool)
-> (TxCert -> TxCert -> Bool)
-> (TxCert -> TxCert -> Bool)
-> (TxCert -> TxCert -> Bool)
-> (TxCert -> TxCert -> TxCert)
-> (TxCert -> TxCert -> TxCert)
-> Ord TxCert
TxCert -> TxCert -> Bool
TxCert -> TxCert -> Ordering
TxCert -> TxCert -> TxCert
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TxCert -> TxCert -> Ordering
compare :: TxCert -> TxCert -> Ordering
$c< :: TxCert -> TxCert -> Bool
< :: TxCert -> TxCert -> Bool
$c<= :: TxCert -> TxCert -> Bool
<= :: TxCert -> TxCert -> Bool
$c> :: TxCert -> TxCert -> Bool
> :: TxCert -> TxCert -> Bool
$c>= :: TxCert -> TxCert -> Bool
>= :: TxCert -> TxCert -> Bool
$cmax :: TxCert -> TxCert -> TxCert
max :: TxCert -> TxCert -> TxCert
$cmin :: TxCert -> TxCert -> TxCert
min :: TxCert -> TxCert -> TxCert
Haskell.Ord)
  deriving anyclass (DefinitionId
DefinitionId -> HasBlueprintDefinition TxCert
forall t. DefinitionId -> HasBlueprintDefinition t
$cdefinitionId :: DefinitionId
definitionId :: DefinitionId
HasBlueprintDefinition)
  deriving ((forall ann. TxCert -> Doc ann)
-> (forall ann. [TxCert] -> Doc ann) -> Pretty TxCert
forall ann. [TxCert] -> Doc ann
forall ann. TxCert -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
$cpretty :: forall ann. TxCert -> Doc ann
pretty :: forall ann. TxCert -> Doc ann
$cprettyList :: forall ann. [TxCert] -> Doc ann
prettyList :: forall ann. [TxCert] -> Doc ann
Pretty) via (PrettyShow TxCert)

PlutusTx.deriveEq ''TxCert

data ScriptPurpose
  = Minting V2.ScriptHash V2.CurrencySymbol
  | Spending V2.ScriptHash TxOutRef
  | Withdrawing V2.ScriptHash V2.Credential
  | Certifying V2.ScriptHash Haskell.Integer TxCert
  | Voting V2.ScriptHash Voter
  | Proposing V2.ScriptHash Haskell.Integer ProposalProcedure
  | Guarding V2.ScriptHash Haskell.Integer
  deriving stock ((forall x. ScriptPurpose -> Rep ScriptPurpose x)
-> (forall x. Rep ScriptPurpose x -> ScriptPurpose)
-> Generic ScriptPurpose
forall x. Rep ScriptPurpose x -> ScriptPurpose
forall x. ScriptPurpose -> Rep ScriptPurpose x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ScriptPurpose -> Rep ScriptPurpose x
from :: forall x. ScriptPurpose -> Rep ScriptPurpose x
$cto :: forall x. Rep ScriptPurpose x -> ScriptPurpose
to :: forall x. Rep ScriptPurpose x -> ScriptPurpose
Generic, Int -> ScriptPurpose -> ShowS
[ScriptPurpose] -> ShowS
ScriptPurpose -> String
(Int -> ScriptPurpose -> ShowS)
-> (ScriptPurpose -> String)
-> ([ScriptPurpose] -> ShowS)
-> Show ScriptPurpose
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ScriptPurpose -> ShowS
showsPrec :: Int -> ScriptPurpose -> ShowS
$cshow :: ScriptPurpose -> String
show :: ScriptPurpose -> String
$cshowList :: [ScriptPurpose] -> ShowS
showList :: [ScriptPurpose] -> ShowS
Haskell.Show, ScriptPurpose -> ScriptPurpose -> Bool
(ScriptPurpose -> ScriptPurpose -> Bool)
-> (ScriptPurpose -> ScriptPurpose -> Bool) -> Eq ScriptPurpose
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ScriptPurpose -> ScriptPurpose -> Bool
== :: ScriptPurpose -> ScriptPurpose -> Bool
$c/= :: ScriptPurpose -> ScriptPurpose -> Bool
/= :: ScriptPurpose -> ScriptPurpose -> Bool
Haskell.Eq, Eq ScriptPurpose
Eq ScriptPurpose =>
(ScriptPurpose -> ScriptPurpose -> Ordering)
-> (ScriptPurpose -> ScriptPurpose -> Bool)
-> (ScriptPurpose -> ScriptPurpose -> Bool)
-> (ScriptPurpose -> ScriptPurpose -> Bool)
-> (ScriptPurpose -> ScriptPurpose -> Bool)
-> (ScriptPurpose -> ScriptPurpose -> ScriptPurpose)
-> (ScriptPurpose -> ScriptPurpose -> ScriptPurpose)
-> Ord ScriptPurpose
ScriptPurpose -> ScriptPurpose -> Bool
ScriptPurpose -> ScriptPurpose -> Ordering
ScriptPurpose -> ScriptPurpose -> ScriptPurpose
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ScriptPurpose -> ScriptPurpose -> Ordering
compare :: ScriptPurpose -> ScriptPurpose -> Ordering
$c< :: ScriptPurpose -> ScriptPurpose -> Bool
< :: ScriptPurpose -> ScriptPurpose -> Bool
$c<= :: ScriptPurpose -> ScriptPurpose -> Bool
<= :: ScriptPurpose -> ScriptPurpose -> Bool
$c> :: ScriptPurpose -> ScriptPurpose -> Bool
> :: ScriptPurpose -> ScriptPurpose -> Bool
$c>= :: ScriptPurpose -> ScriptPurpose -> Bool
>= :: ScriptPurpose -> ScriptPurpose -> Bool
$cmax :: ScriptPurpose -> ScriptPurpose -> ScriptPurpose
max :: ScriptPurpose -> ScriptPurpose -> ScriptPurpose
$cmin :: ScriptPurpose -> ScriptPurpose -> ScriptPurpose
min :: ScriptPurpose -> ScriptPurpose -> ScriptPurpose
Haskell.Ord)
  deriving anyclass (DefinitionId
DefinitionId -> HasBlueprintDefinition ScriptPurpose
forall t. DefinitionId -> HasBlueprintDefinition t
$cdefinitionId :: DefinitionId
definitionId :: DefinitionId
HasBlueprintDefinition)
  deriving ((forall ann. ScriptPurpose -> Doc ann)
-> (forall ann. [ScriptPurpose] -> Doc ann) -> Pretty ScriptPurpose
forall ann. [ScriptPurpose] -> Doc ann
forall ann. ScriptPurpose -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
$cpretty :: forall ann. ScriptPurpose -> Doc ann
pretty :: forall ann. ScriptPurpose -> Doc ann
$cprettyList :: forall ann. [ScriptPurpose] -> Doc ann
prettyList :: forall ann. [ScriptPurpose] -> Doc ann
Pretty) via (PrettyShow ScriptPurpose)

-- | An input of a pending transaction.
data TxInInfo = TxInInfo
  { TxInInfo -> TxOutRef
txInInfoOutRef :: TxOutRef
  , TxInInfo -> TxOut
txInInfoResolved :: TxOut
  }
  deriving stock ((forall x. TxInInfo -> Rep TxInInfo x)
-> (forall x. Rep TxInInfo x -> TxInInfo) -> Generic TxInInfo
forall x. Rep TxInInfo x -> TxInInfo
forall x. TxInInfo -> Rep TxInInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TxInInfo -> Rep TxInInfo x
from :: forall x. TxInInfo -> Rep TxInInfo x
$cto :: forall x. Rep TxInInfo x -> TxInInfo
to :: forall x. Rep TxInInfo x -> TxInInfo
Generic, Int -> TxInInfo -> ShowS
[TxInInfo] -> ShowS
TxInInfo -> String
(Int -> TxInInfo -> ShowS)
-> (TxInInfo -> String) -> ([TxInInfo] -> ShowS) -> Show TxInInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TxInInfo -> ShowS
showsPrec :: Int -> TxInInfo -> ShowS
$cshow :: TxInInfo -> String
show :: TxInInfo -> String
$cshowList :: [TxInInfo] -> ShowS
showList :: [TxInInfo] -> ShowS
Haskell.Show, TxInInfo -> TxInInfo -> Bool
(TxInInfo -> TxInInfo -> Bool)
-> (TxInInfo -> TxInInfo -> Bool) -> Eq TxInInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TxInInfo -> TxInInfo -> Bool
== :: TxInInfo -> TxInInfo -> Bool
$c/= :: TxInInfo -> TxInInfo -> Bool
/= :: TxInInfo -> TxInInfo -> Bool
Haskell.Eq)
  deriving anyclass (DefinitionId
DefinitionId -> HasBlueprintDefinition TxInInfo
forall t. DefinitionId -> HasBlueprintDefinition t
$cdefinitionId :: DefinitionId
definitionId :: DefinitionId
HasBlueprintDefinition)

PlutusTx.deriveEq ''TxInInfo

instance Pretty TxInInfo where
  pretty :: forall ann. TxInInfo -> Doc ann
pretty TxInInfo {TxOutRef
txInInfoOutRef :: TxInInfo -> TxOutRef
txInInfoOutRef :: TxOutRef
txInInfoOutRef, TxOut
txInInfoResolved :: TxInInfo -> TxOut
txInInfoResolved :: TxOut
txInInfoResolved} =
    TxOutRef -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. TxOutRef -> Doc ann
pretty TxOutRef
txInInfoOutRef Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc ann
"->" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> TxOut -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. TxOut -> Doc ann
pretty TxOut
txInInfoResolved

data TxInfo = TxInfo
  { TxInfo -> TxId
txInfoId :: V3.TxId
  , TxInfo -> Maybe Integer
txInfoSubTxIx :: Haskell.Maybe Haskell.Integer
  , TxInfo -> [TxInInfo]
txInfoInputs :: [TxInInfo]
  , TxInfo -> [TxInInfo]
txInfoReferenceInputs :: [TxInInfo]
  , TxInfo -> [TxOut]
txInfoOutputs :: [TxOut]
  , TxInfo -> MintValue
txInfoMint :: V3.MintValue
  , TxInfo -> [TxCert]
txInfoTxCerts :: [TxCert]
  , TxInfo -> Map Credential Lovelace
txInfoWithdrawals :: Map V2.Credential V2.Lovelace
  , TxInfo -> Map Credential Lovelace
txInfoDirectDeposits :: Map V2.Credential V2.Lovelace
  , TxInfo -> AccountBalanceIntervals
txInfoAccountBalanceIntervals :: AccountBalanceIntervals
  , TxInfo -> POSIXTimeRange
txInfoValidRange :: POSIXTimeRange
  , TxInfo -> [Credential]
txInfoGuards :: [V2.Credential]
  , TxInfo -> Map Credential (Maybe Datum)
txInfoRequiredTopLevelGuards :: Map V2.Credential (Haskell.Maybe V2.Datum)
  , TxInfo -> Map ScriptPurpose Redeemer
txInfoRedeemers :: Map ScriptPurpose V2.Redeemer
  , TxInfo -> Map DatumHash Datum
txInfoData :: Map V2.DatumHash V2.Datum
  , TxInfo -> Map Voter (Map GovernanceActionId Vote)
txInfoVotes :: Map Voter (Map GovernanceActionId Vote)
  , TxInfo -> [ProposalProcedure]
txInfoProposalProcedures :: [ProposalProcedure]
  , TxInfo -> Maybe Lovelace
txInfoCurrentTreasuryAmount :: Haskell.Maybe V2.Lovelace
  , TxInfo -> Lovelace
txInfoTreasuryDonation :: V2.Lovelace
  }
  deriving stock ((forall x. TxInfo -> Rep TxInfo x)
-> (forall x. Rep TxInfo x -> TxInfo) -> Generic TxInfo
forall x. Rep TxInfo x -> TxInfo
forall x. TxInfo -> Rep TxInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TxInfo -> Rep TxInfo x
from :: forall x. TxInfo -> Rep TxInfo x
$cto :: forall x. Rep TxInfo x -> TxInfo
to :: forall x. Rep TxInfo x -> TxInfo
Generic, Int -> TxInfo -> ShowS
[TxInfo] -> ShowS
TxInfo -> String
(Int -> TxInfo -> ShowS)
-> (TxInfo -> String) -> ([TxInfo] -> ShowS) -> Show TxInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TxInfo -> ShowS
showsPrec :: Int -> TxInfo -> ShowS
$cshow :: TxInfo -> String
show :: TxInfo -> String
$cshowList :: [TxInfo] -> ShowS
showList :: [TxInfo] -> ShowS
Haskell.Show, TxInfo -> TxInfo -> Bool
(TxInfo -> TxInfo -> Bool)
-> (TxInfo -> TxInfo -> Bool) -> Eq TxInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TxInfo -> TxInfo -> Bool
== :: TxInfo -> TxInfo -> Bool
$c/= :: TxInfo -> TxInfo -> Bool
/= :: TxInfo -> TxInfo -> Bool
Haskell.Eq)
  deriving anyclass (DefinitionId
DefinitionId -> HasBlueprintDefinition TxInfo
forall t. DefinitionId -> HasBlueprintDefinition t
$cdefinitionId :: DefinitionId
definitionId :: DefinitionId
HasBlueprintDefinition)

instance Pretty TxInfo where
  pretty :: forall ann. TxInfo -> Doc ann
pretty TxInfo {[Credential]
[TxOut]
[ProposalProcedure]
[TxCert]
[TxInInfo]
Maybe Integer
Maybe Lovelace
Map DatumHash Datum
Map Credential (Maybe Datum)
Map Credential Lovelace
Map Voter (Map GovernanceActionId Vote)
Map ScriptPurpose Redeemer
POSIXTimeRange
TxId
Lovelace
MintValue
AccountBalanceIntervals
txInfoId :: TxInfo -> TxId
txInfoSubTxIx :: TxInfo -> Maybe Integer
txInfoInputs :: TxInfo -> [TxInInfo]
txInfoReferenceInputs :: TxInfo -> [TxInInfo]
txInfoOutputs :: TxInfo -> [TxOut]
txInfoMint :: TxInfo -> MintValue
txInfoTxCerts :: TxInfo -> [TxCert]
txInfoWithdrawals :: TxInfo -> Map Credential Lovelace
txInfoDirectDeposits :: TxInfo -> Map Credential Lovelace
txInfoAccountBalanceIntervals :: TxInfo -> AccountBalanceIntervals
txInfoValidRange :: TxInfo -> POSIXTimeRange
txInfoGuards :: TxInfo -> [Credential]
txInfoRequiredTopLevelGuards :: TxInfo -> Map Credential (Maybe Datum)
txInfoRedeemers :: TxInfo -> Map ScriptPurpose Redeemer
txInfoData :: TxInfo -> Map DatumHash Datum
txInfoVotes :: TxInfo -> Map Voter (Map GovernanceActionId Vote)
txInfoProposalProcedures :: TxInfo -> [ProposalProcedure]
txInfoCurrentTreasuryAmount :: TxInfo -> Maybe Lovelace
txInfoTreasuryDonation :: TxInfo -> Lovelace
txInfoId :: TxId
txInfoSubTxIx :: Maybe Integer
txInfoInputs :: [TxInInfo]
txInfoReferenceInputs :: [TxInInfo]
txInfoOutputs :: [TxOut]
txInfoMint :: MintValue
txInfoTxCerts :: [TxCert]
txInfoWithdrawals :: Map Credential Lovelace
txInfoDirectDeposits :: Map Credential Lovelace
txInfoAccountBalanceIntervals :: AccountBalanceIntervals
txInfoValidRange :: POSIXTimeRange
txInfoGuards :: [Credential]
txInfoRequiredTopLevelGuards :: Map Credential (Maybe Datum)
txInfoRedeemers :: Map ScriptPurpose Redeemer
txInfoData :: Map DatumHash Datum
txInfoVotes :: Map Voter (Map GovernanceActionId Vote)
txInfoProposalProcedures :: [ProposalProcedure]
txInfoCurrentTreasuryAmount :: Maybe Lovelace
txInfoTreasuryDonation :: Lovelace
..} =
    [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep
      [ Doc ann
"TxId:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> TxId -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. TxId -> Doc ann
pretty TxId
txInfoId
      , Doc ann
"Sub-transaction index:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Maybe Integer -> Doc ann
forall ann. Maybe Integer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Maybe Integer
txInfoSubTxIx
      , Doc ann
"Inputs:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [TxInInfo] -> Doc ann
forall ann. [TxInInfo] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [TxInInfo]
txInfoInputs
      , Doc ann
"Reference inputs:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [TxInInfo] -> Doc ann
forall ann. [TxInInfo] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [TxInInfo]
txInfoReferenceInputs
      , Doc ann
"Outputs:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [TxOut] -> Doc ann
forall ann. [TxOut] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [TxOut]
txInfoOutputs
      , Doc ann
"Value minted:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> MintValue -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. MintValue -> Doc ann
pretty MintValue
txInfoMint
      , Doc ann
"TxCerts:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [TxCert] -> Doc ann
forall ann. [TxCert] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [TxCert]
txInfoTxCerts
      , Doc ann
"Withdrawals:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Map Credential Lovelace -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Map Credential Lovelace -> Doc ann
pretty Map Credential Lovelace
txInfoWithdrawals
      , Doc ann
"Direct deposits:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Map Credential Lovelace -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Map Credential Lovelace -> Doc ann
pretty Map Credential Lovelace
txInfoDirectDeposits
      , Doc ann
"Account balance intervals:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> AccountBalanceIntervals -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. AccountBalanceIntervals -> Doc ann
pretty AccountBalanceIntervals
txInfoAccountBalanceIntervals
      , Doc ann
"Valid range:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> POSIXTimeRange -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. POSIXTimeRange -> Doc ann
pretty POSIXTimeRange
txInfoValidRange
      , Doc ann
"Guards:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Credential] -> Doc ann
forall ann. [Credential] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [Credential]
txInfoGuards
      , Doc ann
"Required top-level guards:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Map Credential (Maybe Datum) -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Map Credential (Maybe Datum) -> Doc ann
pretty Map Credential (Maybe Datum)
txInfoRequiredTopLevelGuards
      , Doc ann
"Redeemers:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Map ScriptPurpose Redeemer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Map ScriptPurpose Redeemer -> Doc ann
pretty Map ScriptPurpose Redeemer
txInfoRedeemers
      , Doc ann
"Datums:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Map DatumHash Datum -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Map DatumHash Datum -> Doc ann
pretty Map DatumHash Datum
txInfoData
      , Doc ann
"Votes:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Map Voter (Map GovernanceActionId Vote) -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Map Voter (Map GovernanceActionId Vote) -> Doc ann
pretty Map Voter (Map GovernanceActionId Vote)
txInfoVotes
      , Doc ann
"Proposal procedures:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [ProposalProcedure] -> Doc ann
forall ann. [ProposalProcedure] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [ProposalProcedure]
txInfoProposalProcedures
      , Doc ann
"Current treasury amount:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Maybe Lovelace -> Doc ann
forall ann. Maybe Lovelace -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Maybe Lovelace
txInfoCurrentTreasuryAmount
      , Doc ann
"Treasury donation:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Lovelace -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Lovelace -> Doc ann
pretty Lovelace
txInfoTreasuryDonation
      ]

data TopTxInfoSimplified = TopTxInfoSimplified
  { TopTxInfoSimplified -> [TxId]
ttisIds :: [V3.TxId]
  {-^ List of all `TxId`s fro the whole transaction, including the top-level transaction, which is
  always going to be the last one in the list. -}
  , TopTxInfoSimplified -> [TxInInfo]
ttisInputs :: [TxInInfo]
  -- ^ Concatenated list of all `txInfoInputs`'
  , TopTxInfoSimplified -> [TxInInfo]
ttisReferenceInputs :: [TxInInfo]
  -- ^ Concatenated list of all `txInfoReferenceInputs`'
  , TopTxInfoSimplified -> [TxOut]
ttisOutputs :: [TxOut]
  -- ^ Concatenated list of all `txInfoOutputs`'
  , TopTxInfoSimplified -> MintValue
ttisMints :: V3.MintValue
  -- ^ `MintValue`s from all `txInfoMint` with positive amounts
  , TopTxInfoSimplified -> MintValue
ttisBurns :: V3.MintValue
  -- ^ `MintValue`s from all `txInfoMint` with negative amounts
  , TopTxInfoSimplified -> [TxCert]
ttisTxCerts :: [TxCert]
  {-^ Concatenated list of all `ttisTxCerts`'. Note, that unlike individual lists in each
  `txInfoTxCerts`, this one can contain duplicates. -}
  , TopTxInfoSimplified -> Map Credential Lovelace
ttisWithdrawals :: Map V2.Credential V2.Lovelace
  -- ^ Union of all `txInfoWithdrawals` with a sum on the range for duplicate credentials
  , TopTxInfoSimplified -> Map Credential Lovelace
ttisDirectDeposits :: Map V2.Credential V2.Lovelace
  -- ^ Union of all `txInfoWithdrawals` with a sum on the range for duplicate credentials
  , TopTxInfoSimplified -> POSIXTimeRange
ttisValidRange :: POSIXTimeRange
  -- ^ Intersection of all validity intervals from within the whole transaction
  , TopTxInfoSimplified -> [Credential]
ttisGuards :: [V2.Credential]
  -- ^ Concatenated list of all `txInfoGuards`'
  , TopTxInfoSimplified -> [Credential]
ttisRequiredTopLevelGuards :: [V2.Credential]
  {-^ Deduplicated set of required top level guards. It is impossible to keep the range of the Map
  due to potential presence of duplicates in the domain between different sub-transactions,
  therefore the range is eliminated. -}
  , TopTxInfoSimplified -> [ScriptPurpose]
ttisScriptPurposes :: [ScriptPurpose]
  {-^ Union of all of the `Redeemer`s. Note that it is not possible to preserve actual `Redeemer`s
  upon `union` operation due to potential duplicates in the domain. Therefore it is collapsed to
  a Set of `ScriptPurpose`s only with duplicates removed. -}
  , TopTxInfoSimplified -> Map DatumHash Datum
ttisData :: Map V2.DatumHash V2.Datum
  {-^ Union of all `txInfoData`. Duplicates are simply removed, since domain and range are
  a one-to-one mapping. -}
  , TopTxInfoSimplified -> Map Voter (Map GovernanceActionId Vote)
ttisVotes :: Map Voter (Map GovernanceActionId Vote)
  {-^ Union of all of the votes. Note that a vote in a sub-sequent sub-transaction or a top level
  transaction can replace a vote from a prior sub-transaction. -}
  , TopTxInfoSimplified -> [ProposalProcedure]
ttisProposalProcedures :: [ProposalProcedure]
  -- ^ Concatenated list of all `ProposalPrecedure`s.
  , TopTxInfoSimplified -> Maybe Lovelace
ttisCurrentTreasuryAmount :: Haskell.Maybe V2.Lovelace
  {-^ Value of the treasury, which will be present if any of sub-transactions or top level
  transaction included such value -}
  , TopTxInfoSimplified -> Lovelace
ttisTreasuryDonations :: V2.Lovelace
  -- ^ Sum of all `txInfoTreasuryDonation`s
  }
  deriving stock ((forall x. TopTxInfoSimplified -> Rep TopTxInfoSimplified x)
-> (forall x. Rep TopTxInfoSimplified x -> TopTxInfoSimplified)
-> Generic TopTxInfoSimplified
forall x. Rep TopTxInfoSimplified x -> TopTxInfoSimplified
forall x. TopTxInfoSimplified -> Rep TopTxInfoSimplified x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TopTxInfoSimplified -> Rep TopTxInfoSimplified x
from :: forall x. TopTxInfoSimplified -> Rep TopTxInfoSimplified x
$cto :: forall x. Rep TopTxInfoSimplified x -> TopTxInfoSimplified
to :: forall x. Rep TopTxInfoSimplified x -> TopTxInfoSimplified
Generic, Int -> TopTxInfoSimplified -> ShowS
[TopTxInfoSimplified] -> ShowS
TopTxInfoSimplified -> String
(Int -> TopTxInfoSimplified -> ShowS)
-> (TopTxInfoSimplified -> String)
-> ([TopTxInfoSimplified] -> ShowS)
-> Show TopTxInfoSimplified
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TopTxInfoSimplified -> ShowS
showsPrec :: Int -> TopTxInfoSimplified -> ShowS
$cshow :: TopTxInfoSimplified -> String
show :: TopTxInfoSimplified -> String
$cshowList :: [TopTxInfoSimplified] -> ShowS
showList :: [TopTxInfoSimplified] -> ShowS
Haskell.Show, TopTxInfoSimplified -> TopTxInfoSimplified -> Bool
(TopTxInfoSimplified -> TopTxInfoSimplified -> Bool)
-> (TopTxInfoSimplified -> TopTxInfoSimplified -> Bool)
-> Eq TopTxInfoSimplified
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TopTxInfoSimplified -> TopTxInfoSimplified -> Bool
== :: TopTxInfoSimplified -> TopTxInfoSimplified -> Bool
$c/= :: TopTxInfoSimplified -> TopTxInfoSimplified -> Bool
/= :: TopTxInfoSimplified -> TopTxInfoSimplified -> Bool
Haskell.Eq)
  deriving anyclass (DefinitionId
DefinitionId -> HasBlueprintDefinition TopTxInfoSimplified
forall t. DefinitionId -> HasBlueprintDefinition t
$cdefinitionId :: DefinitionId
definitionId :: DefinitionId
HasBlueprintDefinition)
  deriving ((forall ann. TopTxInfoSimplified -> Doc ann)
-> (forall ann. [TopTxInfoSimplified] -> Doc ann)
-> Pretty TopTxInfoSimplified
forall ann. [TopTxInfoSimplified] -> Doc ann
forall ann. TopTxInfoSimplified -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
$cpretty :: forall ann. TopTxInfoSimplified -> Doc ann
pretty :: forall ann. TopTxInfoSimplified -> Doc ann
$cprettyList :: forall ann. [TopTxInfoSimplified] -> Doc ann
prettyList :: forall ann. [TopTxInfoSimplified] -> Doc ann
Pretty) via (PrettyShow TopTxInfoSimplified)

data TopTxInfo = TopTxInfo
  { TopTxInfo -> [TxInfo]
topTxInfoSubTransactions :: [TxInfo]
  {-^ List of `TxInfo`s for all sub-transactions. Not that `TxInfo` for the top level transaction
  itslef is not present in this list. -}
  , TopTxInfo -> Map TxId Datum
topTxInfoDatums :: Map V3.TxId V2.Datum
  {-^ Datums supplied in `requiredTopLevelGuards` for that script. Plutus scripts require a datum
  to be supplied when listed `requiredTopLevelGuards`. That `Map` will be empty if none of the
  transactions within the whole transaction require Plutus scripts to be present in `Guards` -}
  , TopTxInfo -> AccountBalanceIntervals
topTxInfoStartingAccountBalanceIntervals :: AccountBalanceIntervals
  {-^ This is a field that allows top level transaction to specify the balance intervals before
  the whole transaction is applied -}
  , TopTxInfo -> TopTxInfoSimplified
topTxInfoSimplified :: TopTxInfoSimplified
  {-^ Aggregated view on the whole transaction, namely information about sub-transactions and the
  top level transaction all concatenated together with loss of some information -}
  }
  deriving stock ((forall x. TopTxInfo -> Rep TopTxInfo x)
-> (forall x. Rep TopTxInfo x -> TopTxInfo) -> Generic TopTxInfo
forall x. Rep TopTxInfo x -> TopTxInfo
forall x. TopTxInfo -> Rep TopTxInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TopTxInfo -> Rep TopTxInfo x
from :: forall x. TopTxInfo -> Rep TopTxInfo x
$cto :: forall x. Rep TopTxInfo x -> TopTxInfo
to :: forall x. Rep TopTxInfo x -> TopTxInfo
Generic, Int -> TopTxInfo -> ShowS
[TopTxInfo] -> ShowS
TopTxInfo -> String
(Int -> TopTxInfo -> ShowS)
-> (TopTxInfo -> String)
-> ([TopTxInfo] -> ShowS)
-> Show TopTxInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TopTxInfo -> ShowS
showsPrec :: Int -> TopTxInfo -> ShowS
$cshow :: TopTxInfo -> String
show :: TopTxInfo -> String
$cshowList :: [TopTxInfo] -> ShowS
showList :: [TopTxInfo] -> ShowS
Haskell.Show, TopTxInfo -> TopTxInfo -> Bool
(TopTxInfo -> TopTxInfo -> Bool)
-> (TopTxInfo -> TopTxInfo -> Bool) -> Eq TopTxInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TopTxInfo -> TopTxInfo -> Bool
== :: TopTxInfo -> TopTxInfo -> Bool
$c/= :: TopTxInfo -> TopTxInfo -> Bool
/= :: TopTxInfo -> TopTxInfo -> Bool
Haskell.Eq)
  deriving anyclass (DefinitionId
DefinitionId -> HasBlueprintDefinition TopTxInfo
forall t. DefinitionId -> HasBlueprintDefinition t
$cdefinitionId :: DefinitionId
definitionId :: DefinitionId
HasBlueprintDefinition)
  deriving ((forall ann. TopTxInfo -> Doc ann)
-> (forall ann. [TopTxInfo] -> Doc ann) -> Pretty TopTxInfo
forall ann. [TopTxInfo] -> Doc ann
forall ann. TopTxInfo -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
$cpretty :: forall ann. TopTxInfo -> Doc ann
pretty :: forall ann. TopTxInfo -> Doc ann
$cprettyList :: forall ann. [TopTxInfo] -> Doc ann
prettyList :: forall ann. [TopTxInfo] -> Doc ann
Pretty) via (PrettyShow TopTxInfo)

data ScriptInfo
  = MintingScript V2.CurrencySymbol
  | SpendingScript TxOutRef (Haskell.Maybe V2.Datum)
  | WithdrawingScript AccountId
  | CertifyingScript
      Haskell.Integer
      -- ^ 0-based index of the given `TxCert` in `txInfoTxCerts`
      TxCert
  | VotingScript Voter
  | ProposingScript
      Haskell.Integer
      -- ^ 0-based index of the given `ProposalProcedure` in `txInfoProposalProcedures`
      ProposalProcedure
  | {-| Whenever a `Guard` is executed at the top transaction level it will include extra
    information about potential sub-transactions. In other words for sub-transactions this is
    guaranteed to be `Nothing`, while for top level transactions this is guaranteed to be
    `Just` -}
    GuardingScript
      Haskell.Integer
      (Haskell.Maybe TopTxInfo)
  deriving stock ((forall x. ScriptInfo -> Rep ScriptInfo x)
-> (forall x. Rep ScriptInfo x -> ScriptInfo) -> Generic ScriptInfo
forall x. Rep ScriptInfo x -> ScriptInfo
forall x. ScriptInfo -> Rep ScriptInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ScriptInfo -> Rep ScriptInfo x
from :: forall x. ScriptInfo -> Rep ScriptInfo x
$cto :: forall x. Rep ScriptInfo x -> ScriptInfo
to :: forall x. Rep ScriptInfo x -> ScriptInfo
Generic, Int -> ScriptInfo -> ShowS
[ScriptInfo] -> ShowS
ScriptInfo -> String
(Int -> ScriptInfo -> ShowS)
-> (ScriptInfo -> String)
-> ([ScriptInfo] -> ShowS)
-> Show ScriptInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ScriptInfo -> ShowS
showsPrec :: Int -> ScriptInfo -> ShowS
$cshow :: ScriptInfo -> String
show :: ScriptInfo -> String
$cshowList :: [ScriptInfo] -> ShowS
showList :: [ScriptInfo] -> ShowS
Haskell.Show, ScriptInfo -> ScriptInfo -> Bool
(ScriptInfo -> ScriptInfo -> Bool)
-> (ScriptInfo -> ScriptInfo -> Bool) -> Eq ScriptInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ScriptInfo -> ScriptInfo -> Bool
== :: ScriptInfo -> ScriptInfo -> Bool
$c/= :: ScriptInfo -> ScriptInfo -> Bool
/= :: ScriptInfo -> ScriptInfo -> Bool
Haskell.Eq)
  deriving anyclass (DefinitionId
DefinitionId -> HasBlueprintDefinition ScriptInfo
forall t. DefinitionId -> HasBlueprintDefinition t
$cdefinitionId :: DefinitionId
definitionId :: DefinitionId
HasBlueprintDefinition)
  deriving ((forall ann. ScriptInfo -> Doc ann)
-> (forall ann. [ScriptInfo] -> Doc ann) -> Pretty ScriptInfo
forall ann. [ScriptInfo] -> Doc ann
forall ann. ScriptInfo -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
$cpretty :: forall ann. ScriptInfo -> Doc ann
pretty :: forall ann. ScriptInfo -> Doc ann
$cprettyList :: forall ann. [ScriptInfo] -> Doc ann
prettyList :: forall ann. [ScriptInfo] -> Doc ann
Pretty) via (PrettyShow ScriptInfo)

data ScriptContext = ScriptContext
  { ScriptContext -> TxInfo
scriptContextTxInfo :: TxInfo
  -- ^ Information about the transaction the currently-executing script is included in
  , ScriptContext -> Redeemer
scriptContextRedeemer :: V2.Redeemer
  -- ^ Redeemer for the currently-executing script
  , ScriptContext -> ScriptInfo
scriptContextScriptInfo :: ScriptInfo
  {-^ the purpose of the currently-executing script, along with information associated
  with the purpose -}
  , ScriptContext -> ScriptHash
scriptContextScriptHash :: V2.ScriptHash
  -- ^ Hash of the script that is being executed
  }
  deriving stock ((forall x. ScriptContext -> Rep ScriptContext x)
-> (forall x. Rep ScriptContext x -> ScriptContext)
-> Generic ScriptContext
forall x. Rep ScriptContext x -> ScriptContext
forall x. ScriptContext -> Rep ScriptContext x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ScriptContext -> Rep ScriptContext x
from :: forall x. ScriptContext -> Rep ScriptContext x
$cto :: forall x. Rep ScriptContext x -> ScriptContext
to :: forall x. Rep ScriptContext x -> ScriptContext
Generic, ScriptContext -> ScriptContext -> Bool
(ScriptContext -> ScriptContext -> Bool)
-> (ScriptContext -> ScriptContext -> Bool) -> Eq ScriptContext
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ScriptContext -> ScriptContext -> Bool
== :: ScriptContext -> ScriptContext -> Bool
$c/= :: ScriptContext -> ScriptContext -> Bool
/= :: ScriptContext -> ScriptContext -> Bool
Haskell.Eq, Int -> ScriptContext -> ShowS
[ScriptContext] -> ShowS
ScriptContext -> String
(Int -> ScriptContext -> ShowS)
-> (ScriptContext -> String)
-> ([ScriptContext] -> ShowS)
-> Show ScriptContext
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ScriptContext -> ShowS
showsPrec :: Int -> ScriptContext -> ShowS
$cshow :: ScriptContext -> String
show :: ScriptContext -> String
$cshowList :: [ScriptContext] -> ShowS
showList :: [ScriptContext] -> ShowS
Haskell.Show)
  deriving anyclass (DefinitionId
DefinitionId -> HasBlueprintDefinition ScriptContext
forall t. DefinitionId -> HasBlueprintDefinition t
$cdefinitionId :: DefinitionId
definitionId :: DefinitionId
HasBlueprintDefinition)

instance Pretty ScriptContext where
  pretty :: forall ann. ScriptContext -> Doc ann
pretty ScriptContext {ScriptHash
Redeemer
ScriptInfo
TxInfo
scriptContextTxInfo :: ScriptContext -> TxInfo
scriptContextRedeemer :: ScriptContext -> Redeemer
scriptContextScriptInfo :: ScriptContext -> ScriptInfo
scriptContextScriptHash :: ScriptContext -> ScriptHash
scriptContextTxInfo :: TxInfo
scriptContextRedeemer :: Redeemer
scriptContextScriptInfo :: ScriptInfo
scriptContextScriptHash :: ScriptHash
..} =
    [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep
      [ Doc ann
"ScriptInfo:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ScriptInfo -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ScriptInfo -> Doc ann
pretty ScriptInfo
scriptContextScriptInfo
      , Doc ann
"ScriptHash:" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ScriptHash -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ScriptHash -> Doc ann
pretty ScriptHash
scriptContextScriptHash
      , Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 ([Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep [Doc ann
"TxInfo:", TxInfo -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. TxInfo -> Doc ann
pretty TxInfo
scriptContextTxInfo])
      , Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 ([Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep [Doc ann
"Redeemer:", Redeemer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Redeemer -> Doc ann
pretty Redeemer
scriptContextRedeemer])
      ]

findOwnInput :: ScriptContext -> Haskell.Maybe TxInInfo
findOwnInput :: ScriptContext -> Maybe TxInInfo
findOwnInput
  ScriptContext
    { scriptContextTxInfo :: ScriptContext -> TxInfo
scriptContextTxInfo = TxInfo {[TxInInfo]
txInfoInputs :: TxInfo -> [TxInInfo]
txInfoInputs :: [TxInInfo]
txInfoInputs}
    , scriptContextScriptInfo :: ScriptContext -> ScriptInfo
scriptContextScriptInfo = SpendingScript TxOutRef
txOutRef Maybe Datum
_
    } =
    (TxInInfo -> Bool) -> [TxInInfo] -> Maybe TxInInfo
forall a. (a -> Bool) -> [a] -> Maybe a
List.find
      (\TxInInfo {TxOutRef
txInInfoOutRef :: TxInInfo -> TxOutRef
txInInfoOutRef :: TxOutRef
txInInfoOutRef} -> TxOutRef
txInInfoOutRef TxOutRef -> TxOutRef -> Bool
forall a. Eq a => a -> a -> Bool
PlutusTx.== TxOutRef
txOutRef)
      [TxInInfo]
txInfoInputs
findOwnInput ScriptContext
_ = Maybe TxInInfo
forall a. Maybe a
Haskell.Nothing
{-# INLINEABLE findOwnInput #-}

findDatum :: V2.DatumHash -> TxInfo -> Haskell.Maybe V2.Datum
findDatum :: DatumHash -> TxInfo -> Maybe Datum
findDatum DatumHash
dsh TxInfo {Map DatumHash Datum
txInfoData :: TxInfo -> Map DatumHash Datum
txInfoData :: Map DatumHash Datum
txInfoData} = DatumHash -> Map DatumHash Datum -> Maybe Datum
forall k v. Eq k => k -> Map k v -> Maybe v
lookup DatumHash
dsh Map DatumHash Datum
txInfoData
{-# INLINEABLE findDatum #-}

findDatumHash :: V2.Datum -> TxInfo -> Haskell.Maybe V2.DatumHash
findDatumHash :: Datum -> TxInfo -> Maybe DatumHash
findDatumHash Datum
ds TxInfo {Map DatumHash Datum
txInfoData :: TxInfo -> Map DatumHash Datum
txInfoData :: Map DatumHash Datum
txInfoData} =
  (DatumHash, Datum) -> DatumHash
forall a b. (a, b) -> a
PlutusTx.fst ((DatumHash, Datum) -> DatumHash)
-> Maybe (DatumHash, Datum) -> Maybe DatumHash
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
PlutusTx.<$> ((DatumHash, Datum) -> Bool)
-> [(DatumHash, Datum)] -> Maybe (DatumHash, Datum)
forall a. (a -> Bool) -> [a] -> Maybe a
List.find (\(DatumHash
_, Datum
ds') -> Datum
ds' Datum -> Datum -> Bool
forall a. Eq a => a -> a -> Bool
PlutusTx.== Datum
ds) (Map DatumHash Datum -> [(DatumHash, Datum)]
forall k v. Map k v -> [(k, v)]
toList Map DatumHash Datum
txInfoData)
{-# INLINEABLE findDatumHash #-}

findTxInByTxOutRef :: TxOutRef -> TxInfo -> Haskell.Maybe TxInInfo
findTxInByTxOutRef :: TxOutRef -> TxInfo -> Maybe TxInInfo
findTxInByTxOutRef TxOutRef
outRef TxInfo {[TxInInfo]
txInfoInputs :: TxInfo -> [TxInInfo]
txInfoInputs :: [TxInInfo]
txInfoInputs} =
  (TxInInfo -> Bool) -> [TxInInfo] -> Maybe TxInInfo
forall a. (a -> Bool) -> [a] -> Maybe a
List.find
    (\TxInInfo {TxOutRef
txInInfoOutRef :: TxInInfo -> TxOutRef
txInInfoOutRef :: TxOutRef
txInInfoOutRef} -> TxOutRef
txInInfoOutRef TxOutRef -> TxOutRef -> Bool
forall a. Eq a => a -> a -> Bool
PlutusTx.== TxOutRef
outRef)
    [TxInInfo]
txInfoInputs
{-# INLINEABLE findTxInByTxOutRef #-}

{-| Find the indices of outputs in the current sub-transaction or top-level transaction
that pay to the same script address we are currently spending from. This does not search
the outputs of the whole transaction. -}
findContinuingOutputs :: ScriptContext -> [Haskell.Integer]
findContinuingOutputs :: ScriptContext -> [Integer]
findContinuingOutputs ScriptContext
ctx
  | Haskell.Just TxInInfo {txInInfoResolved :: TxInInfo -> TxOut
txInInfoResolved = TxOut {Address
txOutAddress :: Address
txOutAddress :: TxOut -> Address
txOutAddress}} <- ScriptContext -> Maybe TxInInfo
findOwnInput ScriptContext
ctx =
      (TxOut -> Bool) -> [TxOut] -> [Integer]
forall a. (a -> Bool) -> [a] -> [Integer]
List.findIndices
        (\TxOut {txOutAddress :: TxOut -> Address
txOutAddress = Address
otherAddress} -> Address
txOutAddress Address -> Address -> Bool
forall a. Eq a => a -> a -> Bool
PlutusTx.== Address
otherAddress)
        (TxInfo -> [TxOut]
txInfoOutputs (ScriptContext -> TxInfo
scriptContextTxInfo ScriptContext
ctx))
findContinuingOutputs ScriptContext
_ = BuiltinString -> [Integer]
forall a. BuiltinString -> a
PlutusTx.traceError BuiltinString
"Le"
{-# INLINEABLE findContinuingOutputs #-}

{-| Get the outputs in the current sub-transaction or top-level transaction that pay to
the same script address we are currently spending from. This does not search the outputs
of the whole transaction. -}
getContinuingOutputs :: ScriptContext -> [TxOut]
getContinuingOutputs :: ScriptContext -> [TxOut]
getContinuingOutputs ScriptContext
ctx
  | Haskell.Just TxInInfo {txInInfoResolved :: TxInInfo -> TxOut
txInInfoResolved = TxOut {Address
txOutAddress :: TxOut -> Address
txOutAddress :: Address
txOutAddress}} <- ScriptContext -> Maybe TxInInfo
findOwnInput ScriptContext
ctx =
      (TxOut -> Bool) -> [TxOut] -> [TxOut]
forall a. (a -> Bool) -> [a] -> [a]
List.filter
        (\TxOut {txOutAddress :: TxOut -> Address
txOutAddress = Address
otherAddress} -> Address
txOutAddress Address -> Address -> Bool
forall a. Eq a => a -> a -> Bool
PlutusTx.== Address
otherAddress)
        (TxInfo -> [TxOut]
txInfoOutputs (ScriptContext -> TxInfo
scriptContextTxInfo ScriptContext
ctx))
getContinuingOutputs ScriptContext
_ = BuiltinString -> [TxOut]
forall a. BuiltinString -> a
PlutusTx.traceError BuiltinString
"Lf"
{-# INLINEABLE getContinuingOutputs #-}

txSignedBy :: TxInfo -> V2.PubKeyHash -> Haskell.Bool
txSignedBy :: TxInfo -> PubKeyHash -> Bool
txSignedBy TxInfo {[Credential]
txInfoGuards :: TxInfo -> [Credential]
txInfoGuards :: [Credential]
txInfoGuards} PubKeyHash
keyHash =
  (Credential -> Bool) -> [Credential] -> Bool
forall a. (a -> Bool) -> [a] -> Bool
List.any (Credential -> Credential -> Bool
forall a. Eq a => a -> a -> Bool
(PlutusTx.==) (PubKeyHash -> Credential
V2.PubKeyCredential PubKeyHash
keyHash)) [Credential]
txInfoGuards
{-# INLINEABLE txSignedBy #-}

pubKeyOutputsAt :: V2.PubKeyHash -> TxInfo -> [V2.Value]
pubKeyOutputsAt :: PubKeyHash -> TxInfo -> [Value]
pubKeyOutputsAt PubKeyHash
pk TxInfo
txInfo =
  let atPubKey :: TxOut -> Maybe Value
atPubKey TxOut {txOutAddress :: TxOut -> Address
txOutAddress = Address (V2.PubKeyCredential PubKeyHash
pk') Maybe AccountId
_, Value
txOutValue :: Value
txOutValue :: TxOut -> Value
txOutValue}
        | PubKeyHash
pk PubKeyHash -> PubKeyHash -> Bool
forall a. Eq a => a -> a -> Bool
PlutusTx.== PubKeyHash
pk' = Value -> Maybe Value
forall a. a -> Maybe a
Haskell.Just Value
txOutValue
      atPubKey TxOut
_ = Maybe Value
forall a. Maybe a
Haskell.Nothing
   in (TxOut -> Maybe Value) -> [TxOut] -> [Value]
forall a b. (a -> Maybe b) -> [a] -> [b]
PlutusTx.mapMaybe TxOut -> Maybe Value
atPubKey (TxInfo -> [TxOut]
txInfoOutputs TxInfo
txInfo)
{-# INLINEABLE pubKeyOutputsAt #-}

valuePaidTo :: TxInfo -> V2.PubKeyHash -> V2.Value
valuePaidTo :: TxInfo -> PubKeyHash -> Value
valuePaidTo TxInfo
txInfo PubKeyHash
keyHash = [Value] -> Value
forall a. Monoid a => [a] -> a
PlutusTx.mconcat (PubKeyHash -> TxInfo -> [Value]
pubKeyOutputsAt PubKeyHash
keyHash TxInfo
txInfo)
{-# INLINEABLE valuePaidTo #-}

valueSpent :: TxInfo -> V2.Value
valueSpent :: TxInfo -> Value
valueSpent = (TxInInfo -> Value) -> [TxInInfo] -> Value
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
F.foldMap (TxOut -> Value
txOutValue (TxOut -> Value) -> (TxInInfo -> TxOut) -> TxInInfo -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
PlutusTx.. TxInInfo -> TxOut
txInInfoResolved) ([TxInInfo] -> Value) -> (TxInfo -> [TxInInfo]) -> TxInfo -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
PlutusTx.. TxInfo -> [TxInInfo]
txInfoInputs
{-# INLINEABLE valueSpent #-}

valueProduced :: TxInfo -> V2.Value
valueProduced :: TxInfo -> Value
valueProduced = (TxOut -> Value) -> [TxOut] -> Value
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
F.foldMap TxOut -> Value
txOutValue ([TxOut] -> Value) -> (TxInfo -> [TxOut]) -> TxInfo -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
PlutusTx.. TxInfo -> [TxOut]
txInfoOutputs
{-# INLINEABLE valueProduced #-}

ownCurrencySymbol :: ScriptContext -> V2.CurrencySymbol
ownCurrencySymbol :: ScriptContext -> CurrencySymbol
ownCurrencySymbol ScriptContext {scriptContextScriptInfo :: ScriptContext -> ScriptInfo
scriptContextScriptInfo = MintingScript CurrencySymbol
currencySymbol} = CurrencySymbol
currencySymbol
ownCurrencySymbol ScriptContext
_ = BuiltinString -> CurrencySymbol
forall a. BuiltinString -> a
PlutusTx.traceError BuiltinString
"Lh"
{-# INLINEABLE ownCurrencySymbol #-}

spendsOutput :: TxInfo -> V3.TxId -> Haskell.Integer -> Haskell.Bool
spendsOutput :: TxInfo -> TxId -> Integer -> Bool
spendsOutput TxInfo
txInfo TxId
txId Integer
outputIndex =
  (TxInInfo -> Bool) -> [TxInInfo] -> Bool
forall a. (a -> Bool) -> [a] -> Bool
List.any
    ( \TxInInfo {txInInfoOutRef :: TxInInfo -> TxOutRef
txInInfoOutRef = TxOutRef TxId
refId Integer
refIndex} ->
        TxId
txId TxId -> TxId -> Bool
forall a. Eq a => a -> a -> Bool
PlutusTx.== TxId
refId Bool -> Bool -> Bool
PlutusTx.&& Integer
outputIndex Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
PlutusTx.== Integer
refIndex
    )
    (TxInfo -> [TxInInfo]
txInfoInputs TxInfo
txInfo)
{-# INLINEABLE spendsOutput #-}

$(makeLift ''AccountBalanceIntervals)

$(makeLift ''TxCert)
$( makeIsDataSchemaIndexed
     ''TxCert
     [ ('TxCertRegAccount, 0)
     , ('TxCertUnRegAccount, 1)
     , ('TxCertDelegAccount, 2)
     , ('TxCertRegAccountDeleg, 3)
     , ('TxCertRegDRep, 4)
     , ('TxCertUpdateDRep, 5)
     , ('TxCertUnRegDRep, 6)
     , ('TxCertPoolRegister, 7)
     , ('TxCertPoolRetire, 8)
     , ('TxCertAuthHotCommittee, 9)
     , ('TxCertResignColdCommittee, 10)
     ]
 )

$(makeLift ''ScriptPurpose)
$( makeIsDataSchemaIndexed
     ''ScriptPurpose
     [ ('Minting, 0)
     , ('Spending, 1)
     , ('Withdrawing, 2)
     , ('Certifying, 3)
     , ('Voting, 4)
     , ('Proposing, 5)
     , ('Guarding, 6)
     ]
 )

$(makeLift ''TxInInfo)
$(makeIsDataSchemaAsList ''TxInInfo)

$(makeLift ''TxInfo)
$(makeIsDataSchemaAsList ''TxInfo)

$(makeLift ''TopTxInfoSimplified)
$(makeIsDataSchemaAsList ''TopTxInfoSimplified)

$(makeLift ''TopTxInfo)
$(makeIsDataSchemaAsList ''TopTxInfo)

$(makeLift ''ScriptInfo)
$( makeIsDataSchemaIndexed
     ''ScriptInfo
     [ ('MintingScript, 0)
     , ('SpendingScript, 1)
     , ('WithdrawingScript, 2)
     , ('CertifyingScript, 3)
     , ('VotingScript, 4)
     , ('ProposingScript, 5)
     , ('GuardingScript, 6)
     ]
 )

$(makeLift ''ScriptContext)
$(makeIsDataSchemaAsList ''ScriptContext)