iface

type AcceptedContractCaller interface {
	AcceptedCallContract(ctx context.Context, call CallMsg) ([]byte, error)
}

type AcceptedStateReader interface {
	AcceptedCodeAt(ctx context.Context, address common.Address) ([]byte, error)
	AcceptedNonceAt(ctx context.Context, address common.Address) (uint64, error)
}

type AddressedCall = payload.AddressedCall

type AppSender interface {
	SendAppRequest(ctx context.Context, nodeIDs Set, requestID uint32, request []byte) error
	SendAppResponse(ctx context.Context, nodeID NodeID, requestID uint32, response []byte) error
	SendAppGossip(ctx context.Context, config SendConfig, appGossipBytes []byte) error
}

type AtomicMemory interface {
	// NewSharedMemory creates a new shared memory instance for a chain
	NewSharedMemory(chainID ID) SharedMemory
}

type AtomicTx interface {
	// BlockNumber returns the block number
	BlockNumber() *big.Int

	// UTXOs returns the UTXOs
	UTXOs() [][]byte
}

type Batch interface {
	ethdb.Batch
}

type Batcher interface {
	// NewBatch creates a new batch
	NewBatch() ethdb.Batch
}

type Bits = iface.Bits

type Block interface {
	// ID returns the block's ID
	ID() ID

	// Accept marks the block as accepted
	Accept(context.Context) error

	// Reject marks the block as rejected
	Reject(context.Context) error

	// Status returns the block's status
	Status() Status

	// Parent returns the parent block ID
	Parent() ID

	// Height returns the block height
	Height() uint64

	// Timestamp returns the block timestamp
	Timestamp() Timestamp

	// Verify verifies the block
	Verify(context.Context) error

	// Bytes returns the block bytes
	Bytes() []byte
}

type BlockBuildContext struct {
	PChainHeight uint64
}

type BlockContext struct {
	CanTransfer func(StateDB, common.Address, *big.Int) bool
	Transfer    func(StateDB, common.Address, common.Address, *big.Int) error
	GetHash     func(uint64) common.Hash
	Coinbase    common.Address
	GasLimit    uint64
	BlockNumber *big.Int
	Time        uint64
	Difficulty  *big.Int
	BaseFee     *big.Int
}

type BlockGetter interface {
	// GetBlock retrieves a block by ID
	GetBlock(ctx context.Context, blkID BlockID) (NodeBlock, error)
}

type BlockID [32]byte

type BlockParser interface {
	// ParseBlock parses block bytes into a Block
	ParseBlock(ctx context.Context, blockBytes []byte) (NodeBlock, error)
}

type BlockRequest struct {
	Hash    []byte
	Number  uint64
	Parents uint16
}

type BlockSignatureRequest struct {
	BlockID []byte
}

type BoundedBuffer interface {
	// Put adds an item to the buffer
	Put(ctx context.Context, item interface{}) error

	// Get retrieves an item from the buffer
	Get(ctx context.Context) (interface{}, error)

	// Len returns the number of items in the buffer
	Len() int

	// Close closes the buffer
	Close()
}

type BuildBlockWithContextChainVM interface {
	ChainVM
	// BuildBlockWithContext builds a block with additional context
	BuildBlockWithContext(ctx context.Context, blockContext *BlockBuildContext) (NodeBlock, error)
}

type Cache interface {
	// Get retrieves a value from cache
	Get(key interface{}) (interface{}, bool)

	// Put stores a value in cache
	Put(key interface{}, value interface{})

	// Evict removes a value from cache
	Evict(key interface{})

	// Flush clears the cache
	Flush()
}

type Cacher[K comparable, V any] interface {
	// Put adds a value to the cache
	Put(key K, value V)

	// Get retrieves a value from the cache
	Get(key K) (V, bool)

	// Evict removes a value from the cache
	Evict(key K)

	// Flush clears the cache
	Flush()

	// Len returns the number of items in the cache
	Len() int
}

type CallMsg struct {
	From          common.Address  // the sender of the 'transaction'
	To            *common.Address // the destination contract (nil for contract creation)
	Gas           uint64          // if 0, the call executes with near-infinite gas
	GasPrice      *big.Int        // wei <-> gas exchange ratio
	GasFeeCap     *big.Int        // EIP-1559 fee cap per gas.
	GasTipCap     *big.Int        // EIP-1559 tip per gas.
	Value         *big.Int        // amount of wei sent along with the call
	Data          []byte          // input data, usually an ABI-encoded contract method invocation
	BlobGasFeeCap *big.Int        // EIP-4844 blob gas fee cap
	BlobHashes    []common.Hash   // EIP-4844 blob hashes

	AccessList types.AccessList // EIP-2930 access list.
}

