mock_blockchain.go

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

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

import (
	reflect "reflect"

	blockchain "github.com/NethermindEth/juno/blockchain"
	core "github.com/NethermindEth/juno/core"
	felt "github.com/NethermindEth/juno/core/felt"
	utils "github.com/NethermindEth/juno/utils"
	common "github.com/ethereum/go-ethereum/common"
	gomock "go.uber.org/mock/gomock"
)

// MockReader is a mock of Reader interface.
type MockReader struct {
	ctrl     *gomock.Controller
	recorder *MockReaderMockRecorder
	isgomock struct{}
}

// MockReaderMockRecorder is the mock recorder for MockReader.
type MockReaderMockRecorder struct {
	mock *MockReader
}

// NewMockReader creates a new mock instance.
func NewMockReader(ctrl *gomock.Controller) *MockReader {
	mock := &MockReader{ctrl: ctrl}
	mock.recorder = &MockReaderMockRecorder{mock}
	return mock
}

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

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

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

// BlockByNumber mocks base method.
func (m *MockReader) BlockByNumber(number uint64) (*core.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlockByNumber", number)
	ret0, _ := ret[0].(*core.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BlockCommitmentsByNumber mocks base method.
func (m *MockReader) BlockCommitmentsByNumber(blockNumber uint64) (*core.BlockCommitments, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlockCommitmentsByNumber", blockNumber)
	ret0, _ := ret[0].(*core.BlockCommitments)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BlockCommitmentsByNumber indicates an expected call of BlockCommitmentsByNumber.
func (mr *MockReaderMockRecorder) BlockCommitmentsByNumber(blockNumber any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockCommitmentsByNumber", reflect.TypeOf((*MockReader)(nil).BlockCommitmentsByNumber), blockNumber)
}

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

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

// BlockHeaderByNumber mocks base method.
func (m *MockReader) BlockHeaderByNumber(number uint64) (*core.Header, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlockHeaderByNumber", number)
	ret0, _ := ret[0].(*core.Header)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EventFilter mocks base method.
func (m *MockReader) EventFilter(from *felt.Felt, keys [][]felt.Felt) (blockchain.EventFilterer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EventFilter", from, keys)
	ret0, _ := ret[0].(blockchain.EventFilterer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EventFilter indicates an expected call of EventFilter.
func (mr *MockReaderMockRecorder) EventFilter(from, keys any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventFilter", reflect.TypeOf((*MockReader)(nil).EventFilter), from, keys)
}

// Head mocks base method.
func (m *MockReader) Head() (*core.Block, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Head")
	ret0, _ := ret[0].(*core.Block)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// HeadState mocks base method.
func (m *MockReader) HeadState() (core.StateReader, func() error, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HeadState")
	ret0, _ := ret[0].(core.StateReader)
	ret1, _ := ret[1].(func() error)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// HeadsHeader mocks base method.
func (m *MockReader) HeadsHeader() (*core.Header, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HeadsHeader")
	ret0, _ := ret[0].(*core.Header)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

// L1HandlerTxnHash indicates an expected call of L1HandlerTxnHash.
func (mr *MockReaderMockRecorder) L1HandlerTxnHash(msgHash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "L1HandlerTxnHash", reflect.TypeOf((*MockReader)(nil).L1HandlerTxnHash), msgHash)
}

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

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

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

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

// Receipt mocks base method.
func (m *MockReader) Receipt(hash *felt.Felt) (*core.TransactionReceipt, *felt.Felt, uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Receipt", hash)
	ret0, _ := ret[0].(*core.TransactionReceipt)
	ret1, _ := ret[1].(*felt.Felt)
	ret2, _ := ret[2].(uint64)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

// StateAtBlockHash mocks base method.
func (m *MockReader) StateAtBlockHash(blockHash *felt.Felt) (core.StateReader, func() error, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateAtBlockHash", blockHash)
	ret0, _ := ret[0].(core.StateReader)
	ret1, _ := ret[1].(func() error)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// StateAtBlockNumber mocks base method.
func (m *MockReader) StateAtBlockNumber(blockNumber uint64) (core.StateReader, func() error, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateAtBlockNumber", blockNumber)
	ret0, _ := ret[0].(core.StateReader)
	ret1, _ := ret[1].(func() error)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// StateAtBlockNumber indicates an expected call of StateAtBlockNumber.
func (mr *MockReaderMockRecorder) StateAtBlockNumber(blockNumber any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateAtBlockNumber", reflect.TypeOf((*MockReader)(nil).StateAtBlockNumber), blockNumber)
}

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

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

// StateUpdateByNumber mocks base method.
func (m *MockReader) StateUpdateByNumber(number uint64) (*core.StateUpdate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateUpdateByNumber", number)
	ret0, _ := ret[0].(*core.StateUpdate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SubscribeL1Head mocks base method.
func (m *MockReader) SubscribeL1Head() blockchain.L1HeadSubscription {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeL1Head")
	ret0, _ := ret[0].(blockchain.L1HeadSubscription)
	return ret0
}

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

// TransactionByBlockNumberAndIndex mocks base method.
func (m *MockReader) TransactionByBlockNumberAndIndex(blockNumber, index uint64) (core.Transaction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransactionByBlockNumberAndIndex", blockNumber, index)
	ret0, _ := ret[0].(core.Transaction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TransactionByBlockNumberAndIndex indicates an expected call of TransactionByBlockNumberAndIndex.
func (mr *MockReaderMockRecorder) TransactionByBlockNumberAndIndex(blockNumber, index any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByBlockNumberAndIndex", reflect.TypeOf((*MockReader)(nil).TransactionByBlockNumberAndIndex), blockNumber, index)
}

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

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