-
Notifications
You must be signed in to change notification settings - Fork 175
/
context.go
274 lines (243 loc) · 8.35 KB
/
context.go
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
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
package fvm
import (
"github.com/onflow/cadence"
"github.com/rs/zerolog"
"github.com/onflow/flow-go/fvm/state"
"github.com/onflow/flow-go/model/flow"
"github.com/onflow/flow-go/module"
)
// A Context defines a set of execution parameters used by the virtual machine.
type Context struct {
Chain flow.Chain
Blocks Blocks
Metrics *MetricsCollector
Tracer module.Tracer
GasLimit uint64
MaxStateKeySize uint64
MaxStateValueSize uint64
MaxStateInteractionSize uint64
EventCollectionByteSizeLimit uint64
MaxNumOfTxRetries uint8
BlockHeader *flow.Header
ServiceAccountEnabled bool
RestrictedAccountCreationEnabled bool
RestrictedDeploymentEnabled bool
LimitAccountStorage bool
CadenceLoggingEnabled bool
AccountFreezeAvailable bool
ExtensiveTracing bool
SetValueHandler SetValueHandler
SignatureVerifier SignatureVerifier
TransactionProcessors []TransactionProcessor
ScriptProcessors []ScriptProcessor
Logger zerolog.Logger
}
// SetValueHandler receives a value written by the Cadence runtime.
type SetValueHandler func(owner flow.Address, key string, value cadence.Value) error
// NewContext initializes a new execution context with the provided options.
func NewContext(logger zerolog.Logger, opts ...Option) Context {
return newContext(defaultContext(logger), opts...)
}
// NewContextFromParent spawns a child execution context with the provided options.
func NewContextFromParent(parent Context, opts ...Option) Context {
return newContext(parent, opts...)
}
func newContext(ctx Context, opts ...Option) Context {
for _, applyOption := range opts {
ctx = applyOption(ctx)
}
return ctx
}
const AccountKeyWeightThreshold = 1000
const (
DefaultGasLimit = 100_000 // 100K
DefaultEventCollectionByteSizeLimit = 256_000 // 256KB
DefaultMaxNumOfTxRetries = 3
)
func defaultContext(logger zerolog.Logger) Context {
return Context{
Chain: flow.Mainnet.Chain(),
Blocks: nil,
Metrics: nil,
Tracer: nil,
GasLimit: DefaultGasLimit,
MaxStateKeySize: state.DefaultMaxKeySize,
MaxStateValueSize: state.DefaultMaxValueSize,
MaxStateInteractionSize: state.DefaultMaxInteractionSize,
EventCollectionByteSizeLimit: DefaultEventCollectionByteSizeLimit,
MaxNumOfTxRetries: DefaultMaxNumOfTxRetries,
BlockHeader: nil,
ServiceAccountEnabled: true,
RestrictedAccountCreationEnabled: true,
RestrictedDeploymentEnabled: true,
CadenceLoggingEnabled: false,
AccountFreezeAvailable: false,
ExtensiveTracing: false,
SetValueHandler: nil,
SignatureVerifier: NewDefaultSignatureVerifier(),
TransactionProcessors: []TransactionProcessor{
NewTransactionAccountFrozenChecker(),
NewTransactionSignatureVerifier(AccountKeyWeightThreshold),
NewTransactionSequenceNumberChecker(),
NewTransactionFeeDeductor(),
NewTransactionAccountFrozenEnabler(),
NewTransactionInvocator(logger),
},
ScriptProcessors: []ScriptProcessor{
NewScriptInvocator(),
},
Logger: logger,
}
}
// An Option sets a configuration parameter for a virtual machine context.
type Option func(ctx Context) Context
// WithChain sets the chain parameters for a virtual machine context.
func WithChain(chain flow.Chain) Option {
return func(ctx Context) Context {
ctx.Chain = chain
return ctx
}
}
// WithGasLimit sets the gas limit for a virtual machine context.
func WithGasLimit(limit uint64) Option {
return func(ctx Context) Context {
ctx.GasLimit = limit
return ctx
}
}
// WithMaxStateKeySize sets the byte size limit for ledger keys
func WithMaxStateKeySize(limit uint64) Option {
return func(ctx Context) Context {
ctx.MaxStateKeySize = limit
return ctx
}
}
// WithMaxStateValueSize sets the byte size limit for ledger values
func WithMaxStateValueSize(limit uint64) Option {
return func(ctx Context) Context {
ctx.MaxStateValueSize = limit
return ctx
}
}
// WithMaxStateInteractionSize sets the byte size limit for total interaction with ledger.
// this prevents attacks such as reading all large registers
func WithMaxStateInteractionSize(limit uint64) Option {
return func(ctx Context) Context {
ctx.MaxStateInteractionSize = limit
return ctx
}
}
// WithEventCollectionSizeLimit sets the event collection byte size limit for a virtual machine context.
func WithEventCollectionSizeLimit(limit uint64) Option {
return func(ctx Context) Context {
ctx.EventCollectionByteSizeLimit = limit
return ctx
}
}
// WithBlockHeader sets the block header for a virtual machine context.
//
// The VM uses the header to provide current block information to the Cadence runtime,
// as well as to seed the pseudorandom number generator.
func WithBlockHeader(header *flow.Header) Option {
return func(ctx Context) Context {
ctx.BlockHeader = header
return ctx
}
}
// WithAccountFreezeAvailable sets availability of account freeze function for a virtual machine context.
//
// With this option set to true, a setAccountFreeze function will be enabled for transactions processed by the VM
func WithAccountFreezeAvailable(accountFreezeAvailable bool) Option {
return func(ctx Context) Context {
ctx.AccountFreezeAvailable = accountFreezeAvailable
return ctx
}
}
// WithExtensiveTracing sets the extensive tracing
func WithExtensiveTracing() Option {
return func(ctx Context) Context {
ctx.ExtensiveTracing = true
return ctx
}
}
// WithBlocks sets the block storage provider for a virtual machine context.
//
// The VM uses the block storage provider to provide historical block information to
// the Cadence runtime.
func WithBlocks(blocks Blocks) Option {
return func(ctx Context) Context {
ctx.Blocks = blocks
return ctx
}
}
// WithMetricsCollector sets the metrics collector for a virtual machine context.
//
// A metrics collector is used to gather metrics reported by the Cadence runtime.
func WithMetricsCollector(mc *MetricsCollector) Option {
return func(ctx Context) Context {
ctx.Metrics = mc
return ctx
}
}
// WithTracer sets the tracer for a virtual machine context.
func WithTracer(tr module.Tracer) Option {
return func(ctx Context) Context {
ctx.Tracer = tr
return ctx
}
}
// WithTransactionProcessors sets the transaction processors for a
// virtual machine context.
func WithTransactionProcessors(processors ...TransactionProcessor) Option {
return func(ctx Context) Context {
ctx.TransactionProcessors = processors
return ctx
}
}
// WithServiceAccount enables or disables calls to the Flow service account.
func WithServiceAccount(enabled bool) Option {
return func(ctx Context) Context {
ctx.ServiceAccountEnabled = enabled
return ctx
}
}
// WithRestrictedDeployment enables or disables restricted contract deployment for a
// virtual machine context.
func WithRestrictedDeployment(enabled bool) Option {
return func(ctx Context) Context {
ctx.RestrictedDeploymentEnabled = enabled
return ctx
}
}
// WithCadenceLogging enables or disables Cadence logging for a
// virtual machine context.
func WithCadenceLogging(enabled bool) Option {
return func(ctx Context) Context {
ctx.CadenceLoggingEnabled = enabled
return ctx
}
}
// WithRestrictedAccountCreation enables or disables restricted account creation for a
// virtual machine context
func WithRestrictedAccountCreation(enabled bool) Option {
return func(ctx Context) Context {
ctx.RestrictedAccountCreationEnabled = enabled
return ctx
}
}
// WithSetValueHandler sets a handler that is called when a value is written
// by the Cadence runtime.
func WithSetValueHandler(handler SetValueHandler) Option {
return func(ctx Context) Context {
ctx.SetValueHandler = handler
return ctx
}
}
// WithAccountStorageLimit enables or disables checking if account storage used is
// over its storage capacity
func WithAccountStorageLimit(enabled bool) Option {
return func(ctx Context) Context {
ctx.LimitAccountStorage = enabled
return ctx
}
}