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 struct {
	SourceAddress []byte
	Payload       []byte
}

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 BLSPublicKey struct {
	// contains filtered or unexported fields
}

type BLSSignature struct {
	// contains filtered or unexported fields
}

type Batch interface {
	ethdb.Batch
}

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

type Bits interface {
	// Add adds a bit to the set
	Add(i int)

	// Contains checks if a bit is in the set
	Contains(i int) bool

	// Remove removes a bit from the set
	Remove(i int)

	// Clear clears all bits
	Clear()

	// Len returns the number of bits set
	Len() int

	// Bytes returns the byte representation
	Bytes() []byte
}

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 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 BlockID = ID

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

type BlockSignatureRequest struct {
	BlockID []byte
}

type Cacher[K comparable, V any] interface {
	Put(key K, value V)
	Get(key K) (V, bool)
	Evict(key K)
	Flush()
	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 CanonicalValidatorSet struct {
	// Validators slice in canonical ordering of the validators that has public key
	Validators []*WarpValidator
	// The total weight of all the validators, including the ones that doesn't have a public key
	TotalWeight uint64
}

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
	// For v2.0.0, all upgrades are active at genesis
	IsGenesis(time uint64) bool
	AllowedFeeRecipients() bool
	GenesisRules(blockNum *big.Int, timestamp uint64) GenesisRules

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

type ChainContext struct {
	NetworkID uint32
	SubnetID  SubnetID
	ChainID   ChainID
	NodeID    NodeID

	// Node version
	AppVersion uint32

	// Chain configuration
	ChainDataDir string

	// Validator state
	ValidatorState ValidatorState
}

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 [32]byte

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 Choice uint32

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 Context struct {
	// PChainHeight is the height that this block will use to verify it's state.
	PChainHeight uint64
}

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 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 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 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 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(items ...T)
	Remove(item T)
	Contains(item T) bool
	Clear()
	Len() int
	List() []T
}

type GenesisRules interface {
	IsGenesis() 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 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 Hash struct {
	Hash [32]byte
}

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

type ID [32]byte

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

type Iterator interface {
	ethdb.Iterator
}

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 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 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() time.Time
	Set(time time.Time)
	Advance(duration 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 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 [32]byte

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 interface {
	Address() common.Address
	IsDisabled() bool
	Timestamp() *uint64
}

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 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 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 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 {
	GetBalance(common.Address) *uint256.Int
	GetNonce(common.Address) uint64
	GetCode(common.Address) []byte
	GetState(common.Address, common.Hash) common.Hash
	Exist(common.Address) bool
	Empty(common.Address) bool
}

type Status int

type SubnetID [32]byte

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 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 struct {
	NetworkID     uint32
	SourceChainID common.Hash
	Payload       []byte
}

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 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 ValidatorOutput struct {
	NodeID    common.Hash
	PublicKey *BLSPublicKey
	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 common.Hash) (map[common.Hash]*ValidatorOutput, error)

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

	// GetSubnetID returns the subnet ID for a given chain ID
	GetSubnetID(ctx context.Context, chainID common.Hash) (common.Hash, 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 WarpChainContext interface {
	GetValidatorPublicKey(validationID [32]byte) ([]byte, error)
}

type WarpSignedMessage struct {
	UnsignedMessage UnsignedMessage
	Signature       *BLSSignature
	SourceChainID   common.Hash
}

type WarpValidator struct {
	PublicKey      *BLSPublicKey
	PublicKeyBytes []byte
	Weight         uint64
	NodeIDs        []common.Hash
}