protocol

type AttestedReportMany[RI any] struct {
	ReportWithInfo       ocr3types.ReportWithInfo[RI]
	AttributedSignatures []types.AttributedOnchainSignature
}

type AttributedCommitSignature struct {
	Signature CommitSignature
	Signer    commontypes.OracleID
}

type AttributedPrepareSignature struct {
	Signature PrepareSignature
	Signer    commontypes.OracleID
}

type AttributedSignedHighestCertifiedTimestamp struct {
	SignedHighestCertifiedTimestamp SignedHighestCertifiedTimestamp
	Signer                          commontypes.OracleID
}

type AttributedSignedObservation struct {
	SignedObservation SignedObservation
	Observer          commontypes.OracleID
}

type CertifiedCommit struct {
	CommitEpoch             uint64
	SeqNr                   uint64
	Outcome                 ocr3types.Outcome
	CommitQuorumCertificate []AttributedCommitSignature
}

type CertifiedPrepare struct {
	PrepareEpoch             uint64
	SeqNr                    uint64
	OutcomeInputsDigest      OutcomeInputsDigest
	Outcome                  ocr3types.Outcome
	PrepareQuorumCertificate []AttributedPrepareSignature
}

type CertifiedPrepareOrCommit interface {
	Epoch() uint64
	Timestamp() HighestCertifiedTimestamp
	IsGenesis() bool
	Verify(
		_ types.ConfigDigest,
		_ []config.OracleIdentity,
		byzQuorumSize int,
	) error
	CheckSize(n int, f int, limits ocr3types.ReportingPluginLimits, maxReportSigLen int) bool
	// contains filtered or unexported methods
}

type CommitSignature []byte

type Database interface {
	types.ConfigDatabase

	ReadPacemakerState(ctx context.Context, configDigest types.ConfigDigest) (PacemakerState, error)
	WritePacemakerState(ctx context.Context, configDigest types.ConfigDigest, state PacemakerState) error

	ReadCert(ctx context.Context, configDigest types.ConfigDigest) (CertifiedPrepareOrCommit, error)
	WriteCert(ctx context.Context, configDigest types.ConfigDigest, cert CertifiedPrepareOrCommit) error
}

type EpochStartProof struct {
	HighestCertified      CertifiedPrepareOrCommit
	HighestCertifiedProof []AttributedSignedHighestCertifiedTimestamp
}

type EventAttestedReport[RI any] struct {
	SeqNr          uint64
	Index          int
	AttestedReport AttestedReportMany[RI]
}

type EventCommittedOutcome[RI any] struct {
	CertifiedCommit CertifiedCommit
}

type EventMissingOutcome[RI any] struct {
	SeqNr uint64
}

type EventNewEpochRequest[RI any] struct{}

type EventNewEpochStart[RI any] struct {
	Epoch uint64
}

type EventProgress[RI any] struct{}

type EventToOutcomeGeneration[RI any] interface {
	// contains filtered or unexported methods
}

type EventToPacemaker[RI any] interface {
	// contains filtered or unexported methods
}

type EventToReportAttestation[RI any] interface {
	// contains filtered or unexported methods
}

type EventToTransmission[RI any] interface {
	// contains filtered or unexported methods
}

type HighestCertifiedTimestamp struct {
	SeqNr                 uint64
	CommittedElsePrepared bool
}

type Message[RI any] interface {
	// CheckSize checks whether the given message conforms to the limits imposed by
	// reportingPluginLimits
	CheckSize(n int, f int, limits ocr3types.ReportingPluginLimits, maxReportSigLen int) bool
	// contains filtered or unexported methods
}

type MessageBuffer[RI any] ringbuffer.RingBuffer[MessageToOutcomeGeneration[RI]]

type MessageCertifiedCommit[RI any] struct {
	CertifiedCommit CertifiedCommit
}

type MessageCertifiedCommitRequest[RI any] struct {
	SeqNr uint64
}

type MessageCommit[RI any] struct {
	Epoch     uint64
	SeqNr     uint64
	Signature CommitSignature
}

type MessageEpochStart[RI any] struct {
	Epoch           uint64
	EpochStartProof EpochStartProof
}

type MessageEpochStartRequest[RI any] struct {
	Epoch                           uint64
	HighestCertified                CertifiedPrepareOrCommit
	SignedHighestCertifiedTimestamp SignedHighestCertifiedTimestamp
}

type MessageNewEpochWish[RI any] struct {
	Epoch uint64
}

type MessageObservation[RI any] struct {
	Epoch             uint64
	SeqNr             uint64
	SignedObservation SignedObservation
}

type MessagePrepare[RI any] struct {
	Epoch     uint64
	SeqNr     uint64
	Signature PrepareSignature
}

type MessageProposal[RI any] struct {
	Epoch                        uint64
	SeqNr                        uint64
	AttributedSignedObservations []AttributedSignedObservation
}

type MessageReportSignatures[RI any] struct {
	SeqNr            uint64
	ReportSignatures [][]byte
}

type MessageRoundStart[RI any] struct {
	Epoch uint64
	SeqNr uint64
	Query types.Query
}

type MessageToOutcomeGeneration[RI any] interface {
	Message[RI]
	// contains filtered or unexported methods
}

type MessageToOutcomeGenerationWithSender[RI any] struct {
	// contains filtered or unexported fields
}

type MessageToPacemaker[RI any] interface {
	Message[RI]
	// contains filtered or unexported methods
}

type MessageToPacemakerWithSender[RI any] struct {
	// contains filtered or unexported fields
}

type MessageToReportAttestation[RI any] interface {
	Message[RI]
	// contains filtered or unexported methods
}

type MessageToReportAttestationWithSender[RI any] struct {
	// contains filtered or unexported fields
}

type MessageWithSender[RI any] struct {
	Msg    Message[RI]
	Sender commontypes.OracleID
}

type NetworkEndpoint[RI any] interface {
	NetworkSender[RI]
	// Receive returns channel which carries all messages sent to this oracle
	Receive() <-chan MessageWithSender[RI]

	// Start must be called before Receive. Calling Start more than once causes
	// panic.
	Start() error

	// Close must be called before receive. Close can be called multiple times.
	// Close can be called even on an unstarted NetworkEndpoint.
	Close() error
}

type NetworkSender[RI any] interface {
	// SendTo(msg, to) sends msg to "to"
	SendTo(msg Message[RI], to commontypes.OracleID)
	// Broadcast(msg) sends msg to all oracles
	Broadcast(msg Message[RI])
}

type OutcomeDigest [32]byte

type OutcomeGenerationID struct {
	ConfigDigest types.ConfigDigest
	Epoch        uint64
}

type OutcomeInputsDigest [32]byte

type PacemakerState struct {
	Epoch                   uint64
	HighestSentNewEpochWish uint64
}

type PrepareSignature []byte

type SignedHighestCertifiedTimestamp struct {
	HighestCertifiedTimestamp HighestCertifiedTimestamp
	Signature                 []byte
}

type SignedObservation struct {
	Observation types.Observation
	Signature   []byte
}

type SimpleNetwork[RI any] struct {
	// contains filtered or unexported fields
}

type SimpleNetworkEndpoint[RI any] struct {
	// contains filtered or unexported fields
}

type TelemetrySender interface {
	RoundStarted(
		configDigest types.ConfigDigest,
		epoch uint64,
		seqNr uint64,
		round uint64,
		leader commontypes.OracleID,
	)
}