protocol

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

type AttestedStateTransitionBlock struct {
	StateTransitionBlock       StateTransitionBlock
	AttributedCommitSignatures []AttributedCommitSignature
}

type AttributedBlobAvailabilitySignature = blobtypes.AttributedBlobAvailabilitySignature

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 BlobAvailabilitySignature = blobtypes.BlobAvailabilitySignature

type BlobChunkDigest = blobtypes.BlobChunkDigest

type BlobDigest = blobtypes.BlobDigest

type BlobEndpoint struct {
	// contains filtered or unexported fields
}

type BlobEndpointWrapper struct {
	// contains filtered or unexported fields
}

type BlobMeta struct {
	PayloadLength uint64
	ChunksHave    []bool
	ExpirySeqNr   uint64
}

type CertifiedCommit struct {
	CommitEpoch                 uint64
	CommitSeqNr                 uint64
	StateTransitionInputsDigest StateTransitionInputsDigest
	StateTransitionOutputs      StateTransitionOutputs
	StateRootDigest             StateRootDigest
	ReportsPlusPrecursor        ocr3_1types.ReportsPlusPrecursor
	CommitQuorumCertificate     []AttributedCommitSignature
}

type CertifiedCommittedReports[RI any] struct {
	CommitEpoch                 uint64
	SeqNr                       uint64
	StateTransitionInputsDigest StateTransitionInputsDigest
	StateTransitionOutputDigest StateTransitionOutputDigest
	StateRootDigest             StateRootDigest
	ReportsPlusPrecursor        ocr3_1types.ReportsPlusPrecursor
	CommitQuorumCertificate     []AttributedCommitSignature
}

type CertifiedPrepare struct {
	PrepareEpoch                uint64
	PrepareSeqNr                uint64
	StateTransitionInputsDigest StateTransitionInputsDigest
	StateTransitionOutputs      StateTransitionOutputs
	StateRootDigest             StateRootDigest
	ReportsPlusPrecursor        ocr3_1types.ReportsPlusPrecursor
	PrepareQuorumCertificate    []AttributedPrepareSignature
}

type CertifiedPrepareOrCommit interface {
	Epoch() uint64
	SeqNr() uint64
	Timestamp() HighestCertifiedTimestamp
	IsGenesis() bool
	Verify(
		_ types.ConfigDigest,
		_ []config.OracleIdentity,
		byzQuorumSize int,
	) error
	CheckSize(n int, f int, limits ocr3_1types.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]
	TransmissionScheduleOverride *ocr3types.TransmissionSchedule
}

type EventBlobBroadcastGraceTimeout[RI any] struct {
	BlobDigest BlobDigest
}

type EventBlobBroadcastRequestDone[RI any] struct {
	BlobDigest BlobDigest
}

type EventBlobBroadcastRequestRespond[RI any] struct {
	BlobDigest BlobDigest
	Request    blobBroadcastRequest
}

type EventBlobFetchRequestDone[RI any] struct {
	BlobDigest BlobDigest
}

type EventBlobFetchRequestRespond[RI any] struct {
	BlobDigest BlobDigest
	Request    blobFetchRequest
}

type EventCertifiedCommit[RI any] struct {
	CertifiedCommittedReports CertifiedCommittedReports[RI]
}

type EventComputedCommitted[RI any] struct {
	Epoch uint64
	SeqNr uint64
}

type EventComputedObservation[RI any] struct {
	Epoch           uint64
	SeqNr           uint64
	AttributedQuery types.AttributedQuery
	Observation     types.Observation
}

type EventComputedObservationQuorumSuccess[RI any] struct {
	Epoch uint64
	SeqNr uint64
}

type EventComputedProposalStateTransition[RI any] struct {
	Epoch                                uint64
	SeqNr                                uint64
	KeyValueDatabaseReadWriteTransaction KeyValueDatabaseReadWriteTransaction
	// contains filtered or unexported fields
}

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

type EventComputedReports[RI any] struct {
	SeqNr       uint64
	ReportsPlus []ocr3types.ReportPlus[RI]
}

type EventComputedValidateVerifyObservation[RI any] struct {
	Epoch  uint64
	SeqNr  uint64
	Sender commontypes.OracleID
}

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 EventStateSyncRequest[RI any] struct {
	SeqNr uint64
}

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

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 EventToStateSync[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
	Epoch                 uint64
}