type ChainConfig interface {
	// Chain identification
	GetChainID() *big.Int

	// Fork activation checks
	IsHomestead(num *big.Int) bool
	IsEIP150(num *big.Int) bool
	IsEIP155(num *big.Int) bool
	IsEIP158(num *big.Int) bool
	IsByzantium(num *big.Int) bool
	IsConstantinople(num *big.Int) bool
	IsPetersburg(num *big.Int) bool
	IsIstanbul(num *big.Int) bool
	IsBerlin(num *big.Int) bool
	IsLondon(num *big.Int) bool
	IsShanghai(num *big.Int, time uint64) bool
	IsCancun(time uint64) bool

	// Lux-specific methods
	IsEVM(time uint64) bool
	IsDurango(time uint64) bool
	AllowedFeeRecipients() bool
	LuxRules(blockNum *big.Int, timestamp uint64) LuxRules

	// AsGeth returns the underlying geth ChainConfig for compatibility
	AsGeth() interface{}
}

type ChainContext = iface.ChainContext

type ChainHeaderReader interface {
	// Config retrieves the blockchain's chain configuration.
	Config() ChainConfig

	// CurrentHeader retrieves the current header from the local chain.
	CurrentHeader() *types.Header

	// GetHeader retrieves a block header from the database by hash and number.
	GetHeader(hash common.Hash, number uint64) *types.Header

	// GetHeaderByNumber retrieves a block header from the database by number.
	GetHeaderByNumber(number uint64) *types.Header

	// GetHeaderByHash retrieves a block header from the database by its hash.
	GetHeaderByHash(hash common.Hash) *types.Header

	// GetTd retrieves the total difficulty from the database by hash and number.
	GetTd(hash common.Hash, number uint64) *big.Int

	// GetCoinbaseAt returns the configured coinbase address at the given timestamp
	GetCoinbaseAt(timestamp uint64) common.Address

	// GetFeeConfigAt returns the fee configuration at the given timestamp
	GetFeeConfigAt(timestamp uint64) (FeeConfig, error)
}

type ChainID = iface.ChainID

type ChainReader interface {
	ChainHeaderReader

	// GetBlock retrieves a block from the database by hash and number.
	GetBlock(hash common.Hash, number uint64) *types.Block
}

type ChainStateReader interface {
	BalanceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (*big.Int, error)
	StorageAt(ctx context.Context, account common.Address, key common.Hash, blockNumber *big.Int) ([]byte, error)
	CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error)
	NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error)
}

type ChainSyncReader interface {
	SyncProgress(ctx context.Context) (*SyncProgress, error)
}

type ChainVM interface {
	NodeVM
	BlockGetter
	BlockParser

	// BuildBlock attempts to build a new block
	BuildBlock(context.Context) (NodeBlock, error)

	// SetPreference sets the preferred block ID
	SetPreference(ctx context.Context, blkID BlockID) error

	// LastAccepted returns the last accepted block ID
	LastAccepted(context.Context) (BlockID, error)
}

type Choice uint32

type Clock interface {
	Time() time.Time
	Unix() int64
}

type CodeRequest struct {
	Hashes [][]byte
}

type Codec interface {
	// Marshal serializes an object into bytes
	Marshal(v interface{}) ([]byte, error)

	// Unmarshal deserializes bytes into an object
	Unmarshal(b []byte, v interface{}) error
}

type CodecRegistry interface {
	// RegisterCodec registers a codec for a type
	RegisterCodec(version uint16, codec Codec) error

	// GetCodec gets a codec for a version
	GetCodec(version uint16) (Codec, error)
}

type Compacter interface {
	// Compact compacts the underlying DB
	Compact(start []byte, limit []byte) error
}

type Constants interface {
	// NetworkID returns the network ID
	NetworkID() uint32

	// NetworkName returns the network name
	NetworkName() string
}

type ContractCaller interface {
	CallContract(ctx context.Context, call CallMsg, blockNumber *big.Int) ([]byte, error)
}

