// Copyright 2025 Sonic Operations Ltd
// This file is part of the Sonic Client
//
// Sonic is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Sonic is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Sonic. If not, see <http://www.gnu.org/licenses/>.

// Code generated by MockGen. DO NOT EDIT.
// Source: adapter.go
//
// Generated by this command:
//
//	mockgen -source adapter.go -destination adapter_mock.go -package state
//

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

import (
	reflect "reflect"

	witness "github.com/0xsoniclabs/carmen/go/common/witness"
	common "github.com/ethereum/go-ethereum/common"
	state "github.com/ethereum/go-ethereum/core/state"
	stateless "github.com/ethereum/go-ethereum/core/stateless"
	tracing "github.com/ethereum/go-ethereum/core/tracing"
	types "github.com/ethereum/go-ethereum/core/types"
	params "github.com/ethereum/go-ethereum/params"
	utils "github.com/ethereum/go-ethereum/trie/utils"
	uint256 "github.com/holiman/uint256"
	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
}

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

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

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

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

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

// AddBalance indicates an expected call of AddBalance.
func (mr *MockStateDBMockRecorder) AddBalance(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBalance", reflect.TypeOf((*MockStateDB)(nil).AddBalance), 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)
}

// AddPreimage mocks base method.
func (m *MockStateDB) AddPreimage(arg0 common.Hash, arg1 []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddPreimage", arg0, arg1)
}

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

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

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

// AddSlotToAccessList mocks base method.
func (m *MockStateDB) AddSlotToAccessList(addr common.Address, slot common.Hash) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddSlotToAccessList", addr, slot)
}

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

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

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

// BeginBlock mocks base method.
func (m *MockStateDB) BeginBlock(number uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "BeginBlock", number)
}

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

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

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

// 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)
}

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

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

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

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

// EndBlock mocks base method.
func (m *MockStateDB) EndBlock(number uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EndBlock", number)
}

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

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

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

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

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

// 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)
}

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

// Finalise indicates an expected call of Finalise.
func (mr *MockStateDBMockRecorder) Finalise(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Finalise", reflect.TypeOf((*MockStateDB)(nil).Finalise), 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)
}

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

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

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

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

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

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

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

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

// 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)
}

// GetProof mocks base method.
func (m *MockStateDB) GetProof(addr common.Address, keys []common.Hash) (witness.Proof, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProof", addr, keys)
	ret0, _ := ret[0].(witness.Proof)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Prepare mocks base method.
func (m *MockStateDB) Prepare(rules params.Rules, sender, coinbase common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Prepare", rules, sender, coinbase, dest, precompiles, txAccesses)
}

// Prepare indicates an expected call of Prepare.
func (mr *MockStateDBMockRecorder) Prepare(rules, sender, coinbase, dest, precompiles, txAccesses any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prepare", reflect.TypeOf((*MockStateDB)(nil).Prepare), rules, sender, coinbase, dest, precompiles, txAccesses)
}

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

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

// 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)
}

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

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

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

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

// SetBalance mocks base method.
func (m *MockStateDB) SetBalance(addr common.Address, amount *uint256.Int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBalance", addr, amount)
}

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

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

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

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

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

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

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

// SetStorage mocks base method.
func (m *MockStateDB) SetStorage(addr common.Address, storage map[common.Hash]common.Hash) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorage", addr, storage)
}

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

// SetTransientState mocks base method.
func (m *MockStateDB) SetTransientState(addr common.Address, key, value common.Hash) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTransientState", addr, key, value)
}

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

// SetTxContext mocks base method.
func (m *MockStateDB) SetTxContext(thash common.Hash, ti int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTxContext", thash, ti)
}

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

// SlotInAccessList mocks base method.
func (m *MockStateDB) SlotInAccessList(addr common.Address, slot common.Hash) (bool, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SlotInAccessList", addr, slot)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

// 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))
}

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

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

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

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

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

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

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

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