protocol

type AttestedOrGenesisStateTransitionBlock interface {
	// contains filtered or unexported methods
}

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

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
	ChunkHaves    []bool
	ChunkDigests  []BlobChunkDigest
	ExpirySeqNr   uint64
	Submitter     commontypes.OracleID
}

type BlobQuotaStats struct {
	Count                   uint64
	CumulativePayloadLength uint64
}

type BlobQuotaStatsType string

type CertifiedCommit struct {
	PrevHistoryDigest           HistoryDigest
	CommitEpoch                 uint64
	CommitSeqNr                 uint64
	StateTransitionInputsDigest StateTransitionInputsDigest
	StateWriteSetDigest         StateWriteSetDigest
	StateRootDigest             StateRootDigest
	ReportsPlusPrecursorDigest  ReportsPlusPrecursorDigest
	CommitQuorumCertificate     []AttributedCommitSignature
}

type CertifiedPrepare struct {
	PrevHistoryDigest           HistoryDigest
	PrepareEpoch                uint64
	PrepareSeqNr                uint64
	StateTransitionInputsDigest StateTransitionInputsDigest
	StateWriteSetDigest         StateWriteSetDigest
	StateRootDigest             StateRootDigest
	ReportsPlusPrecursorDigest  ReportsPlusPrecursorDigest
	PrepareQuorumCertificate    []AttributedPrepareSignature
}

type CertifiedPrepareOrCommit interface {
	Epoch() uint64
	SeqNr() uint64
	Timestamp() HighestCertifiedTimestamp
	HistoryDigest(_ types.ConfigDigest) HistoryDigest
	Verify(_ ocr3_1config.PublicConfig) 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 EventComputedCommitted[RI any] struct {
	Epoch uint64
	SeqNr uint64
}

type EventComputedObservation[RI any] struct {
	Epoch           uint64
	SeqNr           uint64
	RequestHandle   types.RequestHandle
	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 EventMissingReportsPlusPrecursor[RI any] struct {
	SeqNr uint64
}

type EventNewCertifiedCommit[RI any] struct {
	SeqNr                      uint64
	ReportsPlusPrecursorDigest ReportsPlusPrecursorDigest
}

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 GenesisFromPrevInstance struct {
	PrevHistoryDigest HistoryDigest
	PrevSeqNr         uint64
}

type GenesisFromScratch struct{}

type GenesisStateTransitionBlock struct {
	PrevHistoryDigest           HistoryDigest
	SeqNr                       uint64
	StateTransitionInputsDigest StateTransitionInputsDigest
	StateWriteSetDigest         StateWriteSetDigest
	StateRootDigest             StateRootDigest
	ReportsPlusPrecursorDigest  ReportsPlusPrecursorDigest
}

type HighestCertifiedTimestamp struct {
	SeqNr                 uint64
	CommittedElsePrepared bool
	Epoch                 uint64
}

type HistoryDigest = types.HistoryDigest

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)

	ExistsUnattestedStateTransitionBlock(seqNr uint64, stateTransitionInputsDigest StateTransitionInputsDigest) (bool, error)
	ReadUnattestedStateTransitionBlock(seqNr uint64, stateTransitionInputsDigest StateTransitionInputsDigest) (*StateTransitionBlock, 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,
		maxCumulativeKeysPlusValuesBytes int,
	) (
		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)
	ReadBlobQuotaStats(blobQuotaStatsType BlobQuotaStatsType, submitter commontypes.OracleID) (BlobQuotaStats, error)
	ReadBlobChunk(BlobDigest, uint64) ([]byte, error)
	ReadStaleBlobIndex(maxStaleSinceSeqNr uint64, limit int) ([]StaleBlob, error)

	ReadReportsPlusPrecursor(seqNr uint64, reportsPlusPrecursorDigest ReportsPlusPrecursorDigest) (*ocr3_1types.ReportsPlusPrecursor, error)

	jmt.RootReader
	jmt.NodeReader

	ReadPrevInstanceGenesisStateTransitionBlock() (*GenesisStateTransitionBlock, error)
}

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)

	WriteUnattestedStateTransitionBlock(seqNr uint64, stateTransitionInputsDigest StateTransitionInputsDigest, stb StateTransitionBlock) error
	DeleteUnattestedStateTransitionBlocks(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]. It also verifies that endInclIndex is in the range of
	// [startIndex, requestEndInclIndex], and that keyValues is non-empty unless
	// requestEndInclIndex == endInclIndex. Only after doing all the above, it
	// writes all keyValues into the tree and flat representation.
	VerifyAndWriteTreeSyncChunk(
		targetRootDigest StateRootDigest,
		targetSeqNr uint64,
		startIndex jmt.Digest,
		requestEndInclIndex jmt.Digest,
		endInclIndex jmt.Digest,
		boundingLeaves []jmt.BoundingLeaf,
		keyValues []KeyValuePair,
	) (VerifyAndWriteTreeSyncChunkResult, error)

	WriteTreeSyncStatus(state TreeSyncStatus) error
	WriteBlobMeta(BlobDigest, BlobMeta) error
	DeleteBlobMeta(BlobDigest) error
	WriteBlobQuotaStats(blobQuotaStatsType BlobQuotaStatsType, submitter commontypes.OracleID, blobQuotaStats BlobQuotaStats) error
	WriteBlobChunk(BlobDigest, uint64, []byte) error
	DeleteBlobChunk(BlobDigest, uint64) error
	WriteStaleBlobIndex(StaleBlob) error
	DeleteStaleBlobIndex(StaleBlob) error

	WriteReportsPlusPrecursor(seqNr uint64, reportsPlusPrecursorDigest ReportsPlusPrecursorDigest, reportsPlusPrecursor ocr3_1types.ReportsPlusPrecursor) error
	DeleteReportsPlusPrecursors(minSeqNrToKeep uint64, maxItems int) (done bool, err 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)

	WritePrevInstanceGenesisStateTransitionBlock(genesisStateTransitionBlock GenesisStateTransitionBlock) 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, config ocr3_1config.PublicConfig) bool
	// contains filtered or unexported methods
}

