median

type DataSource interface {
	// Observe queries the data source. Returns a value or an error. Once the
	// context is expires, Observe may still do cheap computations and return a
	// result, but should return as quickly as possible.
	//
	// More details: In the current implementation, the context passed to
	// Observe will time out after MaxDurationObservation. However, Observe
	// should *not* make any assumptions about context timeout behavior. Once
	// the context times out, Observe should prioritize returning as quickly as
	// possible, but may still perform fast computations to return a result
	// rather than error. For example, if Observe medianizes a number of data
	// sources, some of which already returned a result to Observe prior to the
	// context's expiry, Observe might still compute their median, and return it
	// instead of an error.
	//
	// Important: Observe should not perform any potentially time-consuming
	// actions like database access, once the context passed has expired.
	Observe(context.Context, types.ReportTimestamp) (*big.Int, error)
}

type MedianContract interface {
	LatestTransmissionDetails(
		ctx context.Context,
	) (
		configDigest types.ConfigDigest,
		epoch uint32,
		round uint8,
		latestAnswer *big.Int,
		latestTimestamp time.Time,
		err error,
	)

	// LatestRoundRequested returns the configDigest, epoch, and round from the latest
	// RoundRequested event emitted by the contract. LatestRoundRequested may or may not
	// return a result if the latest such event was emitted in a block b such that
	// b.timestamp < tip.timestamp - lookback.
	//
	// If no event is found, LatestRoundRequested should return zero values, not an error.
	// An error should only be returned if an actual error occurred during execution,
	// e.g. because there was an error querying the blockchain or the database.
	//
	// As an optimization, this function may also return zero values, if no
	// RoundRequested event has been emitted after the latest NewTransmission event.
	LatestRoundRequested(
		ctx context.Context,
		lookback time.Duration,
	) (
		configDigest types.ConfigDigest,
		epoch uint32,
		round uint8,
		err error,
	)
}

type NumericalMedianConfigProto struct {
	AlphaReportInfinite bool   `protobuf:"varint,1,opt,name=alpha_report_infinite,json=alphaReportInfinite,proto3" json:"alpha_report_infinite,omitempty"`
	AlphaReportPpb      uint64 `protobuf:"varint,2,opt,name=alpha_report_ppb,json=alphaReportPpb,proto3" json:"alpha_report_ppb,omitempty"`
	AlphaAcceptInfinite bool   `protobuf:"varint,3,opt,name=alpha_accept_infinite,json=alphaAcceptInfinite,proto3" json:"alpha_accept_infinite,omitempty"`
	AlphaAcceptPpb      uint64 `protobuf:"varint,4,opt,name=alpha_accept_ppb,json=alphaAcceptPpb,proto3" json:"alpha_accept_ppb,omitempty"`
	DeltaCNanoseconds   uint64 `protobuf:"varint,5,opt,name=delta_c_nanoseconds,json=deltaCNanoseconds,proto3" json:"delta_c_nanoseconds,omitempty"`
	// contains filtered or unexported fields
}

type NumericalMedianFactory struct {
	ContractTransmitter       MedianContract
	DataSource                DataSource
	JuelsPerFeeCoinDataSource DataSource
	Logger                    commontypes.Logger
	OnchainConfigCodec        OnchainConfigCodec
	ReportCodec               ReportCodec
}

type NumericalMedianObservationProto struct {
	Timestamp       uint32 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Value           []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	JuelsPerFeeCoin []byte `protobuf:"bytes,3,opt,name=juelsPerFeeCoin,proto3" json:"juelsPerFeeCoin,omitempty"`
	// contains filtered or unexported fields
}

type OffchainConfig struct {
	// If AlphaReportInfinite is true, the deviation check parametrized by
	// AlphaReportPPB will never be satisfied.
	AlphaReportInfinite bool
	// AlphaReportPPB determines the relative deviation between the median (i.e.
	// answer) in the contract and the current median of observations (offchain)
	// at which a report should be issued. That is, a report is issued if
	// abs((offchainMedian - contractMedian)/contractMedian) >= alphaReport.
	AlphaReportPPB uint64 // PPB is parts-per-billion
	// If AlphaAcceptInfinite is true, the deviation check parametrized by
	// AlphaAcceptPPB will never be satisfied.
	AlphaAcceptInfinite bool
	// AlphaAcceptPPB determines the relative deviation between the median in a
	// newly generated report considered for transmission and the median of the
	// currently pending report. That is, a report is accepted for transmission
	// if abs((newMedian - pendingMedian)/pendingMedian) >= alphaAccept. If no
	// report is pending, this variable has no effect.
	AlphaAcceptPPB uint64 // PPB is parts-per-billion
	// DeltaC is the maximum age of the latest report in the contract. If the
	// maximum age is exceeded, a new report will be created by the report
	// generation protocol.
	DeltaC time.Duration
}

type OnchainConfig struct {
	Min *big.Int
	Max *big.Int
}

type OnchainConfigCodec interface {
	Encode(OnchainConfig) ([]byte, error)
	Decode([]byte) (OnchainConfig, error)
}

type ParsedAttributedObservation struct {
	Timestamp       uint32
	Value           *big.Int
	JuelsPerFeeCoin *big.Int
	Observer        commontypes.OracleID
}

type ReportCodec interface {
	// Implementers may assume that there is at most one
	// ParsedAttributedObservation per observer, and that all observers are
	// valid. However, observation values, timestamps, etc... should all be
	// treated as untrusted.
	BuildReport([]ParsedAttributedObservation) (types.Report, error)

	// Gets the "median" (the n//2-th ranked element to be more precise where n
	// is the length of the list) observation from the report. The input to this
	// function should be an output of BuildReport in the benign case.
	// Nevertheless, make sure to treat the input to this function as untrusted.
	MedianFromReport(types.Report) (*big.Int, error)

	// Returns the maximum length of a report based on n, the number of oracles.
	// The output of BuildReport must respect this maximum length.
	MaxReportLength(n int) (int, error)
}

type StandardOnchainConfigCodec struct{}