github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/x/evm/types/params.go (about)

     1  package types
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"gopkg.in/yaml.v2"
     7  
     8  	"github.com/ethereum/go-ethereum/core/vm"
     9  
    10  	"github.com/fibonacci-chain/fbc/x/params"
    11  )
    12  
    13  const (
    14  	// DefaultParamspace for params keeper
    15  	DefaultParamspace       = ModuleName
    16  	defaultMaxGasLimitPerTx = 30000000
    17  )
    18  
    19  // Parameter keys
    20  var (
    21  	ParamStoreKeyEnableCreate                = []byte("EnableCreate")
    22  	ParamStoreKeyEnableCall                  = []byte("EnableCall")
    23  	ParamStoreKeyExtraEIPs                   = []byte("EnableExtraEIPs")
    24  	ParamStoreKeyContractDeploymentWhitelist = []byte("EnableContractDeploymentWhitelist")
    25  	ParamStoreKeyContractBlockedList         = []byte("EnableContractBlockedList")
    26  	ParamStoreKeyMaxGasLimitPerTx            = []byte("MaxGasLimitPerTx")
    27  )
    28  
    29  // ParamKeyTable returns the parameter key table.
    30  func ParamKeyTable() params.KeyTable {
    31  	return params.NewKeyTable().RegisterParamSet(&Params{})
    32  }
    33  
    34  // Params defines the EVM module parameters
    35  type Params struct {
    36  	// EnableCreate toggles state transitions that use the vm.Create function
    37  	EnableCreate bool `json:"enable_create" yaml:"enable_create"`
    38  	// EnableCall toggles state transitions that use the vm.Call function
    39  	EnableCall bool `json:"enable_call" yaml:"enable_call"`
    40  	// ExtraEIPs defines the additional EIPs for the vm.Config
    41  	ExtraEIPs []int `json:"extra_eips" yaml:"extra_eips"`
    42  	// EnableContractDeploymentWhitelist controls the authorization of contract deployer
    43  	EnableContractDeploymentWhitelist bool `json:"enable_contract_deployment_whitelist" yaml:"enable_contract_deployment_whitelist"`
    44  	// EnableContractBlockedList controls the availability of contracts
    45  	EnableContractBlockedList bool `json:"enable_contract_blocked_list" yaml:"enable_contract_blocked_list"`
    46  	// MaxGasLimit defines the max gas limit in transaction
    47  	MaxGasLimitPerTx uint64 `json:"max_gas_limit_per_tx" yaml:"max_gas_limit_per_tx"`
    48  }
    49  
    50  // NewParams creates a new Params instance
    51  func NewParams(enableCreate, enableCall, enableContractDeploymentWhitelist, enableContractBlockedList bool, maxGasLimitPerTx uint64,
    52  	extraEIPs ...int) Params {
    53  	return Params{
    54  		EnableCreate:                      enableCreate,
    55  		EnableCall:                        enableCall,
    56  		ExtraEIPs:                         extraEIPs,
    57  		EnableContractDeploymentWhitelist: enableContractDeploymentWhitelist,
    58  		EnableContractBlockedList:         enableContractBlockedList,
    59  		MaxGasLimitPerTx:                  maxGasLimitPerTx,
    60  	}
    61  }
    62  
    63  // DefaultParams returns default evm parameters
    64  func DefaultParams() Params {
    65  	return Params{
    66  		EnableCreate:                      false,
    67  		EnableCall:                        false,
    68  		ExtraEIPs:                         []int(nil), // TODO: define default values
    69  		EnableContractDeploymentWhitelist: false,
    70  		EnableContractBlockedList:         false,
    71  		MaxGasLimitPerTx:                  defaultMaxGasLimitPerTx,
    72  	}
    73  }
    74  
    75  // String implements the fmt.Stringer interface
    76  func (p Params) String() string {
    77  	out, _ := yaml.Marshal(p)
    78  	return string(out)
    79  }
    80  
    81  // ParamSetPairs returns the parameter set pairs.
    82  func (p *Params) ParamSetPairs() params.ParamSetPairs {
    83  	return params.ParamSetPairs{
    84  		params.NewParamSetPair(ParamStoreKeyEnableCreate, &p.EnableCreate, validateBool),
    85  		params.NewParamSetPair(ParamStoreKeyEnableCall, &p.EnableCall, validateBool),
    86  		params.NewParamSetPair(ParamStoreKeyExtraEIPs, &p.ExtraEIPs, validateEIPs),
    87  		params.NewParamSetPair(ParamStoreKeyContractDeploymentWhitelist, &p.EnableContractDeploymentWhitelist, validateBool),
    88  		params.NewParamSetPair(ParamStoreKeyContractBlockedList, &p.EnableContractBlockedList, validateBool),
    89  		params.NewParamSetPair(ParamStoreKeyMaxGasLimitPerTx, &p.MaxGasLimitPerTx, validateUint64),
    90  	}
    91  }
    92  
    93  // Validate performs basic validation on evm parameters.
    94  func (p Params) Validate() error {
    95  	return validateEIPs(p.ExtraEIPs)
    96  }
    97  
    98  func validateBool(i interface{}) error {
    99  	_, ok := i.(bool)
   100  	if !ok {
   101  		return fmt.Errorf("invalid parameter type: %T", i)
   102  	}
   103  	return nil
   104  }
   105  
   106  func validateEIPs(i interface{}) error {
   107  	eips, ok := i.([]int)
   108  	if !ok {
   109  		return fmt.Errorf("invalid EIP slice type: %T", i)
   110  	}
   111  
   112  	for _, eip := range eips {
   113  		if !vm.ValidEip(eip) {
   114  			return fmt.Errorf("EIP %d is not activateable", eip)
   115  		}
   116  	}
   117  
   118  	return nil
   119  }
   120  
   121  func validateUint64(i interface{}) error {
   122  	_, ok := i.(uint64)
   123  	if !ok {
   124  		return fmt.Errorf("invalid parameter type: %T", i)
   125  	}
   126  	return nil
   127  }