type KeyDigestRange struct {
	StartIndex   jmt.Digest
	EndInclIndex jmt.Digest
}

type KeyValueDatabase interface {
	// Must error if the key value store is not ready to apply state transition
	// for the given sequence number. Must update the highest committed sequence
	// number magic key upon commit. Convenience method for synchronization
	// between outcome generation & state sync.
	NewSerializedReadWriteTransaction(postSeqNr uint64) (KeyValueDatabaseReadWriteTransaction, error)
	// Must error if the key value store is not ready to apply state transition
	// for the given sequence number. Convenience method for synchronization
	// between outcome generation & state sync.
	NewReadTransaction(postSeqNr uint64) (KeyValueDatabaseReadTransaction, error)

	// Unchecked transactions are useful when you don't care that the
	// transaction state represents the kv state as of some particular sequence
	// number, mostly when writing auxiliary data to the kv store. Unchecked
	// transactions do not update the highest committed sequence number magic
	// key upon commit, as would checked transactions.
	NewSerializedReadWriteTransactionUnchecked() (KeyValueDatabaseReadWriteTransaction, error)
	// Unserialized transactions are guaranteed to commit.
	// The protocol should make sure that there are no conflicts across potentially concurrent unserialized transactions,
	// and if two unserialized transactions could actually have conflicts the protocol ensures that the are
	// never opened concurrently.
	NewUnserializedReadWriteTransactionUnchecked() (KeyValueDatabaseReadWriteTransaction, error)
	// Unchecked transactions are useful when you don't care that the
	// transaction state represents the kv state as of some particular sequence
	// number, mostly when reading auxiliary data from the kv store.
	NewReadTransactionUnchecked() (KeyValueDatabaseReadTransaction, error)

	// Deprecated: Kept for convenience/small diff, consider using
	// [KeyValueDatabaseSemanticRead.ReadHighestCommittedSeqNr] instead.
	HighestCommittedSeqNr() (uint64, error)
	Close() error
}

type KeyValueDatabaseFactory interface {
	NewKeyValueDatabase(configDigest types.ConfigDigest) (KeyValueDatabase, error)
}

type KeyValueDatabaseReadTransaction interface {
	// The only read part of the interface that the plugin might see. The rest
	// of the methods might only be called by protocol code.
	ocr3_1types.KeyValueStateReader
	KeyValueDatabaseSemanticRead
	Discard()
}

type KeyValueDatabaseReadWriteTransaction interface {
	KeyValueDatabaseReadTransaction
	// The only write part of the interface that the plugin might see. The rest
	// of the methods might only be called by protocol code.
	ocr3_1types.KeyValueStateReadWriter
	KeyValueDatabaseSemanticWrite
	// Commit writes the new highest committed sequence number to the magic key
	// (if the transaction is _not_ unchecked) and commits the transaction to
	// the key value store, then discards the transaction.
	Commit() error
}

type KeyValueDatabaseSemanticRead interface {
	// ReadHighestCommittedSeqNr returns the sequence number of which the state the transaction
	// represents. Really read from the database here, no cached values allowed.
	ReadHighestCommittedSeqNr() (uint64, error)
	ReadLowestPersistedSeqNr() (uint64, error)

	ReadAttestedStateTransitionBlock(seqNr uint64) (AttestedStateTransitionBlock, error)
	ReadAttestedStateTransitionBlocks(minSeqNr uint64, maxItems int) (blocks []AttestedStateTransitionBlock, more bool, err error)

	ReadTreeSyncStatus() (TreeSyncStatus, error)
	// ReadTreeSyncChunk retrieves a chunk of undigested key-value pairs in the
	// range [startIndex, requestEndInclIndex] of the key digest space. It
	// returns a maximally sized chunk that fully covers the range [startIndex,
	// endInclIndex], where endInclIndex <= requestEndInclIndex, such that the
	// chunk respects the protocol.MaxTreeSyncChunkKeys and
	// protocol.MaxTreeSyncChunkKeysPlusValuesLength limits. It also includes in
	// boundingLeaves the subrange proof, proving inclusion of key-values in the
	// range [startIndex, endInclIndex] without omissions.
	ReadTreeSyncChunk(
		toSeqNr uint64,
		startIndex jmt.Digest,
		requestEndInclIndex jmt.Digest,
	) (
		endInclIndex jmt.Digest,
		boundingLeaves []jmt.BoundingLeaf,
		keyValues []KeyValuePair,
		err error,
	)
	// ReadBlobPayload returns the payload of the blob if it exists in full and
	// the blob has not expired. If the blob existed at some point but has since
	// expired, it returns an error. If the blob never existed, it returns nil.
	// If only some chunks are present, it returns an error.
	ReadBlobPayload(BlobDigest) ([]byte, error)
	ReadBlobMeta(BlobDigest) (*BlobMeta, error)
	ReadBlobChunk(BlobDigest, uint64) ([]byte, error)
	ReadStaleBlobIndex(maxStaleSinceSeqNr uint64, limit int) ([]StaleBlob, error)

	jmt.RootReader
	jmt.NodeReader
}

