mercury

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) (Observation, error)
}

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

type Fetcher interface {
	// FetchInitialMaxFinalizedBlockNumber should fetch the initial max
	// finalized block number from the mercury server.
	FetchInitialMaxFinalizedBlockNumber(context.Context) (int64, error)
}

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

type MercuryObservationProto struct {
	Timestamp         uint32 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	BenchmarkPrice    []byte `protobuf:"bytes,2,opt,name=benchmarkPrice,proto3" json:"benchmarkPrice,omitempty"`
	Bid               []byte `protobuf:"bytes,3,opt,name=bid,proto3" json:"bid,omitempty"`
	Ask               []byte `protobuf:"bytes,4,opt,name=ask,proto3" json:"ask,omitempty"`
	CurrentBlockNum   int64  `protobuf:"varint,5,opt,name=currentBlockNum,proto3" json:"currentBlockNum,omitempty"`
	CurrentBlockHash  []byte `protobuf:"bytes,6,opt,name=currentBlockHash,proto3" json:"currentBlockHash,omitempty"`
	ValidFromBlockNum int64  `protobuf:"varint,7,opt,name=validFromBlockNum,proto3" json:"validFromBlockNum,omitempty"`
	// contains filtered or unexported fields
}

type Observation struct {
	BenchmarkPrice    *big.Int
	Bid               *big.Int
	Ask               *big.Int
	CurrentBlockNum   int64
	CurrentBlockHash  []byte
	ValidFromBlockNum int64
}

type OffchainConfig struct{}

type OnchainConfig struct {
	// applies to all values: price, bid and ask
	Min *big.Int
	Max *big.Int
}

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

type ParsedAttributedObservation struct {
	Timestamp         uint32
	BenchmarkPrice    *big.Int
	Bid               *big.Int
	Ask               *big.Int
	CurrentBlockNum   int64 // inclusive; current block
	CurrentBlockHash  []byte
	ValidFromBlockNum int64 // exclusive; one above previous upper block
	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(paos []ParsedAttributedObservation, f int) (ocrtypes.Report, 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

	// CurrentBlockNumFromReport returns the median current block number from a report
	CurrentBlockNumFromReport(types.Report) (int64, error)
}

type StandardOnchainConfigCodec struct{}

type Transmitter interface {
	Fetcher
	// NOTE: Mercury doesn't actually transmit on-chain, so there is no
	// "contract" involved with the transmitter.
	// - Transmit should be implemented and send to Mercury server
	// - LatestConfigDigestAndEpoch should be implemented and fetch from Mercury server
	// - FromAccount() should return CSA public key
	ocrtypes.ContractTransmitter
}