mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ./interface.go
//
// Generated by this command:
//
//	mockgen -typed -package=activation -destination=./mocks.go -source=./interface.go
//

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

import (
	context "context"
	reflect "reflect"
	time "time"

	types "github.com/spacemeshos/go-spacemesh/common/types"
	signing "github.com/spacemeshos/go-spacemesh/signing"
	nipost "github.com/spacemeshos/go-spacemesh/sql/localsql/nipost"
	shared "github.com/spacemeshos/post/shared"
	verifying "github.com/spacemeshos/post/verifying"
	gomock "go.uber.org/mock/gomock"
)

// MockAtxReceiver is a mock of AtxReceiver interface.
type MockAtxReceiver struct {
	ctrl     *gomock.Controller
	recorder *MockAtxReceiverMockRecorder
}

// MockAtxReceiverMockRecorder is the mock recorder for MockAtxReceiver.
type MockAtxReceiverMockRecorder struct {
	mock *MockAtxReceiver
}

// NewMockAtxReceiver creates a new mock instance.
func NewMockAtxReceiver(ctrl *gomock.Controller) *MockAtxReceiver {
	mock := &MockAtxReceiver{ctrl: ctrl}
	mock.recorder = &MockAtxReceiverMockRecorder{mock}
	return mock
}

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

// OnAtx mocks base method.
func (m *MockAtxReceiver) OnAtx(arg0 *types.ActivationTxHeader) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnAtx", arg0)
}

// OnAtx indicates an expected call of OnAtx.
func (mr *MockAtxReceiverMockRecorder) OnAtx(arg0 any) *MockAtxReceiverOnAtxCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnAtx", reflect.TypeOf((*MockAtxReceiver)(nil).OnAtx), arg0)
	return &MockAtxReceiverOnAtxCall{Call: call}
}

// MockAtxReceiverOnAtxCall wrap *gomock.Call
type MockAtxReceiverOnAtxCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockAtxReceiverOnAtxCall) Return() *MockAtxReceiverOnAtxCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAtxReceiverOnAtxCall) Do(f func(*types.ActivationTxHeader)) *MockAtxReceiverOnAtxCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAtxReceiverOnAtxCall) DoAndReturn(f func(*types.ActivationTxHeader)) *MockAtxReceiverOnAtxCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockPostVerifier is a mock of PostVerifier interface.
type MockPostVerifier struct {
	ctrl     *gomock.Controller
	recorder *MockPostVerifierMockRecorder
}

// MockPostVerifierMockRecorder is the mock recorder for MockPostVerifier.
type MockPostVerifierMockRecorder struct {
	mock *MockPostVerifier
}

// NewMockPostVerifier creates a new mock instance.
func NewMockPostVerifier(ctrl *gomock.Controller) *MockPostVerifier {
	mock := &MockPostVerifier{ctrl: ctrl}
	mock.recorder = &MockPostVerifierMockRecorder{mock}
	return mock
}

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

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

// Close indicates an expected call of Close.
func (mr *MockPostVerifierMockRecorder) Close() *MockPostVerifierCloseCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPostVerifier)(nil).Close))
	return &MockPostVerifierCloseCall{Call: call}
}

// MockPostVerifierCloseCall wrap *gomock.Call
type MockPostVerifierCloseCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPostVerifierCloseCall) Return(arg0 error) *MockPostVerifierCloseCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPostVerifierCloseCall) Do(f func() error) *MockPostVerifierCloseCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPostVerifierCloseCall) DoAndReturn(f func() error) *MockPostVerifierCloseCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Verify mocks base method.
func (m_2 *MockPostVerifier) Verify(ctx context.Context, p *shared.Proof, m *shared.ProofMetadata, opts ...verifying.OptionFunc) error {
	m_2.ctrl.T.Helper()
	varargs := []any{ctx, p, m}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m_2.ctrl.Call(m_2, "Verify", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Verify indicates an expected call of Verify.
func (mr *MockPostVerifierMockRecorder) Verify(ctx, p, m any, opts ...any) *MockPostVerifierVerifyCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, p, m}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Verify", reflect.TypeOf((*MockPostVerifier)(nil).Verify), varargs...)
	return &MockPostVerifierVerifyCall{Call: call}
}

// MockPostVerifierVerifyCall wrap *gomock.Call
type MockPostVerifierVerifyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPostVerifierVerifyCall) Return(arg0 error) *MockPostVerifierVerifyCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPostVerifierVerifyCall) Do(f func(context.Context, *shared.Proof, *shared.ProofMetadata, ...verifying.OptionFunc) error) *MockPostVerifierVerifyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPostVerifierVerifyCall) DoAndReturn(f func(context.Context, *shared.Proof, *shared.ProofMetadata, ...verifying.OptionFunc) error) *MockPostVerifierVerifyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Mockscaler is a mock of scaler interface.
type Mockscaler struct {
	ctrl     *gomock.Controller
	recorder *MockscalerMockRecorder
}

// MockscalerMockRecorder is the mock recorder for Mockscaler.
type MockscalerMockRecorder struct {
	mock *Mockscaler
}

// NewMockscaler creates a new mock instance.
func NewMockscaler(ctrl *gomock.Controller) *Mockscaler {
	mock := &Mockscaler{ctrl: ctrl}
	mock.recorder = &MockscalerMockRecorder{mock}
	return mock
}

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

// scale mocks base method.
func (m *Mockscaler) scale(arg0 int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "scale", arg0)
}

// scale indicates an expected call of scale.
func (mr *MockscalerMockRecorder) scale(arg0 any) *MockscalerscaleCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "scale", reflect.TypeOf((*Mockscaler)(nil).scale), arg0)
	return &MockscalerscaleCall{Call: call}
}

// MockscalerscaleCall wrap *gomock.Call
type MockscalerscaleCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockscalerscaleCall) Return() *MockscalerscaleCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockscalerscaleCall) Do(f func(int)) *MockscalerscaleCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockscalerscaleCall) DoAndReturn(f func(int)) *MockscalerscaleCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MocknipostValidator is a mock of nipostValidator interface.
type MocknipostValidator struct {
	ctrl     *gomock.Controller
	recorder *MocknipostValidatorMockRecorder
}

// MocknipostValidatorMockRecorder is the mock recorder for MocknipostValidator.
type MocknipostValidatorMockRecorder struct {
	mock *MocknipostValidator
}

// NewMocknipostValidator creates a new mock instance.
func NewMocknipostValidator(ctrl *gomock.Controller) *MocknipostValidator {
	mock := &MocknipostValidator{ctrl: ctrl}
	mock.recorder = &MocknipostValidatorMockRecorder{mock}
	return mock
}

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