type ContractRef interface {
	Address() common.Address
}

type CrossChainRequestHandler interface {
	// HandleEthCallRequest handles ethereum call requests
	HandleEthCallRequest(ctx context.Context, requestingChainID ChainID, requestID uint32, ethCallRequest EthCallRequest) ([]byte, error)
}

type Database interface {
	KeyValueReader
	KeyValueWriter
	KeyValueDeleter
	Batcher
	Iteratee
	Compacter
	io.Closer
	HealthChecker
}

type Decidable interface {
	// ID returns the ID of this element
	ID() BlockID

	// Status returns the current status
	Status() Choice

	// Accept accepts this element
	Accept(context.Context) error

	// Reject rejects this element
	Reject(context.Context) error
}

type EVM interface {
	// Context returns the EVM context
	Context() VMContext

	// Call executes the contract with the given input
	Call(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error)

	// CallCode executes the contract with the caller's context
	CallCode(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error)

	// DelegateCall executes the contract with the caller's context and storage
	DelegateCall(caller ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, err error)

	// StaticCall executes the contract with read-only access
	StaticCall(caller ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, err error)

	// Create creates a new contract
	Create(caller ContractRef, code []byte, gas uint64, value *big.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error)

	// Create2 creates a new contract with deterministic address
	Create2(caller ContractRef, code []byte, gas uint64, endowment *big.Int, salt *big.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error)
}

type EVMChainReader interface {
	BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error)
	BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error)
	HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error)
	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
	TransactionCount(ctx context.Context, blockHash common.Hash) (uint, error)
	TransactionInBlock(ctx context.Context, blockHash common.Hash, index uint) (*types.Transaction, error)

	// This method subscribes to notifications about changes of the head block of
	// the canonical chain.
	SubscribeNewHead(ctx context.Context, ch chan<- *types.Header) (Subscription, error)
}

type Encoding uint8

type EndpointRequester interface {
	// SendRequest sends an RPC request
	SendRequest(ctx context.Context, method string, params interface{}, reply interface{}, options ...RPCOption) error
}

