// Code generated by mockery v2.40.1. DO NOT EDIT.

package mocks

import (
	context "context"
	big "math/big"

	common "github.com/ethereum/go-ethereum/common"

	corestate "github.com/ethereum/go-ethereum/core/state"

	mock "github.com/stretchr/testify/mock"

	params "github.com/ethereum/go-ethereum/params"

	types "github.com/ethereum/go-ethereum/core/types"
)

// PolarStateDB is an autogenerated mock type for the PolarStateDB type
type PolarStateDB struct {
	mock.Mock
}

type PolarStateDB_Expecter struct {
	mock *mock.Mock
}

func (_m *PolarStateDB) EXPECT() *PolarStateDB_Expecter {
	return &PolarStateDB_Expecter{mock: &_m.Mock}
}

// AddAddressToAccessList provides a mock function with given fields: addr
func (_m *PolarStateDB) AddAddressToAccessList(addr common.Address) {
	_m.Called(addr)
}

// PolarStateDB_AddAddressToAccessList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAddressToAccessList'
type PolarStateDB_AddAddressToAccessList_Call struct {
	*mock.Call
}

// AddAddressToAccessList is a helper method to define mock.On call
//   - addr common.Address
func (_e *PolarStateDB_Expecter) AddAddressToAccessList(addr interface{}) *PolarStateDB_AddAddressToAccessList_Call {
	return &PolarStateDB_AddAddressToAccessList_Call{Call: _e.mock.On("AddAddressToAccessList", addr)}
}

func (_c *PolarStateDB_AddAddressToAccessList_Call) Run(run func(addr common.Address)) *PolarStateDB_AddAddressToAccessList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_AddAddressToAccessList_Call) Return() *PolarStateDB_AddAddressToAccessList_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_AddAddressToAccessList_Call) RunAndReturn(run func(common.Address)) *PolarStateDB_AddAddressToAccessList_Call {
	_c.Call.Return(run)
	return _c
}

// AddBalance provides a mock function with given fields: _a0, _a1
func (_m *PolarStateDB) AddBalance(_a0 common.Address, _a1 *big.Int) {
	_m.Called(_a0, _a1)
}

// PolarStateDB_AddBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddBalance'
type PolarStateDB_AddBalance_Call struct {
	*mock.Call
}

// AddBalance is a helper method to define mock.On call
//   - _a0 common.Address
//   - _a1 *big.Int
func (_e *PolarStateDB_Expecter) AddBalance(_a0 interface{}, _a1 interface{}) *PolarStateDB_AddBalance_Call {
	return &PolarStateDB_AddBalance_Call{Call: _e.mock.On("AddBalance", _a0, _a1)}
}

func (_c *PolarStateDB_AddBalance_Call) Run(run func(_a0 common.Address, _a1 *big.Int)) *PolarStateDB_AddBalance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address), args[1].(*big.Int))
	})
	return _c
}

func (_c *PolarStateDB_AddBalance_Call) Return() *PolarStateDB_AddBalance_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_AddBalance_Call) RunAndReturn(run func(common.Address, *big.Int)) *PolarStateDB_AddBalance_Call {
	_c.Call.Return(run)
	return _c
}

// AddLog provides a mock function with given fields: _a0
func (_m *PolarStateDB) AddLog(_a0 *types.Log) {
	_m.Called(_a0)
}

// PolarStateDB_AddLog_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddLog'
type PolarStateDB_AddLog_Call struct {
	*mock.Call
}

// AddLog is a helper method to define mock.On call
//   - _a0 *types.Log
func (_e *PolarStateDB_Expecter) AddLog(_a0 interface{}) *PolarStateDB_AddLog_Call {
	return &PolarStateDB_AddLog_Call{Call: _e.mock.On("AddLog", _a0)}
}

func (_c *PolarStateDB_AddLog_Call) Run(run func(_a0 *types.Log)) *PolarStateDB_AddLog_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*types.Log))
	})
	return _c
}

func (_c *PolarStateDB_AddLog_Call) Return() *PolarStateDB_AddLog_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_AddLog_Call) RunAndReturn(run func(*types.Log)) *PolarStateDB_AddLog_Call {
	_c.Call.Return(run)
	return _c
}

// AddPreimage provides a mock function with given fields: _a0, _a1
func (_m *PolarStateDB) AddPreimage(_a0 common.Hash, _a1 []byte) {
	_m.Called(_a0, _a1)
}

// PolarStateDB_AddPreimage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddPreimage'
type PolarStateDB_AddPreimage_Call struct {
	*mock.Call
}

// AddPreimage is a helper method to define mock.On call
//   - _a0 common.Hash
//   - _a1 []byte
func (_e *PolarStateDB_Expecter) AddPreimage(_a0 interface{}, _a1 interface{}) *PolarStateDB_AddPreimage_Call {
	return &PolarStateDB_AddPreimage_Call{Call: _e.mock.On("AddPreimage", _a0, _a1)}
}

func (_c *PolarStateDB_AddPreimage_Call) Run(run func(_a0 common.Hash, _a1 []byte)) *PolarStateDB_AddPreimage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Hash), args[1].([]byte))
	})
	return _c
}

func (_c *PolarStateDB_AddPreimage_Call) Return() *PolarStateDB_AddPreimage_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_AddPreimage_Call) RunAndReturn(run func(common.Hash, []byte)) *PolarStateDB_AddPreimage_Call {
	_c.Call.Return(run)
	return _c
}

// AddRefund provides a mock function with given fields: _a0
func (_m *PolarStateDB) AddRefund(_a0 uint64) {
	_m.Called(_a0)
}

// PolarStateDB_AddRefund_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddRefund'
type PolarStateDB_AddRefund_Call struct {
	*mock.Call
}

// AddRefund is a helper method to define mock.On call
//   - _a0 uint64
func (_e *PolarStateDB_Expecter) AddRefund(_a0 interface{}) *PolarStateDB_AddRefund_Call {
	return &PolarStateDB_AddRefund_Call{Call: _e.mock.On("AddRefund", _a0)}
}

func (_c *PolarStateDB_AddRefund_Call) Run(run func(_a0 uint64)) *PolarStateDB_AddRefund_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(uint64))
	})
	return _c
}

func (_c *PolarStateDB_AddRefund_Call) Return() *PolarStateDB_AddRefund_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_AddRefund_Call) RunAndReturn(run func(uint64)) *PolarStateDB_AddRefund_Call {
	_c.Call.Return(run)
	return _c
}

// AddSlotToAccessList provides a mock function with given fields: addr, slot
func (_m *PolarStateDB) AddSlotToAccessList(addr common.Address, slot common.Hash) {
	_m.Called(addr, slot)
}

// PolarStateDB_AddSlotToAccessList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddSlotToAccessList'
type PolarStateDB_AddSlotToAccessList_Call struct {
	*mock.Call
}

// AddSlotToAccessList is a helper method to define mock.On call
//   - addr common.Address
//   - slot common.Hash
func (_e *PolarStateDB_Expecter) AddSlotToAccessList(addr interface{}, slot interface{}) *PolarStateDB_AddSlotToAccessList_Call {
	return &PolarStateDB_AddSlotToAccessList_Call{Call: _e.mock.On("AddSlotToAccessList", addr, slot)}
}

func (_c *PolarStateDB_AddSlotToAccessList_Call) Run(run func(addr common.Address, slot common.Hash)) *PolarStateDB_AddSlotToAccessList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address), args[1].(common.Hash))
	})
	return _c
}

func (_c *PolarStateDB_AddSlotToAccessList_Call) Return() *PolarStateDB_AddSlotToAccessList_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_AddSlotToAccessList_Call) RunAndReturn(run func(common.Address, common.Hash)) *PolarStateDB_AddSlotToAccessList_Call {
	_c.Call.Return(run)
	return _c
}

// AddressInAccessList provides a mock function with given fields: addr
func (_m *PolarStateDB) AddressInAccessList(addr common.Address) bool {
	ret := _m.Called(addr)

	if len(ret) == 0 {
		panic("no return value specified for AddressInAccessList")
	}

	var r0 bool
	if rf, ok := ret.Get(0).(func(common.Address) bool); ok {
		r0 = rf(addr)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// PolarStateDB_AddressInAccessList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddressInAccessList'
type PolarStateDB_AddressInAccessList_Call struct {
	*mock.Call
}

// AddressInAccessList is a helper method to define mock.On call
//   - addr common.Address
func (_e *PolarStateDB_Expecter) AddressInAccessList(addr interface{}) *PolarStateDB_AddressInAccessList_Call {
	return &PolarStateDB_AddressInAccessList_Call{Call: _e.mock.On("AddressInAccessList", addr)}
}

func (_c *PolarStateDB_AddressInAccessList_Call) Run(run func(addr common.Address)) *PolarStateDB_AddressInAccessList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_AddressInAccessList_Call) Return(_a0 bool) *PolarStateDB_AddressInAccessList_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_AddressInAccessList_Call) RunAndReturn(run func(common.Address) bool) *PolarStateDB_AddressInAccessList_Call {
	_c.Call.Return(run)
	return _c
}

