// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq

package mock

import (
	"context"
	"github.com/berachain/polaris/eth/core/vm"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/params"
	"math/big"
	"sync"
)

// Ensure, that PolarStateDBMock does implement vm.PolarStateDB.
// If this is not the case, regenerate this file with moq.
var _ vm.PolarStateDB = &PolarStateDBMock{}

// PolarStateDBMock is a mock implementation of vm.PolarStateDB.
//
//	func TestSomethingThatUsesPolarStateDB(t *testing.T) {
//
//		// make and configure a mocked vm.PolarStateDB
//		mockedPolarStateDB := &PolarStateDBMock{
//			AddAddressToAccessListFunc: func(addr common.Address)  {
//				panic("mock out the AddAddressToAccessList method")
//			},
//			AddBalanceFunc: func(address common.Address, intMoqParam *big.Int)  {
//				panic("mock out the AddBalance method")
//			},
//			AddLogFunc: func(log *types.Log)  {
//				panic("mock out the AddLog method")
//			},
//			AddPreimageFunc: func(hash common.Hash, bytes []byte)  {
//				panic("mock out the AddPreimage method")
//			},
//			AddRefundFunc: func(v uint64)  {
//				panic("mock out the AddRefund method")
//			},
//			AddSlotToAccessListFunc: func(addr common.Address, slot common.Hash)  {
//				panic("mock out the AddSlotToAccessList method")
//			},
//			AddressInAccessListFunc: func(addr common.Address) bool {
//				panic("mock out the AddressInAccessList method")
//			},
//			CreateAccountFunc: func(address common.Address)  {
//				panic("mock out the CreateAccount method")
//			},
//			EmptyFunc: func(address common.Address) bool {
//				panic("mock out the Empty method")
//			},
//			ExistFunc: func(address common.Address) bool {
//				panic("mock out the Exist method")
//			},
//			GetBalanceFunc: func(address common.Address) *big.Int {
//				panic("mock out the GetBalance method")
//			},
//			GetCodeFunc: func(address common.Address) []byte {
//				panic("mock out the GetCode method")
//			},
//			GetCodeHashFunc: func(address common.Address) common.Hash {
//				panic("mock out the GetCodeHash method")
//			},
//			GetCodeSizeFunc: func(address common.Address) int {
//				panic("mock out the GetCodeSize method")
//			},
//			GetCommittedStateFunc: func(address common.Address, hash common.Hash) common.Hash {
//				panic("mock out the GetCommittedState method")
//			},
//			GetContextFunc: func() context.Context {
//				panic("mock out the GetContext method")
//			},
//			GetNonceFunc: func(address common.Address) uint64 {
//				panic("mock out the GetNonce method")
//			},
//			GetPrecompileManagerFunc: func() any {
//				panic("mock out the GetPrecompileManager method")
//			},
//			GetRefundFunc: func() uint64 {
//				panic("mock out the GetRefund method")
//			},
//			GetStateFunc: func(address common.Address, hash common.Hash) common.Hash {
//				panic("mock out the GetState method")
//			},
//			GetTransientStateFunc: func(addr common.Address, key common.Hash) common.Hash {
//				panic("mock out the GetTransientState method")
//			},
//			HasSelfDestructedFunc: func(address common.Address) bool {
//				panic("mock out the HasSelfDestructed method")
//			},
//			PrepareFunc: func(rules params.Rules, sender common.Address, coinbase common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList)  {
//				panic("mock out the Prepare method")
//			},
//			RevertToSnapshotFunc: func(n int)  {
//				panic("mock out the RevertToSnapshot method")
//			},
//			SelfDestructFunc: func(address common.Address)  {
//				panic("mock out the SelfDestruct method")
//			},
//			Selfdestruct6780Func: func(address common.Address)  {
//				panic("mock out the Selfdestruct6780 method")
//			},
//			SetCodeFunc: func(address common.Address, bytes []byte)  {
//				panic("mock out the SetCode method")
//			},
//			SetNonceFunc: func(address common.Address, v uint64)  {
//				panic("mock out the SetNonce method")
//			},
//			SetStateFunc: func(address common.Address, hash1 common.Hash, hash2 common.Hash)  {
//				panic("mock out the SetState method")
//			},
//			SetTransientStateFunc: func(addr common.Address, key common.Hash, value common.Hash)  {
//				panic("mock out the SetTransientState method")
//			},
//			SlotInAccessListFunc: func(addr common.Address, slot common.Hash) (bool, bool) {
//				panic("mock out the SlotInAccessList method")
//			},
//			SnapshotFunc: func() int {
//				panic("mock out the Snapshot method")
//			},
//			SubBalanceFunc: func(address common.Address, intMoqParam *big.Int)  {
//				panic("mock out the SubBalance method")
//			},
//			SubRefundFunc: func(v uint64)  {
//				panic("mock out the SubRefund method")
//			},
//		}
//
//		// use mockedPolarStateDB in code that requires vm.PolarStateDB
//		// and then make assertions.
//
//	}
type PolarStateDBMock struct {
	// AddAddressToAccessListFunc mocks the AddAddressToAccessList method.
	AddAddressToAccessListFunc func(addr common.Address)

	// AddBalanceFunc mocks the AddBalance method.
	AddBalanceFunc func(address common.Address, intMoqParam *big.Int)

	// AddLogFunc mocks the AddLog method.
	AddLogFunc func(log *types.Log)

	// AddPreimageFunc mocks the AddPreimage method.
	AddPreimageFunc func(hash common.Hash, bytes []byte)

	// AddRefundFunc mocks the AddRefund method.
	AddRefundFunc func(v uint64)

	// AddSlotToAccessListFunc mocks the AddSlotToAccessList method.
	AddSlotToAccessListFunc func(addr common.Address, slot common.Hash)

	// AddressInAccessListFunc mocks the AddressInAccessList method.
	AddressInAccessListFunc func(addr common.Address) bool

	// CreateAccountFunc mocks the CreateAccount method.
	CreateAccountFunc func(address common.Address)

	// EmptyFunc mocks the Empty method.
	EmptyFunc func(address common.Address) bool

	// ExistFunc mocks the Exist method.
	ExistFunc func(address common.Address) bool

	// GetBalanceFunc mocks the GetBalance method.
	GetBalanceFunc func(address common.Address) *big.Int

	// GetCodeFunc mocks the GetCode method.
	GetCodeFunc func(address common.Address) []byte

	// GetCodeHashFunc mocks the GetCodeHash method.
	GetCodeHashFunc func(address common.Address) common.Hash

	// GetCodeSizeFunc mocks the GetCodeSize method.
	GetCodeSizeFunc func(address common.Address) int

	// GetCommittedStateFunc mocks the GetCommittedState method.
	GetCommittedStateFunc func(address common.Address, hash common.Hash) common.Hash

	// GetContextFunc mocks the GetContext method.
	GetContextFunc func() context.Context

	// GetNonceFunc mocks the GetNonce method.
	GetNonceFunc func(address common.Address) uint64

	// GetPrecompileManagerFunc mocks the GetPrecompileManager method.
	GetPrecompileManagerFunc func() any

	// GetRefundFunc mocks the GetRefund method.
	GetRefundFunc func() uint64

	// GetStateFunc mocks the GetState method.
	GetStateFunc func(address common.Address, hash common.Hash) common.Hash

	// GetTransientStateFunc mocks the GetTransientState method.
	GetTransientStateFunc func(addr common.Address, key common.Hash) common.Hash

	// HasSelfDestructedFunc mocks the HasSelfDestructed method.
	HasSelfDestructedFunc func(address common.Address) bool

	// PrepareFunc mocks the Prepare method.
	PrepareFunc func(rules params.Rules, sender common.Address, coinbase common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList)

	// RevertToSnapshotFunc mocks the RevertToSnapshot method.
	RevertToSnapshotFunc func(n int)

	// SelfDestructFunc mocks the SelfDestruct method.
	SelfDestructFunc func(address common.Address)

	// Selfdestruct6780Func mocks the Selfdestruct6780 method.
	Selfdestruct6780Func func(address common.Address)

	// SetCodeFunc mocks the SetCode method.
	SetCodeFunc func(address common.Address, bytes []byte)

	// SetNonceFunc mocks the SetNonce method.
	SetNonceFunc func(address common.Address, v uint64)

	// SetStateFunc mocks the SetState method.
	SetStateFunc func(address common.Address, hash1 common.Hash, hash2 common.Hash)

	// SetTransientStateFunc mocks the SetTransientState method.
	SetTransientStateFunc func(addr common.Address, key common.Hash, value common.Hash)

	// SlotInAccessListFunc mocks the SlotInAccessList method.
	SlotInAccessListFunc func(addr common.Address, slot common.Hash) (bool, bool)

	// SnapshotFunc mocks the Snapshot method.
	SnapshotFunc func() int

	// SubBalanceFunc mocks the SubBalance method.
	SubBalanceFunc func(address common.Address, intMoqParam *big.Int)

	// SubRefundFunc mocks the SubRefund method.
	SubRefundFunc func(v uint64)

	// calls tracks calls to the methods.
	calls struct {
		// AddAddressToAccessList holds details about calls to the AddAddressToAccessList method.
		AddAddressToAccessList []struct {
			// Addr is the addr argument value.
			Addr common.Address
		}
		// AddBalance holds details about calls to the AddBalance method.
		AddBalance []struct {
			// Address is the address argument value.
			Address common.Address
			// IntMoqParam is the intMoqParam argument value.
			IntMoqParam *big.Int
		}
		// AddLog holds details about calls to the AddLog method.
		AddLog []struct {
			// Log is the log argument value.
			Log *types.Log
		}
		// AddPreimage holds details about calls to the AddPreimage method.
		AddPreimage []struct {
			// Hash is the hash argument value.
			Hash common.Hash
			// Bytes is the bytes argument value.
			Bytes []byte
		}
		// AddRefund holds details about calls to the AddRefund method.
		AddRefund []struct {
			// V is the v argument value.
			V uint64
		}
		// AddSlotToAccessList holds details about calls to the AddSlotToAccessList method.
		AddSlotToAccessList []struct {
			// Addr is the addr argument value.
			Addr common.Address
			// Slot is the slot argument value.
			Slot common.Hash
		}
		// AddressInAccessList holds details about calls to the AddressInAccessList method.
		AddressInAccessList []struct {
			// Addr is the addr argument value.
			Addr common.Address
		}
		// CreateAccount holds details about calls to the CreateAccount method.
		CreateAccount []struct {
			// Address is the address argument value.
			Address common.Address
		}
		// Empty holds details about calls to the Empty method.
		Empty []struct {
			// Address is the address argument value.
			Address common.Address
		}
		// Exist holds details about calls to the Exist method.
		Exist []struct {
			// Address is the address argument value.
			Address common.Address
		}
		// GetBalance holds details about calls to the GetBalance method.
		GetBalance []struct {
			// Address is the address argument value.
			Address common.Address
		}
		// GetCode holds details about calls to the GetCode method.
		GetCode []struct {
			// Address is the address argument value.
			Address common.Address
		}
		// GetCodeHash holds details about calls to the GetCodeHash method.
		GetCodeHash []struct {
			// Address is the address argument value.
			Address common.Address
		}
		// GetCodeSize holds details about calls to the GetCodeSize method.
		GetCodeSize []struct {
			// Address is the address argument value.
			Address common.Address
		}
		// GetCommittedState holds details about calls to the GetCommittedState method.
		GetCommittedState []struct {
			// Address is the address argument value.
			Address common.Address
			// Hash is the hash argument value.
			Hash common.Hash
		}
		// GetContext holds details about calls to the GetContext method.
		GetContext []struct {
		}
		// GetNonce holds details about calls to the GetNonce method.
		GetNonce []struct {
			// Address is the address argument value.
			Address common.Address
		}
		// GetPrecompileManager holds details about calls to the GetPrecompileManager method.
		GetPrecompileManager []struct {
		}
		// GetRefund holds details about calls to the GetRefund method.
		GetRefund []struct {
		}
		// GetState holds details about calls to the GetState method.
		GetState []struct {
			// Address is the address argument value.
			Address common.Address
			// Hash is the hash argument value.
			Hash common.Hash
		}
		// GetTransientState holds details about calls to the GetTransientState method.
		GetTransientState []struct {
			// Addr is the addr argument value.
			Addr common.Address
			// Key is the key argument value.
			Key common.Hash
		}
		// HasSelfDestructed holds details about calls to the HasSelfDestructed method.
		HasSelfDestructed []struct {
			// Address is the address argument value.
			Address common.Address
		}
		// Prepare holds details about calls to the Prepare method.
		Prepare []struct {
			// Rules is the rules argument value.
			Rules params.Rules
			// Sender is the sender argument value.
			Sender common.Address
			// Coinbase is the coinbase argument value.
			Coinbase common.Address
			// Dest is the dest argument value.
			Dest *common.Address
			// Precompiles is the precompiles argument value.
			Precompiles []common.Address
			// TxAccesses is the txAccesses argument value.
			TxAccesses types.AccessList
		}
		// RevertToSnapshot holds details about calls to the RevertToSnapshot method.
		RevertToSnapshot []struct {
			// N is the n argument value.
			N int
		}
		// SelfDestruct holds details about calls to the SelfDestruct method.
		SelfDestruct []struct {
			// Address is the address argument value.
			Address common.Address
		}
		// Selfdestruct6780 holds details about calls to the Selfdestruct6780 method.
		Selfdestruct6780 []struct {
			// Address is the address argument value.
			Address common.Address
		}
		// SetCode holds details about calls to the SetCode method.
		SetCode []struct {
			// Address is the address argument value.
			Address common.Address
			// Bytes is the bytes argument value.
			Bytes []byte
		}
		// SetNonce holds details about calls to the SetNonce method.
		SetNonce []struct {
			// Address is the address argument value.
			Address common.Address
			// V is the v argument value.
			V uint64
		}
		// SetState holds details about calls to the SetState method.
		SetState []struct {
			// Address is the address argument value.
			Address common.Address
			// Hash1 is the hash1 argument value.
			Hash1 common.Hash
			// Hash2 is the hash2 argument value.
			Hash2 common.Hash
		}
		// SetTransientState holds details about calls to the SetTransientState method.
		SetTransientState []struct {
			// Addr is the addr argument value.
			Addr common.Address
			// Key is the key argument value.
			Key common.Hash
			// Value is the value argument value.
			Value common.Hash
		}
		// SlotInAccessList holds details about calls to the SlotInAccessList method.
		SlotInAccessList []struct {
			// Addr is the addr argument value.
			Addr common.Address
			// Slot is the slot argument value.
			Slot common.Hash
		}
		// Snapshot holds details about calls to the Snapshot method.
		Snapshot []struct {
		}
		// SubBalance holds details about calls to the SubBalance method.
		SubBalance []struct {
			// Address is the address argument value.
			Address common.Address
			// IntMoqParam is the intMoqParam argument value.
			IntMoqParam *big.Int
		}
		// SubRefund holds details about calls to the SubRefund method.
		SubRefund []struct {
			// V is the v argument value.
			V uint64
		}
	}
	lockAddAddressToAccessList sync.RWMutex
	lockAddBalance             sync.RWMutex
	lockAddLog                 sync.RWMutex
	lockAddPreimage            sync.RWMutex
	lockAddRefund              sync.RWMutex
	lockAddSlotToAccessList    sync.RWMutex
	lockAddressInAccessList    sync.RWMutex
	lockCreateAccount          sync.RWMutex
	lockEmpty                  sync.RWMutex
	lockExist                  sync.RWMutex
	lockGetBalance             sync.RWMutex
	lockGetCode                sync.RWMutex
	lockGetCodeHash            sync.RWMutex
	lockGetCodeSize            sync.RWMutex
	lockGetCommittedState      sync.RWMutex
	lockGetContext             sync.RWMutex
	lockGetNonce               sync.RWMutex
	lockGetPrecompileManager   sync.RWMutex
	lockGetRefund              sync.RWMutex
	lockGetState               sync.RWMutex
	lockGetTransientState      sync.RWMutex
	lockHasSelfDestructed      sync.RWMutex
	lockPrepare                sync.RWMutex
	lockRevertToSnapshot       sync.RWMutex
	lockSelfDestruct           sync.RWMutex
	lockSelfdestruct6780       sync.RWMutex
	lockSetCode                sync.RWMutex
	lockSetNonce               sync.RWMutex
	lockSetState               sync.RWMutex
	lockSetTransientState      sync.RWMutex
	lockSlotInAccessList       sync.RWMutex
	lockSnapshot               sync.RWMutex
	lockSubBalance             sync.RWMutex
	lockSubRefund              sync.RWMutex
}