type Engine interface {
	// Author retrieves the Ethereum address of the account that minted the given block.
	Author(header *types.Header) (common.Address, error)

	// VerifyHeader checks whether a header conforms to the consensus rules of a given engine.
	VerifyHeader(chain ChainHeaderReader, header *types.Header, seal bool) error

	// VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers concurrently.
	VerifyHeaders(chain ChainHeaderReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error)

	// VerifyUncles verifies that the given block's uncles conform to the consensus rules.
	VerifyUncles(chain ChainReader, block *types.Block) error

	// Prepare initializes the consensus fields of a block header according to the rules.
	Prepare(chain ChainHeaderReader, header *types.Header) error

	// Finalize runs any post-transaction state modifications and assembles the final block.
	Finalize(chain ChainHeaderReader, header *types.Header, state StateDB, txs []*types.Transaction,
		uncles []*types.Header) (*types.Block, error)

	// FinalizeAndAssemble runs any post-transaction state modifications and assembles the final block.
	FinalizeAndAssemble(chain ChainHeaderReader, header *types.Header, state StateDB, txs []*types.Transaction,
		uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error)

	// Seal generates a new sealing request for the given input block and pushes it to the sealer.
	Seal(chain ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error

	// SealHash returns the hash of a block prior to it being sealed.
	SealHash(header *types.Header) common.Hash

	// CalcDifficulty is the difficulty adjustment algorithm.
	CalcDifficulty(chain ChainHeaderReader, time uint64, parent *types.Header) *big.Int

	// Close terminates any background threads maintained by the consensus engine.
	Close() error
}

type EngineMessage struct {
	InboundMessage
	EngineType
}

type EngineType uint32

type EthCallRequest struct {
	RequestArgs []byte
}

type FeeConfig interface {
	// Basic getters for fee configuration
	GetGasLimit() *big.Int
	GetTargetBlockRate() uint64
	GetMinBaseFee() *big.Int
	GetTargetGas() *big.Int
	GetBaseFeeChangeDenominator() *big.Int
	GetMinBlockGasCost() *big.Int
	GetMaxBlockGasCost() *big.Int
	GetBlockGasCostStep() *big.Int
}

type FeeHistory struct {
	OldestBlock      *big.Int     // block corresponding to first response value
	Reward           [][]*big.Int // list every txs priority fee per block
	BaseFee          []*big.Int   // list of each block's base fee
	GasUsedRatio     []float64    // ratio of gas used out of the total available limit
	BlobBaseFee      []*big.Int   // list of each block's blob base fee
	BlobGasUsedRatio []float64    // ratio of blob gas used out of the total available limit
	NextBaseFee      *big.Int     // base fee for the next block
	NextBlobBaseFee  *big.Int     // blob base fee for the next block
}

type FeeHistoryReader interface {
	FeeHistory(ctx context.Context, blockCount uint64, lastBlock *big.Int, rewardPercentiles []float64) (*FeeHistory, error)
}

type FilePermissions uint32

type FilterQuery struct {
	BlockHash *common.Hash     // used by eth_getLogs, return logs only from block with this hash
	FromBlock *big.Int         // beginning of the queried range, nil means genesis block
	ToBlock   *big.Int         // end of the range, nil means latest block
	Addresses []common.Address // restricts matches to events created by specific contracts

	// The Topic list restricts matches to particular event topics. Each event has a list
	// of topics. Topics matches a prefix of that list. An empty element slice matches any
	// topic. Non-empty elements represent an alternative that matches any of the
	// contained topics.
	//
	// Examples:
	// {} or nil          matches any topic list
	// {{A}}              matches topic A in first position
	// {{}, {B}}          matches any topic in first position AND B in second position
	// {{A}, {B}}         matches topic A in first position AND B in second position
	// {{A, B}, {C, D}}   matches topic (A OR B) in first position AND (C OR D) in second position
	Topics [][]common.Hash
}

type Formatting interface {
	// Encode encodes bytes to string
	Encode(encoding Encoding, bytes []byte) (string, error)

	// Decode decodes string to bytes
	Decode(encoding Encoding, str string) ([]byte, error)
}

type Fx interface{}

type GasEstimator interface {
	EstimateGas(ctx context.Context, call CallMsg) (uint64, error)
}

type GasPricer interface {
	SuggestGasPrice(ctx context.Context) (*big.Int, error)
}

type GasPricer1559 interface {
	SuggestGasTipCap(ctx context.Context) (*big.Int, error)
}

type GenericSet[T comparable] interface {
	// Add adds items to the set
	Add(items ...T)

	// Contains checks if an item is in the set
	Contains(item T) bool

	// Remove removes an item from the set
	Remove(item T)

	// Clear clears all items
	Clear()

	// Len returns the number of items
	Len() int

	// List returns all items as a slice
	List() []T
}

type GetValidatorOutput struct {
	NodeID    NodeID
	PublicKey []byte
	Weight    uint64
}

type GossipHandler interface {
	// HandleEthTxs handles ethereum transaction gossip
	HandleEthTxs(nodeID NodeID, msg GossipMessage) error
}

type GossipMessage interface {
	// Bytes returns the message bytes
	Bytes() []byte
}

type HTTPHandler interface{}

type Hash = payload.Hash

type HealthChecker interface {
	HealthCheck() (interface{}, error)
}

type ID [32]byte

type InboundMessage interface{}

type Iteratee interface {
	// NewIterator creates a new iterator
	NewIterator(prefix []byte, start []byte) ethdb.Iterator
}

type Iterator interface {
	ethdb.Iterator
}

type JSON interface {
	// Marshal converts a Go value to JSON
	Marshal(v interface{}) ([]byte, error)

	// Unmarshal parses JSON data
	Unmarshal(data []byte, v interface{}) error
}

type KeyValueDeleter interface {
	// Delete removes the key from the key-value data store.
	Delete(key []byte) error
}

type KeyValueReader interface {
	// Has retrieves if a key is present in the key-value data store.
	Has(key []byte) (bool, error)

	// Get retrieves the given key if it's present in the key-value data store.
	Get(key []byte) ([]byte, error)
}

type KeyValueWriter interface {
	// Put inserts the given value into the key-value data store.
	Put(key []byte, value []byte) error
}

type LRU interface {
	Cache
	// Len returns the number of items in cache
	Len() int
}

type LeafsRequest struct {
	Root     []byte
	Account  []byte
	Start    []byte
	End      []byte
	Limit    uint16
	NodeType uint
}

type LogFilterer interface {
	FilterLogs(ctx context.Context, q FilterQuery) ([]types.Log, error)
	SubscribeFilterLogs(ctx context.Context, q FilterQuery, ch chan<- types.Log) (Subscription, error)
}

type Logger interface {
	// Fatal logs a fatal error and exits
	Fatal(msg string, keyVals ...interface{})

	// Error logs an error
	Error(msg string, keyVals ...interface{})

	// Warn logs a warning
	Warn(msg string, keyVals ...interface{})

	// Info logs an info message
	Info(msg string, keyVals ...interface{})

	// Debug logs a debug message
	Debug(msg string, keyVals ...interface{})

	// Trace logs a trace message
	Trace(msg string, keyVals ...interface{})

	// With returns a logger with additional context
	With(keyVals ...interface{}) Logger
}

type LuxRules interface {
	IsEVM() bool
	IsDurango() bool
	IsEtna() bool
	IsFortuna() bool
	IsGranite() bool

	// Precompile access
	PredicatersExist() bool
	PredicaterExists(addr common.Address) bool
	GetActivePrecompiles() map[common.Address]interface{}
	GetPredicaters() map[common.Address]interface{}
	GetAccepterPrecompiles() map[common.Address]interface{}
}

type Message interface {
	From() common.Address
	To() *common.Address
	GasPrice() *big.Int
	GasFeeCap() *big.Int
	GasTipCap() *big.Int
	Gas() uint64
	Value() *big.Int
	Nonce() uint64
	IsFake() bool
	Data() []byte
	AccessList() types.AccessList
}

type MessageSignatureRequest struct {
	MessageID []byte
}

type Metrics interface {
	// IncCounter increments a counter metric
	IncCounter(name string)

	// AddSample adds a sample to a metric
	AddSample(name string, value float64)

	// SetGauge sets a gauge metric
	SetGauge(name string, value float64)
}

type MockableTimer interface {
	// Time returns the current time
	Time() time.Time

	// Set sets the current time (for testing)
	Set(time.Time)

	// Advance advances the time by duration (for testing)
	Advance(time.Duration)
}

type Network interface {
	// SendAppRequest sends an application request to specified nodes
	SendAppRequest(ctx context.Context, nodeIDs Set, requestID uint32, request []byte) error

	// SendAppResponse sends an application response to a specific node
	SendAppResponse(ctx context.Context, nodeID NodeID, requestID uint32, response []byte) error

	// SendAppGossip gossips application data to peers
	SendAppGossip(ctx context.Context, config SendConfig, appGossipBytes []byte) error

	// SendCrossChainAppRequest sends a cross-chain app request
	SendCrossChainAppRequest(ctx context.Context, chainID ChainID, requestID uint32, appRequestBytes []byte) error

	// SendCrossChainAppResponse sends a cross-chain app response
	SendCrossChainAppResponse(ctx context.Context, chainID ChainID, requestID uint32, appResponseBytes []byte) error
}

type NodeBlock interface {
	ID() BlockID
	Parent() BlockID
	Height() uint64
	Timestamp() uint64
	Bytes() []byte
	Verify(context.Context) error
	Accept(context.Context) error
	Reject(context.Context) error
}

type NodeConsensus interface {
	// GetConsensusParamsAt returns consensus parameters at a given block height
	GetConsensusParamsAt(ctx context.Context, blockHeight uint64) (*NodeConsensusParams, error)

	// IsUpgradeActive checks if an upgrade is active at a given timestamp
	IsUpgradeActive(upgradeID string, timestamp uint64) bool
}

type NodeConsensusParams struct {
	// BlockGasCost is the base gas cost for a block
	BlockGasCost uint64

	// BlockGasLimit is the maximum gas allowed in a block
	BlockGasLimit uint64

	// MinBaseFee is the minimum base fee
	MinBaseFee uint64

	// TargetBlockRate is the target rate for block production
	TargetBlockRate uint64

	// BaseFeeChangeDenominator controls base fee adjustment rate
	BaseFeeChangeDenominator uint64

	// MinBlockGasCost is the minimum gas cost for a block
	MinBlockGasCost uint64

	// MaxBlockGasCost is the maximum gas cost for a block
	MaxBlockGasCost uint64

	// BlockGasCostStep is the step size for block gas cost changes
	BlockGasCostStep uint64
}

type NodeID = iface.NodeID

type NodeVM interface {
	// Initialize initializes the VM
	Initialize(
		ctx context.Context,
		chainCtx *ChainContext,
		db Database,
		genesisBytes []byte,
		upgradeBytes []byte,
		configBytes []byte,
		toEngine chan<- EngineMessage,
		fxs []Fx,
		appSender AppSender,
	) error

	// SetState sets the VM state
	SetState(ctx context.Context, state State) error

	// Shutdown shuts down the VM
	Shutdown(context.Context) error

	// Version returns the VM version
	Version(context.Context) (string, error)

	// CreateHandlers returns HTTP handlers
	CreateHandlers(context.Context) (map[string]HTTPHandler, error)

	// HealthCheck returns the VM health
	HealthCheck(context.Context) (interface{}, error)
}

type P2PClient interface {
	// SendRequest sends a request to a peer
	SendRequest(ctx context.Context, nodeID NodeID, request []byte, responseHandler func([]byte, error)) error

	// TrackBandwidth tracks bandwidth usage
	TrackBandwidth(nodeID NodeID, bandwidth float64)
}

type PeerTracker interface {
	// Connected notifies that a peer connected
	Connected(nodeID NodeID, version *Version)

	// Disconnected notifies that a peer disconnected
	Disconnected(nodeID NodeID)

	// NumPeers returns the number of connected peers
	NumPeers() int

	// ConnectedPeers returns the set of connected peers
	ConnectedPeers() []NodeID
}

type PendingContractCaller interface {
	PendingCallContract(ctx context.Context, call CallMsg) ([]byte, error)
}

type PendingStateEventer interface {
	SubscribePendingTransactions(ctx context.Context, ch chan<- *types.Transaction) (Subscription, error)
}

type PendingStateReader interface {
	PendingBalanceAt(ctx context.Context, account common.Address) (*big.Int, error)
	PendingStorageAt(ctx context.Context, account common.Address, key common.Hash) ([]byte, error)
	PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error)
	PendingNonceAt(ctx context.Context, account common.Address) (uint64, error)
	PendingTransactionCount(ctx context.Context) (uint, error)
}

