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"
	url "net/url"
	reflect "reflect"
	time "time"

	wire "github.com/spacemeshos/go-spacemesh/activation/wire"
	types "github.com/spacemeshos/go-spacemesh/common/types"
	signing "github.com/spacemeshos/go-spacemesh/signing"
	certifier "github.com/spacemeshos/go-spacemesh/sql/localsql/certifier"
	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.ActivationTx) {
	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.ActivationTx)) *MockAtxReceiverOnAtxCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAtxReceiverOnAtxCall) DoAndReturn(f func(*types.ActivationTx)) *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
}

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

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

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

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

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

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

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

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MocknipostValidatorNIPostChallengeV1Call) Do(f func(*wire.NIPostChallengeV1, *types.ActivationTx, types.NodeID) error) *MocknipostValidatorNIPostChallengeV1Call {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostValidatorNIPostChallengeV1Call) DoAndReturn(f func(*wire.NIPostChallengeV1, *types.ActivationTx, types.NodeID) error) *MocknipostValidatorNIPostChallengeV1Call {
	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
}

// PoetMembership mocks base method.
func (m *MocknipostValidator) PoetMembership(ctx context.Context, membership *types.MultiMerkleProof, postChallenge types.Hash32, poetChallenges [][]byte) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PoetMembership", ctx, membership, postChallenge, poetChallenges)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PoetMembership indicates an expected call of PoetMembership.
func (mr *MocknipostValidatorMockRecorder) PoetMembership(ctx, membership, postChallenge, poetChallenges any) *MocknipostValidatorPoetMembershipCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PoetMembership", reflect.TypeOf((*MocknipostValidator)(nil).PoetMembership), ctx, membership, postChallenge, poetChallenges)
	return &MocknipostValidatorPoetMembershipCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MocknipostValidatorPoetMembershipCall) Do(f func(context.Context, *types.MultiMerkleProof, types.Hash32, [][]byte) (uint64, error)) *MocknipostValidatorPoetMembershipCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostValidatorPoetMembershipCall) DoAndReturn(f func(context.Context, *types.MultiMerkleProof, types.Hash32, [][]byte) (uint64, error)) *MocknipostValidatorPoetMembershipCall {
	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, metadata *types.PostMetadata, numUnits uint32, opts ...validatorOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, nodeId, commitmentAtxId, post, metadata, 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, metadata, numUnits any, opts ...any) *MocknipostValidatorPostCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, nodeId, commitmentAtxId, post, metadata, 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
}

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

// PostV2 indicates an expected call of PostV2.
func (mr *MocknipostValidatorMockRecorder) PostV2(ctx, smesherID, commitment, post, challenge, numUnits any, opts ...any) *MocknipostValidatorPostV2Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, smesherID, commitment, post, challenge, numUnits}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostV2", reflect.TypeOf((*MocknipostValidator)(nil).PostV2), varargs...)
	return &MocknipostValidatorPostV2Call{Call: call}
}

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

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

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

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

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

// VRFNonce indicates an expected call of VRFNonce.
func (mr *MocknipostValidatorMockRecorder) VRFNonce(nodeId, commitmentAtxId, vrfNonce, labelsPerUnit, numUnits any) *MocknipostValidatorVRFNonceCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VRFNonce", reflect.TypeOf((*MocknipostValidator)(nil).VRFNonce), nodeId, commitmentAtxId, vrfNonce, labelsPerUnit, 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, uint64, uint64, 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, uint64, uint64, uint32) error) *MocknipostValidatorVRFNonceCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// VRFNonceV2 mocks base method.
func (m *MocknipostValidator) VRFNonceV2(smesherID types.NodeID, commitment types.ATXID, vrfNonce uint64, numUnits uint32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VRFNonceV2", smesherID, commitment, vrfNonce, numUnits)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MocknipostValidatorVRFNonceV2Call) DoAndReturn(f func(types.NodeID, types.ATXID, uint64, uint32) error) *MocknipostValidatorVRFNonceV2Call {
	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, challengeHash types.Hash32, postChallenge *types.NIPostChallenge) (*nipost.NIPostState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildNIPost", ctx, sig, challengeHash, postChallenge)
	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, challengeHash, postChallenge any) *MocknipostBuilderBuildNIPostCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildNIPost", reflect.TypeOf((*MocknipostBuilder)(nil).BuildNIPost), ctx, sig, challengeHash, postChallenge)
	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.Hash32, *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.Hash32, *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, postChallenge *types.NIPostChallenge) (*types.Post, *types.PostInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Proof", ctx, nodeID, challenge, postChallenge)
	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, postChallenge any) *MocknipostBuilderProofCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Proof", reflect.TypeOf((*MocknipostBuilder)(nil).Proof), ctx, nodeID, challenge, postChallenge)
	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.NIPostChallenge) (*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.NIPostChallenge) (*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
}

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

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

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

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

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

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