// InitialNIPostChallenge mocks base method.
func (m *MocknipostValidator) InitialNIPostChallenge(challenge *types.NIPostChallenge, atxs atxProvider, goldenATXID types.ATXID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InitialNIPostChallenge", challenge, atxs, goldenATXID)
	ret0, _ := ret[0].(error)
	return ret0
}

// InitialNIPostChallenge indicates an expected call of InitialNIPostChallenge.
func (mr *MocknipostValidatorMockRecorder) InitialNIPostChallenge(challenge, atxs, goldenATXID any) *MocknipostValidatorInitialNIPostChallengeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitialNIPostChallenge", reflect.TypeOf((*MocknipostValidator)(nil).InitialNIPostChallenge), challenge, atxs, goldenATXID)
	return &MocknipostValidatorInitialNIPostChallengeCall{Call: call}
}

// MocknipostValidatorInitialNIPostChallengeCall wrap *gomock.Call
type MocknipostValidatorInitialNIPostChallengeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocknipostValidatorInitialNIPostChallengeCall) Return(arg0 error) *MocknipostValidatorInitialNIPostChallengeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocknipostValidatorInitialNIPostChallengeCall) Do(f func(*types.NIPostChallenge, atxProvider, types.ATXID) error) *MocknipostValidatorInitialNIPostChallengeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostValidatorInitialNIPostChallengeCall) DoAndReturn(f func(*types.NIPostChallenge, atxProvider, types.ATXID) error) *MocknipostValidatorInitialNIPostChallengeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// IsVerifyingFullPost indicates an expected call of IsVerifyingFullPost.
func (mr *MocknipostValidatorMockRecorder) IsVerifyingFullPost() *MocknipostValidatorIsVerifyingFullPostCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsVerifyingFullPost", reflect.TypeOf((*MocknipostValidator)(nil).IsVerifyingFullPost))
	return &MocknipostValidatorIsVerifyingFullPostCall{Call: call}
}

// MocknipostValidatorIsVerifyingFullPostCall wrap *gomock.Call
type MocknipostValidatorIsVerifyingFullPostCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocknipostValidatorIsVerifyingFullPostCall) Return(arg0 bool) *MocknipostValidatorIsVerifyingFullPostCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocknipostValidatorIsVerifyingFullPostCall) Do(f func() bool) *MocknipostValidatorIsVerifyingFullPostCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostValidatorIsVerifyingFullPostCall) DoAndReturn(f func() bool) *MocknipostValidatorIsVerifyingFullPostCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// NIPost mocks base method.
func (m *MocknipostValidator) NIPost(ctx context.Context, nodeId types.NodeID, commitmentAtxId types.ATXID, NIPost *types.NIPost, expectedChallenge types.Hash32, numUnits uint32, opts ...validatorOption) (uint64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, nodeId, commitmentAtxId, NIPost, expectedChallenge, numUnits}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NIPost", varargs...)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NIPost indicates an expected call of NIPost.
func (mr *MocknipostValidatorMockRecorder) NIPost(ctx, nodeId, commitmentAtxId, NIPost, expectedChallenge, numUnits any, opts ...any) *MocknipostValidatorNIPostCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, nodeId, commitmentAtxId, NIPost, expectedChallenge, numUnits}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NIPost", reflect.TypeOf((*MocknipostValidator)(nil).NIPost), varargs...)
	return &MocknipostValidatorNIPostCall{Call: call}
}

// MocknipostValidatorNIPostCall wrap *gomock.Call
type MocknipostValidatorNIPostCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocknipostValidatorNIPostCall) Return(arg0 uint64, arg1 error) *MocknipostValidatorNIPostCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocknipostValidatorNIPostCall) Do(f func(context.Context, types.NodeID, types.ATXID, *types.NIPost, types.Hash32, uint32, ...validatorOption) (uint64, error)) *MocknipostValidatorNIPostCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostValidatorNIPostCall) DoAndReturn(f func(context.Context, types.NodeID, types.ATXID, *types.NIPost, types.Hash32, uint32, ...validatorOption) (uint64, error)) *MocknipostValidatorNIPostCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// NIPostChallenge mocks base method.
func (m *MocknipostValidator) NIPostChallenge(challenge *types.NIPostChallenge, atxs atxProvider, nodeID types.NodeID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NIPostChallenge", challenge, atxs, nodeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// NIPostChallenge indicates an expected call of NIPostChallenge.
func (mr *MocknipostValidatorMockRecorder) NIPostChallenge(challenge, atxs, nodeID any) *MocknipostValidatorNIPostChallengeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NIPostChallenge", reflect.TypeOf((*MocknipostValidator)(nil).NIPostChallenge), challenge, atxs, nodeID)
	return &MocknipostValidatorNIPostChallengeCall{Call: call}
}

// MocknipostValidatorNIPostChallengeCall wrap *gomock.Call
type MocknipostValidatorNIPostChallengeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocknipostValidatorNIPostChallengeCall) Return(arg0 error) *MocknipostValidatorNIPostChallengeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocknipostValidatorNIPostChallengeCall) Do(f func(*types.NIPostChallenge, atxProvider, types.NodeID) error) *MocknipostValidatorNIPostChallengeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostValidatorNIPostChallengeCall) DoAndReturn(f func(*types.NIPostChallenge, atxProvider, types.NodeID) error) *MocknipostValidatorNIPostChallengeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// NumUnits mocks base method.
func (m *MocknipostValidator) NumUnits(cfg *PostConfig, numUnits uint32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NumUnits", cfg, numUnits)
	ret0, _ := ret[0].(error)
	return ret0
}

// NumUnits indicates an expected call of NumUnits.
func (mr *MocknipostValidatorMockRecorder) NumUnits(cfg, numUnits any) *MocknipostValidatorNumUnitsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NumUnits", reflect.TypeOf((*MocknipostValidator)(nil).NumUnits), cfg, numUnits)
	return &MocknipostValidatorNumUnitsCall{Call: call}
}

// MocknipostValidatorNumUnitsCall wrap *gomock.Call
type MocknipostValidatorNumUnitsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocknipostValidatorNumUnitsCall) Return(arg0 error) *MocknipostValidatorNumUnitsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocknipostValidatorNumUnitsCall) Do(f func(*PostConfig, uint32) error) *MocknipostValidatorNumUnitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostValidatorNumUnitsCall) DoAndReturn(f func(*PostConfig, uint32) error) *MocknipostValidatorNumUnitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PositioningAtx mocks base method.
func (m *MocknipostValidator) PositioningAtx(id types.ATXID, atxs atxProvider, goldenATXID types.ATXID, pubepoch types.EpochID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PositioningAtx", id, atxs, goldenATXID, pubepoch)
	ret0, _ := ret[0].(error)
	return ret0
}

