-
Notifications
You must be signed in to change notification settings - Fork 182
/
params.go
126 lines (109 loc) · 4.25 KB
/
params.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
package types
import (
"fmt"
"gopkg.in/yaml.v2"
"github.com/ethereum/go-ethereum/core/vm"
"github.com/okex/exchain/x/params"
)
const (
// DefaultParamspace for params keeper
DefaultParamspace = ModuleName
DefaultMaxGasLimitPerTx = 30000000
)
// Parameter keys
var (
ParamStoreKeyEnableCreate = []byte("EnableCreate")
ParamStoreKeyEnableCall = []byte("EnableCall")
ParamStoreKeyExtraEIPs = []byte("EnableExtraEIPs")
ParamStoreKeyContractDeploymentWhitelist = []byte("EnableContractDeploymentWhitelist")
ParamStoreKeyContractBlockedList = []byte("EnableContractBlockedList")
ParamStoreKeyMaxGasLimitPerTx = []byte("MaxGasLimitPerTx")
)
// ParamKeyTable returns the parameter key table.
func ParamKeyTable() params.KeyTable {
return params.NewKeyTable().RegisterParamSet(&Params{})
}
// Params defines the EVM module parameters
type Params struct {
// EnableCreate toggles state transitions that use the vm.Create function
EnableCreate bool `json:"enable_create" yaml:"enable_create"`
// EnableCall toggles state transitions that use the vm.Call function
EnableCall bool `json:"enable_call" yaml:"enable_call"`
// ExtraEIPs defines the additional EIPs for the vm.Config
ExtraEIPs []int `json:"extra_eips" yaml:"extra_eips"`
// EnableContractDeploymentWhitelist controls the authorization of contract deployer
EnableContractDeploymentWhitelist bool `json:"enable_contract_deployment_whitelist" yaml:"enable_contract_deployment_whitelist"`
// EnableContractBlockedList controls the availability of contracts
EnableContractBlockedList bool `json:"enable_contract_blocked_list" yaml:"enable_contract_blocked_list"`
// MaxGasLimit defines the max gas limit in transaction
MaxGasLimitPerTx uint64 `json:"max_gas_limit_per_tx" yaml:"max_gas_limit_per_tx"`
}
// NewParams creates a new Params instance
func NewParams(enableCreate, enableCall, enableContractDeploymentWhitelist, enableContractBlockedList bool, maxGasLimitPerTx uint64,
extraEIPs ...int) Params {
return Params{
EnableCreate: enableCreate,
EnableCall: enableCall,
ExtraEIPs: extraEIPs,
EnableContractDeploymentWhitelist: enableContractDeploymentWhitelist,
EnableContractBlockedList: enableContractBlockedList,
MaxGasLimitPerTx: maxGasLimitPerTx,
}
}
// DefaultParams returns default evm parameters
func DefaultParams() Params {
return Params{
EnableCreate: false,
EnableCall: false,
ExtraEIPs: []int(nil), // TODO: define default values
EnableContractDeploymentWhitelist: false,
EnableContractBlockedList: false,
MaxGasLimitPerTx: DefaultMaxGasLimitPerTx,
}
}
// String implements the fmt.Stringer interface
func (p Params) String() string {
out, _ := yaml.Marshal(p)
return string(out)
}
// ParamSetPairs returns the parameter set pairs.
func (p *Params) ParamSetPairs() params.ParamSetPairs {
return params.ParamSetPairs{
params.NewParamSetPair(ParamStoreKeyEnableCreate, &p.EnableCreate, validateBool),
params.NewParamSetPair(ParamStoreKeyEnableCall, &p.EnableCall, validateBool),
params.NewParamSetPair(ParamStoreKeyExtraEIPs, &p.ExtraEIPs, validateEIPs),
params.NewParamSetPair(ParamStoreKeyContractDeploymentWhitelist, &p.EnableContractDeploymentWhitelist, validateBool),
params.NewParamSetPair(ParamStoreKeyContractBlockedList, &p.EnableContractBlockedList, validateBool),
params.NewParamSetPair(ParamStoreKeyMaxGasLimitPerTx, &p.MaxGasLimitPerTx, validateUint64),
}
}
// Validate performs basic validation on evm parameters.
func (p Params) Validate() error {
return validateEIPs(p.ExtraEIPs)
}
func validateBool(i interface{}) error {
_, ok := i.(bool)
if !ok {
return fmt.Errorf("invalid parameter type: %T", i)
}
return nil
}
func validateEIPs(i interface{}) error {
eips, ok := i.([]int)
if !ok {
return fmt.Errorf("invalid EIP slice type: %T", i)
}
for _, eip := range eips {
if !vm.ValidEip(eip) {
return fmt.Errorf("EIP %d is not activateable", eip)
}
}
return nil
}
func validateUint64(i interface{}) error {
_, ok := i.(uint64)
if !ok {
return fmt.Errorf("invalid parameter type: %T", i)
}
return nil
}