// Certify mocks base method.
func (m *MockPoetClient) Certify(ctx context.Context, id types.NodeID) (*certifier.PoetCert, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Certify", ctx, id)
	ret0, _ := ret[0].(*certifier.PoetCert)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Certify indicates an expected call of Certify.
func (mr *MockPoetClientMockRecorder) Certify(ctx, id any) *MockPoetClientCertifyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Certify", reflect.TypeOf((*MockPoetClient)(nil).Certify), ctx, id)
	return &MockPoetClientCertifyCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockPoetClientCertifyCall) Return(arg0 *certifier.PoetCert, arg1 error) *MockPoetClientCertifyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// Proof mocks base method.
func (m *MockPoetClient) Proof(ctx context.Context, roundID string) (*types.PoetProof, []types.Hash32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Proof", ctx, roundID)
	ret0, _ := ret[0].(*types.PoetProof)
	ret1, _ := ret[1].([]types.Hash32)
	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.PoetProof, arg1 []types.Hash32, 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.PoetProof, []types.Hash32, 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.PoetProof, []types.Hash32, 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) (*types.PoetRound, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Submit", ctx, deadline, prefix, challenge, signature, nodeID)
	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 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)
	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) (*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) (*types.PoetRound, error)) *MockPoetClientSubmitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockcertifierClient is a mock of certifierClient interface.
type MockcertifierClient struct {
	ctrl     *gomock.Controller
	recorder *MockcertifierClientMockRecorder
}

// MockcertifierClientMockRecorder is the mock recorder for MockcertifierClient.
type MockcertifierClientMockRecorder struct {
	mock *MockcertifierClient
}

// NewMockcertifierClient creates a new mock instance.
func NewMockcertifierClient(ctrl *gomock.Controller) *MockcertifierClient {
	mock := &MockcertifierClient{ctrl: ctrl}
	mock.recorder = &MockcertifierClientMockRecorder{mock}
	return mock
}

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

// Certify mocks base method.
func (m *MockcertifierClient) Certify(ctx context.Context, id types.NodeID, certifierAddress *url.URL, pubkey []byte) (*certifier.PoetCert, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Certify", ctx, id, certifierAddress, pubkey)
	ret0, _ := ret[0].(*certifier.PoetCert)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Certify indicates an expected call of Certify.
func (mr *MockcertifierClientMockRecorder) Certify(ctx, id, certifierAddress, pubkey any) *MockcertifierClientCertifyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Certify", reflect.TypeOf((*MockcertifierClient)(nil).Certify), ctx, id, certifierAddress, pubkey)
	return &MockcertifierClientCertifyCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockcertifierClientCertifyCall) Return(arg0 *certifier.PoetCert, arg1 error) *MockcertifierClientCertifyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockcertifierClientCertifyCall) Do(f func(context.Context, types.NodeID, *url.URL, []byte) (*certifier.PoetCert, error)) *MockcertifierClientCertifyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockcertifierClientCertifyCall) DoAndReturn(f func(context.Context, types.NodeID, *url.URL, []byte) (*certifier.PoetCert, error)) *MockcertifierClientCertifyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockcertifierService is a mock of certifierService interface.
type MockcertifierService struct {
	ctrl     *gomock.Controller
	recorder *MockcertifierServiceMockRecorder
}

// MockcertifierServiceMockRecorder is the mock recorder for MockcertifierService.
type MockcertifierServiceMockRecorder struct {
	mock *MockcertifierService
}

// NewMockcertifierService creates a new mock instance.
func NewMockcertifierService(ctrl *gomock.Controller) *MockcertifierService {
	mock := &MockcertifierService{ctrl: ctrl}
	mock.recorder = &MockcertifierServiceMockRecorder{mock}
	return mock
}

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

// Certificate mocks base method.
func (m *MockcertifierService) Certificate(ctx context.Context, id types.NodeID, certifierAddress *url.URL, pubkey []byte) (*certifier.PoetCert, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Certificate", ctx, id, certifierAddress, pubkey)
	ret0, _ := ret[0].(*certifier.PoetCert)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Certificate indicates an expected call of Certificate.
func (mr *MockcertifierServiceMockRecorder) Certificate(ctx, id, certifierAddress, pubkey any) *MockcertifierServiceCertificateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Certificate", reflect.TypeOf((*MockcertifierService)(nil).Certificate), ctx, id, certifierAddress, pubkey)
	return &MockcertifierServiceCertificateCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockcertifierServiceCertificateCall) Return(arg0 *certifier.PoetCert, arg1 error) *MockcertifierServiceCertificateCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockcertifierServiceCertificateCall) Do(f func(context.Context, types.NodeID, *url.URL, []byte) (*certifier.PoetCert, error)) *MockcertifierServiceCertificateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockcertifierServiceCertificateCall) DoAndReturn(f func(context.Context, types.NodeID, *url.URL, []byte) (*certifier.PoetCert, error)) *MockcertifierServiceCertificateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Recertify mocks base method.