// PositioningAtx indicates an expected call of PositioningAtx.
func (mr *MocknipostValidatorMockRecorder) PositioningAtx(id, atxs, goldenATXID, pubepoch any) *MocknipostValidatorPositioningAtxCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PositioningAtx", reflect.TypeOf((*MocknipostValidator)(nil).PositioningAtx), id, atxs, goldenATXID, pubepoch)
	return &MocknipostValidatorPositioningAtxCall{Call: call}
}

// MocknipostValidatorPositioningAtxCall wrap *gomock.Call
type MocknipostValidatorPositioningAtxCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocknipostValidatorPositioningAtxCall) Return(arg0 error) *MocknipostValidatorPositioningAtxCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocknipostValidatorPositioningAtxCall) Do(f func(types.ATXID, atxProvider, types.ATXID, types.EpochID) error) *MocknipostValidatorPositioningAtxCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostValidatorPositioningAtxCall) DoAndReturn(f func(types.ATXID, atxProvider, types.ATXID, types.EpochID) error) *MocknipostValidatorPositioningAtxCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Post mocks base method.
func (m *MocknipostValidator) Post(ctx context.Context, nodeId types.NodeID, commitmentAtxId types.ATXID, Post *types.Post, PostMetadata *types.PostMetadata, numUnits uint32, opts ...validatorOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, nodeId, commitmentAtxId, Post, PostMetadata, numUnits}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Post", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Post indicates an expected call of Post.
func (mr *MocknipostValidatorMockRecorder) Post(ctx, nodeId, commitmentAtxId, Post, PostMetadata, numUnits any, opts ...any) *MocknipostValidatorPostCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, nodeId, commitmentAtxId, Post, PostMetadata, numUnits}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MocknipostValidator)(nil).Post), varargs...)
	return &MocknipostValidatorPostCall{Call: call}
}

// MocknipostValidatorPostCall wrap *gomock.Call
type MocknipostValidatorPostCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocknipostValidatorPostCall) Return(arg0 error) *MocknipostValidatorPostCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocknipostValidatorPostCall) Do(f func(context.Context, types.NodeID, types.ATXID, *types.Post, *types.PostMetadata, uint32, ...validatorOption) error) *MocknipostValidatorPostCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostValidatorPostCall) DoAndReturn(f func(context.Context, types.NodeID, types.ATXID, *types.Post, *types.PostMetadata, uint32, ...validatorOption) error) *MocknipostValidatorPostCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PostMetadata mocks base method.
func (m *MocknipostValidator) PostMetadata(cfg *PostConfig, metadata *types.PostMetadata) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PostMetadata", cfg, metadata)
	ret0, _ := ret[0].(error)
	return ret0
}

// PostMetadata indicates an expected call of PostMetadata.
func (mr *MocknipostValidatorMockRecorder) PostMetadata(cfg, metadata any) *MocknipostValidatorPostMetadataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMetadata", reflect.TypeOf((*MocknipostValidator)(nil).PostMetadata), cfg, metadata)
	return &MocknipostValidatorPostMetadataCall{Call: call}
}

// MocknipostValidatorPostMetadataCall wrap *gomock.Call
type MocknipostValidatorPostMetadataCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocknipostValidatorPostMetadataCall) Return(arg0 error) *MocknipostValidatorPostMetadataCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocknipostValidatorPostMetadataCall) Do(f func(*PostConfig, *types.PostMetadata) error) *MocknipostValidatorPostMetadataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostValidatorPostMetadataCall) DoAndReturn(f func(*PostConfig, *types.PostMetadata) error) *MocknipostValidatorPostMetadataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// VRFNonce mocks base method.
func (m *MocknipostValidator) VRFNonce(nodeId types.NodeID, commitmentAtxId types.ATXID, vrfNonce *types.VRFPostIndex, PostMetadata *types.PostMetadata, numUnits uint32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VRFNonce", nodeId, commitmentAtxId, vrfNonce, PostMetadata, numUnits)
	ret0, _ := ret[0].(error)
	return ret0
}

// VRFNonce indicates an expected call of VRFNonce.
func (mr *MocknipostValidatorMockRecorder) VRFNonce(nodeId, commitmentAtxId, vrfNonce, PostMetadata, numUnits any) *MocknipostValidatorVRFNonceCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VRFNonce", reflect.TypeOf((*MocknipostValidator)(nil).VRFNonce), nodeId, commitmentAtxId, vrfNonce, PostMetadata, numUnits)
	return &MocknipostValidatorVRFNonceCall{Call: call}
}

// MocknipostValidatorVRFNonceCall wrap *gomock.Call
type MocknipostValidatorVRFNonceCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocknipostValidatorVRFNonceCall) Return(arg0 error) *MocknipostValidatorVRFNonceCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocknipostValidatorVRFNonceCall) Do(f func(types.NodeID, types.ATXID, *types.VRFPostIndex, *types.PostMetadata, uint32) error) *MocknipostValidatorVRFNonceCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostValidatorVRFNonceCall) DoAndReturn(f func(types.NodeID, types.ATXID, *types.VRFPostIndex, *types.PostMetadata, uint32) error) *MocknipostValidatorVRFNonceCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// VerifyChain mocks base method.
func (m *MocknipostValidator) VerifyChain(ctx context.Context, id, goldenATXID types.ATXID, opts ...VerifyChainOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, id, goldenATXID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyChain", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyChain indicates an expected call of VerifyChain.
func (mr *MocknipostValidatorMockRecorder) VerifyChain(ctx, id, goldenATXID any, opts ...any) *MocknipostValidatorVerifyChainCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, id, goldenATXID}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyChain", reflect.TypeOf((*MocknipostValidator)(nil).VerifyChain), varargs...)
	return &MocknipostValidatorVerifyChainCall{Call: call}
}

// MocknipostValidatorVerifyChainCall wrap *gomock.Call
type MocknipostValidatorVerifyChainCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocknipostValidatorVerifyChainCall) Return(arg0 error) *MocknipostValidatorVerifyChainCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocknipostValidatorVerifyChainCall) Do(f func(context.Context, types.ATXID, types.ATXID, ...VerifyChainOption) error) *MocknipostValidatorVerifyChainCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostValidatorVerifyChainCall) DoAndReturn(f func(context.Context, types.ATXID, types.ATXID, ...VerifyChainOption) error) *MocknipostValidatorVerifyChainCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MocklayerClock is a mock of layerClock interface.
type MocklayerClock struct {
	ctrl     *gomock.Controller
	recorder *MocklayerClockMockRecorder
}

// MocklayerClockMockRecorder is the mock recorder for MocklayerClock.
type MocklayerClockMockRecorder struct {
	mock *MocklayerClock
}

// NewMocklayerClock creates a new mock instance.
func NewMocklayerClock(ctrl *gomock.Controller) *MocklayerClock {
	mock := &MocklayerClock{ctrl: ctrl}
	mock.recorder = &MocklayerClockMockRecorder{mock}
	return mock
}

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