// AddAddressToAccessList calls AddAddressToAccessListFunc.
func (mock *PolarStateDBMock) AddAddressToAccessList(addr common.Address) {
	if mock.AddAddressToAccessListFunc == nil {
		panic("PolarStateDBMock.AddAddressToAccessListFunc: method is nil but PolarStateDB.AddAddressToAccessList was just called")
	}
	callInfo := struct {
		Addr common.Address
	}{
		Addr: addr,
	}
	mock.lockAddAddressToAccessList.Lock()
	mock.calls.AddAddressToAccessList = append(mock.calls.AddAddressToAccessList, callInfo)
	mock.lockAddAddressToAccessList.Unlock()
	mock.AddAddressToAccessListFunc(addr)
}

// AddAddressToAccessListCalls gets all the calls that were made to AddAddressToAccessList.
// Check the length with:
//
//	len(mockedPolarStateDB.AddAddressToAccessListCalls())
func (mock *PolarStateDBMock) AddAddressToAccessListCalls() []struct {
	Addr common.Address
} {
	var calls []struct {
		Addr common.Address
	}
	mock.lockAddAddressToAccessList.RLock()
	calls = mock.calls.AddAddressToAccessList
	mock.lockAddAddressToAccessList.RUnlock()
	return calls
}

// AddBalance calls AddBalanceFunc.
func (mock *PolarStateDBMock) AddBalance(address common.Address, intMoqParam *big.Int) {
	if mock.AddBalanceFunc == nil {
		panic("PolarStateDBMock.AddBalanceFunc: method is nil but PolarStateDB.AddBalance was just called")
	}
	callInfo := struct {
		Address     common.Address
		IntMoqParam *big.Int
	}{
		Address:     address,
		IntMoqParam: intMoqParam,
	}
	mock.lockAddBalance.Lock()
	mock.calls.AddBalance = append(mock.calls.AddBalance, callInfo)
	mock.lockAddBalance.Unlock()
	mock.AddBalanceFunc(address, intMoqParam)
}

