github.com/InjectiveLabs/sdk-go@v1.53.0/chain/wasmx/types/params.go (about)

     1  package types
     2  
     3  import (
     4  	"fmt"
     5  
     6  	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
     7  	sdk "github.com/cosmos/cosmos-sdk/types"
     8  	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
     9  )
    10  
    11  var _ paramtypes.ParamSet = &Params{}
    12  
    13  const (
    14  	GasForFeeDeduction     uint64 = 13419
    15  	GasForFeeRefund        uint64 = 13419
    16  	DefaultGasContractCall uint64 = 63558
    17  	MinExecutionGasLimit          = GasForFeeDeduction + GasForFeeRefund + DefaultGasContractCall
    18  )
    19  
    20  // Wasmx params default values
    21  var (
    22  	DefaultIsExecutionEnabled           = false
    23  	DefaultMaxBeginBlockTotalGas uint64 = 42_000_000                        // 42M
    24  	DefaultMaxContractGasLimit   uint64 = DefaultMaxBeginBlockTotalGas / 12 // 3.5M
    25  	DefaultMinGasPrice           uint64 = 1_000_000_000                     // 1B
    26  )
    27  
    28  // Parameter keys
    29  var (
    30  	KeyIsExecutionEnabled     = []byte("IsExecutionEnabled")
    31  	KeyMaxBeginBlockTotalGas  = []byte("MaxBeginBlockTotalGas")
    32  	KeyMaxContractGasLimit    = []byte("MaxContractGasLimit")
    33  	KeyMinGasPrice            = []byte("MinGasPrice")
    34  	KeyRegisterContractAccess = []byte("RegisterContractAccess")
    35  )
    36  
    37  // ParamKeyTable returns the parameter key table.
    38  func ParamKeyTable() paramtypes.KeyTable {
    39  	return paramtypes.NewKeyTable().RegisterParamSet(&Params{})
    40  }
    41  
    42  // NewParams creates a new Params instance
    43  func NewParams(
    44  	isExecutionEnabled bool,
    45  	maxBeginBlockTotalGas uint64,
    46  	maxContractGasLimit uint64,
    47  	minGasPrice uint64,
    48  	registerContractAccess wasmtypes.AccessConfig,
    49  ) Params {
    50  	return Params{
    51  		IsExecutionEnabled:     isExecutionEnabled,
    52  		MaxBeginBlockTotalGas:  maxBeginBlockTotalGas,
    53  		MaxContractGasLimit:    maxContractGasLimit,
    54  		MinGasPrice:            minGasPrice,
    55  		RegisterContractAccess: registerContractAccess,
    56  	}
    57  }
    58  
    59  // ParamSetPairs returns the parameter set pairs.
    60  func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
    61  	return paramtypes.ParamSetPairs{
    62  		paramtypes.NewParamSetPair(KeyMinGasPrice, &p.MinGasPrice, validateMinGasPrice),
    63  		paramtypes.NewParamSetPair(KeyIsExecutionEnabled, &p.IsExecutionEnabled, validateIsExecutionEnabled),
    64  		paramtypes.NewParamSetPair(KeyMaxBeginBlockTotalGas, &p.MaxBeginBlockTotalGas, validateMaxBeginBlockTotalGas),
    65  		paramtypes.NewParamSetPair(KeyMaxContractGasLimit, &p.MaxContractGasLimit, validateMaxContractGasLimit),
    66  		paramtypes.NewParamSetPair(KeyRegisterContractAccess, &p.RegisterContractAccess, validateAccessConfig),
    67  	}
    68  }
    69  
    70  // DefaultParams returns a default set of parameters.
    71  func DefaultParams() Params {
    72  	return Params{
    73  		IsExecutionEnabled:     DefaultIsExecutionEnabled,
    74  		MaxBeginBlockTotalGas:  DefaultMaxBeginBlockTotalGas,
    75  		MaxContractGasLimit:    DefaultMaxContractGasLimit,
    76  		MinGasPrice:            DefaultMinGasPrice,
    77  		RegisterContractAccess: wasmtypes.AccessConfig{},
    78  	}
    79  }
    80  
    81  // Validate performs basic validation on wasmx parameters.
    82  func (p Params) Validate() error {
    83  	if err := validateIsExecutionEnabled(p.IsExecutionEnabled); err != nil {
    84  		return err
    85  	}
    86  
    87  	if err := validateMaxBeginBlockTotalGas(p.MaxBeginBlockTotalGas); err != nil {
    88  		return err
    89  	}
    90  
    91  	if err := validateMaxContractGasLimit(p.MaxContractGasLimit); err != nil {
    92  		return err
    93  	}
    94  
    95  	if err := validateMinGasPrice(p.MinGasPrice); err != nil {
    96  		return err
    97  	}
    98  
    99  	if err := validateAccessConfig(p.RegisterContractAccess); err != nil {
   100  		return err
   101  	}
   102  	return nil
   103  }
   104  
   105  func validateMaxBeginBlockTotalGas(i interface{}) error {
   106  	v, ok := i.(uint64)
   107  	if !ok {
   108  		return fmt.Errorf("invalid parameter type: %T", i)
   109  	}
   110  
   111  	if v == 0 {
   112  		return fmt.Errorf("MaxBeginBlockTotalGas must be positive: %d", v)
   113  	}
   114  
   115  	return nil
   116  }
   117  
   118  func validateMaxContractGasLimit(i interface{}) error {
   119  	v, ok := i.(uint64)
   120  	if !ok {
   121  		return fmt.Errorf("invalid parameter type: %T", i)
   122  	}
   123  
   124  	if v < MinExecutionGasLimit {
   125  		return fmt.Errorf("MaxContractGasLimit %d must be greater than the MinExecutionGasLimit: %d", v, MinExecutionGasLimit)
   126  	}
   127  	return nil
   128  }
   129  
   130  func validateIsExecutionEnabled(i interface{}) error {
   131  	_, ok := i.(bool)
   132  	if !ok {
   133  		return fmt.Errorf("invalid parameter type: %T", i)
   134  	}
   135  
   136  	return nil
   137  }
   138  
   139  func validateMinGasPrice(i interface{}) error {
   140  	v, ok := i.(uint64)
   141  	if !ok {
   142  		return fmt.Errorf("invalid parameter type: %T", i)
   143  	}
   144  
   145  	if v == 0 {
   146  		return fmt.Errorf("MinGasPrice must be positive: %d", v)
   147  	}
   148  	return nil
   149  }
   150  
   151  func validateAccessConfig(i interface{}) error {
   152  	v, ok := i.(wasmtypes.AccessConfig)
   153  	if !ok {
   154  		return fmt.Errorf("invalid parameter type: %T", i)
   155  	}
   156  
   157  	uploaders := make(map[string]struct{})
   158  
   159  	for _, addr := range v.Addresses {
   160  		address, err := sdk.AccAddressFromBech32(addr)
   161  		if err != nil {
   162  			return fmt.Errorf("invalid address: %s", addr)
   163  		}
   164  
   165  		if _, found := uploaders[address.String()]; found {
   166  			return fmt.Errorf("duplicate address: %s", addr)
   167  		}
   168  		uploaders[address.String()] = struct{}{}
   169  	}
   170  	return nil
   171  }