// Commit provides a mock function with given fields: _a0, _a1
func (_m *PolarStateDB) Commit(_a0 uint64, _a1 bool) (common.Hash, error) {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for Commit")
	}

	var r0 common.Hash
	var r1 error
	if rf, ok := ret.Get(0).(func(uint64, bool) (common.Hash, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(uint64, bool) common.Hash); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Hash)
		}
	}

	if rf, ok := ret.Get(1).(func(uint64, bool) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PolarStateDB_Commit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Commit'
type PolarStateDB_Commit_Call struct {
	*mock.Call
}

// Commit is a helper method to define mock.On call
//   - _a0 uint64
//   - _a1 bool
func (_e *PolarStateDB_Expecter) Commit(_a0 interface{}, _a1 interface{}) *PolarStateDB_Commit_Call {
	return &PolarStateDB_Commit_Call{Call: _e.mock.On("Commit", _a0, _a1)}
}

func (_c *PolarStateDB_Commit_Call) Run(run func(_a0 uint64, _a1 bool)) *PolarStateDB_Commit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(uint64), args[1].(bool))
	})
	return _c
}

func (_c *PolarStateDB_Commit_Call) Return(_a0 common.Hash, _a1 error) *PolarStateDB_Commit_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PolarStateDB_Commit_Call) RunAndReturn(run func(uint64, bool) (common.Hash, error)) *PolarStateDB_Commit_Call {
	_c.Call.Return(run)
	return _c
}

// Copy provides a mock function with given fields:
func (_m *PolarStateDB) Copy() corestate.StateDBI {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Copy")
	}

	var r0 corestate.StateDBI
	if rf, ok := ret.Get(0).(func() corestate.StateDBI); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(corestate.StateDBI)
		}
	}

	return r0
}

// PolarStateDB_Copy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Copy'
type PolarStateDB_Copy_Call struct {
	*mock.Call
}

// Copy is a helper method to define mock.On call
func (_e *PolarStateDB_Expecter) Copy() *PolarStateDB_Copy_Call {
	return &PolarStateDB_Copy_Call{Call: _e.mock.On("Copy")}
}

func (_c *PolarStateDB_Copy_Call) Run(run func()) *PolarStateDB_Copy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *PolarStateDB_Copy_Call) Return(_a0 corestate.StateDBI) *PolarStateDB_Copy_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_Copy_Call) RunAndReturn(run func() corestate.StateDBI) *PolarStateDB_Copy_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAccount provides a mock function with given fields: _a0
func (_m *PolarStateDB) CreateAccount(_a0 common.Address) {
	_m.Called(_a0)
}

// PolarStateDB_CreateAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAccount'
type PolarStateDB_CreateAccount_Call struct {
	*mock.Call
}

// CreateAccount is a helper method to define mock.On call
//   - _a0 common.Address
func (_e *PolarStateDB_Expecter) CreateAccount(_a0 interface{}) *PolarStateDB_CreateAccount_Call {
	return &PolarStateDB_CreateAccount_Call{Call: _e.mock.On("CreateAccount", _a0)}
}

func (_c *PolarStateDB_CreateAccount_Call) Run(run func(_a0 common.Address)) *PolarStateDB_CreateAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_CreateAccount_Call) Return() *PolarStateDB_CreateAccount_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_CreateAccount_Call) RunAndReturn(run func(common.Address)) *PolarStateDB_CreateAccount_Call {
	_c.Call.Return(run)
	return _c
}

// Database provides a mock function with given fields:
func (_m *PolarStateDB) Database() corestate.Database {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Database")
	}

	var r0 corestate.Database
	if rf, ok := ret.Get(0).(func() corestate.Database); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(corestate.Database)
		}
	}

	return r0
}

// PolarStateDB_Database_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Database'
type PolarStateDB_Database_Call struct {
	*mock.Call
}

// Database is a helper method to define mock.On call
func (_e *PolarStateDB_Expecter) Database() *PolarStateDB_Database_Call {
	return &PolarStateDB_Database_Call{Call: _e.mock.On("Database")}
}

func (_c *PolarStateDB_Database_Call) Run(run func()) *PolarStateDB_Database_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *PolarStateDB_Database_Call) Return(_a0 corestate.Database) *PolarStateDB_Database_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_Database_Call) RunAndReturn(run func() corestate.Database) *PolarStateDB_Database_Call {
	_c.Call.Return(run)
	return _c
}

// Dump provides a mock function with given fields: opts
func (_m *PolarStateDB) Dump(opts *corestate.DumpConfig) []byte {
	ret := _m.Called(opts)

	if len(ret) == 0 {
		panic("no return value specified for Dump")
	}

	var r0 []byte
	if rf, ok := ret.Get(0).(func(*corestate.DumpConfig) []byte); ok {
		r0 = rf(opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}

	return r0
}

// PolarStateDB_Dump_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Dump'
type PolarStateDB_Dump_Call struct {
	*mock.Call
}

// Dump is a helper method to define mock.On call
//   - opts *corestate.DumpConfig
func (_e *PolarStateDB_Expecter) Dump(opts interface{}) *PolarStateDB_Dump_Call {
	return &PolarStateDB_Dump_Call{Call: _e.mock.On("Dump", opts)}
}

func (_c *PolarStateDB_Dump_Call) Run(run func(opts *corestate.DumpConfig)) *PolarStateDB_Dump_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*corestate.DumpConfig))
	})
	return _c
}

func (_c *PolarStateDB_Dump_Call) Return(_a0 []byte) *PolarStateDB_Dump_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_Dump_Call) RunAndReturn(run func(*corestate.DumpConfig) []byte) *PolarStateDB_Dump_Call {
	_c.Call.Return(run)
	return _c
}

// DumpToCollector provides a mock function with given fields: c, conf
func (_m *PolarStateDB) DumpToCollector(c corestate.DumpCollector, conf *corestate.DumpConfig) []byte {
	ret := _m.Called(c, conf)

	if len(ret) == 0 {
		panic("no return value specified for DumpToCollector")
	}

	var r0 []byte
	if rf, ok := ret.Get(0).(func(corestate.DumpCollector, *corestate.DumpConfig) []byte); ok {
		r0 = rf(c, conf)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}

	return r0
}

// PolarStateDB_DumpToCollector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DumpToCollector'
type PolarStateDB_DumpToCollector_Call struct {
	*mock.Call
}

// DumpToCollector is a helper method to define mock.On call
//   - c corestate.DumpCollector
//   - conf *corestate.DumpConfig
func (_e *PolarStateDB_Expecter) DumpToCollector(c interface{}, conf interface{}) *PolarStateDB_DumpToCollector_Call {
	return &PolarStateDB_DumpToCollector_Call{Call: _e.mock.On("DumpToCollector", c, conf)}
}

func (_c *PolarStateDB_DumpToCollector_Call) Run(run func(c corestate.DumpCollector, conf *corestate.DumpConfig)) *PolarStateDB_DumpToCollector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(corestate.DumpCollector), args[1].(*corestate.DumpConfig))
	})
	return _c
}

func (_c *PolarStateDB_DumpToCollector_Call) Return(nextKey []byte) *PolarStateDB_DumpToCollector_Call {
	_c.Call.Return(nextKey)
	return _c
}

func (_c *PolarStateDB_DumpToCollector_Call) RunAndReturn(run func(corestate.DumpCollector, *corestate.DumpConfig) []byte) *PolarStateDB_DumpToCollector_Call {
	_c.Call.Return(run)
	return _c
}