// AddBalanceCalls gets all the calls that were made to AddBalance.
// Check the length with:
//
//	len(mockedPolarStateDB.AddBalanceCalls())
func (mock *PolarStateDBMock) AddBalanceCalls() []struct {
	Address     common.Address
	IntMoqParam *big.Int
} {
	var calls []struct {
		Address     common.Address
		IntMoqParam *big.Int
	}
	mock.lockAddBalance.RLock()
	calls = mock.calls.AddBalance
	mock.lockAddBalance.RUnlock()
	return calls
}

// AddLog calls AddLogFunc.
func (mock *PolarStateDBMock) AddLog(log *types.Log) {
	if mock.AddLogFunc == nil {
		panic("PolarStateDBMock.AddLogFunc: method is nil but PolarStateDB.AddLog was just called")
	}
	callInfo := struct {
		Log *types.Log
	}{
		Log: log,
	}
	mock.lockAddLog.Lock()
	mock.calls.AddLog = append(mock.calls.AddLog, callInfo)
	mock.lockAddLog.Unlock()
	mock.AddLogFunc(log)
}

// AddLogCalls gets all the calls that were made to AddLog.
// Check the length with:
//
//	len(mockedPolarStateDB.AddLogCalls())
func (mock *PolarStateDBMock) AddLogCalls() []struct {
	Log *types.Log
} {
	var calls []struct {
		Log *types.Log
	}
	mock.lockAddLog.RLock()
	calls = mock.calls.AddLog
	mock.lockAddLog.RUnlock()
	return calls
}

// AddPreimage calls AddPreimageFunc.
func (mock *PolarStateDBMock) AddPreimage(hash common.Hash, bytes []byte) {
	if mock.AddPreimageFunc == nil {
		panic("PolarStateDBMock.AddPreimageFunc: method is nil but PolarStateDB.AddPreimage was just called")
	}
	callInfo := struct {
		Hash  common.Hash
		Bytes []byte
	}{
		Hash:  hash,
		Bytes: bytes,
	}
	mock.lockAddPreimage.Lock()
	mock.calls.AddPreimage = append(mock.calls.AddPreimage, callInfo)
	mock.lockAddPreimage.Unlock()
	mock.AddPreimageFunc(hash, bytes)
}