// AwaitLayer mocks base method.
func (m *MocklayerClock) AwaitLayer(layerID types.LayerID) <-chan struct{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AwaitLayer", layerID)
	ret0, _ := ret[0].(<-chan struct{})
	return ret0
}

// AwaitLayer indicates an expected call of AwaitLayer.
func (mr *MocklayerClockMockRecorder) AwaitLayer(layerID any) *MocklayerClockAwaitLayerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AwaitLayer", reflect.TypeOf((*MocklayerClock)(nil).AwaitLayer), layerID)
	return &MocklayerClockAwaitLayerCall{Call: call}
}

// MocklayerClockAwaitLayerCall wrap *gomock.Call
type MocklayerClockAwaitLayerCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocklayerClockAwaitLayerCall) Return(arg0 <-chan struct{}) *MocklayerClockAwaitLayerCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocklayerClockAwaitLayerCall) Do(f func(types.LayerID) <-chan struct{}) *MocklayerClockAwaitLayerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocklayerClockAwaitLayerCall) DoAndReturn(f func(types.LayerID) <-chan struct{}) *MocklayerClockAwaitLayerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CurrentLayer mocks base method.
func (m *MocklayerClock) CurrentLayer() types.LayerID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CurrentLayer")
	ret0, _ := ret[0].(types.LayerID)
	return ret0
}

// CurrentLayer indicates an expected call of CurrentLayer.
func (mr *MocklayerClockMockRecorder) CurrentLayer() *MocklayerClockCurrentLayerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentLayer", reflect.TypeOf((*MocklayerClock)(nil).CurrentLayer))
	return &MocklayerClockCurrentLayerCall{Call: call}
}

// MocklayerClockCurrentLayerCall wrap *gomock.Call
type MocklayerClockCurrentLayerCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocklayerClockCurrentLayerCall) Return(arg0 types.LayerID) *MocklayerClockCurrentLayerCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocklayerClockCurrentLayerCall) Do(f func() types.LayerID) *MocklayerClockCurrentLayerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocklayerClockCurrentLayerCall) DoAndReturn(f func() types.LayerID) *MocklayerClockCurrentLayerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LayerToTime mocks base method.
func (m *MocklayerClock) LayerToTime(arg0 types.LayerID) time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LayerToTime", arg0)
	ret0, _ := ret[0].(time.Time)
	return ret0
}

// LayerToTime indicates an expected call of LayerToTime.
func (mr *MocklayerClockMockRecorder) LayerToTime(arg0 any) *MocklayerClockLayerToTimeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LayerToTime", reflect.TypeOf((*MocklayerClock)(nil).LayerToTime), arg0)
	return &MocklayerClockLayerToTimeCall{Call: call}
}

// MocklayerClockLayerToTimeCall wrap *gomock.Call
type MocklayerClockLayerToTimeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocklayerClockLayerToTimeCall) Return(arg0 time.Time) *MocklayerClockLayerToTimeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocklayerClockLayerToTimeCall) Do(f func(types.LayerID) time.Time) *MocklayerClockLayerToTimeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocklayerClockLayerToTimeCall) DoAndReturn(f func(types.LayerID) time.Time) *MocklayerClockLayerToTimeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MocknipostBuilder is a mock of nipostBuilder interface.
type MocknipostBuilder struct {
	ctrl     *gomock.Controller
	recorder *MocknipostBuilderMockRecorder
}

// MocknipostBuilderMockRecorder is the mock recorder for MocknipostBuilder.
type MocknipostBuilderMockRecorder struct {
	mock *MocknipostBuilder
}

// NewMocknipostBuilder creates a new mock instance.
func NewMocknipostBuilder(ctrl *gomock.Controller) *MocknipostBuilder {
	mock := &MocknipostBuilder{ctrl: ctrl}
	mock.recorder = &MocknipostBuilderMockRecorder{mock}
	return mock
}

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

// BuildNIPost mocks base method.
func (m *MocknipostBuilder) BuildNIPost(ctx context.Context, sig *signing.EdSigner, challenge *types.NIPostChallenge) (*nipost.NIPostState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildNIPost", ctx, sig, challenge)
	ret0, _ := ret[0].(*nipost.NIPostState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuildNIPost indicates an expected call of BuildNIPost.
func (mr *MocknipostBuilderMockRecorder) BuildNIPost(ctx, sig, challenge any) *MocknipostBuilderBuildNIPostCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildNIPost", reflect.TypeOf((*MocknipostBuilder)(nil).BuildNIPost), ctx, sig, challenge)
	return &MocknipostBuilderBuildNIPostCall{Call: call}
}

// MocknipostBuilderBuildNIPostCall wrap *gomock.Call
type MocknipostBuilderBuildNIPostCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocknipostBuilderBuildNIPostCall) Return(arg0 *nipost.NIPostState, arg1 error) *MocknipostBuilderBuildNIPostCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocknipostBuilderBuildNIPostCall) Do(f func(context.Context, *signing.EdSigner, *types.NIPostChallenge) (*nipost.NIPostState, error)) *MocknipostBuilderBuildNIPostCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostBuilderBuildNIPostCall) DoAndReturn(f func(context.Context, *signing.EdSigner, *types.NIPostChallenge) (*nipost.NIPostState, error)) *MocknipostBuilderBuildNIPostCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Proof mocks base method.
func (m *MocknipostBuilder) Proof(ctx context.Context, nodeID types.NodeID, challenge []byte) (*types.Post, *types.PostInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Proof", ctx, nodeID, challenge)
	ret0, _ := ret[0].(*types.Post)
	ret1, _ := ret[1].(*types.PostInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Proof indicates an expected call of Proof.
func (mr *MocknipostBuilderMockRecorder) Proof(ctx, nodeID, challenge any) *MocknipostBuilderProofCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Proof", reflect.TypeOf((*MocknipostBuilder)(nil).Proof), ctx, nodeID, challenge)
	return &MocknipostBuilderProofCall{Call: call}
}

// MocknipostBuilderProofCall wrap *gomock.Call
type MocknipostBuilderProofCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocknipostBuilderProofCall) Return(arg0 *types.Post, arg1 *types.PostInfo, arg2 error) *MocknipostBuilderProofCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocknipostBuilderProofCall) Do(f func(context.Context, types.NodeID, []byte) (*types.Post, *types.PostInfo, error)) *MocknipostBuilderProofCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostBuilderProofCall) DoAndReturn(f func(context.Context, types.NodeID, []byte) (*types.Post, *types.PostInfo, error)) *MocknipostBuilderProofCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// ResetState indicates an expected call of ResetState.
func (mr *MocknipostBuilderMockRecorder) ResetState(arg0 any) *MocknipostBuilderResetStateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetState", reflect.TypeOf((*MocknipostBuilder)(nil).ResetState), arg0)
	return &MocknipostBuilderResetStateCall{Call: call}
}