// Empty provides a mock function with given fields: _a0
func (_m *PolarStateDB) Empty(_a0 common.Address) bool {
	ret := _m.Called(_a0)

	if len(ret) == 0 {
		panic("no return value specified for Empty")
	}

	var r0 bool
	if rf, ok := ret.Get(0).(func(common.Address) bool); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// PolarStateDB_Empty_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Empty'
type PolarStateDB_Empty_Call struct {
	*mock.Call
}

// Empty is a helper method to define mock.On call
//   - _a0 common.Address
func (_e *PolarStateDB_Expecter) Empty(_a0 interface{}) *PolarStateDB_Empty_Call {
	return &PolarStateDB_Empty_Call{Call: _e.mock.On("Empty", _a0)}
}

func (_c *PolarStateDB_Empty_Call) Run(run func(_a0 common.Address)) *PolarStateDB_Empty_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_Empty_Call) Return(_a0 bool) *PolarStateDB_Empty_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_Empty_Call) RunAndReturn(run func(common.Address) bool) *PolarStateDB_Empty_Call {
	_c.Call.Return(run)
	return _c
}

// Error provides a mock function with given fields:
func (_m *PolarStateDB) Error() error {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Error")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// PolarStateDB_Error_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Error'
type PolarStateDB_Error_Call struct {
	*mock.Call
}

// Error is a helper method to define mock.On call
func (_e *PolarStateDB_Expecter) Error() *PolarStateDB_Error_Call {
	return &PolarStateDB_Error_Call{Call: _e.mock.On("Error")}
}

func (_c *PolarStateDB_Error_Call) Run(run func()) *PolarStateDB_Error_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *PolarStateDB_Error_Call) Return(_a0 error) *PolarStateDB_Error_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_Error_Call) RunAndReturn(run func() error) *PolarStateDB_Error_Call {
	_c.Call.Return(run)
	return _c
}

// Exist provides a mock function with given fields: _a0
func (_m *PolarStateDB) Exist(_a0 common.Address) bool {
	ret := _m.Called(_a0)

	if len(ret) == 0 {
		panic("no return value specified for Exist")
	}

	var r0 bool
	if rf, ok := ret.Get(0).(func(common.Address) bool); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// PolarStateDB_Exist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exist'
type PolarStateDB_Exist_Call struct {
	*mock.Call
}

// Exist is a helper method to define mock.On call
//   - _a0 common.Address
func (_e *PolarStateDB_Expecter) Exist(_a0 interface{}) *PolarStateDB_Exist_Call {
	return &PolarStateDB_Exist_Call{Call: _e.mock.On("Exist", _a0)}
}

func (_c *PolarStateDB_Exist_Call) Run(run func(_a0 common.Address)) *PolarStateDB_Exist_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_Exist_Call) Return(_a0 bool) *PolarStateDB_Exist_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_Exist_Call) RunAndReturn(run func(common.Address) bool) *PolarStateDB_Exist_Call {
	_c.Call.Return(run)
	return _c
}

// Finalise provides a mock function with given fields: deleteEmptyObjects
func (_m *PolarStateDB) Finalise(deleteEmptyObjects bool) {
	_m.Called(deleteEmptyObjects)
}

// PolarStateDB_Finalise_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Finalise'
type PolarStateDB_Finalise_Call struct {
	*mock.Call
}

// Finalise is a helper method to define mock.On call
//   - deleteEmptyObjects bool
func (_e *PolarStateDB_Expecter) Finalise(deleteEmptyObjects interface{}) *PolarStateDB_Finalise_Call {
	return &PolarStateDB_Finalise_Call{Call: _e.mock.On("Finalise", deleteEmptyObjects)}
}

func (_c *PolarStateDB_Finalise_Call) Run(run func(deleteEmptyObjects bool)) *PolarStateDB_Finalise_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(bool))
	})
	return _c
}

func (_c *PolarStateDB_Finalise_Call) Return() *PolarStateDB_Finalise_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_Finalise_Call) RunAndReturn(run func(bool)) *PolarStateDB_Finalise_Call {
	_c.Call.Return(run)
	return _c
}

// GetBalance provides a mock function with given fields: _a0
func (_m *PolarStateDB) GetBalance(_a0 common.Address) *big.Int {
	ret := _m.Called(_a0)

	if len(ret) == 0 {
		panic("no return value specified for GetBalance")
	}

	var r0 *big.Int
	if rf, ok := ret.Get(0).(func(common.Address) *big.Int); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*big.Int)
		}
	}

	return r0
}

// PolarStateDB_GetBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBalance'
type PolarStateDB_GetBalance_Call struct {
	*mock.Call
}

// GetBalance is a helper method to define mock.On call
//   - _a0 common.Address
func (_e *PolarStateDB_Expecter) GetBalance(_a0 interface{}) *PolarStateDB_GetBalance_Call {
	return &PolarStateDB_GetBalance_Call{Call: _e.mock.On("GetBalance", _a0)}
}

func (_c *PolarStateDB_GetBalance_Call) Run(run func(_a0 common.Address)) *PolarStateDB_GetBalance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_GetBalance_Call) Return(_a0 *big.Int) *PolarStateDB_GetBalance_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_GetBalance_Call) RunAndReturn(run func(common.Address) *big.Int) *PolarStateDB_GetBalance_Call {
	_c.Call.Return(run)
	return _c
}

// GetCode provides a mock function with given fields: _a0
func (_m *PolarStateDB) GetCode(_a0 common.Address) []byte {
	ret := _m.Called(_a0)

	if len(ret) == 0 {
		panic("no return value specified for GetCode")
	}

	var r0 []byte
	if rf, ok := ret.Get(0).(func(common.Address) []byte); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}

	return r0
}

// PolarStateDB_GetCode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCode'
type PolarStateDB_GetCode_Call struct {
	*mock.Call
}

// GetCode is a helper method to define mock.On call
//   - _a0 common.Address
func (_e *PolarStateDB_Expecter) GetCode(_a0 interface{}) *PolarStateDB_GetCode_Call {
	return &PolarStateDB_GetCode_Call{Call: _e.mock.On("GetCode", _a0)}
}

func (_c *PolarStateDB_GetCode_Call) Run(run func(_a0 common.Address)) *PolarStateDB_GetCode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_GetCode_Call) Return(_a0 []byte) *PolarStateDB_GetCode_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_GetCode_Call) RunAndReturn(run func(common.Address) []byte) *PolarStateDB_GetCode_Call {
	_c.Call.Return(run)
	return _c
}

// GetCodeHash provides a mock function with given fields: _a0
func (_m *PolarStateDB) GetCodeHash(_a0 common.Address) common.Hash {
	ret := _m.Called(_a0)

	if len(ret) == 0 {
		panic("no return value specified for GetCodeHash")
	}

	var r0 common.Hash
	if rf, ok := ret.Get(0).(func(common.Address) common.Hash); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Hash)
		}
	}

	return r0
}

// PolarStateDB_GetCodeHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCodeHash'
type PolarStateDB_GetCodeHash_Call struct {
	*mock.Call
}

// GetCodeHash is a helper method to define mock.On call
//   - _a0 common.Address
func (_e *PolarStateDB_Expecter) GetCodeHash(_a0 interface{}) *PolarStateDB_GetCodeHash_Call {
	return &PolarStateDB_GetCodeHash_Call{Call: _e.mock.On("GetCodeHash", _a0)}
}

func (_c *PolarStateDB_GetCodeHash_Call) Run(run func(_a0 common.Address)) *PolarStateDB_GetCodeHash_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_GetCodeHash_Call) Return(_a0 common.Hash) *PolarStateDB_GetCodeHash_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_GetCodeHash_Call) RunAndReturn(run func(common.Address) common.Hash) *PolarStateDB_GetCodeHash_Call {
	_c.Call.Return(run)
	return _c
}

// GetCodeSize provides a mock function with given fields: _a0
func (_m *PolarStateDB) GetCodeSize(_a0 common.Address) int {
	ret := _m.Called(_a0)

	if len(ret) == 0 {
		panic("no return value specified for GetCodeSize")
	}

	var r0 int
	if rf, ok := ret.Get(0).(func(common.Address) int); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(int)
	}

	return r0
}

// PolarStateDB_GetCodeSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCodeSize'
type PolarStateDB_GetCodeSize_Call struct {
	*mock.Call
}

// GetCodeSize is a helper method to define mock.On call
//   - _a0 common.Address
func (_e *PolarStateDB_Expecter) GetCodeSize(_a0 interface{}) *PolarStateDB_GetCodeSize_Call {
	return &PolarStateDB_GetCodeSize_Call{Call: _e.mock.On("GetCodeSize", _a0)}
}