type PluginRegistry interface {
	// Register registers a VM factory with a name
	Register(name string, factory VMFactory) error

	// Get retrieves a VM factory by name
	Get(name string) (VMFactory, error)

	// List returns all registered VM names
	List() []string
}

type PrecompileConfig struct {
}

type PrecompileManager interface {
	GetConfig(height uint64) *PrecompileConfig
}

type PrecompileModule interface {
	// Address returns the address of the precompile
	Address() common.Address

	// Contract returns the precompile contract
	Contract() interface{}

	// Configurator returns the configurator for this precompile
	Configurator() interface{}

	// DefaultConfig returns the default config for this precompile
	DefaultConfig() interface{}

	// MakeConfig creates a new config instance
	MakeConfig() interface{}

	// ConfigKey returns the configuration key for this module
	ConfigKey() string
}

type PrecompileRegistry interface {
	// GetPrecompileModule returns a precompile module by key
	GetPrecompileModule(key string) (PrecompileModule, bool)

	// GetPrecompileModuleByAddress returns a precompile module by address
	GetPrecompileModuleByAddress(address common.Address) (PrecompileModule, bool)

	// RegisteredModules returns all registered modules
	RegisteredModules() []PrecompileModule
}

type PrefixDB interface {
	Database
}

type Profiler interface {
	// StartCPUProfiler starts CPU profiling
	StartCPUProfiler() error

	// StopCPUProfiler stops CPU profiling
	StopCPUProfiler() error

	// MemoryProfile captures a memory profile
	MemoryProfile() error
}

