coreth/precompile/contract/mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: interfaces.go
//
// Generated by this command:
//
//	mockgen -package=contract -source=interfaces.go -destination=mocks.go -exclude_interfaces StatefulPrecompiledContract,StateReader,ConfigurationBlockContext,Configurator
//

// Package contract is a generated GoMock package.
package contract

import (
	big "math/big"
	reflect "reflect"

	uint256 "github.com/holiman/uint256"
	consensusctx "github.com/luxfi/consensus/context"
	precompileconfig "github.com/luxfi/coreth/precompile/precompileconfig"
	common "github.com/luxfi/geth/common"
	stateconf "github.com/luxfi/geth/core/stateconf"
	types "github.com/luxfi/geth/core/types"
	vm "github.com/luxfi/geth/core/vm"
	gomock "go.uber.org/mock/gomock"
)

// MockStateDB is a mock of StateDB interface.
type MockStateDB struct {
	ctrl     *gomock.Controller
	recorder *MockStateDBMockRecorder
	isgomock struct{}
}

// MockStateDBMockRecorder is the mock recorder for MockStateDB.
type MockStateDBMockRecorder struct {
	mock *MockStateDB
}

// NewMockStateDB creates a new mock instance.
func NewMockStateDB(ctrl *gomock.Controller) *MockStateDB {
	mock := &MockStateDB{ctrl: ctrl}
	mock.recorder = &MockStateDBMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockStateDB) EXPECT() *MockStateDBMockRecorder {
	return m.recorder
}

// AddBalance mocks base method.
func (m *MockStateDB) AddBalance(arg0 common.Address, arg1 *uint256.Int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddBalance", arg0, arg1)
}

// AddBalance indicates an expected call of AddBalance.
func (mr *MockStateDBMockRecorder) AddBalance(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBalance", reflect.TypeOf((*MockStateDB)(nil).AddBalance), arg0, arg1)
}

// AddBalanceMultiCoin mocks base method.
func (m *MockStateDB) AddBalanceMultiCoin(arg0 common.Address, arg1 common.Hash, arg2 *big.Int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddBalanceMultiCoin", arg0, arg1, arg2)
}

// AddBalanceMultiCoin indicates an expected call of AddBalanceMultiCoin.
func (mr *MockStateDBMockRecorder) AddBalanceMultiCoin(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBalanceMultiCoin", reflect.TypeOf((*MockStateDB)(nil).AddBalanceMultiCoin), arg0, arg1, arg2)
}

// AddLog mocks base method.
func (m *MockStateDB) AddLog(arg0 *types.Log) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddLog", arg0)
}

// AddLog indicates an expected call of AddLog.
func (mr *MockStateDBMockRecorder) AddLog(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLog", reflect.TypeOf((*MockStateDB)(nil).AddLog), arg0)
}

// CreateAccount mocks base method.
func (m *MockStateDB) CreateAccount(arg0 common.Address) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CreateAccount", arg0)
}

// CreateAccount indicates an expected call of CreateAccount.
func (mr *MockStateDBMockRecorder) CreateAccount(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAccount", reflect.TypeOf((*MockStateDB)(nil).CreateAccount), arg0)
}

// Exist mocks base method.
func (m *MockStateDB) Exist(arg0 common.Address) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Exist", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// Exist indicates an expected call of Exist.
func (mr *MockStateDBMockRecorder) Exist(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exist", reflect.TypeOf((*MockStateDB)(nil).Exist), arg0)
}

// GetBalance mocks base method.
func (m *MockStateDB) GetBalance(arg0 common.Address) *uint256.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBalance", arg0)
	ret0, _ := ret[0].(*uint256.Int)
	return ret0
}

// GetBalance indicates an expected call of GetBalance.
func (mr *MockStateDBMockRecorder) GetBalance(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBalance", reflect.TypeOf((*MockStateDB)(nil).GetBalance), arg0)
}

// GetBalanceMultiCoin mocks base method.
func (m *MockStateDB) GetBalanceMultiCoin(arg0 common.Address, arg1 common.Hash) *big.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBalanceMultiCoin", arg0, arg1)
	ret0, _ := ret[0].(*big.Int)
	return ret0
}

// GetBalanceMultiCoin indicates an expected call of GetBalanceMultiCoin.
func (mr *MockStateDBMockRecorder) GetBalanceMultiCoin(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBalanceMultiCoin", reflect.TypeOf((*MockStateDB)(nil).GetBalanceMultiCoin), arg0, arg1)
}

