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"
	proving "github.com/spacemeshos/post/proving"
	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) *AtxReceiverOnAtxCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnAtx", reflect.TypeOf((*MockAtxReceiver)(nil).OnAtx), arg0)
	return &AtxReceiverOnAtxCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *AtxReceiverOnAtxCall) DoAndReturn(f func(*types.ActivationTxHeader)) *AtxReceiverOnAtxCall {
	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() *PostVerifierCloseCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPostVerifier)(nil).Close))
	return &PostVerifierCloseCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *PostVerifierCloseCall) DoAndReturn(f func() error) *PostVerifierCloseCall {
	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) *PostVerifierVerifyCall {
	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 &PostVerifierVerifyCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *PostVerifierVerifyCall) DoAndReturn(f func(context.Context, *shared.Proof, *shared.ProofMetadata, ...verifying.OptionFunc) error) *PostVerifierVerifyCall {
	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) *scalerscaleCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "scale", reflect.TypeOf((*Mockscaler)(nil).scale), arg0)
	return &scalerscaleCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *scalerscaleCall) DoAndReturn(f func(int)) *scalerscaleCall {
	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) *nipostValidatorInitialNIPostChallengeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitialNIPostChallenge", reflect.TypeOf((*MocknipostValidator)(nil).InitialNIPostChallenge), challenge, atxs, goldenATXID)
	return &nipostValidatorInitialNIPostChallengeCall{Call: call}
}

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

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

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

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

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

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *nipostValidatorNIPostCall) DoAndReturn(f func(context.Context, types.NodeID, types.ATXID, *types.NIPost, types.Hash32, uint32) (uint64, error)) *nipostValidatorNIPostCall {
	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) *nipostValidatorNIPostChallengeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NIPostChallenge", reflect.TypeOf((*MocknipostValidator)(nil).NIPostChallenge), challenge, atxs, nodeID)
	return &nipostValidatorNIPostChallengeCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *nipostValidatorNIPostChallengeCall) DoAndReturn(f func(*types.NIPostChallenge, atxProvider, types.NodeID) error) *nipostValidatorNIPostChallengeCall {
	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) *nipostValidatorNumUnitsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NumUnits", reflect.TypeOf((*MocknipostValidator)(nil).NumUnits), cfg, numUnits)
	return &nipostValidatorNumUnitsCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *nipostValidatorNumUnitsCall) DoAndReturn(f func(*PostConfig, uint32) error) *nipostValidatorNumUnitsCall {
	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) *nipostValidatorPositioningAtxCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PositioningAtx", reflect.TypeOf((*MocknipostValidator)(nil).PositioningAtx), id, atxs, goldenATXID, pubepoch)
	return &nipostValidatorPositioningAtxCall{Call: call}
}

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

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

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

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

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

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *nipostValidatorPostCall) DoAndReturn(f func(context.Context, types.NodeID, types.ATXID, *types.Post, *types.PostMetadata, uint32) error) *nipostValidatorPostCall {
	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) *nipostValidatorPostMetadataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMetadata", reflect.TypeOf((*MocknipostValidator)(nil).PostMetadata), cfg, metadata)
	return &nipostValidatorPostMetadataCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *nipostValidatorPostMetadataCall) DoAndReturn(f func(*PostConfig, *types.PostMetadata) error) *nipostValidatorPostMetadataCall {
	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) *nipostValidatorVRFNonceCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VRFNonce", reflect.TypeOf((*MocknipostValidator)(nil).VRFNonce), nodeId, commitmentAtxId, vrfNonce, PostMetadata, numUnits)
	return &nipostValidatorVRFNonceCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *nipostValidatorVRFNonceCall) DoAndReturn(f func(types.NodeID, types.ATXID, *types.VRFPostIndex, *types.PostMetadata, uint32) error) *nipostValidatorVRFNonceCall {
	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) *layerClockAwaitLayerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AwaitLayer", reflect.TypeOf((*MocklayerClock)(nil).AwaitLayer), layerID)
	return &layerClockAwaitLayerCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *layerClockAwaitLayerCall) DoAndReturn(f func(types.LayerID) <-chan struct{}) *layerClockAwaitLayerCall {
	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() *layerClockCurrentLayerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentLayer", reflect.TypeOf((*MocklayerClock)(nil).CurrentLayer))
	return &layerClockCurrentLayerCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *layerClockCurrentLayerCall) DoAndReturn(f func() types.LayerID) *layerClockCurrentLayerCall {
	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) *layerClockLayerToTimeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LayerToTime", reflect.TypeOf((*MocklayerClock)(nil).LayerToTime), arg0)
	return &layerClockLayerToTimeCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *layerClockLayerToTimeCall) DoAndReturn(f func(types.LayerID) time.Time) *layerClockLayerToTimeCall {
	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, challenge *types.NIPostChallenge) (*types.NIPost, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildNIPost", ctx, challenge)
	ret0, _ := ret[0].(*types.NIPost)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

// UpdatePoETProvers mocks base method.
func (m *MocknipostBuilder) UpdatePoETProvers(arg0 []PoetProvingServiceClient) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdatePoETProvers", arg0)
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *nipostBuilderUpdatePoETProversCall) Do(f func([]PoetProvingServiceClient)) *nipostBuilderUpdatePoETProversCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *nipostBuilderUpdatePoETProversCall) DoAndReturn(f func([]PoetProvingServiceClient)) *nipostBuilderUpdatePoETProversCall {
	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() *syncerRegisterForATXSyncedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterForATXSynced", reflect.TypeOf((*Mocksyncer)(nil).RegisterForATXSynced))
	return &syncerRegisterForATXSyncedCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *syncerRegisterForATXSyncedCall) DoAndReturn(f func() chan struct{}) *syncerRegisterForATXSyncedCall {
	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) *atxProviderGetAtxHeaderCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAtxHeader", reflect.TypeOf((*MockatxProvider)(nil).GetAtxHeader), id)
	return &atxProviderGetAtxHeaderCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *atxProviderGetAtxHeaderCall) DoAndReturn(f func(types.ATXID) (*types.ActivationTxHeader, error)) *atxProviderGetAtxHeaderCall {
	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
}

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

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

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

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