type RPCOption func(*RPCOptions)

type RPCOptions struct {
	Headers http.Header
}

type RequestHandler interface {
	// HandleTrieLeafsRequest handles trie leafs requests
	HandleTrieLeafsRequest(ctx context.Context, nodeID NodeID, requestID uint32, request LeafsRequest) ([]byte, error)

	// HandleBlockRequest handles block requests
	HandleBlockRequest(ctx context.Context, nodeID NodeID, requestID uint32, request BlockRequest) ([]byte, error)

	// HandleCodeRequest handles code requests
	HandleCodeRequest(ctx context.Context, nodeID NodeID, requestID uint32, request CodeRequest) ([]byte, error)

	// HandleMessageSignatureRequest handles message signature requests
	HandleMessageSignatureRequest(ctx context.Context, nodeID NodeID, requestID uint32, request MessageSignatureRequest) ([]byte, error)

	// HandleBlockSignatureRequest handles block signature requests
	HandleBlockSignatureRequest(ctx context.Context, nodeID NodeID, requestID uint32, request BlockSignatureRequest) ([]byte, error)
}

type RequestID uint32

type SendConfig struct {
	NodeIDs       Set
	Validators    int
	NonValidators int
	Peers         int
}

type Set interface {
	Contains(NodeID) bool
	Len() int
	List() []NodeID
	Add(...NodeID)
	Remove(...NodeID)
}

