mock_state.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/NethermindEth/juno/core (interfaces: StateHistoryReader)
//
// Generated by this command:
//
//	mockgen -destination=../mocks/mock_state.go -package=mocks github.com/NethermindEth/juno/core StateHistoryReader
//

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

import (
	reflect "reflect"

	core "github.com/NethermindEth/juno/core"
	felt "github.com/NethermindEth/juno/core/felt"
	trie "github.com/NethermindEth/juno/core/trie"
	gomock "go.uber.org/mock/gomock"
)

// MockStateHistoryReader is a mock of StateHistoryReader interface.
type MockStateHistoryReader struct {
	ctrl     *gomock.Controller
	recorder *MockStateHistoryReaderMockRecorder
}

// MockStateHistoryReaderMockRecorder is the mock recorder for MockStateHistoryReader.
type MockStateHistoryReaderMockRecorder struct {
	mock *MockStateHistoryReader
}

// NewMockStateHistoryReader creates a new mock instance.
func NewMockStateHistoryReader(ctrl *gomock.Controller) *MockStateHistoryReader {
	mock := &MockStateHistoryReader{ctrl: ctrl}
	mock.recorder = &MockStateHistoryReaderMockRecorder{mock}
	return mock
}

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

// Class mocks base method.
func (m *MockStateHistoryReader) Class(arg0 *felt.Felt) (*core.DeclaredClass, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Class", arg0)
	ret0, _ := ret[0].(*core.DeclaredClass)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ClassTrie mocks base method.
func (m *MockStateHistoryReader) ClassTrie() (*trie.Trie, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClassTrie")
	ret0, _ := ret[0].(*trie.Trie)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ContractClassHash mocks base method.
func (m *MockStateHistoryReader) ContractClassHash(arg0 *felt.Felt) (*felt.Felt, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContractClassHash", arg0)
	ret0, _ := ret[0].(*felt.Felt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ContractClassHashAt mocks base method.
func (m *MockStateHistoryReader) ContractClassHashAt(arg0 *felt.Felt, arg1 uint64) (*felt.Felt, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContractClassHashAt", arg0, arg1)
	ret0, _ := ret[0].(*felt.Felt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ContractIsAlreadyDeployedAt mocks base method.
func (m *MockStateHistoryReader) ContractIsAlreadyDeployedAt(arg0 *felt.Felt, arg1 uint64) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContractIsAlreadyDeployedAt", arg0, arg1)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ContractNonce mocks base method.
func (m *MockStateHistoryReader) ContractNonce(arg0 *felt.Felt) (*felt.Felt, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContractNonce", arg0)
	ret0, _ := ret[0].(*felt.Felt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ContractNonceAt mocks base method.
func (m *MockStateHistoryReader) ContractNonceAt(arg0 *felt.Felt, arg1 uint64) (*felt.Felt, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContractNonceAt", arg0, arg1)
	ret0, _ := ret[0].(*felt.Felt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ContractStorage mocks base method.
func (m *MockStateHistoryReader) ContractStorage(arg0, arg1 *felt.Felt) (*felt.Felt, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContractStorage", arg0, arg1)
	ret0, _ := ret[0].(*felt.Felt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ContractStorageAt mocks base method.
func (m *MockStateHistoryReader) ContractStorageAt(arg0, arg1 *felt.Felt, arg2 uint64) (*felt.Felt, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContractStorageAt", arg0, arg1, arg2)
	ret0, _ := ret[0].(*felt.Felt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ContractStorageTrie mocks base method.
func (m *MockStateHistoryReader) ContractStorageTrie(arg0 *felt.Felt) (*trie.Trie, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContractStorageTrie", arg0)
	ret0, _ := ret[0].(*trie.Trie)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ContractTrie mocks base method.
func (m *MockStateHistoryReader) ContractTrie() (*trie.Trie, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContractTrie")
	ret0, _ := ret[0].(*trie.Trie)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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