// AddPreimageCalls gets all the calls that were made to AddPreimage.
// Check the length with:
//
//	len(mockedPolarStateDB.AddPreimageCalls())
func (mock *PolarStateDBMock) AddPreimageCalls() []struct {
	Hash  common.Hash
	Bytes []byte
} {
	var calls []struct {
		Hash  common.Hash
		Bytes []byte
	}
	mock.lockAddPreimage.RLock()
	calls = mock.calls.AddPreimage
	mock.lockAddPreimage.RUnlock()
	return calls
}

// AddRefund calls AddRefundFunc.
func (mock *PolarStateDBMock) AddRefund(v uint64) {
	if mock.AddRefundFunc == nil {
		panic("PolarStateDBMock.AddRefundFunc: method is nil but PolarStateDB.AddRefund was just called")
	}
	callInfo := struct {
		V uint64
	}{
		V: v,
	}
	mock.lockAddRefund.Lock()
	mock.calls.AddRefund = append(mock.calls.AddRefund, callInfo)
	mock.lockAddRefund.Unlock()
	mock.AddRefundFunc(v)
}

// AddRefundCalls gets all the calls that were made to AddRefund.
// Check the length with:
//
//	len(mockedPolarStateDB.AddRefundCalls())
func (mock *PolarStateDBMock) AddRefundCalls() []struct {
	V uint64
} {
	var calls []struct {
		V uint64
	}
	mock.lockAddRefund.RLock()
	calls = mock.calls.AddRefund
	mock.lockAddRefund.RUnlock()
	return calls
}

// AddSlotToAccessList calls AddSlotToAccessListFunc.
func (mock *PolarStateDBMock) AddSlotToAccessList(addr common.Address, slot common.Hash) {
	if mock.AddSlotToAccessListFunc == nil {
		panic("PolarStateDBMock.AddSlotToAccessListFunc: method is nil but PolarStateDB.AddSlotToAccessList was just called")
	}
	callInfo := struct {
		Addr common.Address
		Slot common.Hash
	}{
		Addr: addr,
		Slot: slot,
	}
	mock.lockAddSlotToAccessList.Lock()
	mock.calls.AddSlotToAccessList = append(mock.calls.AddSlotToAccessList, callInfo)
	mock.lockAddSlotToAccessList.Unlock()
	mock.AddSlotToAccessListFunc(addr, slot)
}

// AddSlotToAccessListCalls gets all the calls that were made to AddSlotToAccessList.
// Check the length with:
//
//	len(mockedPolarStateDB.AddSlotToAccessListCalls())
func (mock *PolarStateDBMock) AddSlotToAccessListCalls() []struct {
	Addr common.Address
	Slot common.Hash
} {
	var calls []struct {
		Addr common.Address
		Slot common.Hash
	}
	mock.lockAddSlotToAccessList.RLock()
	calls = mock.calls.AddSlotToAccessList
	mock.lockAddSlotToAccessList.RUnlock()
	return calls
}

// AddressInAccessList calls AddressInAccessListFunc.
func (mock *PolarStateDBMock) AddressInAccessList(addr common.Address) bool {
	if mock.AddressInAccessListFunc == nil {
		panic("PolarStateDBMock.AddressInAccessListFunc: method is nil but PolarStateDB.AddressInAccessList was just called")
	}
	callInfo := struct {
		Addr common.Address
	}{
		Addr: addr,
	}
	mock.lockAddressInAccessList.Lock()
	mock.calls.AddressInAccessList = append(mock.calls.AddressInAccessList, callInfo)
	mock.lockAddressInAccessList.Unlock()
	return mock.AddressInAccessListFunc(addr)
}

// AddressInAccessListCalls gets all the calls that were made to AddressInAccessList.
// Check the length with:
//
//	len(mockedPolarStateDB.AddressInAccessListCalls())
func (mock *PolarStateDBMock) AddressInAccessListCalls() []struct {
	Addr common.Address
} {
	var calls []struct {
		Addr common.Address
	}
	mock.lockAddressInAccessList.RLock()
	calls = mock.calls.AddressInAccessList
	mock.lockAddressInAccessList.RUnlock()
	return calls
}

// CreateAccount calls CreateAccountFunc.
func (mock *PolarStateDBMock) CreateAccount(address common.Address) {
	if mock.CreateAccountFunc == nil {
		panic("PolarStateDBMock.CreateAccountFunc: method is nil but PolarStateDB.CreateAccount was just called")
	}
	callInfo := struct {
		Address common.Address
	}{
		Address: address,
	}
	mock.lockCreateAccount.Lock()
	mock.calls.CreateAccount = append(mock.calls.CreateAccount, callInfo)
	mock.lockCreateAccount.Unlock()
	mock.CreateAccountFunc(address)
}

// CreateAccountCalls gets all the calls that were made to CreateAccount.
// Check the length with:
//
//	len(mockedPolarStateDB.CreateAccountCalls())
func (mock *PolarStateDBMock) CreateAccountCalls() []struct {
	Address common.Address
} {
	var calls []struct {
		Address common.Address
	}
	mock.lockCreateAccount.RLock()
	calls = mock.calls.CreateAccount
	mock.lockCreateAccount.RUnlock()
	return calls
}

// Empty calls EmptyFunc.
func (mock *PolarStateDBMock) Empty(address common.Address) bool {
	if mock.EmptyFunc == nil {
		panic("PolarStateDBMock.EmptyFunc: method is nil but PolarStateDB.Empty was just called")
	}
	callInfo := struct {
		Address common.Address
	}{
		Address: address,
	}
	mock.lockEmpty.Lock()
	mock.calls.Empty = append(mock.calls.Empty, callInfo)
	mock.lockEmpty.Unlock()
	return mock.EmptyFunc(address)
}

// EmptyCalls gets all the calls that were made to Empty.
// Check the length with:
//
//	len(mockedPolarStateDB.EmptyCalls())
func (mock *PolarStateDBMock) EmptyCalls() []struct {
	Address common.Address
} {
	var calls []struct {
		Address common.Address
	}
	mock.lockEmpty.RLock()
	calls = mock.calls.Empty
	mock.lockEmpty.RUnlock()
	return calls
}

// Exist calls ExistFunc.
func (mock *PolarStateDBMock) Exist(address common.Address) bool {
	if mock.ExistFunc == nil {
		panic("PolarStateDBMock.ExistFunc: method is nil but PolarStateDB.Exist was just called")
	}
	callInfo := struct {
		Address common.Address
	}{
		Address: address,
	}
	mock.lockExist.Lock()
	mock.calls.Exist = append(mock.calls.Exist, callInfo)
	mock.lockExist.Unlock()
	return mock.ExistFunc(address)
}