func (_c *PolarStateDB_GetCodeSize_Call) Run(run func(_a0 common.Address)) *PolarStateDB_GetCodeSize_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_GetCodeSize_Call) Return(_a0 int) *PolarStateDB_GetCodeSize_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_GetCodeSize_Call) RunAndReturn(run func(common.Address) int) *PolarStateDB_GetCodeSize_Call {
	_c.Call.Return(run)
	return _c
}

// GetCommittedState provides a mock function with given fields: _a0, _a1
func (_m *PolarStateDB) GetCommittedState(_a0 common.Address, _a1 common.Hash) common.Hash {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for GetCommittedState")
	}

	var r0 common.Hash
	if rf, ok := ret.Get(0).(func(common.Address, common.Hash) common.Hash); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Hash)
		}
	}

	return r0
}

// PolarStateDB_GetCommittedState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCommittedState'
type PolarStateDB_GetCommittedState_Call struct {
	*mock.Call
}

// GetCommittedState is a helper method to define mock.On call
//   - _a0 common.Address
//   - _a1 common.Hash
func (_e *PolarStateDB_Expecter) GetCommittedState(_a0 interface{}, _a1 interface{}) *PolarStateDB_GetCommittedState_Call {
	return &PolarStateDB_GetCommittedState_Call{Call: _e.mock.On("GetCommittedState", _a0, _a1)}
}

func (_c *PolarStateDB_GetCommittedState_Call) Run(run func(_a0 common.Address, _a1 common.Hash)) *PolarStateDB_GetCommittedState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address), args[1].(common.Hash))
	})
	return _c
}

func (_c *PolarStateDB_GetCommittedState_Call) Return(_a0 common.Hash) *PolarStateDB_GetCommittedState_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_GetCommittedState_Call) RunAndReturn(run func(common.Address, common.Hash) common.Hash) *PolarStateDB_GetCommittedState_Call {
	_c.Call.Return(run)
	return _c
}

// GetContext provides a mock function with given fields:
func (_m *PolarStateDB) GetContext() context.Context {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetContext")
	}

	var r0 context.Context
	if rf, ok := ret.Get(0).(func() context.Context); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(context.Context)
		}
	}

	return r0
}

// PolarStateDB_GetContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetContext'
type PolarStateDB_GetContext_Call struct {
	*mock.Call
}

// GetContext is a helper method to define mock.On call
func (_e *PolarStateDB_Expecter) GetContext() *PolarStateDB_GetContext_Call {
	return &PolarStateDB_GetContext_Call{Call: _e.mock.On("GetContext")}
}

func (_c *PolarStateDB_GetContext_Call) Run(run func()) *PolarStateDB_GetContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *PolarStateDB_GetContext_Call) Return(_a0 context.Context) *PolarStateDB_GetContext_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_GetContext_Call) RunAndReturn(run func() context.Context) *PolarStateDB_GetContext_Call {
	_c.Call.Return(run)
	return _c
}

// GetLogs provides a mock function with given fields: hash, blockNumber, blockHash
func (_m *PolarStateDB) GetLogs(hash common.Hash, blockNumber uint64, blockHash common.Hash) []*types.Log {
	ret := _m.Called(hash, blockNumber, blockHash)

	if len(ret) == 0 {
		panic("no return value specified for GetLogs")
	}

	var r0 []*types.Log
	if rf, ok := ret.Get(0).(func(common.Hash, uint64, common.Hash) []*types.Log); ok {
		r0 = rf(hash, blockNumber, blockHash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Log)
		}
	}

	return r0
}

// PolarStateDB_GetLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLogs'
type PolarStateDB_GetLogs_Call struct {
	*mock.Call
}

// GetLogs is a helper method to define mock.On call
//   - hash common.Hash
//   - blockNumber uint64
//   - blockHash common.Hash
func (_e *PolarStateDB_Expecter) GetLogs(hash interface{}, blockNumber interface{}, blockHash interface{}) *PolarStateDB_GetLogs_Call {
	return &PolarStateDB_GetLogs_Call{Call: _e.mock.On("GetLogs", hash, blockNumber, blockHash)}
}

func (_c *PolarStateDB_GetLogs_Call) Run(run func(hash common.Hash, blockNumber uint64, blockHash common.Hash)) *PolarStateDB_GetLogs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Hash), args[1].(uint64), args[2].(common.Hash))
	})
	return _c
}

func (_c *PolarStateDB_GetLogs_Call) Return(_a0 []*types.Log) *PolarStateDB_GetLogs_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_GetLogs_Call) RunAndReturn(run func(common.Hash, uint64, common.Hash) []*types.Log) *PolarStateDB_GetLogs_Call {
	_c.Call.Return(run)
	return _c
}

// GetNonce provides a mock function with given fields: _a0
func (_m *PolarStateDB) GetNonce(_a0 common.Address) uint64 {
	ret := _m.Called(_a0)

	if len(ret) == 0 {
		panic("no return value specified for GetNonce")
	}

	var r0 uint64
	if rf, ok := ret.Get(0).(func(common.Address) uint64); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(uint64)
	}

	return r0
}

// PolarStateDB_GetNonce_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNonce'
type PolarStateDB_GetNonce_Call struct {
	*mock.Call
}

// GetNonce is a helper method to define mock.On call
//   - _a0 common.Address
func (_e *PolarStateDB_Expecter) GetNonce(_a0 interface{}) *PolarStateDB_GetNonce_Call {
	return &PolarStateDB_GetNonce_Call{Call: _e.mock.On("GetNonce", _a0)}
}

func (_c *PolarStateDB_GetNonce_Call) Run(run func(_a0 common.Address)) *PolarStateDB_GetNonce_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_GetNonce_Call) Return(_a0 uint64) *PolarStateDB_GetNonce_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_GetNonce_Call) RunAndReturn(run func(common.Address) uint64) *PolarStateDB_GetNonce_Call {
	_c.Call.Return(run)
	return _c
}

// GetOrNewStateObject provides a mock function with given fields: addr
func (_m *PolarStateDB) GetOrNewStateObject(addr common.Address) *corestate.StateObject {
	ret := _m.Called(addr)

	if len(ret) == 0 {
		panic("no return value specified for GetOrNewStateObject")
	}

	var r0 *corestate.StateObject
	if rf, ok := ret.Get(0).(func(common.Address) *corestate.StateObject); ok {
		r0 = rf(addr)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*corestate.StateObject)
		}
	}

	return r0
}

// PolarStateDB_GetOrNewStateObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrNewStateObject'
type PolarStateDB_GetOrNewStateObject_Call struct {
	*mock.Call
}

// GetOrNewStateObject is a helper method to define mock.On call
//   - addr common.Address
func (_e *PolarStateDB_Expecter) GetOrNewStateObject(addr interface{}) *PolarStateDB_GetOrNewStateObject_Call {
	return &PolarStateDB_GetOrNewStateObject_Call{Call: _e.mock.On("GetOrNewStateObject", addr)}
}

func (_c *PolarStateDB_GetOrNewStateObject_Call) Run(run func(addr common.Address)) *PolarStateDB_GetOrNewStateObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_GetOrNewStateObject_Call) Return(_a0 *corestate.StateObject) *PolarStateDB_GetOrNewStateObject_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_GetOrNewStateObject_Call) RunAndReturn(run func(common.Address) *corestate.StateObject) *PolarStateDB_GetOrNewStateObject_Call {
	_c.Call.Return(run)
	return _c
}

// GetPrecompileManager provides a mock function with given fields:
func (_m *PolarStateDB) GetPrecompileManager() interface{} {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPrecompileManager")
	}

	var r0 interface{}
	if rf, ok := ret.Get(0).(func() interface{}); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(interface{})
		}
	}

	return r0
}

// PolarStateDB_GetPrecompileManager_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPrecompileManager'
type PolarStateDB_GetPrecompileManager_Call struct {
	*mock.Call
}

// GetPrecompileManager is a helper method to define mock.On call
func (_e *PolarStateDB_Expecter) GetPrecompileManager() *PolarStateDB_GetPrecompileManager_Call {
	return &PolarStateDB_GetPrecompileManager_Call{Call: _e.mock.On("GetPrecompileManager")}
}

func (_c *PolarStateDB_GetPrecompileManager_Call) Run(run func()) *PolarStateDB_GetPrecompileManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *PolarStateDB_GetPrecompileManager_Call) Return(_a0 interface{}) *PolarStateDB_GetPrecompileManager_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_GetPrecompileManager_Call) RunAndReturn(run func() interface{}) *PolarStateDB_GetPrecompileManager_Call {
	_c.Call.Return(run)
	return _c
}