// MocknipostBuilderResetStateCall wrap *gomock.Call
type MocknipostBuilderResetStateCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocknipostBuilderResetStateCall) Return(arg0 error) *MocknipostBuilderResetStateCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocknipostBuilderResetStateCall) Do(f func(types.NodeID) error) *MocknipostBuilderResetStateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostBuilderResetStateCall) DoAndReturn(f func(types.NodeID) error) *MocknipostBuilderResetStateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Mocksyncer is a mock of syncer interface.
type Mocksyncer struct {
	ctrl     *gomock.Controller
	recorder *MocksyncerMockRecorder
}

// MocksyncerMockRecorder is the mock recorder for Mocksyncer.
type MocksyncerMockRecorder struct {
	mock *Mocksyncer
}

// NewMocksyncer creates a new mock instance.
func NewMocksyncer(ctrl *gomock.Controller) *Mocksyncer {
	mock := &Mocksyncer{ctrl: ctrl}
	mock.recorder = &MocksyncerMockRecorder{mock}
	return mock
}

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

// RegisterForATXSynced mocks base method.
func (m *Mocksyncer) RegisterForATXSynced() <-chan struct{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterForATXSynced")
	ret0, _ := ret[0].(<-chan struct{})
	return ret0
}

// RegisterForATXSynced indicates an expected call of RegisterForATXSynced.
func (mr *MocksyncerMockRecorder) RegisterForATXSynced() *MocksyncerRegisterForATXSyncedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterForATXSynced", reflect.TypeOf((*Mocksyncer)(nil).RegisterForATXSynced))
	return &MocksyncerRegisterForATXSyncedCall{Call: call}
}

// MocksyncerRegisterForATXSyncedCall wrap *gomock.Call
type MocksyncerRegisterForATXSyncedCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MocksyncerRegisterForATXSyncedCall) Return(arg0 <-chan struct{}) *MocksyncerRegisterForATXSyncedCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MocksyncerRegisterForATXSyncedCall) Do(f func() <-chan struct{}) *MocksyncerRegisterForATXSyncedCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocksyncerRegisterForATXSyncedCall) DoAndReturn(f func() <-chan struct{}) *MocksyncerRegisterForATXSyncedCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockatxProvider is a mock of atxProvider interface.
type MockatxProvider struct {
	ctrl     *gomock.Controller
	recorder *MockatxProviderMockRecorder
}

// MockatxProviderMockRecorder is the mock recorder for MockatxProvider.
type MockatxProviderMockRecorder struct {
	mock *MockatxProvider
}

// NewMockatxProvider creates a new mock instance.
func NewMockatxProvider(ctrl *gomock.Controller) *MockatxProvider {
	mock := &MockatxProvider{ctrl: ctrl}
	mock.recorder = &MockatxProviderMockRecorder{mock}
	return mock
}

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

// GetAtxHeader mocks base method.
func (m *MockatxProvider) GetAtxHeader(id types.ATXID) (*types.ActivationTxHeader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAtxHeader", id)
	ret0, _ := ret[0].(*types.ActivationTxHeader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAtxHeader indicates an expected call of GetAtxHeader.
func (mr *MockatxProviderMockRecorder) GetAtxHeader(id any) *MockatxProviderGetAtxHeaderCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAtxHeader", reflect.TypeOf((*MockatxProvider)(nil).GetAtxHeader), id)
	return &MockatxProviderGetAtxHeaderCall{Call: call}
}

// MockatxProviderGetAtxHeaderCall wrap *gomock.Call
type MockatxProviderGetAtxHeaderCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockatxProviderGetAtxHeaderCall) Return(arg0 *types.ActivationTxHeader, arg1 error) *MockatxProviderGetAtxHeaderCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockatxProviderGetAtxHeaderCall) Do(f func(types.ATXID) (*types.ActivationTxHeader, error)) *MockatxProviderGetAtxHeaderCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockatxProviderGetAtxHeaderCall) DoAndReturn(f func(types.ATXID) (*types.ActivationTxHeader, error)) *MockatxProviderGetAtxHeaderCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockpostSetupProvider is a mock of postSetupProvider interface.
type MockpostSetupProvider struct {
	ctrl     *gomock.Controller
	recorder *MockpostSetupProviderMockRecorder
}

// MockpostSetupProviderMockRecorder is the mock recorder for MockpostSetupProvider.
type MockpostSetupProviderMockRecorder struct {
	mock *MockpostSetupProvider
}

// NewMockpostSetupProvider creates a new mock instance.
func NewMockpostSetupProvider(ctrl *gomock.Controller) *MockpostSetupProvider {
	mock := &MockpostSetupProvider{ctrl: ctrl}
	mock.recorder = &MockpostSetupProviderMockRecorder{mock}
	return mock
}

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

// PrepareInitializer mocks base method.
func (m *MockpostSetupProvider) PrepareInitializer(ctx context.Context, opts PostSetupOpts, id types.NodeID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrepareInitializer", ctx, opts, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// PrepareInitializer indicates an expected call of PrepareInitializer.
func (mr *MockpostSetupProviderMockRecorder) PrepareInitializer(ctx, opts, id any) *MockpostSetupProviderPrepareInitializerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareInitializer", reflect.TypeOf((*MockpostSetupProvider)(nil).PrepareInitializer), ctx, opts, id)
	return &MockpostSetupProviderPrepareInitializerCall{Call: call}
}

// MockpostSetupProviderPrepareInitializerCall wrap *gomock.Call
type MockpostSetupProviderPrepareInitializerCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockpostSetupProviderPrepareInitializerCall) Return(arg0 error) *MockpostSetupProviderPrepareInitializerCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockpostSetupProviderPrepareInitializerCall) Do(f func(context.Context, PostSetupOpts, types.NodeID) error) *MockpostSetupProviderPrepareInitializerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockpostSetupProviderPrepareInitializerCall) DoAndReturn(f func(context.Context, PostSetupOpts, types.NodeID) error) *MockpostSetupProviderPrepareInitializerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Reset indicates an expected call of Reset.
func (mr *MockpostSetupProviderMockRecorder) Reset() *MockpostSetupProviderResetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockpostSetupProvider)(nil).Reset))
	return &MockpostSetupProviderResetCall{Call: call}
}