// ExistCalls gets all the calls that were made to Exist.
// Check the length with:
//
//	len(mockedPolarStateDB.ExistCalls())
func (mock *PolarStateDBMock) ExistCalls() []struct {
	Address common.Address
} {
	var calls []struct {
		Address common.Address
	}
	mock.lockExist.RLock()
	calls = mock.calls.Exist
	mock.lockExist.RUnlock()
	return calls
}

// GetBalance calls GetBalanceFunc.
func (mock *PolarStateDBMock) GetBalance(address common.Address) *big.Int {
	if mock.GetBalanceFunc == nil {
		panic("PolarStateDBMock.GetBalanceFunc: method is nil but PolarStateDB.GetBalance was just called")
	}
	callInfo := struct {
		Address common.Address
	}{
		Address: address,
	}
	mock.lockGetBalance.Lock()
	mock.calls.GetBalance = append(mock.calls.GetBalance, callInfo)
	mock.lockGetBalance.Unlock()
	return mock.GetBalanceFunc(address)
}

// GetBalanceCalls gets all the calls that were made to GetBalance.
// Check the length with:
//
//	len(mockedPolarStateDB.GetBalanceCalls())
func (mock *PolarStateDBMock) GetBalanceCalls() []struct {
	Address common.Address
} {
	var calls []struct {
		Address common.Address
	}
	mock.lockGetBalance.RLock()
	calls = mock.calls.GetBalance
	mock.lockGetBalance.RUnlock()
	return calls
}

// GetCode calls GetCodeFunc.
func (mock *PolarStateDBMock) GetCode(address common.Address) []byte {
	if mock.GetCodeFunc == nil {
		panic("PolarStateDBMock.GetCodeFunc: method is nil but PolarStateDB.GetCode was just called")
	}
	callInfo := struct {
		Address common.Address
	}{
		Address: address,
	}
	mock.lockGetCode.Lock()
	mock.calls.GetCode = append(mock.calls.GetCode, callInfo)
	mock.lockGetCode.Unlock()
	return mock.GetCodeFunc(address)
}

// GetCodeCalls gets all the calls that were made to GetCode.
// Check the length with:
//
//	len(mockedPolarStateDB.GetCodeCalls())
func (mock *PolarStateDBMock) GetCodeCalls() []struct {
	Address common.Address
} {
	var calls []struct {
		Address common.Address
	}
	mock.lockGetCode.RLock()
	calls = mock.calls.GetCode
	mock.lockGetCode.RUnlock()
	return calls
}

// GetCodeHash calls GetCodeHashFunc.
func (mock *PolarStateDBMock) GetCodeHash(address common.Address) common.Hash {
	if mock.GetCodeHashFunc == nil {
		panic("PolarStateDBMock.GetCodeHashFunc: method is nil but PolarStateDB.GetCodeHash was just called")
	}
	callInfo := struct {
		Address common.Address
	}{
		Address: address,
	}
	mock.lockGetCodeHash.Lock()
	mock.calls.GetCodeHash = append(mock.calls.GetCodeHash, callInfo)
	mock.lockGetCodeHash.Unlock()
	return mock.GetCodeHashFunc(address)
}

// GetCodeHashCalls gets all the calls that were made to GetCodeHash.
// Check the length with:
//
//	len(mockedPolarStateDB.GetCodeHashCalls())
func (mock *PolarStateDBMock) GetCodeHashCalls() []struct {
	Address common.Address
} {
	var calls []struct {
		Address common.Address
	}
	mock.lockGetCodeHash.RLock()
	calls = mock.calls.GetCodeHash
	mock.lockGetCodeHash.RUnlock()
	return calls
}

// GetCodeSize calls GetCodeSizeFunc.
func (mock *PolarStateDBMock) GetCodeSize(address common.Address) int {
	if mock.GetCodeSizeFunc == nil {
		panic("PolarStateDBMock.GetCodeSizeFunc: method is nil but PolarStateDB.GetCodeSize was just called")
	}
	callInfo := struct {
		Address common.Address
	}{
		Address: address,
	}
	mock.lockGetCodeSize.Lock()
	mock.calls.GetCodeSize = append(mock.calls.GetCodeSize, callInfo)
	mock.lockGetCodeSize.Unlock()
	return mock.GetCodeSizeFunc(address)
}

// GetCodeSizeCalls gets all the calls that were made to GetCodeSize.
// Check the length with:
//
//	len(mockedPolarStateDB.GetCodeSizeCalls())
func (mock *PolarStateDBMock) GetCodeSizeCalls() []struct {
	Address common.Address
} {
	var calls []struct {
		Address common.Address
	}
	mock.lockGetCodeSize.RLock()
	calls = mock.calls.GetCodeSize
	mock.lockGetCodeSize.RUnlock()
	return calls
}

// GetCommittedState calls GetCommittedStateFunc.
func (mock *PolarStateDBMock) GetCommittedState(address common.Address, hash common.Hash) common.Hash {
	if mock.GetCommittedStateFunc == nil {
		panic("PolarStateDBMock.GetCommittedStateFunc: method is nil but PolarStateDB.GetCommittedState was just called")
	}
	callInfo := struct {
		Address common.Address
		Hash    common.Hash
	}{
		Address: address,
		Hash:    hash,
	}
	mock.lockGetCommittedState.Lock()
	mock.calls.GetCommittedState = append(mock.calls.GetCommittedState, callInfo)
	mock.lockGetCommittedState.Unlock()
	return mock.GetCommittedStateFunc(address, hash)
}

// GetCommittedStateCalls gets all the calls that were made to GetCommittedState.
// Check the length with:
//
//	len(mockedPolarStateDB.GetCommittedStateCalls())
func (mock *PolarStateDBMock) GetCommittedStateCalls() []struct {
	Address common.Address
	Hash    common.Hash
} {
	var calls []struct {
		Address common.Address
		Hash    common.Hash
	}
	mock.lockGetCommittedState.RLock()
	calls = mock.calls.GetCommittedState
	mock.lockGetCommittedState.RUnlock()
	return calls
}

// GetContext calls GetContextFunc.
func (mock *PolarStateDBMock) GetContext() context.Context {
	if mock.GetContextFunc == nil {
		panic("PolarStateDBMock.GetContextFunc: method is nil but PolarStateDB.GetContext was just called")
	}
	callInfo := struct {
	}{}
	mock.lockGetContext.Lock()
	mock.calls.GetContext = append(mock.calls.GetContext, callInfo)
	mock.lockGetContext.Unlock()
	return mock.GetContextFunc()
}

// GetContextCalls gets all the calls that were made to GetContext.
// Check the length with:
//
//	len(mockedPolarStateDB.GetContextCalls())
func (mock *PolarStateDBMock) GetContextCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetContext.RLock()
	calls = mock.calls.GetContext
	mock.lockGetContext.RUnlock()
	return calls
}