// GetRefund provides a mock function with given fields:
func (_m *PolarStateDB) GetRefund() uint64 {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetRefund")
	}

	var r0 uint64
	if rf, ok := ret.Get(0).(func() uint64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(uint64)
	}

	return r0
}

// PolarStateDB_GetRefund_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRefund'
type PolarStateDB_GetRefund_Call struct {
	*mock.Call
}

// GetRefund is a helper method to define mock.On call
func (_e *PolarStateDB_Expecter) GetRefund() *PolarStateDB_GetRefund_Call {
	return &PolarStateDB_GetRefund_Call{Call: _e.mock.On("GetRefund")}
}

func (_c *PolarStateDB_GetRefund_Call) Run(run func()) *PolarStateDB_GetRefund_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *PolarStateDB_GetRefund_Call) Return(_a0 uint64) *PolarStateDB_GetRefund_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_GetRefund_Call) RunAndReturn(run func() uint64) *PolarStateDB_GetRefund_Call {
	_c.Call.Return(run)
	return _c
}

// GetState provides a mock function with given fields: _a0, _a1
func (_m *PolarStateDB) GetState(_a0 common.Address, _a1 common.Hash) common.Hash {
	ret := _m.Called(_a0, _a1)

	if len(ret) == 0 {
		panic("no return value specified for GetState")
	}

	var r0 common.Hash
	if rf, ok := ret.Get(0).(func(common.Address, common.Hash) common.Hash); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Hash)
		}
	}

	return r0
}

// PolarStateDB_GetState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetState'
type PolarStateDB_GetState_Call struct {
	*mock.Call
}

// GetState is a helper method to define mock.On call
//   - _a0 common.Address
//   - _a1 common.Hash
func (_e *PolarStateDB_Expecter) GetState(_a0 interface{}, _a1 interface{}) *PolarStateDB_GetState_Call {
	return &PolarStateDB_GetState_Call{Call: _e.mock.On("GetState", _a0, _a1)}
}

func (_c *PolarStateDB_GetState_Call) Run(run func(_a0 common.Address, _a1 common.Hash)) *PolarStateDB_GetState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address), args[1].(common.Hash))
	})
	return _c
}

func (_c *PolarStateDB_GetState_Call) Return(_a0 common.Hash) *PolarStateDB_GetState_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_GetState_Call) RunAndReturn(run func(common.Address, common.Hash) common.Hash) *PolarStateDB_GetState_Call {
	_c.Call.Return(run)
	return _c
}

// GetStorageRoot provides a mock function with given fields: addr
func (_m *PolarStateDB) GetStorageRoot(addr common.Address) common.Hash {
	ret := _m.Called(addr)

	if len(ret) == 0 {
		panic("no return value specified for GetStorageRoot")
	}

	var r0 common.Hash
	if rf, ok := ret.Get(0).(func(common.Address) common.Hash); ok {
		r0 = rf(addr)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Hash)
		}
	}

	return r0
}

// PolarStateDB_GetStorageRoot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStorageRoot'
type PolarStateDB_GetStorageRoot_Call struct {
	*mock.Call
}

// GetStorageRoot is a helper method to define mock.On call
//   - addr common.Address
func (_e *PolarStateDB_Expecter) GetStorageRoot(addr interface{}) *PolarStateDB_GetStorageRoot_Call {
	return &PolarStateDB_GetStorageRoot_Call{Call: _e.mock.On("GetStorageRoot", addr)}
}

func (_c *PolarStateDB_GetStorageRoot_Call) Run(run func(addr common.Address)) *PolarStateDB_GetStorageRoot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_GetStorageRoot_Call) Return(_a0 common.Hash) *PolarStateDB_GetStorageRoot_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_GetStorageRoot_Call) RunAndReturn(run func(common.Address) common.Hash) *PolarStateDB_GetStorageRoot_Call {
	_c.Call.Return(run)
	return _c
}

// GetTransientState provides a mock function with given fields: addr, key
func (_m *PolarStateDB) GetTransientState(addr common.Address, key common.Hash) common.Hash {
	ret := _m.Called(addr, key)

	if len(ret) == 0 {
		panic("no return value specified for GetTransientState")
	}

	var r0 common.Hash
	if rf, ok := ret.Get(0).(func(common.Address, common.Hash) common.Hash); ok {
		r0 = rf(addr, key)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Hash)
		}
	}

	return r0
}

// PolarStateDB_GetTransientState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTransientState'
type PolarStateDB_GetTransientState_Call struct {
	*mock.Call
}

// GetTransientState is a helper method to define mock.On call
//   - addr common.Address
//   - key common.Hash
func (_e *PolarStateDB_Expecter) GetTransientState(addr interface{}, key interface{}) *PolarStateDB_GetTransientState_Call {
	return &PolarStateDB_GetTransientState_Call{Call: _e.mock.On("GetTransientState", addr, key)}
}

func (_c *PolarStateDB_GetTransientState_Call) Run(run func(addr common.Address, key common.Hash)) *PolarStateDB_GetTransientState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address), args[1].(common.Hash))
	})
	return _c
}

func (_c *PolarStateDB_GetTransientState_Call) Return(_a0 common.Hash) *PolarStateDB_GetTransientState_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_GetTransientState_Call) RunAndReturn(run func(common.Address, common.Hash) common.Hash) *PolarStateDB_GetTransientState_Call {
	_c.Call.Return(run)
	return _c
}

// HasSelfDestructed provides a mock function with given fields: _a0
func (_m *PolarStateDB) HasSelfDestructed(_a0 common.Address) bool {
	ret := _m.Called(_a0)

	if len(ret) == 0 {
		panic("no return value specified for HasSelfDestructed")
	}

	var r0 bool
	if rf, ok := ret.Get(0).(func(common.Address) bool); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// PolarStateDB_HasSelfDestructed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasSelfDestructed'
type PolarStateDB_HasSelfDestructed_Call struct {
	*mock.Call
}

// HasSelfDestructed is a helper method to define mock.On call
//   - _a0 common.Address
func (_e *PolarStateDB_Expecter) HasSelfDestructed(_a0 interface{}) *PolarStateDB_HasSelfDestructed_Call {
	return &PolarStateDB_HasSelfDestructed_Call{Call: _e.mock.On("HasSelfDestructed", _a0)}
}

func (_c *PolarStateDB_HasSelfDestructed_Call) Run(run func(_a0 common.Address)) *PolarStateDB_HasSelfDestructed_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_HasSelfDestructed_Call) Return(_a0 bool) *PolarStateDB_HasSelfDestructed_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_HasSelfDestructed_Call) RunAndReturn(run func(common.Address) bool) *PolarStateDB_HasSelfDestructed_Call {
	_c.Call.Return(run)
	return _c
}

// IntermediateRoot provides a mock function with given fields: deleteEmptyObjects
func (_m *PolarStateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
	ret := _m.Called(deleteEmptyObjects)

	if len(ret) == 0 {
		panic("no return value specified for IntermediateRoot")
	}

	var r0 common.Hash
	if rf, ok := ret.Get(0).(func(bool) common.Hash); ok {
		r0 = rf(deleteEmptyObjects)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Hash)
		}
	}

	return r0
}

// PolarStateDB_IntermediateRoot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IntermediateRoot'
type PolarStateDB_IntermediateRoot_Call struct {
	*mock.Call
}

// IntermediateRoot is a helper method to define mock.On call
//   - deleteEmptyObjects bool
func (_e *PolarStateDB_Expecter) IntermediateRoot(deleteEmptyObjects interface{}) *PolarStateDB_IntermediateRoot_Call {
	return &PolarStateDB_IntermediateRoot_Call{Call: _e.mock.On("IntermediateRoot", deleteEmptyObjects)}
}

func (_c *PolarStateDB_IntermediateRoot_Call) Run(run func(deleteEmptyObjects bool)) *PolarStateDB_IntermediateRoot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(bool))
	})
	return _c
}

func (_c *PolarStateDB_IntermediateRoot_Call) Return(_a0 common.Hash) *PolarStateDB_IntermediateRoot_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_IntermediateRoot_Call) RunAndReturn(run func(bool) common.Hash) *PolarStateDB_IntermediateRoot_Call {
	_c.Call.Return(run)
	return _c
}

// Logs provides a mock function with given fields:
func (_m *PolarStateDB) Logs() []*types.Log {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Logs")
	}

	var r0 []*types.Log
	if rf, ok := ret.Get(0).(func() []*types.Log); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*types.Log)
		}
	}

	return r0
}