// MockpostSetupProviderResetCall wrap *gomock.Call
type MockpostSetupProviderResetCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockpostSetupProviderResetCall) Return(arg0 error) *MockpostSetupProviderResetCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockpostSetupProviderResetCall) Do(f func() error) *MockpostSetupProviderResetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockpostSetupProviderResetCall) DoAndReturn(f func() error) *MockpostSetupProviderResetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// StartSession mocks base method.
func (m *MockpostSetupProvider) StartSession(context context.Context, id types.NodeID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartSession", context, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// StartSession indicates an expected call of StartSession.
func (mr *MockpostSetupProviderMockRecorder) StartSession(context, id any) *MockpostSetupProviderStartSessionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartSession", reflect.TypeOf((*MockpostSetupProvider)(nil).StartSession), context, id)
	return &MockpostSetupProviderStartSessionCall{Call: call}
}

// MockpostSetupProviderStartSessionCall wrap *gomock.Call
type MockpostSetupProviderStartSessionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockpostSetupProviderStartSessionCall) Return(arg0 error) *MockpostSetupProviderStartSessionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockpostSetupProviderStartSessionCall) Do(f func(context.Context, types.NodeID) error) *MockpostSetupProviderStartSessionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockpostSetupProviderStartSessionCall) DoAndReturn(f func(context.Context, types.NodeID) error) *MockpostSetupProviderStartSessionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Status indicates an expected call of Status.
func (mr *MockpostSetupProviderMockRecorder) Status() *MockpostSetupProviderStatusCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockpostSetupProvider)(nil).Status))
	return &MockpostSetupProviderStatusCall{Call: call}
}

// MockpostSetupProviderStatusCall wrap *gomock.Call
type MockpostSetupProviderStatusCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockpostSetupProviderStatusCall) Return(arg0 *PostSetupStatus) *MockpostSetupProviderStatusCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockpostSetupProviderStatusCall) Do(f func() *PostSetupStatus) *MockpostSetupProviderStatusCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockpostSetupProviderStatusCall) DoAndReturn(f func() *PostSetupStatus) *MockpostSetupProviderStatusCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockSmeshingProvider is a mock of SmeshingProvider interface.
type MockSmeshingProvider struct {
	ctrl     *gomock.Controller
	recorder *MockSmeshingProviderMockRecorder
}

// MockSmeshingProviderMockRecorder is the mock recorder for MockSmeshingProvider.
type MockSmeshingProviderMockRecorder struct {
	mock *MockSmeshingProvider
}

// NewMockSmeshingProvider creates a new mock instance.
func NewMockSmeshingProvider(ctrl *gomock.Controller) *MockSmeshingProvider {
	mock := &MockSmeshingProvider{ctrl: ctrl}
	mock.recorder = &MockSmeshingProviderMockRecorder{mock}
	return mock
}

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

// Coinbase mocks base method.
func (m *MockSmeshingProvider) Coinbase() types.Address {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Coinbase")
	ret0, _ := ret[0].(types.Address)
	return ret0
}

// Coinbase indicates an expected call of Coinbase.
func (mr *MockSmeshingProviderMockRecorder) Coinbase() *MockSmeshingProviderCoinbaseCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Coinbase", reflect.TypeOf((*MockSmeshingProvider)(nil).Coinbase))
	return &MockSmeshingProviderCoinbaseCall{Call: call}
}

// MockSmeshingProviderCoinbaseCall wrap *gomock.Call
type MockSmeshingProviderCoinbaseCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSmeshingProviderCoinbaseCall) Return(arg0 types.Address) *MockSmeshingProviderCoinbaseCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSmeshingProviderCoinbaseCall) Do(f func() types.Address) *MockSmeshingProviderCoinbaseCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSmeshingProviderCoinbaseCall) DoAndReturn(f func() types.Address) *MockSmeshingProviderCoinbaseCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetCoinbase mocks base method.
func (m *MockSmeshingProvider) SetCoinbase(coinbase types.Address) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCoinbase", coinbase)
}

// SetCoinbase indicates an expected call of SetCoinbase.
func (mr *MockSmeshingProviderMockRecorder) SetCoinbase(coinbase any) *MockSmeshingProviderSetCoinbaseCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCoinbase", reflect.TypeOf((*MockSmeshingProvider)(nil).SetCoinbase), coinbase)
	return &MockSmeshingProviderSetCoinbaseCall{Call: call}
}

// MockSmeshingProviderSetCoinbaseCall wrap *gomock.Call
type MockSmeshingProviderSetCoinbaseCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSmeshingProviderSetCoinbaseCall) Return() *MockSmeshingProviderSetCoinbaseCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSmeshingProviderSetCoinbaseCall) Do(f func(types.Address)) *MockSmeshingProviderSetCoinbaseCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSmeshingProviderSetCoinbaseCall) DoAndReturn(f func(types.Address)) *MockSmeshingProviderSetCoinbaseCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SmesherIDs mocks base method.
func (m *MockSmeshingProvider) SmesherIDs() []types.NodeID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SmesherIDs")
	ret0, _ := ret[0].([]types.NodeID)
	return ret0
}

// SmesherIDs indicates an expected call of SmesherIDs.
func (mr *MockSmeshingProviderMockRecorder) SmesherIDs() *MockSmeshingProviderSmesherIDsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SmesherIDs", reflect.TypeOf((*MockSmeshingProvider)(nil).SmesherIDs))
	return &MockSmeshingProviderSmesherIDsCall{Call: call}
}

// MockSmeshingProviderSmesherIDsCall wrap *gomock.Call
type MockSmeshingProviderSmesherIDsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSmeshingProviderSmesherIDsCall) Return(arg0 []types.NodeID) *MockSmeshingProviderSmesherIDsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSmeshingProviderSmesherIDsCall) Do(f func() []types.NodeID) *MockSmeshingProviderSmesherIDsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSmeshingProviderSmesherIDsCall) DoAndReturn(f func() []types.NodeID) *MockSmeshingProviderSmesherIDsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Smeshing indicates an expected call of Smeshing.
func (mr *MockSmeshingProviderMockRecorder) Smeshing() *MockSmeshingProviderSmeshingCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Smeshing", reflect.TypeOf((*MockSmeshingProvider)(nil).Smeshing))
	return &MockSmeshingProviderSmeshingCall{Call: call}
}

// MockSmeshingProviderSmeshingCall wrap *gomock.Call
type MockSmeshingProviderSmeshingCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSmeshingProviderSmeshingCall) Return(arg0 bool) *MockSmeshingProviderSmeshingCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSmeshingProviderSmeshingCall) Do(f func() bool) *MockSmeshingProviderSmeshingCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSmeshingProviderSmeshingCall) DoAndReturn(f func() bool) *MockSmeshingProviderSmeshingCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// StartSmeshing indicates an expected call of StartSmeshing.
func (mr *MockSmeshingProviderMockRecorder) StartSmeshing(arg0 any) *MockSmeshingProviderStartSmeshingCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartSmeshing", reflect.TypeOf((*MockSmeshingProvider)(nil).StartSmeshing), arg0)
	return &MockSmeshingProviderStartSmeshingCall{Call: call}
}