type SharedMemory interface {
	// Get retrieves data from shared memory
	Get(key []byte) ([]byte, error)

	// Put stores data in shared memory
	Put(key []byte, value []byte) error

	// Remove deletes data from shared memory
	Remove(key []byte) error

	// NewBatch creates a new batch
	NewBatch() Batch
}

type Signature = warp.Signature

type State interface {
	// GetCurrentHeight returns the current blockchain height
	GetCurrentHeight(ctx context.Context) (uint64, error)

	// GetMinimumHeight returns the minimum height
	GetMinimumHeight(ctx context.Context) (uint64, error)

	// GetSubnetID returns the subnet ID for a chain
	GetSubnetID(ctx context.Context, chainID ID) (ID, error)

	// GetValidatorSet returns the validator set at a given height
	GetValidatorSet(ctx context.Context, height uint64, subnetID ID) (map[NodeID]*GetValidatorOutput, error)
}

type StateDB interface {
	CreateAccount(common.Address)

	SubBalance(common.Address, *uint256.Int, ...string) error
	AddBalance(common.Address, *uint256.Int, ...string) error
	GetBalance(common.Address) *uint256.Int

	GetNonce(common.Address) uint64
	SetNonce(common.Address, uint64)

	GetCodeHash(common.Address) common.Hash
	GetCode(common.Address) []byte
	SetCode(common.Address, []byte)
	GetCodeSize(common.Address) int

	AddRefund(uint64)
	SubRefund(uint64)
	GetRefund() uint64

	GetCommittedState(common.Address, common.Hash) common.Hash
	GetState(common.Address, common.Hash) common.Hash
	SetState(common.Address, common.Hash, common.Hash)

	GetStorageRoot(addr common.Address) common.Hash

	Suicide(common.Address) bool
	HasSuicided(common.Address) bool

	// Exist reports whether the given account exists in state.
	Exist(common.Address) bool
	// Empty returns whether the given account is empty.
	Empty(common.Address) bool

	PrepareAccessList(sender common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList)
	AddressInAccessList(addr common.Address) bool
	SlotInAccessList(addr common.Address, slot common.Hash) (addressOk bool, slotOk bool)
	AddAddressToAccessList(addr common.Address)
	AddSlotToAccessList(addr common.Address, slot common.Hash)

	RevertToSnapshot(int)
	Snapshot() int

	AddLog(*types.Log)
	AddPreimage(common.Hash, []byte)

	ForEachStorage(common.Address, func(common.Hash, common.Hash) bool) error

	// Lux specific
	GetLogData() [][]byte
	GetPredicateStorageSlots(address common.Address, index int) ([]byte, bool)
	SetPredicateStorageSlots(address common.Address, predicates [][]byte)
}

type StateSummary interface {
	ID() BlockID
	Height() uint64
	Bytes() []byte
	Accept(context.Context) error
}

type StateSyncableVM interface {
	ChainVM
	// StateSyncEnabled returns if state sync is enabled
	StateSyncEnabled(context.Context) (bool, error)
	// GetOngoingSyncStateSummary returns the ongoing sync state summary
	GetOngoingSyncStateSummary(context.Context) (StateSummary, error)
	// GetLastStateSummary returns the last state summary
	GetLastStateSummary(context.Context) (StateSummary, error)
	// ParseStateSummary parses state summary bytes
	ParseStateSummary(ctx context.Context, summaryBytes []byte) (StateSummary, error)
	// GetStateSummary returns a state summary at the given height
	GetStateSummary(ctx context.Context, height uint64) (StateSummary, error)
	// VerifyHeightIndex verifies the height index
	VerifyHeightIndex(context.Context) error
	// AcceptStateSummary accepts a state summary
	AcceptStateSummary(ctx context.Context, stateSummary StateSummary) error
}

