gossiptopics

type BenchmarkConsensus interface {
	BroadcastBenchmarkConsensusCommit(ctx context.Context, input *BenchmarkConsensusCommitInput) (*EmptyOutput, error)
	SendBenchmarkConsensusCommitted(ctx context.Context, input *BenchmarkConsensusCommittedInput) (*EmptyOutput, error)
	RegisterBenchmarkConsensusHandler(handler BenchmarkConsensusHandler)
}

type BenchmarkConsensusCommitInput struct {
	Message *gossipmessages.BenchmarkConsensusCommitMessage
}

type BenchmarkConsensusCommittedInput struct {
	RecipientNodeAddress primitives.NodeAddress
	Message              *gossipmessages.BenchmarkConsensusCommittedMessage
}

type BenchmarkConsensusHandler interface {
	HandleBenchmarkConsensusCommit(ctx context.Context, input *BenchmarkConsensusCommitInput) (*EmptyOutput, error)
	HandleBenchmarkConsensusCommitted(ctx context.Context, input *BenchmarkConsensusCommittedInput) (*EmptyOutput, error)
}

type BlockAvailabilityRequestInput struct {
	Message *gossipmessages.BlockAvailabilityRequestMessage
}

type BlockAvailabilityResponseInput struct {
	RecipientNodeAddress primitives.NodeAddress
	Message              *gossipmessages.BlockAvailabilityResponseMessage
}

type BlockSync interface {
	BroadcastBlockAvailabilityRequest(ctx context.Context, input *BlockAvailabilityRequestInput) (*EmptyOutput, error)
	SendBlockAvailabilityResponse(ctx context.Context, input *BlockAvailabilityResponseInput) (*EmptyOutput, error)
	SendBlockSyncRequest(ctx context.Context, input *BlockSyncRequestInput) (*EmptyOutput, error)
	SendBlockSyncResponse(ctx context.Context, input *BlockSyncResponseInput) (*EmptyOutput, error)
	RegisterBlockSyncHandler(handler BlockSyncHandler)
}

type BlockSyncHandler interface {
	HandleBlockAvailabilityRequest(ctx context.Context, input *BlockAvailabilityRequestInput) (*EmptyOutput, error)
	HandleBlockAvailabilityResponse(ctx context.Context, input *BlockAvailabilityResponseInput) (*EmptyOutput, error)
	HandleBlockSyncRequest(ctx context.Context, input *BlockSyncRequestInput) (*EmptyOutput, error)
	HandleBlockSyncResponse(ctx context.Context, input *BlockSyncResponseInput) (*EmptyOutput, error)
}

type BlockSyncRequestInput struct {
	RecipientNodeAddress primitives.NodeAddress
	Message              *gossipmessages.BlockSyncRequestMessage
}

type BlockSyncResponseInput struct {
	RecipientNodeAddress primitives.NodeAddress
	Message              *gossipmessages.BlockSyncResponseMessage
}

type EmptyOutput struct {
}

type ForwardedTransactionsInput struct {
	Message *gossipmessages.ForwardedTransactionsMessage
}

type LeanHelix interface {
	SendLeanHelixMessage(ctx context.Context, input *LeanHelixInput) (*EmptyOutput, error)
	RegisterLeanHelixHandler(handler LeanHelixHandler)
}

type LeanHelixHandler interface {
	HandleLeanHelixMessage(ctx context.Context, input *LeanHelixInput) (*EmptyOutput, error)
}

type LeanHelixInput struct {
	RecipientsList *RecipientsList
	Message        *gossipmessages.LeanHelixMessage
}

type MockBenchmarkConsensus struct {
	mock.Mock
}

type MockBenchmarkConsensusHandler struct {
	mock.Mock
}

type MockBlockSync struct {
	mock.Mock
}

type MockBlockSyncHandler struct {
	mock.Mock
}

type MockLeanHelix struct {
	mock.Mock
}

type MockLeanHelixHandler struct {
	mock.Mock
}

type MockTransactionRelay struct {
	mock.Mock
}

type MockTransactionRelayHandler struct {
	mock.Mock
}

type RecipientsList struct {
	RecipientNodeAddresses []primitives.NodeAddress
	RecipientMode          gossipmessages.RecipientsListMode
}

type TransactionRelay interface {
	BroadcastForwardedTransactions(ctx context.Context, input *ForwardedTransactionsInput) (*EmptyOutput, error)
	RegisterTransactionRelayHandler(handler TransactionRelayHandler)
}

type TransactionRelayHandler interface {
	HandleForwardedTransactions(ctx context.Context, input *ForwardedTransactionsInput) (*EmptyOutput, error)
}