// MockSmeshingProviderStartSmeshingCall wrap *gomock.Call
type MockSmeshingProviderStartSmeshingCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSmeshingProviderStartSmeshingCall) Return(arg0 error) *MockSmeshingProviderStartSmeshingCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSmeshingProviderStartSmeshingCall) Do(f func(types.Address) error) *MockSmeshingProviderStartSmeshingCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSmeshingProviderStartSmeshingCall) DoAndReturn(f func(types.Address) error) *MockSmeshingProviderStartSmeshingCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// StopSmeshing indicates an expected call of StopSmeshing.
func (mr *MockSmeshingProviderMockRecorder) StopSmeshing(arg0 any) *MockSmeshingProviderStopSmeshingCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopSmeshing", reflect.TypeOf((*MockSmeshingProvider)(nil).StopSmeshing), arg0)
	return &MockSmeshingProviderStopSmeshingCall{Call: call}
}

// MockSmeshingProviderStopSmeshingCall wrap *gomock.Call
type MockSmeshingProviderStopSmeshingCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSmeshingProviderStopSmeshingCall) Return(arg0 error) *MockSmeshingProviderStopSmeshingCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSmeshingProviderStopSmeshingCall) Do(f func(bool) error) *MockSmeshingProviderStopSmeshingCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSmeshingProviderStopSmeshingCall) DoAndReturn(f func(bool) error) *MockSmeshingProviderStopSmeshingCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockpoetClient is a mock of poetClient interface.
type MockpoetClient struct {
	ctrl     *gomock.Controller
	recorder *MockpoetClientMockRecorder
}

// MockpoetClientMockRecorder is the mock recorder for MockpoetClient.
type MockpoetClientMockRecorder struct {
	mock *MockpoetClient
}

// NewMockpoetClient creates a new mock instance.
func NewMockpoetClient(ctrl *gomock.Controller) *MockpoetClient {
	mock := &MockpoetClient{ctrl: ctrl}
	mock.recorder = &MockpoetClientMockRecorder{mock}
	return mock
}

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

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

// Address indicates an expected call of Address.
func (mr *MockpoetClientMockRecorder) Address() *MockpoetClientAddressCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Address", reflect.TypeOf((*MockpoetClient)(nil).Address))
	return &MockpoetClientAddressCall{Call: call}
}

// MockpoetClientAddressCall wrap *gomock.Call
type MockpoetClientAddressCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockpoetClientAddressCall) Return(arg0 string) *MockpoetClientAddressCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockpoetClientAddressCall) Do(f func() string) *MockpoetClientAddressCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockpoetClientAddressCall) DoAndReturn(f func() string) *MockpoetClientAddressCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PowParams mocks base method.
func (m *MockpoetClient) PowParams(ctx context.Context) (*PoetPowParams, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PowParams", ctx)
	ret0, _ := ret[0].(*PoetPowParams)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PowParams indicates an expected call of PowParams.
func (mr *MockpoetClientMockRecorder) PowParams(ctx any) *MockpoetClientPowParamsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PowParams", reflect.TypeOf((*MockpoetClient)(nil).PowParams), ctx)
	return &MockpoetClientPowParamsCall{Call: call}
}

// MockpoetClientPowParamsCall wrap *gomock.Call
type MockpoetClientPowParamsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockpoetClientPowParamsCall) Return(arg0 *PoetPowParams, arg1 error) *MockpoetClientPowParamsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockpoetClientPowParamsCall) Do(f func(context.Context) (*PoetPowParams, error)) *MockpoetClientPowParamsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockpoetClientPowParamsCall) DoAndReturn(f func(context.Context) (*PoetPowParams, error)) *MockpoetClientPowParamsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Proof mocks base method.
func (m *MockpoetClient) Proof(ctx context.Context, roundID string) (*types.PoetProofMessage, []types.Member, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Proof", ctx, roundID)
	ret0, _ := ret[0].(*types.PoetProofMessage)
	ret1, _ := ret[1].([]types.Member)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Proof indicates an expected call of Proof.
func (mr *MockpoetClientMockRecorder) Proof(ctx, roundID any) *MockpoetClientProofCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Proof", reflect.TypeOf((*MockpoetClient)(nil).Proof), ctx, roundID)
	return &MockpoetClientProofCall{Call: call}
}

// MockpoetClientProofCall wrap *gomock.Call
type MockpoetClientProofCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockpoetClientProofCall) Return(arg0 *types.PoetProofMessage, arg1 []types.Member, arg2 error) *MockpoetClientProofCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockpoetClientProofCall) Do(f func(context.Context, string) (*types.PoetProofMessage, []types.Member, error)) *MockpoetClientProofCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockpoetClientProofCall) DoAndReturn(f func(context.Context, string) (*types.PoetProofMessage, []types.Member, error)) *MockpoetClientProofCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Submit mocks base method.
func (m *MockpoetClient) Submit(ctx context.Context, deadline time.Time, prefix, challenge []byte, signature types.EdSignature, nodeID types.NodeID, pow PoetPoW) (*types.PoetRound, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Submit", ctx, deadline, prefix, challenge, signature, nodeID, pow)
	ret0, _ := ret[0].(*types.PoetRound)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Submit indicates an expected call of Submit.
func (mr *MockpoetClientMockRecorder) Submit(ctx, deadline, prefix, challenge, signature, nodeID, pow any) *MockpoetClientSubmitCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Submit", reflect.TypeOf((*MockpoetClient)(nil).Submit), ctx, deadline, prefix, challenge, signature, nodeID, pow)
	return &MockpoetClientSubmitCall{Call: call}
}

// MockpoetClientSubmitCall wrap *gomock.Call
type MockpoetClientSubmitCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockpoetClientSubmitCall) Return(arg0 *types.PoetRound, arg1 error) *MockpoetClientSubmitCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockpoetClientSubmitCall) Do(f func(context.Context, time.Time, []byte, []byte, types.EdSignature, types.NodeID, PoetPoW) (*types.PoetRound, error)) *MockpoetClientSubmitCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockpoetClientSubmitCall) DoAndReturn(f func(context.Context, time.Time, []byte, []byte, types.EdSignature, types.NodeID, PoetPoW) (*types.PoetRound, error)) *MockpoetClientSubmitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockpoetDbAPI is a mock of poetDbAPI interface.
type MockpoetDbAPI struct {
	ctrl     *gomock.Controller
	recorder *MockpoetDbAPIMockRecorder
}

// MockpoetDbAPIMockRecorder is the mock recorder for MockpoetDbAPI.
type MockpoetDbAPIMockRecorder struct {
	mock *MockpoetDbAPI
}