type Status int

type SubnetID = iface.SubnetID

type Subscription interface {
	// Unsubscribe cancels the sending of events to the data channel
	// and closes the error channel.
	Unsubscribe()
	// Err returns the subscription error channel. The error channel receives
	// a value if there is an issue with the subscription (e.g. the network connection
	// delivering the events has been closed). Only one value will ever be sent.
	// The error channel is closed by Unsubscribe.
	Err() <-chan error
}

type SyncProgress struct {
	StartingBlock uint64 // Block number where sync began
	CurrentBlock  uint64 // Current block number where sync is at
	HighestBlock  uint64 // Highest alleged block number in the chain
}

type Timer interface {
	NewTimer(func()) *TimerID
	Dispatch()
}

type TimerID struct{}

type Timestamp struct {
	Unix int64
}

type TransactionReader interface {
	// TransactionByHash checks the pool of pending transactions in addition to the
	// blockchain. The isPending return value indicates whether the transaction has been
	// mined yet. Note that the transaction may not be part of the canonical chain even if
	// it's not pending.
	TransactionByHash(ctx context.Context, txHash common.Hash) (tx *types.Transaction, isPending bool, err error)
	// TransactionReceipt returns the receipt of a mined transaction. Note that the
	// transaction may not be included in the current canonical chain even if a receipt
	// exists.
	TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
}

type TransactionSender interface {
	SendTransaction(ctx context.Context, tx *types.Transaction) error
}

type TxContext struct {
	Origin   common.Address
	GasPrice *big.Int
}

type UnsignedMessage = warp.UnsignedMessage

type VMContext interface {
	// CanTransfer checks if the account has enough balance
	CanTransfer(db StateDB, addr common.Address, amount *big.Int) bool

	// Transfer transfers amount from one account to another
	Transfer(db StateDB, sender, recipient common.Address, amount *big.Int) error

	// GetHash returns the hash of a block by number
	GetHash(n uint64) common.Hash

	// Message information
	Origin() common.Address
	GasPrice() *big.Int
	BlockNumber() *big.Int
	Time() uint64
	Difficulty() *big.Int
	GasLimit() uint64
	Coinbase() common.Address
}

type VMFactory interface {
	// New creates a new VM instance
	New() (interface{}, error)
}

type VMState uint32

type Validator interface {
	// NodeID returns the validator's node ID
	NodeID() NodeID

	// Weight returns the validator's weight
	Weight() uint64
}

type ValidatorData struct {
	NodeID    NodeID
	PublicKey []byte
	Weight    uint64
}

type ValidatorState interface {
	// GetCurrentHeight returns the current P-chain height
	GetCurrentHeight(ctx context.Context) (uint64, error)

	// GetValidatorSet returns the validator set at a given height
	GetValidatorSet(ctx context.Context, height uint64, subnetID SubnetID) (map[NodeID]*ValidatorData, error)

	// GetMinimumHeight returns the minimum height
	GetMinimumHeight(ctx context.Context) (uint64, error)
}

type Version struct {
	// Application version
	App uint32

	// Application name
	AppName string

	// Version timestamp
	VersionTime time.Time

	// Git commit
	GitCommit string
}

type VersionDB interface {
	Database
	// Commit commits the current database state
	Commit() error
	// Abort aborts the current database operations
	Abort()
}

type WarpBackend interface {
	GetBlockSignature(ctx context.Context, blockID BlockID) (*WarpSignature, error)
	GetMessageSignature(ctx context.Context, msg *WarpUnsignedMessage) (*WarpSignature, error)
	AddMessage(ctx context.Context, msg *WarpUnsignedMessage) error
}

type WarpChainContext interface {
	GetValidatorPublicKey(validationID ids.ID) ([]byte, error)
}

type WarpMessage struct {
	SourceChainID       common.Hash
	OriginSenderAddress common.Address
	Payload             []byte
}

type WarpSignature struct {
	Signers   []byte
	Signature []byte
}

type WarpSignedMessage = warp.Message

type WarpUnsignedMessage struct {
	NetworkID     uint32
	SourceChainID common.Hash
	Payload       []byte
}

type Wrappers interface {
	// Errs wraps multiple errors
	Errs(errs ...error) error
}