// GetNonce calls GetNonceFunc.
func (mock *PolarStateDBMock) GetNonce(address common.Address) uint64 {
	if mock.GetNonceFunc == nil {
		panic("PolarStateDBMock.GetNonceFunc: method is nil but PolarStateDB.GetNonce was just called")
	}
	callInfo := struct {
		Address common.Address
	}{
		Address: address,
	}
	mock.lockGetNonce.Lock()
	mock.calls.GetNonce = append(mock.calls.GetNonce, callInfo)
	mock.lockGetNonce.Unlock()
	return mock.GetNonceFunc(address)
}

// GetNonceCalls gets all the calls that were made to GetNonce.
// Check the length with:
//
//	len(mockedPolarStateDB.GetNonceCalls())
func (mock *PolarStateDBMock) GetNonceCalls() []struct {
	Address common.Address
} {
	var calls []struct {
		Address common.Address
	}
	mock.lockGetNonce.RLock()
	calls = mock.calls.GetNonce
	mock.lockGetNonce.RUnlock()
	return calls
}

// GetPrecompileManager calls GetPrecompileManagerFunc.
func (mock *PolarStateDBMock) GetPrecompileManager() any {
	if mock.GetPrecompileManagerFunc == nil {
		panic("PolarStateDBMock.GetPrecompileManagerFunc: method is nil but PolarStateDB.GetPrecompileManager was just called")
	}
	callInfo := struct {
	}{}
	mock.lockGetPrecompileManager.Lock()
	mock.calls.GetPrecompileManager = append(mock.calls.GetPrecompileManager, callInfo)
	mock.lockGetPrecompileManager.Unlock()
	return mock.GetPrecompileManagerFunc()
}

// GetPrecompileManagerCalls gets all the calls that were made to GetPrecompileManager.
// Check the length with:
//
//	len(mockedPolarStateDB.GetPrecompileManagerCalls())
func (mock *PolarStateDBMock) GetPrecompileManagerCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPrecompileManager.RLock()
	calls = mock.calls.GetPrecompileManager
	mock.lockGetPrecompileManager.RUnlock()
	return calls
}

// GetRefund calls GetRefundFunc.
func (mock *PolarStateDBMock) GetRefund() uint64 {
	if mock.GetRefundFunc == nil {
		panic("PolarStateDBMock.GetRefundFunc: method is nil but PolarStateDB.GetRefund was just called")
	}
	callInfo := struct {
	}{}
	mock.lockGetRefund.Lock()
	mock.calls.GetRefund = append(mock.calls.GetRefund, callInfo)
	mock.lockGetRefund.Unlock()
	return mock.GetRefundFunc()
}

// GetRefundCalls gets all the calls that were made to GetRefund.
// Check the length with:
//
//	len(mockedPolarStateDB.GetRefundCalls())
func (mock *PolarStateDBMock) GetRefundCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetRefund.RLock()
	calls = mock.calls.GetRefund
	mock.lockGetRefund.RUnlock()
	return calls
}

// GetState calls GetStateFunc.
func (mock *PolarStateDBMock) GetState(address common.Address, hash common.Hash) common.Hash {
	if mock.GetStateFunc == nil {
		panic("PolarStateDBMock.GetStateFunc: method is nil but PolarStateDB.GetState was just called")
	}
	callInfo := struct {
		Address common.Address
		Hash    common.Hash
	}{
		Address: address,
		Hash:    hash,
	}
	mock.lockGetState.Lock()
	mock.calls.GetState = append(mock.calls.GetState, callInfo)
	mock.lockGetState.Unlock()
	return mock.GetStateFunc(address, hash)
}

// GetStateCalls gets all the calls that were made to GetState.
// Check the length with:
//
//	len(mockedPolarStateDB.GetStateCalls())
func (mock *PolarStateDBMock) GetStateCalls() []struct {
	Address common.Address
	Hash    common.Hash
} {
	var calls []struct {
		Address common.Address
		Hash    common.Hash
	}
	mock.lockGetState.RLock()
	calls = mock.calls.GetState
	mock.lockGetState.RUnlock()
	return calls
}

// GetTransientState calls GetTransientStateFunc.
func (mock *PolarStateDBMock) GetTransientState(addr common.Address, key common.Hash) common.Hash {
	if mock.GetTransientStateFunc == nil {
		panic("PolarStateDBMock.GetTransientStateFunc: method is nil but PolarStateDB.GetTransientState was just called")
	}
	callInfo := struct {
		Addr common.Address
		Key  common.Hash
	}{
		Addr: addr,
		Key:  key,
	}
	mock.lockGetTransientState.Lock()
	mock.calls.GetTransientState = append(mock.calls.GetTransientState, callInfo)
	mock.lockGetTransientState.Unlock()
	return mock.GetTransientStateFunc(addr, key)
}

// GetTransientStateCalls gets all the calls that were made to GetTransientState.
// Check the length with:
//
//	len(mockedPolarStateDB.GetTransientStateCalls())
func (mock *PolarStateDBMock) GetTransientStateCalls() []struct {
	Addr common.Address
	Key  common.Hash
} {
	var calls []struct {
		Addr common.Address
		Key  common.Hash
	}
	mock.lockGetTransientState.RLock()
	calls = mock.calls.GetTransientState
	mock.lockGetTransientState.RUnlock()
	return calls
}

// HasSelfDestructed calls HasSelfDestructedFunc.
func (mock *PolarStateDBMock) HasSelfDestructed(address common.Address) bool {
	if mock.HasSelfDestructedFunc == nil {
		panic("PolarStateDBMock.HasSelfDestructedFunc: method is nil but PolarStateDB.HasSelfDestructed was just called")
	}
	callInfo := struct {
		Address common.Address
	}{
		Address: address,
	}
	mock.lockHasSelfDestructed.Lock()
	mock.calls.HasSelfDestructed = append(mock.calls.HasSelfDestructed, callInfo)
	mock.lockHasSelfDestructed.Unlock()
	return mock.HasSelfDestructedFunc(address)
}

// HasSelfDestructedCalls gets all the calls that were made to HasSelfDestructed.
// Check the length with:
//
//	len(mockedPolarStateDB.HasSelfDestructedCalls())
func (mock *PolarStateDBMock) HasSelfDestructedCalls() []struct {
	Address common.Address
} {
	var calls []struct {
		Address common.Address
	}
	mock.lockHasSelfDestructed.RLock()
	calls = mock.calls.HasSelfDestructed
	mock.lockHasSelfDestructed.RUnlock()
	return calls
}