// NewMockpoetDbAPI creates a new mock instance.
func NewMockpoetDbAPI(ctrl *gomock.Controller) *MockpoetDbAPI {
	mock := &MockpoetDbAPI{ctrl: ctrl}
	mock.recorder = &MockpoetDbAPIMockRecorder{mock}
	return mock
}

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

// GetProof mocks base method.
func (m *MockpoetDbAPI) GetProof(arg0 types.PoetProofRef) (*types.PoetProof, *types.Hash32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProof", arg0)
	ret0, _ := ret[0].(*types.PoetProof)
	ret1, _ := ret[1].(*types.Hash32)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetProof indicates an expected call of GetProof.
func (mr *MockpoetDbAPIMockRecorder) GetProof(arg0 any) *MockpoetDbAPIGetProofCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProof", reflect.TypeOf((*MockpoetDbAPI)(nil).GetProof), arg0)
	return &MockpoetDbAPIGetProofCall{Call: call}
}

// MockpoetDbAPIGetProofCall wrap *gomock.Call
type MockpoetDbAPIGetProofCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockpoetDbAPIGetProofCall) Return(arg0 *types.PoetProof, arg1 *types.Hash32, arg2 error) *MockpoetDbAPIGetProofCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockpoetDbAPIGetProofCall) Do(f func(types.PoetProofRef) (*types.PoetProof, *types.Hash32, error)) *MockpoetDbAPIGetProofCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockpoetDbAPIGetProofCall) DoAndReturn(f func(types.PoetProofRef) (*types.PoetProof, *types.Hash32, error)) *MockpoetDbAPIGetProofCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ValidateAndStore mocks base method.
func (m *MockpoetDbAPI) ValidateAndStore(ctx context.Context, proofMessage *types.PoetProofMessage) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateAndStore", ctx, proofMessage)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidateAndStore indicates an expected call of ValidateAndStore.
func (mr *MockpoetDbAPIMockRecorder) ValidateAndStore(ctx, proofMessage any) *MockpoetDbAPIValidateAndStoreCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateAndStore", reflect.TypeOf((*MockpoetDbAPI)(nil).ValidateAndStore), ctx, proofMessage)
	return &MockpoetDbAPIValidateAndStoreCall{Call: call}
}

// MockpoetDbAPIValidateAndStoreCall wrap *gomock.Call
type MockpoetDbAPIValidateAndStoreCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockpoetDbAPIValidateAndStoreCall) Return(arg0 error) *MockpoetDbAPIValidateAndStoreCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockpoetDbAPIValidateAndStoreCall) Do(f func(context.Context, *types.PoetProofMessage) error) *MockpoetDbAPIValidateAndStoreCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockpoetDbAPIValidateAndStoreCall) DoAndReturn(f func(context.Context, *types.PoetProofMessage) error) *MockpoetDbAPIValidateAndStoreCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockpostService is a mock of postService interface.
type MockpostService struct {
	ctrl     *gomock.Controller
	recorder *MockpostServiceMockRecorder
}

// MockpostServiceMockRecorder is the mock recorder for MockpostService.
type MockpostServiceMockRecorder struct {
	mock *MockpostService
}

// NewMockpostService creates a new mock instance.
func NewMockpostService(ctrl *gomock.Controller) *MockpostService {
	mock := &MockpostService{ctrl: ctrl}
	mock.recorder = &MockpostServiceMockRecorder{mock}
	return mock
}

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

// Client mocks base method.
func (m *MockpostService) Client(nodeId types.NodeID) (PostClient, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Client", nodeId)
	ret0, _ := ret[0].(PostClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Client indicates an expected call of Client.
func (mr *MockpostServiceMockRecorder) Client(nodeId any) *MockpostServiceClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Client", reflect.TypeOf((*MockpostService)(nil).Client), nodeId)
	return &MockpostServiceClientCall{Call: call}
}

// MockpostServiceClientCall wrap *gomock.Call
type MockpostServiceClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockpostServiceClientCall) Return(arg0 PostClient, arg1 error) *MockpostServiceClientCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockpostServiceClientCall) Do(f func(types.NodeID) (PostClient, error)) *MockpostServiceClientCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockpostServiceClientCall) DoAndReturn(f func(types.NodeID) (PostClient, error)) *MockpostServiceClientCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockPostClient is a mock of PostClient interface.
type MockPostClient struct {
	ctrl     *gomock.Controller
	recorder *MockPostClientMockRecorder
}

// MockPostClientMockRecorder is the mock recorder for MockPostClient.
type MockPostClientMockRecorder struct {
	mock *MockPostClient
}

// NewMockPostClient creates a new mock instance.
func NewMockPostClient(ctrl *gomock.Controller) *MockPostClient {
	mock := &MockPostClient{ctrl: ctrl}
	mock.recorder = &MockPostClientMockRecorder{mock}
	return mock
}

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

// Info mocks base method.
func (m *MockPostClient) Info(ctx context.Context) (*types.PostInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Info", ctx)
	ret0, _ := ret[0].(*types.PostInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Info indicates an expected call of Info.
func (mr *MockPostClientMockRecorder) Info(ctx any) *MockPostClientInfoCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockPostClient)(nil).Info), ctx)
	return &MockPostClientInfoCall{Call: call}
}

// MockPostClientInfoCall wrap *gomock.Call
type MockPostClientInfoCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPostClientInfoCall) Return(arg0 *types.PostInfo, arg1 error) *MockPostClientInfoCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPostClientInfoCall) Do(f func(context.Context) (*types.PostInfo, error)) *MockPostClientInfoCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPostClientInfoCall) DoAndReturn(f func(context.Context) (*types.PostInfo, error)) *MockPostClientInfoCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Proof mocks base method.
func (m *MockPostClient) Proof(ctx context.Context, challenge []byte) (*types.Post, *types.PostInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Proof", ctx, challenge)
	ret0, _ := ret[0].(*types.Post)
	ret1, _ := ret[1].(*types.PostInfo)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Proof indicates an expected call of Proof.
func (mr *MockPostClientMockRecorder) Proof(ctx, challenge any) *MockPostClientProofCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Proof", reflect.TypeOf((*MockPostClient)(nil).Proof), ctx, challenge)
	return &MockPostClientProofCall{Call: call}
}

// MockPostClientProofCall wrap *gomock.Call
type MockPostClientProofCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPostClientProofCall) Return(arg0 *types.Post, arg1 *types.PostInfo, arg2 error) *MockPostClientProofCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPostClientProofCall) Do(f func(context.Context, []byte) (*types.Post, *types.PostInfo, error)) *MockPostClientProofCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPostClientProofCall) DoAndReturn(f func(context.Context, []byte) (*types.Post, *types.PostInfo, error)) *MockPostClientProofCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}