// PolarStateDB_Logs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Logs'
type PolarStateDB_Logs_Call struct {
	*mock.Call
}

// Logs is a helper method to define mock.On call
func (_e *PolarStateDB_Expecter) Logs() *PolarStateDB_Logs_Call {
	return &PolarStateDB_Logs_Call{Call: _e.mock.On("Logs")}
}

func (_c *PolarStateDB_Logs_Call) Run(run func()) *PolarStateDB_Logs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *PolarStateDB_Logs_Call) Return(_a0 []*types.Log) *PolarStateDB_Logs_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_Logs_Call) RunAndReturn(run func() []*types.Log) *PolarStateDB_Logs_Call {
	_c.Call.Return(run)
	return _c
}

// Preimages provides a mock function with given fields:
func (_m *PolarStateDB) Preimages() map[common.Hash][]byte {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Preimages")
	}

	var r0 map[common.Hash][]byte
	if rf, ok := ret.Get(0).(func() map[common.Hash][]byte); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[common.Hash][]byte)
		}
	}

	return r0
}

// PolarStateDB_Preimages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Preimages'
type PolarStateDB_Preimages_Call struct {
	*mock.Call
}

// Preimages is a helper method to define mock.On call
func (_e *PolarStateDB_Expecter) Preimages() *PolarStateDB_Preimages_Call {
	return &PolarStateDB_Preimages_Call{Call: _e.mock.On("Preimages")}
}

func (_c *PolarStateDB_Preimages_Call) Run(run func()) *PolarStateDB_Preimages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *PolarStateDB_Preimages_Call) Return(_a0 map[common.Hash][]byte) *PolarStateDB_Preimages_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_Preimages_Call) RunAndReturn(run func() map[common.Hash][]byte) *PolarStateDB_Preimages_Call {
	_c.Call.Return(run)
	return _c
}

// Prepare provides a mock function with given fields: rules, sender, coinbase, dest, precompiles, txAccesses
func (_m *PolarStateDB) Prepare(rules params.Rules, sender common.Address, coinbase common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList) {
	_m.Called(rules, sender, coinbase, dest, precompiles, txAccesses)
}

// PolarStateDB_Prepare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prepare'
type PolarStateDB_Prepare_Call struct {
	*mock.Call
}

// Prepare is a helper method to define mock.On call
//   - rules params.Rules
//   - sender common.Address
//   - coinbase common.Address
//   - dest *common.Address
//   - precompiles []common.Address
//   - txAccesses types.AccessList
func (_e *PolarStateDB_Expecter) Prepare(rules interface{}, sender interface{}, coinbase interface{}, dest interface{}, precompiles interface{}, txAccesses interface{}) *PolarStateDB_Prepare_Call {
	return &PolarStateDB_Prepare_Call{Call: _e.mock.On("Prepare", rules, sender, coinbase, dest, precompiles, txAccesses)}
}

func (_c *PolarStateDB_Prepare_Call) Run(run func(rules params.Rules, sender common.Address, coinbase common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList)) *PolarStateDB_Prepare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(params.Rules), args[1].(common.Address), args[2].(common.Address), args[3].(*common.Address), args[4].([]common.Address), args[5].(types.AccessList))
	})
	return _c
}

func (_c *PolarStateDB_Prepare_Call) Return() *PolarStateDB_Prepare_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_Prepare_Call) RunAndReturn(run func(params.Rules, common.Address, common.Address, *common.Address, []common.Address, types.AccessList)) *PolarStateDB_Prepare_Call {
	_c.Call.Return(run)
	return _c
}

// RawDump provides a mock function with given fields: opts
func (_m *PolarStateDB) RawDump(opts *corestate.DumpConfig) corestate.Dump {
	ret := _m.Called(opts)

	if len(ret) == 0 {
		panic("no return value specified for RawDump")
	}

	var r0 corestate.Dump
	if rf, ok := ret.Get(0).(func(*corestate.DumpConfig) corestate.Dump); ok {
		r0 = rf(opts)
	} else {
		r0 = ret.Get(0).(corestate.Dump)
	}

	return r0
}

// PolarStateDB_RawDump_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RawDump'
type PolarStateDB_RawDump_Call struct {
	*mock.Call
}

// RawDump is a helper method to define mock.On call
//   - opts *corestate.DumpConfig
func (_e *PolarStateDB_Expecter) RawDump(opts interface{}) *PolarStateDB_RawDump_Call {
	return &PolarStateDB_RawDump_Call{Call: _e.mock.On("RawDump", opts)}
}

func (_c *PolarStateDB_RawDump_Call) Run(run func(opts *corestate.DumpConfig)) *PolarStateDB_RawDump_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*corestate.DumpConfig))
	})
	return _c
}

func (_c *PolarStateDB_RawDump_Call) Return(_a0 corestate.Dump) *PolarStateDB_RawDump_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_RawDump_Call) RunAndReturn(run func(*corestate.DumpConfig) corestate.Dump) *PolarStateDB_RawDump_Call {
	_c.Call.Return(run)
	return _c
}

// RevertToSnapshot provides a mock function with given fields: _a0
func (_m *PolarStateDB) RevertToSnapshot(_a0 int) {
	_m.Called(_a0)
}

// PolarStateDB_RevertToSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevertToSnapshot'
type PolarStateDB_RevertToSnapshot_Call struct {
	*mock.Call
}

// RevertToSnapshot is a helper method to define mock.On call
//   - _a0 int
func (_e *PolarStateDB_Expecter) RevertToSnapshot(_a0 interface{}) *PolarStateDB_RevertToSnapshot_Call {
	return &PolarStateDB_RevertToSnapshot_Call{Call: _e.mock.On("RevertToSnapshot", _a0)}
}

func (_c *PolarStateDB_RevertToSnapshot_Call) Run(run func(_a0 int)) *PolarStateDB_RevertToSnapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int))
	})
	return _c
}

func (_c *PolarStateDB_RevertToSnapshot_Call) Return() *PolarStateDB_RevertToSnapshot_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_RevertToSnapshot_Call) RunAndReturn(run func(int)) *PolarStateDB_RevertToSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// SelfDestruct provides a mock function with given fields: _a0
func (_m *PolarStateDB) SelfDestruct(_a0 common.Address) {
	_m.Called(_a0)
}

// PolarStateDB_SelfDestruct_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelfDestruct'
type PolarStateDB_SelfDestruct_Call struct {
	*mock.Call
}

// SelfDestruct is a helper method to define mock.On call
//   - _a0 common.Address
func (_e *PolarStateDB_Expecter) SelfDestruct(_a0 interface{}) *PolarStateDB_SelfDestruct_Call {
	return &PolarStateDB_SelfDestruct_Call{Call: _e.mock.On("SelfDestruct", _a0)}
}

func (_c *PolarStateDB_SelfDestruct_Call) Run(run func(_a0 common.Address)) *PolarStateDB_SelfDestruct_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_SelfDestruct_Call) Return() *PolarStateDB_SelfDestruct_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_SelfDestruct_Call) RunAndReturn(run func(common.Address)) *PolarStateDB_SelfDestruct_Call {
	_c.Call.Return(run)
	return _c
}

// Selfdestruct6780 provides a mock function with given fields: _a0
func (_m *PolarStateDB) Selfdestruct6780(_a0 common.Address) {
	_m.Called(_a0)
}

// PolarStateDB_Selfdestruct6780_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Selfdestruct6780'
type PolarStateDB_Selfdestruct6780_Call struct {
	*mock.Call
}

// Selfdestruct6780 is a helper method to define mock.On call
//   - _a0 common.Address
func (_e *PolarStateDB_Expecter) Selfdestruct6780(_a0 interface{}) *PolarStateDB_Selfdestruct6780_Call {
	return &PolarStateDB_Selfdestruct6780_Call{Call: _e.mock.On("Selfdestruct6780", _a0)}
}

func (_c *PolarStateDB_Selfdestruct6780_Call) Run(run func(_a0 common.Address)) *PolarStateDB_Selfdestruct6780_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address))
	})
	return _c
}

func (_c *PolarStateDB_Selfdestruct6780_Call) Return() *PolarStateDB_Selfdestruct6780_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_Selfdestruct6780_Call) RunAndReturn(run func(common.Address)) *PolarStateDB_Selfdestruct6780_Call {
	_c.Call.Return(run)
	return _c
}

// SetBalance provides a mock function with given fields: addr, amount
func (_m *PolarStateDB) SetBalance(addr common.Address, amount *big.Int) {
	_m.Called(addr, amount)
}