// GetNonce mocks base method.
func (m *MockStateDB) GetNonce(arg0 common.Address) uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNonce", arg0)
	ret0, _ := ret[0].(uint64)
	return ret0
}

// GetNonce indicates an expected call of GetNonce.
func (mr *MockStateDBMockRecorder) GetNonce(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNonce", reflect.TypeOf((*MockStateDB)(nil).GetNonce), arg0)
}

// GetPredicateStorageSlots mocks base method.
func (m *MockStateDB) GetPredicateStorageSlots(address common.Address, index int) ([]byte, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPredicateStorageSlots", address, index)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetPredicateStorageSlots indicates an expected call of GetPredicateStorageSlots.
func (mr *MockStateDBMockRecorder) GetPredicateStorageSlots(address, index any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPredicateStorageSlots", reflect.TypeOf((*MockStateDB)(nil).GetPredicateStorageSlots), address, index)
}

// GetState mocks base method.
func (m *MockStateDB) GetState(arg0 common.Address, arg1 common.Hash, arg2 ...stateconf.StateDBStateOption) common.Hash {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetState", varargs...)
	ret0, _ := ret[0].(common.Hash)
	return ret0
}

// GetState indicates an expected call of GetState.
func (mr *MockStateDBMockRecorder) GetState(arg0, arg1 any, arg2 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetState", reflect.TypeOf((*MockStateDB)(nil).GetState), varargs...)
}

// Logs mocks base method.
func (m *MockStateDB) Logs() []*types.Log {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Logs")
	ret0, _ := ret[0].([]*types.Log)
	return ret0
}

// Logs indicates an expected call of Logs.
func (mr *MockStateDBMockRecorder) Logs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Logs", reflect.TypeOf((*MockStateDB)(nil).Logs))
}

// RevertToSnapshot mocks base method.
func (m *MockStateDB) RevertToSnapshot(arg0 int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RevertToSnapshot", arg0)
}

// RevertToSnapshot indicates an expected call of RevertToSnapshot.
func (mr *MockStateDBMockRecorder) RevertToSnapshot(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevertToSnapshot", reflect.TypeOf((*MockStateDB)(nil).RevertToSnapshot), arg0)
}

// SetNonce mocks base method.
func (m *MockStateDB) SetNonce(arg0 common.Address, arg1 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetNonce", arg0, arg1)
}

// SetNonce indicates an expected call of SetNonce.
func (mr *MockStateDBMockRecorder) SetNonce(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNonce", reflect.TypeOf((*MockStateDB)(nil).SetNonce), arg0, arg1)
}

// SetState mocks base method.
func (m *MockStateDB) SetState(arg0 common.Address, arg1, arg2 common.Hash, arg3 ...stateconf.StateDBStateOption) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "SetState", varargs...)
}

// SetState indicates an expected call of SetState.
func (mr *MockStateDBMockRecorder) SetState(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetState", reflect.TypeOf((*MockStateDB)(nil).SetState), varargs...)
}

// Snapshot mocks base method.
func (m *MockStateDB) Snapshot() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Snapshot")
	ret0, _ := ret[0].(int)
	return ret0
}

// Snapshot indicates an expected call of Snapshot.
func (mr *MockStateDBMockRecorder) Snapshot() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Snapshot", reflect.TypeOf((*MockStateDB)(nil).Snapshot))
}

// SubBalanceMultiCoin mocks base method.
func (m *MockStateDB) SubBalanceMultiCoin(arg0 common.Address, arg1 common.Hash, arg2 *big.Int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SubBalanceMultiCoin", arg0, arg1, arg2)
}

// SubBalanceMultiCoin indicates an expected call of SubBalanceMultiCoin.
func (mr *MockStateDBMockRecorder) SubBalanceMultiCoin(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubBalanceMultiCoin", reflect.TypeOf((*MockStateDB)(nil).SubBalanceMultiCoin), arg0, arg1, arg2)
}

// TxHash mocks base method.
func (m *MockStateDB) TxHash() common.Hash {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TxHash")
	ret0, _ := ret[0].(common.Hash)
	return ret0
}

// TxHash indicates an expected call of TxHash.
func (mr *MockStateDBMockRecorder) TxHash() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxHash", reflect.TypeOf((*MockStateDB)(nil).TxHash))
}

// MockAccessibleState is a mock of AccessibleState interface.
type MockAccessibleState struct {
	ctrl     *gomock.Controller
	recorder *MockAccessibleStateMockRecorder
	isgomock struct{}
}

// MockAccessibleStateMockRecorder is the mock recorder for MockAccessibleState.
type MockAccessibleStateMockRecorder struct {
	mock *MockAccessibleState
}