type KeyValueDatabaseSemanticWrite interface {
	// GetWriteSet returns a slice the KeyValuePair entries that
	// have been written in this transaction. If the value of a key has been
	// deleted, it the value is mapped to nil.
	GetWriteSet() ([]KeyValuePairWithDeletions, error)

	// CloseWriteSet returns the state root, writes it to the KV store
	// and closes the transaction for writing: any future attempts for Writes or Deletes
	// on this transaction will fail.
	CloseWriteSet() (StateRootDigest, error)

	// ApplyWriteSet applies the write set to the transaction and returns the
	// state root digest. Useful for reproposals and state synchronization. Only
	// works on checked transactions where the postSeqNr is specified at
	// creation.
	ApplyWriteSet(writeSet []KeyValuePairWithDeletions) (StateRootDigest, error)

	WriteAttestedStateTransitionBlock(seqNr uint64, block AttestedStateTransitionBlock) error
	DeleteAttestedStateTransitionBlocks(maxSeqNrToDelete uint64, maxItems int) (done bool, err error)

	// WriteHighestCommittedSeqNr writes the given sequence number to the magic
	// key. It is called before Commit on checked transactions.
	WriteHighestCommittedSeqNr(seqNr uint64) error
	WriteLowestPersistedSeqNr(seqNr uint64) error
	// VerifyAndWriteTreeSyncChunk first verifies that the keyValues are fully
	// and without omissions included in the key digest range of [startIndex,
	// endInclIndex]. Only after doing so, it writes all keyValues into the tree
	// and flat representation.
	VerifyAndWriteTreeSyncChunk(
		targetRootDigest StateRootDigest,
		targetSeqNr uint64,
		startIndex jmt.Digest,
		endInclIndex jmt.Digest,
		boundingLeaves []jmt.BoundingLeaf,
		keyValues []KeyValuePair,
	) (VerifyAndWriteTreeSyncChunkResult, error)

	WriteTreeSyncStatus(state TreeSyncStatus) error
	WriteBlobMeta(BlobDigest, BlobMeta) error
	DeleteBlobMeta(BlobDigest) error
	WriteBlobChunk(BlobDigest, uint64, []byte) error
	DeleteBlobChunk(BlobDigest, uint64) error
	WriteStaleBlobIndex(StaleBlob) error
	DeleteStaleBlobIndex(StaleBlob) error

	jmt.RootWriter
	DeleteRoots(minVersionToKeep jmt.Version, maxItems int) (done bool, err error)

	jmt.NodeWriter
	jmt.StaleNodeWriter
	DeleteStaleNodes(maxStaleSinceVersion jmt.Version, maxItems int) (done bool, err error)

	DestructiveDestroyForTreeSync(n int) (done bool, err error)
}

type KeyValuePair = jmt.KeyValue

type KeyValuePairWithDeletions struct {
	Key     []byte
	Value   []byte
	Deleted bool
}

type LightCertifiedBlob = blobtypes.LightCertifiedBlob

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

type MessageBlobChunkRequest[RI any] struct {
	RequestHandle types.RequestHandle // actual handle for outbound message, sentinel for inbound

	RequestInfo *MessageBlobChunkRequestInfo

	BlobDigest BlobDigest
	ChunkIndex uint64
}

type MessageBlobChunkRequestInfo struct {
	ExpiryTimestamp time.Time
}