// Prepare calls PrepareFunc.
func (mock *PolarStateDBMock) Prepare(rules params.Rules, sender common.Address, coinbase common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList) {
	if mock.PrepareFunc == nil {
		panic("PolarStateDBMock.PrepareFunc: method is nil but PolarStateDB.Prepare was just called")
	}
	callInfo := struct {
		Rules       params.Rules
		Sender      common.Address
		Coinbase    common.Address
		Dest        *common.Address
		Precompiles []common.Address
		TxAccesses  types.AccessList
	}{
		Rules:       rules,
		Sender:      sender,
		Coinbase:    coinbase,
		Dest:        dest,
		Precompiles: precompiles,
		TxAccesses:  txAccesses,
	}
	mock.lockPrepare.Lock()
	mock.calls.Prepare = append(mock.calls.Prepare, callInfo)
	mock.lockPrepare.Unlock()
	mock.PrepareFunc(rules, sender, coinbase, dest, precompiles, txAccesses)
}

// PrepareCalls gets all the calls that were made to Prepare.
// Check the length with:
//
//	len(mockedPolarStateDB.PrepareCalls())
func (mock *PolarStateDBMock) PrepareCalls() []struct {
	Rules       params.Rules
	Sender      common.Address
	Coinbase    common.Address
	Dest        *common.Address
	Precompiles []common.Address
	TxAccesses  types.AccessList
} {
	var calls []struct {
		Rules       params.Rules
		Sender      common.Address
		Coinbase    common.Address
		Dest        *common.Address
		Precompiles []common.Address
		TxAccesses  types.AccessList
	}
	mock.lockPrepare.RLock()
	calls = mock.calls.Prepare
	mock.lockPrepare.RUnlock()
	return calls
}

// RevertToSnapshot calls RevertToSnapshotFunc.
func (mock *PolarStateDBMock) RevertToSnapshot(n int) {
	if mock.RevertToSnapshotFunc == nil {
		panic("PolarStateDBMock.RevertToSnapshotFunc: method is nil but PolarStateDB.RevertToSnapshot was just called")
	}
	callInfo := struct {
		N int
	}{
		N: n,
	}
	mock.lockRevertToSnapshot.Lock()
	mock.calls.RevertToSnapshot = append(mock.calls.RevertToSnapshot, callInfo)
	mock.lockRevertToSnapshot.Unlock()
	mock.RevertToSnapshotFunc(n)
}

// RevertToSnapshotCalls gets all the calls that were made to RevertToSnapshot.
// Check the length with:
//
//	len(mockedPolarStateDB.RevertToSnapshotCalls())
func (mock *PolarStateDBMock) RevertToSnapshotCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockRevertToSnapshot.RLock()
	calls = mock.calls.RevertToSnapshot
	mock.lockRevertToSnapshot.RUnlock()
	return calls
}

// SelfDestruct calls SelfDestructFunc.
func (mock *PolarStateDBMock) SelfDestruct(address common.Address) {
	if mock.SelfDestructFunc == nil {
		panic("PolarStateDBMock.SelfDestructFunc: method is nil but PolarStateDB.SelfDestruct was just called")
	}
	callInfo := struct {
		Address common.Address
	}{
		Address: address,
	}
	mock.lockSelfDestruct.Lock()
	mock.calls.SelfDestruct = append(mock.calls.SelfDestruct, callInfo)
	mock.lockSelfDestruct.Unlock()
	mock.SelfDestructFunc(address)
}

// SelfDestructCalls gets all the calls that were made to SelfDestruct.
// Check the length with:
//
//	len(mockedPolarStateDB.SelfDestructCalls())
func (mock *PolarStateDBMock) SelfDestructCalls() []struct {
	Address common.Address
} {
	var calls []struct {
		Address common.Address
	}
	mock.lockSelfDestruct.RLock()
	calls = mock.calls.SelfDestruct
	mock.lockSelfDestruct.RUnlock()
	return calls
}

// Selfdestruct6780 calls Selfdestruct6780Func.
func (mock *PolarStateDBMock) Selfdestruct6780(address common.Address) {
	if mock.Selfdestruct6780Func == nil {
		panic("PolarStateDBMock.Selfdestruct6780Func: method is nil but PolarStateDB.Selfdestruct6780 was just called")
	}
	callInfo := struct {
		Address common.Address
	}{
		Address: address,
	}
	mock.lockSelfdestruct6780.Lock()
	mock.calls.Selfdestruct6780 = append(mock.calls.Selfdestruct6780, callInfo)
	mock.lockSelfdestruct6780.Unlock()
	mock.Selfdestruct6780Func(address)
}

// Selfdestruct6780Calls gets all the calls that were made to Selfdestruct6780.
// Check the length with:
//
//	len(mockedPolarStateDB.Selfdestruct6780Calls())
func (mock *PolarStateDBMock) Selfdestruct6780Calls() []struct {
	Address common.Address
} {
	var calls []struct {
		Address common.Address
	}
	mock.lockSelfdestruct6780.RLock()
	calls = mock.calls.Selfdestruct6780
	mock.lockSelfdestruct6780.RUnlock()
	return calls
}

// SetCode calls SetCodeFunc.
func (mock *PolarStateDBMock) SetCode(address common.Address, bytes []byte) {
	if mock.SetCodeFunc == nil {
		panic("PolarStateDBMock.SetCodeFunc: method is nil but PolarStateDB.SetCode was just called")
	}
	callInfo := struct {
		Address common.Address
		Bytes   []byte
	}{
		Address: address,
		Bytes:   bytes,
	}
	mock.lockSetCode.Lock()
	mock.calls.SetCode = append(mock.calls.SetCode, callInfo)
	mock.lockSetCode.Unlock()
	mock.SetCodeFunc(address, bytes)
}

// SetCodeCalls gets all the calls that were made to SetCode.
// Check the length with:
//
//	len(mockedPolarStateDB.SetCodeCalls())
func (mock *PolarStateDBMock) SetCodeCalls() []struct {
	Address common.Address
	Bytes   []byte
} {
	var calls []struct {
		Address common.Address
		Bytes   []byte
	}
	mock.lockSetCode.RLock()
	calls = mock.calls.SetCode
	mock.lockSetCode.RUnlock()
	return calls
}

// SetNonce calls SetNonceFunc.
func (mock *PolarStateDBMock) SetNonce(address common.Address, v uint64) {
	if mock.SetNonceFunc == nil {
		panic("PolarStateDBMock.SetNonceFunc: method is nil but PolarStateDB.SetNonce was just called")
	}
	callInfo := struct {
		Address common.Address
		V       uint64
	}{
		Address: address,
		V:       v,
	}
	mock.lockSetNonce.Lock()
	mock.calls.SetNonce = append(mock.calls.SetNonce, callInfo)
	mock.lockSetNonce.Unlock()
	mock.SetNonceFunc(address, v)
}

// SetNonceCalls gets all the calls that were made to SetNonce.
// Check the length with:
//
//	len(mockedPolarStateDB.SetNonceCalls())
func (mock *PolarStateDBMock) SetNonceCalls() []struct {
	Address common.Address
	V       uint64
} {
	var calls []struct {
		Address common.Address
		V       uint64
	}
	mock.lockSetNonce.RLock()
	calls = mock.calls.SetNonce
	mock.lockSetNonce.RUnlock()
	return calls
}