// NewMockAccessibleState creates a new mock instance.
func NewMockAccessibleState(ctrl *gomock.Controller) *MockAccessibleState {
	mock := &MockAccessibleState{ctrl: ctrl}
	mock.recorder = &MockAccessibleStateMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAccessibleState) EXPECT() *MockAccessibleStateMockRecorder {
	return m.recorder
}

// GetBlockContext mocks base method.
func (m *MockAccessibleState) GetBlockContext() BlockContext {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockContext")
	ret0, _ := ret[0].(BlockContext)
	return ret0
}

// GetBlockContext indicates an expected call of GetBlockContext.
func (mr *MockAccessibleStateMockRecorder) GetBlockContext() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockContext", reflect.TypeOf((*MockAccessibleState)(nil).GetBlockContext))
}

// GetChainConfig mocks base method.
func (m *MockAccessibleState) GetChainConfig() precompileconfig.ChainConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChainConfig")
	ret0, _ := ret[0].(precompileconfig.ChainConfig)
	return ret0
}

// GetChainConfig indicates an expected call of GetChainConfig.
func (mr *MockAccessibleStateMockRecorder) GetChainConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChainConfig", reflect.TypeOf((*MockAccessibleState)(nil).GetChainConfig))
}

// GetPrecompileEnv mocks base method.
func (m *MockAccessibleState) GetPrecompileEnv() vm.PrecompileEnvironment {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPrecompileEnv")
	ret0, _ := ret[0].(vm.PrecompileEnvironment)
	return ret0
}

// GetPrecompileEnv indicates an expected call of GetPrecompileEnv.
func (mr *MockAccessibleStateMockRecorder) GetPrecompileEnv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrecompileEnv", reflect.TypeOf((*MockAccessibleState)(nil).GetPrecompileEnv))
}

// GetConsensusContext mocks base method.
func (m *MockAccessibleState) GetConsensusContext() *consensusctx.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConsensusContext")
	ret0, _ := ret[0].(*consensusctx.Context)
	return ret0
}

// GetConsensusContext indicates an expected call of GetConsensusContext.
func (mr *MockAccessibleStateMockRecorder) GetConsensusContext() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsensusContext", reflect.TypeOf((*MockAccessibleState)(nil).GetConsensusContext))
}

// GetStateDB mocks base method.
func (m *MockAccessibleState) GetStateDB() StateDB {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStateDB")
	ret0, _ := ret[0].(StateDB)
	return ret0
}

// GetStateDB indicates an expected call of GetStateDB.
func (mr *MockAccessibleStateMockRecorder) GetStateDB() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStateDB", reflect.TypeOf((*MockAccessibleState)(nil).GetStateDB))
}

// MockBlockContext is a mock of BlockContext interface.
type MockBlockContext struct {
	ctrl     *gomock.Controller
	recorder *MockBlockContextMockRecorder
	isgomock struct{}
}

// MockBlockContextMockRecorder is the mock recorder for MockBlockContext.
type MockBlockContextMockRecorder struct {
	mock *MockBlockContext
}

// NewMockBlockContext creates a new mock instance.
func NewMockBlockContext(ctrl *gomock.Controller) *MockBlockContext {
	mock := &MockBlockContext{ctrl: ctrl}
	mock.recorder = &MockBlockContextMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBlockContext) EXPECT() *MockBlockContextMockRecorder {
	return m.recorder
}

// GetPredicateResults mocks base method.
func (m *MockBlockContext) GetPredicateResults(txHash common.Hash, precompileAddress common.Address) []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPredicateResults", txHash, precompileAddress)
	ret0, _ := ret[0].([]byte)
	return ret0
}

// GetPredicateResults indicates an expected call of GetPredicateResults.
func (mr *MockBlockContextMockRecorder) GetPredicateResults(txHash, precompileAddress any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPredicateResults", reflect.TypeOf((*MockBlockContext)(nil).GetPredicateResults), txHash, precompileAddress)
}

// Number mocks base method.
func (m *MockBlockContext) Number() *big.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Number")
	ret0, _ := ret[0].(*big.Int)
	return ret0
}

// Number indicates an expected call of Number.
func (mr *MockBlockContextMockRecorder) Number() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Number", reflect.TypeOf((*MockBlockContext)(nil).Number))
}

// Timestamp mocks base method.
func (m *MockBlockContext) Timestamp() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Timestamp")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// Timestamp indicates an expected call of Timestamp.
func (mr *MockBlockContextMockRecorder) Timestamp() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockBlockContext)(nil).Timestamp))
}