func (m *MockcertifierService) Recertify(ctx context.Context, id types.NodeID, certifierAddress *url.URL, pubkey []byte) (*certifier.PoetCert, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recertify", ctx, id, certifierAddress, pubkey)
	ret0, _ := ret[0].(*certifier.PoetCert)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recertify indicates an expected call of Recertify.
func (mr *MockcertifierServiceMockRecorder) Recertify(ctx, id, certifierAddress, pubkey any) *MockcertifierServiceRecertifyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recertify", reflect.TypeOf((*MockcertifierService)(nil).Recertify), ctx, id, certifierAddress, pubkey)
	return &MockcertifierServiceRecertifyCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockcertifierServiceRecertifyCall) Return(arg0 *certifier.PoetCert, arg1 error) *MockcertifierServiceRecertifyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockcertifierServiceRecertifyCall) Do(f func(context.Context, types.NodeID, *url.URL, []byte) (*certifier.PoetCert, error)) *MockcertifierServiceRecertifyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockcertifierServiceRecertifyCall) DoAndReturn(f func(context.Context, types.NodeID, *url.URL, []byte) (*certifier.PoetCert, error)) *MockcertifierServiceRecertifyCall {
	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
}

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

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

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

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

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

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

// ProofForRound mocks base method.
func (m *MockpoetDbAPI) ProofForRound(poetID []byte, roundID string) (*types.PoetProof, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProofForRound", poetID, roundID)
	ret0, _ := ret[0].(*types.PoetProof)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockpoetDbAPIProofForRoundCall) Do(f func([]byte, string) (*types.PoetProof, error)) *MockpoetDbAPIProofForRoundCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockpoetDbAPIProofForRoundCall) DoAndReturn(f func([]byte, string) (*types.PoetProof, error)) *MockpoetDbAPIProofForRoundCall {
	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
}

// MockAtxBuilder is a mock of AtxBuilder interface.
type MockAtxBuilder struct {
	ctrl     *gomock.Controller
	recorder *MockAtxBuilderMockRecorder
}

// MockAtxBuilderMockRecorder is the mock recorder for MockAtxBuilder.
type MockAtxBuilderMockRecorder struct {
	mock *MockAtxBuilder
}

// NewMockAtxBuilder creates a new mock instance.
func NewMockAtxBuilder(ctrl *gomock.Controller) *MockAtxBuilder {
	mock := &MockAtxBuilder{ctrl: ctrl}
	mock.recorder = &MockAtxBuilderMockRecorder{mock}
	return mock
}

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

// Register mocks base method.
func (m *MockAtxBuilder) Register(sig *signing.EdSigner) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Register", sig)
}

// Register indicates an expected call of Register.
func (mr *MockAtxBuilderMockRecorder) Register(sig any) *MockAtxBuilderRegisterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Register", reflect.TypeOf((*MockAtxBuilder)(nil).Register), sig)
	return &MockAtxBuilderRegisterCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockAtxBuilderRegisterCall) Do(f func(*signing.EdSigner)) *MockAtxBuilderRegisterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAtxBuilderRegisterCall) DoAndReturn(f func(*signing.EdSigner)) *MockAtxBuilderRegisterCall {
	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
}

// MockPostStates is a mock of PostStates interface.
type MockPostStates struct {
	ctrl     *gomock.Controller
	recorder *MockPostStatesMockRecorder
}

// MockPostStatesMockRecorder is the mock recorder for MockPostStates.
type MockPostStatesMockRecorder struct {
	mock *MockPostStates
}

// NewMockPostStates creates a new mock instance.
func NewMockPostStates(ctrl *gomock.Controller) *MockPostStates {
	mock := &MockPostStates{ctrl: ctrl}
	mock.recorder = &MockPostStatesMockRecorder{mock}
	return mock
}

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

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

// Get indicates an expected call of Get.
func (mr *MockPostStatesMockRecorder) Get() *MockPostStatesGetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPostStates)(nil).Get))
	return &MockPostStatesGetCall{Call: call}
}

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

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

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

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

// Set mocks base method.
func (m *MockPostStates) Set(id types.NodeID, state types.PostState) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Set", id, state)
}

// Set indicates an expected call of Set.
func (mr *MockPostStatesMockRecorder) Set(id, state any) *MockPostStatesSetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockPostStates)(nil).Set), id, state)
	return &MockPostStatesSetCall{Call: call}
}

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

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

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

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPostStatesSetCall) DoAndReturn(f func(types.NodeID, types.PostState)) *MockPostStatesSetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}