// SetState calls SetStateFunc.
func (mock *PolarStateDBMock) SetState(address common.Address, hash1 common.Hash, hash2 common.Hash) {
	if mock.SetStateFunc == nil {
		panic("PolarStateDBMock.SetStateFunc: method is nil but PolarStateDB.SetState was just called")
	}
	callInfo := struct {
		Address common.Address
		Hash1   common.Hash
		Hash2   common.Hash
	}{
		Address: address,
		Hash1:   hash1,
		Hash2:   hash2,
	}
	mock.lockSetState.Lock()
	mock.calls.SetState = append(mock.calls.SetState, callInfo)
	mock.lockSetState.Unlock()
	mock.SetStateFunc(address, hash1, hash2)
}

// SetStateCalls gets all the calls that were made to SetState.
// Check the length with:
//
//	len(mockedPolarStateDB.SetStateCalls())
func (mock *PolarStateDBMock) SetStateCalls() []struct {
	Address common.Address
	Hash1   common.Hash
	Hash2   common.Hash
} {
	var calls []struct {
		Address common.Address
		Hash1   common.Hash
		Hash2   common.Hash
	}
	mock.lockSetState.RLock()
	calls = mock.calls.SetState
	mock.lockSetState.RUnlock()
	return calls
}

// SetTransientState calls SetTransientStateFunc.
func (mock *PolarStateDBMock) SetTransientState(addr common.Address, key common.Hash, value common.Hash) {
	if mock.SetTransientStateFunc == nil {
		panic("PolarStateDBMock.SetTransientStateFunc: method is nil but PolarStateDB.SetTransientState was just called")
	}
	callInfo := struct {
		Addr  common.Address
		Key   common.Hash
		Value common.Hash
	}{
		Addr:  addr,
		Key:   key,
		Value: value,
	}
	mock.lockSetTransientState.Lock()
	mock.calls.SetTransientState = append(mock.calls.SetTransientState, callInfo)
	mock.lockSetTransientState.Unlock()
	mock.SetTransientStateFunc(addr, key, value)
}

// SetTransientStateCalls gets all the calls that were made to SetTransientState.
// Check the length with:
//
//	len(mockedPolarStateDB.SetTransientStateCalls())
func (mock *PolarStateDBMock) SetTransientStateCalls() []struct {
	Addr  common.Address
	Key   common.Hash
	Value common.Hash
} {
	var calls []struct {
		Addr  common.Address
		Key   common.Hash
		Value common.Hash
	}
	mock.lockSetTransientState.RLock()
	calls = mock.calls.SetTransientState
	mock.lockSetTransientState.RUnlock()
	return calls
}

// SlotInAccessList calls SlotInAccessListFunc.
func (mock *PolarStateDBMock) SlotInAccessList(addr common.Address, slot common.Hash) (bool, bool) {
	if mock.SlotInAccessListFunc == nil {
		panic("PolarStateDBMock.SlotInAccessListFunc: method is nil but PolarStateDB.SlotInAccessList was just called")
	}
	callInfo := struct {
		Addr common.Address
		Slot common.Hash
	}{
		Addr: addr,
		Slot: slot,
	}
	mock.lockSlotInAccessList.Lock()
	mock.calls.SlotInAccessList = append(mock.calls.SlotInAccessList, callInfo)
	mock.lockSlotInAccessList.Unlock()
	return mock.SlotInAccessListFunc(addr, slot)
}

// SlotInAccessListCalls gets all the calls that were made to SlotInAccessList.
// Check the length with:
//
//	len(mockedPolarStateDB.SlotInAccessListCalls())
func (mock *PolarStateDBMock) SlotInAccessListCalls() []struct {
	Addr common.Address
	Slot common.Hash
} {
	var calls []struct {
		Addr common.Address
		Slot common.Hash
	}
	mock.lockSlotInAccessList.RLock()
	calls = mock.calls.SlotInAccessList
	mock.lockSlotInAccessList.RUnlock()
	return calls
}

// Snapshot calls SnapshotFunc.
func (mock *PolarStateDBMock) Snapshot() int {
	if mock.SnapshotFunc == nil {
		panic("PolarStateDBMock.SnapshotFunc: method is nil but PolarStateDB.Snapshot was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSnapshot.Lock()
	mock.calls.Snapshot = append(mock.calls.Snapshot, callInfo)
	mock.lockSnapshot.Unlock()
	return mock.SnapshotFunc()
}

// SnapshotCalls gets all the calls that were made to Snapshot.
// Check the length with:
//
//	len(mockedPolarStateDB.SnapshotCalls())
func (mock *PolarStateDBMock) SnapshotCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSnapshot.RLock()
	calls = mock.calls.Snapshot
	mock.lockSnapshot.RUnlock()
	return calls
}

// SubBalance calls SubBalanceFunc.
func (mock *PolarStateDBMock) SubBalance(address common.Address, intMoqParam *big.Int) {
	if mock.SubBalanceFunc == nil {
		panic("PolarStateDBMock.SubBalanceFunc: method is nil but PolarStateDB.SubBalance was just called")
	}
	callInfo := struct {
		Address     common.Address
		IntMoqParam *big.Int
	}{
		Address:     address,
		IntMoqParam: intMoqParam,
	}
	mock.lockSubBalance.Lock()
	mock.calls.SubBalance = append(mock.calls.SubBalance, callInfo)
	mock.lockSubBalance.Unlock()
	mock.SubBalanceFunc(address, intMoqParam)
}

// SubBalanceCalls gets all the calls that were made to SubBalance.
// Check the length with:
//
//	len(mockedPolarStateDB.SubBalanceCalls())
func (mock *PolarStateDBMock) SubBalanceCalls() []struct {
	Address     common.Address
	IntMoqParam *big.Int
} {
	var calls []struct {
		Address     common.Address
		IntMoqParam *big.Int
	}
	mock.lockSubBalance.RLock()
	calls = mock.calls.SubBalance
	mock.lockSubBalance.RUnlock()
	return calls
}

// SubRefund calls SubRefundFunc.
func (mock *PolarStateDBMock) SubRefund(v uint64) {
	if mock.SubRefundFunc == nil {
		panic("PolarStateDBMock.SubRefundFunc: method is nil but PolarStateDB.SubRefund was just called")
	}
	callInfo := struct {
		V uint64
	}{
		V: v,
	}
	mock.lockSubRefund.Lock()
	mock.calls.SubRefund = append(mock.calls.SubRefund, callInfo)
	mock.lockSubRefund.Unlock()
	mock.SubRefundFunc(v)
}

// SubRefundCalls gets all the calls that were made to SubRefund.
// Check the length with:
//
//	len(mockedPolarStateDB.SubRefundCalls())
func (mock *PolarStateDBMock) SubRefundCalls() []struct {
	V uint64
} {
	var calls []struct {
		V uint64
	}
	mock.lockSubRefund.RLock()
	calls = mock.calls.SubRefund
	mock.lockSubRefund.RUnlock()
	return calls
}