type MessageBlobChunkRequest[RI any] struct {
	RequestHandle types.RequestHandle // actual handle for inbound message, sentinel for outbound
	RequestInfo   *types.RequestInfo
	BlobDigest    BlobDigest
	ChunkIndex    uint64
}

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

	BlobDigest BlobDigest
	ChunkIndex uint64
	GoAway     bool
	Chunk      []byte
	Proof      []mt.Digest
}

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

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 inbound message, sentinel for outbound
	RequestInfo                *types.RequestInfo
	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
	MaxCumulativeWriteSetBytes int
}

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
	GenesisStateTransitionBlock   *GenesisStateTransitionBlock   // optional genesis block info when syncing from prev instance
}

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

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

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

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

type MessageNewEpochWish[RI any] struct {
	Epoch uint64
}

type MessageObservation[RI any] struct {
	RequestHandle     types.RequestHandle // actual handle for outbound message, sentinel for inbound
	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
	ReportsPlusPrecursorDigest ReportsPlusPrecursorDigest
}

type MessageReportsPlusPrecursor[RI any] struct {
	RequestHandle        types.RequestHandle // actual handle for outbound message, sentinel for inbound
	SeqNr                uint64
	ReportsPlusPrecursor ocr3_1types.ReportsPlusPrecursor
}

type MessageReportsPlusPrecursorRequest[RI any] struct {
	RequestHandle types.RequestHandle // actual handle for inbound message, sentinel for outbound
	SeqNr         uint64
}

type MessageRoundStart[RI any] struct {
	RequestHandle types.RequestHandle // actual handle for inbound message, sentinel for outbound
	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 inbound message, sentinel for outbound
	RequestInfo   *types.RequestInfo
	ToSeqNr       uint64
	StartIndex    jmt.Digest
	EndInclIndex  jmt.Digest

	MaxCumulativeKeysPlusValuesBytes int
}

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 {
	PrevHistoryDigest           HistoryDigest
	Epoch                       uint64
	BlockSeqNr                  uint64
	StateTransitionInputsDigest StateTransitionInputsDigest
	StateWriteSet               StateWriteSet
	StateRootDigest             StateRootDigest
	ReportsPlusPrecursorDigest  ReportsPlusPrecursorDigest
}

type StateTransitionInputsDigest [32]byte

type StateWriteSet struct {
	Entries []KeyValuePairWithDeletions
}

type StateWriteSetDigest [32]byte

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