// PolarStateDB_SetBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetBalance'
type PolarStateDB_SetBalance_Call struct {
	*mock.Call
}

// SetBalance is a helper method to define mock.On call
//   - addr common.Address
//   - amount *big.Int
func (_e *PolarStateDB_Expecter) SetBalance(addr interface{}, amount interface{}) *PolarStateDB_SetBalance_Call {
	return &PolarStateDB_SetBalance_Call{Call: _e.mock.On("SetBalance", addr, amount)}
}

func (_c *PolarStateDB_SetBalance_Call) Run(run func(addr common.Address, amount *big.Int)) *PolarStateDB_SetBalance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address), args[1].(*big.Int))
	})
	return _c
}

func (_c *PolarStateDB_SetBalance_Call) Return() *PolarStateDB_SetBalance_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_SetBalance_Call) RunAndReturn(run func(common.Address, *big.Int)) *PolarStateDB_SetBalance_Call {
	_c.Call.Return(run)
	return _c
}

// SetCode provides a mock function with given fields: _a0, _a1
func (_m *PolarStateDB) SetCode(_a0 common.Address, _a1 []byte) {
	_m.Called(_a0, _a1)
}

// PolarStateDB_SetCode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCode'
type PolarStateDB_SetCode_Call struct {
	*mock.Call
}

// SetCode is a helper method to define mock.On call
//   - _a0 common.Address
//   - _a1 []byte
func (_e *PolarStateDB_Expecter) SetCode(_a0 interface{}, _a1 interface{}) *PolarStateDB_SetCode_Call {
	return &PolarStateDB_SetCode_Call{Call: _e.mock.On("SetCode", _a0, _a1)}
}

func (_c *PolarStateDB_SetCode_Call) Run(run func(_a0 common.Address, _a1 []byte)) *PolarStateDB_SetCode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address), args[1].([]byte))
	})
	return _c
}

func (_c *PolarStateDB_SetCode_Call) Return() *PolarStateDB_SetCode_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_SetCode_Call) RunAndReturn(run func(common.Address, []byte)) *PolarStateDB_SetCode_Call {
	_c.Call.Return(run)
	return _c
}

// SetNonce provides a mock function with given fields: _a0, _a1
func (_m *PolarStateDB) SetNonce(_a0 common.Address, _a1 uint64) {
	_m.Called(_a0, _a1)
}

// PolarStateDB_SetNonce_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetNonce'
type PolarStateDB_SetNonce_Call struct {
	*mock.Call
}

// SetNonce is a helper method to define mock.On call
//   - _a0 common.Address
//   - _a1 uint64
func (_e *PolarStateDB_Expecter) SetNonce(_a0 interface{}, _a1 interface{}) *PolarStateDB_SetNonce_Call {
	return &PolarStateDB_SetNonce_Call{Call: _e.mock.On("SetNonce", _a0, _a1)}
}

func (_c *PolarStateDB_SetNonce_Call) Run(run func(_a0 common.Address, _a1 uint64)) *PolarStateDB_SetNonce_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address), args[1].(uint64))
	})
	return _c
}

func (_c *PolarStateDB_SetNonce_Call) Return() *PolarStateDB_SetNonce_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_SetNonce_Call) RunAndReturn(run func(common.Address, uint64)) *PolarStateDB_SetNonce_Call {
	_c.Call.Return(run)
	return _c
}

// SetState provides a mock function with given fields: _a0, _a1, _a2
func (_m *PolarStateDB) SetState(_a0 common.Address, _a1 common.Hash, _a2 common.Hash) {
	_m.Called(_a0, _a1, _a2)
}

// PolarStateDB_SetState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetState'
type PolarStateDB_SetState_Call struct {
	*mock.Call
}

// SetState is a helper method to define mock.On call
//   - _a0 common.Address
//   - _a1 common.Hash
//   - _a2 common.Hash
func (_e *PolarStateDB_Expecter) SetState(_a0 interface{}, _a1 interface{}, _a2 interface{}) *PolarStateDB_SetState_Call {
	return &PolarStateDB_SetState_Call{Call: _e.mock.On("SetState", _a0, _a1, _a2)}
}

func (_c *PolarStateDB_SetState_Call) Run(run func(_a0 common.Address, _a1 common.Hash, _a2 common.Hash)) *PolarStateDB_SetState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address), args[1].(common.Hash), args[2].(common.Hash))
	})
	return _c
}

func (_c *PolarStateDB_SetState_Call) Return() *PolarStateDB_SetState_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_SetState_Call) RunAndReturn(run func(common.Address, common.Hash, common.Hash)) *PolarStateDB_SetState_Call {
	_c.Call.Return(run)
	return _c
}

// SetStorage provides a mock function with given fields: addr, storage
func (_m *PolarStateDB) SetStorage(addr common.Address, storage map[common.Hash]common.Hash) {
	_m.Called(addr, storage)
}

// PolarStateDB_SetStorage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetStorage'
type PolarStateDB_SetStorage_Call struct {
	*mock.Call
}

// SetStorage is a helper method to define mock.On call
//   - addr common.Address
//   - storage map[common.Hash]common.Hash
func (_e *PolarStateDB_Expecter) SetStorage(addr interface{}, storage interface{}) *PolarStateDB_SetStorage_Call {
	return &PolarStateDB_SetStorage_Call{Call: _e.mock.On("SetStorage", addr, storage)}
}

func (_c *PolarStateDB_SetStorage_Call) Run(run func(addr common.Address, storage map[common.Hash]common.Hash)) *PolarStateDB_SetStorage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address), args[1].(map[common.Hash]common.Hash))
	})
	return _c
}

func (_c *PolarStateDB_SetStorage_Call) Return() *PolarStateDB_SetStorage_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_SetStorage_Call) RunAndReturn(run func(common.Address, map[common.Hash]common.Hash)) *PolarStateDB_SetStorage_Call {
	_c.Call.Return(run)
	return _c
}

// SetTransientState provides a mock function with given fields: addr, key, value
func (_m *PolarStateDB) SetTransientState(addr common.Address, key common.Hash, value common.Hash) {
	_m.Called(addr, key, value)
}

// PolarStateDB_SetTransientState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransientState'
type PolarStateDB_SetTransientState_Call struct {
	*mock.Call
}

// SetTransientState is a helper method to define mock.On call
//   - addr common.Address
//   - key common.Hash
//   - value common.Hash
func (_e *PolarStateDB_Expecter) SetTransientState(addr interface{}, key interface{}, value interface{}) *PolarStateDB_SetTransientState_Call {
	return &PolarStateDB_SetTransientState_Call{Call: _e.mock.On("SetTransientState", addr, key, value)}
}

func (_c *PolarStateDB_SetTransientState_Call) Run(run func(addr common.Address, key common.Hash, value common.Hash)) *PolarStateDB_SetTransientState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address), args[1].(common.Hash), args[2].(common.Hash))
	})
	return _c
}

func (_c *PolarStateDB_SetTransientState_Call) Return() *PolarStateDB_SetTransientState_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_SetTransientState_Call) RunAndReturn(run func(common.Address, common.Hash, common.Hash)) *PolarStateDB_SetTransientState_Call {
	_c.Call.Return(run)
	return _c
}

// SetTxContext provides a mock function with given fields: thash, ti
func (_m *PolarStateDB) SetTxContext(thash common.Hash, ti int) {
	_m.Called(thash, ti)
}

// PolarStateDB_SetTxContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTxContext'
type PolarStateDB_SetTxContext_Call struct {
	*mock.Call
}

// SetTxContext is a helper method to define mock.On call
//   - thash common.Hash
//   - ti int
func (_e *PolarStateDB_Expecter) SetTxContext(thash interface{}, ti interface{}) *PolarStateDB_SetTxContext_Call {
	return &PolarStateDB_SetTxContext_Call{Call: _e.mock.On("SetTxContext", thash, ti)}
}

func (_c *PolarStateDB_SetTxContext_Call) Run(run func(thash common.Hash, ti int)) *PolarStateDB_SetTxContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Hash), args[1].(int))
	})
	return _c
}

func (_c *PolarStateDB_SetTxContext_Call) Return() *PolarStateDB_SetTxContext_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_SetTxContext_Call) RunAndReturn(run func(common.Hash, int)) *PolarStateDB_SetTxContext_Call {
	_c.Call.Return(run)
	return _c
}

