/
V1.hs
186 lines (179 loc) · 6.83 KB
/
V1.hs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
-- editorconfig-checker-disable-file
-- | The interface to Plutus V1 for the ledger.
module PlutusLedgerApi.V1 (
-- * Scripts
SerialisedScript
, Script
, fromCompiledCode
-- * Validating scripts
, assertScriptWellFormed
-- * Running scripts
, evaluateScriptRestricting
, evaluateScriptCounting
-- ** Protocol version
, ProtocolVersion (..)
-- ** Verbose mode and log output
, VerboseMode (..)
, LogOutput
-- * Costing-related types
, ExBudget (..)
, ExCPU (..)
, ExMemory (..)
, SatInt
-- ** Cost model
, EvaluationContext
, mkEvaluationContext
, ParamName (..)
, CostModelApplyError (..)
, CostModelParams
, assertWellFormedCostModelParams
-- * Context types
, ScriptContext(..)
, ScriptPurpose(..)
-- ** Supporting types used in the context types
-- *** ByteStrings
, BuiltinByteString
, toBuiltin
, fromBuiltin
-- *** Bytes
, LedgerBytes (..)
, fromBytes
-- *** Certificates
, DCert(..)
-- *** Credentials
, StakingCredential(..)
, Credential(..)
-- *** Value
, Value (..)
, CurrencySymbol (..)
, TokenName (..)
, singleton
, unionWith
, adaSymbol
, adaToken
-- *** Time
, POSIXTime (..)
, POSIXTimeRange
-- *** Types for representing transactions
, Address (..)
, PubKeyHash (..)
, TxId (..)
, TxInfo (..)
, TxOut(..)
, TxOutRef(..)
, TxInInfo(..)
-- *** Intervals
, Interval (..)
, Extended (..)
, Closure
, UpperBound (..)
, LowerBound (..)
, always
, from
, to
, lowerBound
, upperBound
, strictLowerBound
, strictUpperBound
-- *** Newtypes for script/datum types and hash types
, Validator (..)
, mkValidatorScript
, unValidatorScript
, ValidatorHash (..)
, MintingPolicy (..)
, mkMintingPolicyScript
, unMintingPolicyScript
, MintingPolicyHash (..)
, StakeValidator (..)
, mkStakeValidatorScript
, unStakeValidatorScript
, StakeValidatorHash (..)
, Redeemer (..)
, RedeemerHash (..)
, Datum (..)
, DatumHash (..)
-- * Data
, PLC.Data (..)
, BuiltinData (..)
, ToData (..)
, FromData (..)
, UnsafeFromData (..)
, toData
, fromData
, dataToBuiltinData
, builtinDataToData
-- * Errors
, EvaluationError (..)
) where
import Codec.CBOR.Read qualified as CBOR (DeserialiseFailure)
import Control.Monad.Except (MonadError)
import Data.SatInt
import PlutusCore.Data qualified as PLC
import PlutusCore.Evaluation.Machine.ExBudget as PLC
import PlutusCore.Evaluation.Machine.ExMemory (ExCPU (..), ExMemory (..))
import PlutusLedgerApi.Common as Common hiding (assertScriptWellFormed, evaluateScriptCounting,
evaluateScriptRestricting)
import PlutusLedgerApi.Common qualified as Common (assertScriptWellFormed, evaluateScriptCounting,
evaluateScriptRestricting)
import PlutusLedgerApi.V1.Address
import PlutusLedgerApi.V1.Bytes
import PlutusLedgerApi.V1.Contexts
import PlutusLedgerApi.V1.Credential
import PlutusLedgerApi.V1.Crypto
import PlutusLedgerApi.V1.DCert
import PlutusLedgerApi.V1.EvaluationContext
import PlutusLedgerApi.V1.Interval hiding (singleton)
import PlutusLedgerApi.V1.ParamName
import PlutusLedgerApi.V1.Scripts as Scripts
import PlutusLedgerApi.V1.Time
import PlutusLedgerApi.V1.Value
import PlutusTx (FromData (..), ToData (..), UnsafeFromData (..), fromData, toData)
import PlutusTx.Builtins.Internal (BuiltinData (..), builtinDataToData, dataToBuiltinData)
import PlutusTx.Prelude (BuiltinByteString, fromBuiltin, toBuiltin)
{- Note [Abstract types in the ledger API]
We need to support old versions of the ledger API as we update the code that it depends on. You
might think that we should therefore make the types that we expose abstract, and only expose
specific functions for constructing and working with them. However the situation is slightly
different for us.
Normally, when you are in this situation, you want to retain the same *interface* as the old version,
but with the new types and functions underneath. Abstraction lets you do this easily. But we actually
want to keep the old *implementation*, because things really have to work the same, bug-for-bug. And
the types have to translate into Plutus Core in exactly the same way, and so on.
So we're going to end up with multiple versions of the types and functions that we expose here, even
internally. That means we don't lose anything by exposing all the details: we're never going to remove
anything, we're just going to create new versions.
-}
-- | Check if a 'Script' is "valid" according to a protocol version. At the moment this means "deserialises correctly", which in particular
-- implies that it is (almost certainly) an encoded script and the script does not mention any builtins unavailable in the given protocol version.
assertScriptWellFormed :: MonadError CBOR.DeserialiseFailure m
=> ProtocolVersion
-> SerialisedScript
-> m ()
assertScriptWellFormed = Common.assertScriptWellFormed PlutusV1
-- | Evaluates a script, returning the minimum budget that the script would need
-- to evaluate successfully. This will take as long as the script takes, if you need to
-- limit the execution time of the script also, you can use 'evaluateScriptRestricting', which
-- also returns the used budget.
evaluateScriptCounting
:: ProtocolVersion
-> VerboseMode -- ^ Whether to produce log output
-> EvaluationContext -- ^ The cost model that should already be synced to the most recent cost-model-params coming from the current protocol
-> SerialisedScript -- ^ The script to evaluate
-> [PLC.Data] -- ^ The arguments to the script
-> (LogOutput, Either EvaluationError ExBudget)
evaluateScriptCounting = Common.evaluateScriptCounting PlutusV1
-- | Evaluates a script, with a cost model and a budget that restricts how many
-- resources it can use according to the cost model. Also returns the budget that
-- was actually used.
--
-- Can be used to calculate budgets for scripts, but even in this case you must give
-- a limit to guard against scripts that run for a long time or loop.
evaluateScriptRestricting
:: ProtocolVersion
-> VerboseMode -- ^ Whether to produce log output
-> EvaluationContext -- ^ The cost model that should already be synced to the most recent cost-model-params coming from the current protocol
-> ExBudget -- ^ The resource budget which must not be exceeded during evaluation
-> SerialisedScript -- ^ The script to evaluate
-> [PLC.Data] -- ^ The arguments to the script
-> (LogOutput, Either EvaluationError ExBudget)
evaluateScriptRestricting = Common.evaluateScriptRestricting PlutusV1