type MessageBlobChunkResponse[RI any] struct {
	RequestHandle types.RequestHandle // actual handle for outbound message, sentinel for inbound

	BlobDigest BlobDigest
	ChunkIndex uint64
	GoAway     bool
	Chunk      []byte
}

type MessageBlobOffer[RI any] struct {
	RequestHandle types.RequestHandle // actual handle for outbound message, sentinel for inbound
	RequestInfo   *MessageBlobOfferRequestInfo
	ChunkDigests  []BlobChunkDigest
	PayloadLength uint64
	ExpirySeqNr   uint64
}

type MessageBlobOfferRequestInfo struct {
	ExpiryTimestamp time.Time
}

type MessageBlobOfferResponse[RI any] struct {
	RequestHandle types.RequestHandle // actual handle for outbound message, sentinel for inbound
	BlobDigest    BlobDigest
	RejectOffer   bool
	Signature     BlobAvailabilitySignature
}

type MessageBlockSyncRequest[RI any] struct {
	RequestHandle types.RequestHandle // actual handle for outbound message, sentinel for inbound
	StartSeqNr    uint64              // a successful response must contain at least the block with this sequence number
	EndExclSeqNr  uint64              // the response may only contain sequence numbers less than this
}

type MessageBlockSyncResponse[RI any] struct {
	RequestHandle                 types.RequestHandle // actual handle for outbound message, sentinel for inbound
	RequestStartSeqNr             uint64
	RequestEndExclSeqNr           uint64
	AttestedStateTransitionBlocks []AttestedStateTransitionBlock // must be contiguous and (if non-empty) starting at RequestStartSeqNr
}

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

type MessageCertifiedCommit[RI any] struct {
	CertifiedCommittedReports CertifiedCommittedReports[RI]
}

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 MessageStateSyncSummary[RI any] struct {
	LowestPersistedSeqNr  uint64
	HighestCommittedSeqNr uint64
}

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

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

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 MessageToStateSync[RI any] interface {
	Message[RI]
	// contains filtered or unexported methods
}

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

type MessageTreeSyncChunkRequest[RI any] struct {
	RequestHandle types.RequestHandle // actual handle for outbound message, sentinel for inbound
	ToSeqNr       uint64
	StartIndex    jmt.Digest
	EndInclIndex  jmt.Digest
}

type MessageTreeSyncChunkResponse[RI any] struct {
	RequestHandle       types.RequestHandle // actual handle for outbound message, sentinel for inbound
	ToSeqNr             uint64
	StartIndex          jmt.Digest
	RequestEndInclIndex jmt.Digest
	GoAway              bool
	EndInclIndex        jmt.Digest
	KeyValues           []KeyValuePair
	BoundingLeaves      []jmt.BoundingLeaf
}

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]

	// 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 OutcomeGenerationID struct {
	ConfigDigest types.ConfigDigest
	Epoch        uint64
}

type PacemakerState struct {
	Epoch                   uint64
	HighestSentNewEpochWish uint64
}

type PendingKeyDigestRanges struct {
	// contains filtered or unexported fields
}

type PrepareSignature []byte

type ReportsPlusPrecursorDigest [32]byte

type RoundBlobBroadcastFetcher struct {
	// contains filtered or unexported fields
}

type RoundContext struct {
	SeqNr uint64
	Epoch uint64
	Round uint64
}

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 StaleBlob struct {
	StaleSinceSeqNr uint64
	BlobDigest      BlobDigest
}

type StateRootDigest = jmt.Digest

type StateTransitionBlock struct {
	Epoch                       uint64
	BlockSeqNr                  uint64
	StateTransitionInputsDigest StateTransitionInputsDigest
	StateTransitionOutputs      StateTransitionOutputs
	StateRootDigest             StateRootDigest
	ReportsPlusPrecursor        ocr3_1types.ReportsPlusPrecursor
}

type StateTransitionInputsDigest [32]byte

type StateTransitionOutputDigest [32]byte

type StateTransitionOutputs struct {
	WriteSet []KeyValuePairWithDeletions
}

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

type TreeSyncPhase int

type TreeSyncStatus struct {
	Phase                  TreeSyncPhase
	TargetSeqNr            uint64
	TargetStateRootDigest  StateRootDigest
	PendingKeyDigestRanges PendingKeyDigestRanges
}

type VerifyAndWriteTreeSyncChunkResult int