-
Notifications
You must be signed in to change notification settings - Fork 177
/
context.go
180 lines (157 loc) · 5.3 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
package fvm
import (
"github.com/onflow/cadence"
"github.com/rs/zerolog"
"github.com/onflow/flow-go/model/flow"
)
// A Context defines a set of execution parameters used by the virtual machine.
type Context struct {
Chain flow.Chain
ASTCache ASTCache
Blocks Blocks
Metrics *MetricsCollector
GasLimit uint64
BlockHeader *flow.Header
ServiceAccountEnabled bool
RestrictedAccountCreationEnabled bool
RestrictedDeploymentEnabled 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 = 100000
func defaultContext(logger zerolog.Logger) Context {
return Context{
Chain: flow.Mainnet.Chain(),
ASTCache: nil,
Blocks: nil,
Metrics: nil,
GasLimit: defaultGasLimit,
BlockHeader: nil,
ServiceAccountEnabled: true,
RestrictedAccountCreationEnabled: true,
RestrictedDeploymentEnabled: true,
SetValueHandler: nil,
SignatureVerifier: NewDefaultSignatureVerifier(),
TransactionProcessors: []TransactionProcessor{
NewTransactionSignatureVerifier(AccountKeyWeightThreshold),
NewTransactionSequenceNumberChecker(),
NewTransactionFeeDeductor(),
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
}
}
// WithASTCache sets the AST cache for a virtual machine context.
func WithASTCache(cache ASTCache) Option {
return func(ctx Context) Context {
ctx.ASTCache = cache
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
}
}
// 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
}
}
// 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
}
}
// WithTransactionSignatureVerifier 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
}
}
// 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
}
}