// Do rewrite *gomock.Call.Do
func (c *postSetupProviderBenchmarkCall) Do(f func(PostSetupProvider) (int, error)) *postSetupProviderBenchmarkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *postSetupProviderBenchmarkCall) DoAndReturn(f func(PostSetupProvider) (int, error)) *postSetupProviderBenchmarkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

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

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

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

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

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

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

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

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

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

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

// GenerateProof mocks base method.
func (m *MockpostSetupProvider) GenerateProof(ctx context.Context, challenge []byte, options ...proving.OptionFunc) (*types.Post, *types.PostMetadata, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, challenge}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GenerateProof", varargs...)
	ret0, _ := ret[0].(*types.Post)
	ret1, _ := ret[1].(*types.PostMetadata)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GenerateProof indicates an expected call of GenerateProof.
func (mr *MockpostSetupProviderMockRecorder) GenerateProof(ctx, challenge any, options ...any) *postSetupProviderGenerateProofCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, challenge}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateProof", reflect.TypeOf((*MockpostSetupProvider)(nil).GenerateProof), varargs...)
	return &postSetupProviderGenerateProofCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Return rewrite *gomock.Call.Return
func (c *postSetupProviderProvidersCall) Return(arg0 []PostSetupProvider, arg1 error) *postSetupProviderProvidersCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *postSetupProviderProvidersCall) Do(f func() ([]PostSetupProvider, error)) *postSetupProviderProvidersCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *postSetupProviderProvidersCall) DoAndReturn(f func() ([]PostSetupProvider, error)) *postSetupProviderProvidersCall {
	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() *postSetupProviderResetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockpostSetupProvider)(nil).Reset))
	return &postSetupProviderResetCall{Call: call}
}

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

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

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

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

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

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *postSetupProviderStartSessionCall) DoAndReturn(f func(context.Context) error) *postSetupProviderStartSessionCall {
	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() *postSetupProviderStatusCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockpostSetupProvider)(nil).Status))
	return &postSetupProviderStatusCall{Call: call}
}

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

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

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

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

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

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

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

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

// Do rewrite *gomock.Call.Do
func (c *postSetupProviderVRFNonceCall) Do(f func() (*types.VRFPostIndex, error)) *postSetupProviderVRFNonceCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *postSetupProviderVRFNonceCall) DoAndReturn(f func() (*types.VRFPostIndex, error)) *postSetupProviderVRFNonceCall {
	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() *SmeshingProviderCoinbaseCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Coinbase", reflect.TypeOf((*MockSmeshingProvider)(nil).Coinbase))
	return &SmeshingProviderCoinbaseCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *SmeshingProviderCoinbaseCall) DoAndReturn(f func() types.Address) *SmeshingProviderCoinbaseCall {
	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) *SmeshingProviderSetCoinbaseCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCoinbase", reflect.TypeOf((*MockSmeshingProvider)(nil).SetCoinbase), coinbase)
	return &SmeshingProviderSetCoinbaseCall{Call: call}
}

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

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

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

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

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

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *SmeshingProviderSmesherIDCall) DoAndReturn(f func() types.NodeID) *SmeshingProviderSmesherIDCall {
	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() *SmeshingProviderSmeshingCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Smeshing", reflect.TypeOf((*MockSmeshingProvider)(nil).Smeshing))
	return &SmeshingProviderSmeshingCall{Call: call}
}

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

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

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

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

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

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *SmeshingProviderStartSmeshingCall) DoAndReturn(f func(types.Address, PostSetupOpts) error) *SmeshingProviderStartSmeshingCall {
	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) *SmeshingProviderStopSmeshingCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopSmeshing", reflect.TypeOf((*MockSmeshingProvider)(nil).StopSmeshing), arg0)
	return &SmeshingProviderStopSmeshingCall{Call: call}
}

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

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

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

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

// UpdatePoETServers mocks base method.
func (m *MockSmeshingProvider) UpdatePoETServers(ctx context.Context, endpoints []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePoETServers", ctx, endpoints)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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