// SlotInAccessList provides a mock function with given fields: addr, slot
func (_m *PolarStateDB) SlotInAccessList(addr common.Address, slot common.Hash) (bool, bool) {
	ret := _m.Called(addr, slot)

	if len(ret) == 0 {
		panic("no return value specified for SlotInAccessList")
	}

	var r0 bool
	var r1 bool
	if rf, ok := ret.Get(0).(func(common.Address, common.Hash) (bool, bool)); ok {
		return rf(addr, slot)
	}
	if rf, ok := ret.Get(0).(func(common.Address, common.Hash) bool); ok {
		r0 = rf(addr, slot)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(common.Address, common.Hash) bool); ok {
		r1 = rf(addr, slot)
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

// PolarStateDB_SlotInAccessList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlotInAccessList'
type PolarStateDB_SlotInAccessList_Call struct {
	*mock.Call
}

// SlotInAccessList is a helper method to define mock.On call
//   - addr common.Address
//   - slot common.Hash
func (_e *PolarStateDB_Expecter) SlotInAccessList(addr interface{}, slot interface{}) *PolarStateDB_SlotInAccessList_Call {
	return &PolarStateDB_SlotInAccessList_Call{Call: _e.mock.On("SlotInAccessList", addr, slot)}
}

func (_c *PolarStateDB_SlotInAccessList_Call) Run(run func(addr common.Address, slot common.Hash)) *PolarStateDB_SlotInAccessList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address), args[1].(common.Hash))
	})
	return _c
}

func (_c *PolarStateDB_SlotInAccessList_Call) Return(addressOk bool, slotOk bool) *PolarStateDB_SlotInAccessList_Call {
	_c.Call.Return(addressOk, slotOk)
	return _c
}

func (_c *PolarStateDB_SlotInAccessList_Call) RunAndReturn(run func(common.Address, common.Hash) (bool, bool)) *PolarStateDB_SlotInAccessList_Call {
	_c.Call.Return(run)
	return _c
}

// Snapshot provides a mock function with given fields:
func (_m *PolarStateDB) Snapshot() int {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Snapshot")
	}

	var r0 int
	if rf, ok := ret.Get(0).(func() int); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int)
	}

	return r0
}

// PolarStateDB_Snapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Snapshot'
type PolarStateDB_Snapshot_Call struct {
	*mock.Call
}

// Snapshot is a helper method to define mock.On call
func (_e *PolarStateDB_Expecter) Snapshot() *PolarStateDB_Snapshot_Call {
	return &PolarStateDB_Snapshot_Call{Call: _e.mock.On("Snapshot")}
}

func (_c *PolarStateDB_Snapshot_Call) Run(run func()) *PolarStateDB_Snapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *PolarStateDB_Snapshot_Call) Return(_a0 int) *PolarStateDB_Snapshot_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_Snapshot_Call) RunAndReturn(run func() int) *PolarStateDB_Snapshot_Call {
	_c.Call.Return(run)
	return _c
}

// StartPrefetcher provides a mock function with given fields: namespace
func (_m *PolarStateDB) StartPrefetcher(namespace string) {
	_m.Called(namespace)
}

// PolarStateDB_StartPrefetcher_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartPrefetcher'
type PolarStateDB_StartPrefetcher_Call struct {
	*mock.Call
}

// StartPrefetcher is a helper method to define mock.On call
//   - namespace string
func (_e *PolarStateDB_Expecter) StartPrefetcher(namespace interface{}) *PolarStateDB_StartPrefetcher_Call {
	return &PolarStateDB_StartPrefetcher_Call{Call: _e.mock.On("StartPrefetcher", namespace)}
}

func (_c *PolarStateDB_StartPrefetcher_Call) Run(run func(namespace string)) *PolarStateDB_StartPrefetcher_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *PolarStateDB_StartPrefetcher_Call) Return() *PolarStateDB_StartPrefetcher_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_StartPrefetcher_Call) RunAndReturn(run func(string)) *PolarStateDB_StartPrefetcher_Call {
	_c.Call.Return(run)
	return _c
}

// StopPrefetcher provides a mock function with given fields:
func (_m *PolarStateDB) StopPrefetcher() {
	_m.Called()
}

// PolarStateDB_StopPrefetcher_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopPrefetcher'
type PolarStateDB_StopPrefetcher_Call struct {
	*mock.Call
}

// StopPrefetcher is a helper method to define mock.On call
func (_e *PolarStateDB_Expecter) StopPrefetcher() *PolarStateDB_StopPrefetcher_Call {
	return &PolarStateDB_StopPrefetcher_Call{Call: _e.mock.On("StopPrefetcher")}
}

func (_c *PolarStateDB_StopPrefetcher_Call) Run(run func()) *PolarStateDB_StopPrefetcher_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *PolarStateDB_StopPrefetcher_Call) Return() *PolarStateDB_StopPrefetcher_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_StopPrefetcher_Call) RunAndReturn(run func()) *PolarStateDB_StopPrefetcher_Call {
	_c.Call.Return(run)
	return _c
}

// SubBalance provides a mock function with given fields: _a0, _a1
func (_m *PolarStateDB) SubBalance(_a0 common.Address, _a1 *big.Int) {
	_m.Called(_a0, _a1)
}

// PolarStateDB_SubBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubBalance'
type PolarStateDB_SubBalance_Call struct {
	*mock.Call
}

// SubBalance is a helper method to define mock.On call
//   - _a0 common.Address
//   - _a1 *big.Int
func (_e *PolarStateDB_Expecter) SubBalance(_a0 interface{}, _a1 interface{}) *PolarStateDB_SubBalance_Call {
	return &PolarStateDB_SubBalance_Call{Call: _e.mock.On("SubBalance", _a0, _a1)}
}

func (_c *PolarStateDB_SubBalance_Call) Run(run func(_a0 common.Address, _a1 *big.Int)) *PolarStateDB_SubBalance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(common.Address), args[1].(*big.Int))
	})
	return _c
}

func (_c *PolarStateDB_SubBalance_Call) Return() *PolarStateDB_SubBalance_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_SubBalance_Call) RunAndReturn(run func(common.Address, *big.Int)) *PolarStateDB_SubBalance_Call {
	_c.Call.Return(run)
	return _c
}

// SubRefund provides a mock function with given fields: _a0
func (_m *PolarStateDB) SubRefund(_a0 uint64) {
	_m.Called(_a0)
}

// PolarStateDB_SubRefund_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubRefund'
type PolarStateDB_SubRefund_Call struct {
	*mock.Call
}

// SubRefund is a helper method to define mock.On call
//   - _a0 uint64
func (_e *PolarStateDB_Expecter) SubRefund(_a0 interface{}) *PolarStateDB_SubRefund_Call {
	return &PolarStateDB_SubRefund_Call{Call: _e.mock.On("SubRefund", _a0)}
}

func (_c *PolarStateDB_SubRefund_Call) Run(run func(_a0 uint64)) *PolarStateDB_SubRefund_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(uint64))
	})
	return _c
}

func (_c *PolarStateDB_SubRefund_Call) Return() *PolarStateDB_SubRefund_Call {
	_c.Call.Return()
	return _c
}

func (_c *PolarStateDB_SubRefund_Call) RunAndReturn(run func(uint64)) *PolarStateDB_SubRefund_Call {
	_c.Call.Return(run)
	return _c
}

// TxIndex provides a mock function with given fields:
func (_m *PolarStateDB) TxIndex() int {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for TxIndex")
	}

	var r0 int
	if rf, ok := ret.Get(0).(func() int); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int)
	}

	return r0
}

// PolarStateDB_TxIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TxIndex'
type PolarStateDB_TxIndex_Call struct {
	*mock.Call
}

// TxIndex is a helper method to define mock.On call
func (_e *PolarStateDB_Expecter) TxIndex() *PolarStateDB_TxIndex_Call {
	return &PolarStateDB_TxIndex_Call{Call: _e.mock.On("TxIndex")}
}

func (_c *PolarStateDB_TxIndex_Call) Run(run func()) *PolarStateDB_TxIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *PolarStateDB_TxIndex_Call) Return(_a0 int) *PolarStateDB_TxIndex_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PolarStateDB_TxIndex_Call) RunAndReturn(run func() int) *PolarStateDB_TxIndex_Call {
	_c.Call.Return(run)
	return _c
}

// NewPolarStateDB creates a new instance of PolarStateDB. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewPolarStateDB(t interface {
	mock.TestingT
	Cleanup(func())
}) *PolarStateDB {
	mock := &PolarStateDB{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
