types

type AutomationProvider interface {
	PluginProvider
	Registry() automation.Registry
	Encoder() automation.Encoder
	TransmitEventProvider() automation.EventProvider
	BlockSubscriber() automation.BlockSubscriber
	PayloadBuilder() automation.PayloadBuilder
	UpkeepStateStore() automation.UpkeepStateStore
	LogEventProvider() automation.LogEventProvider
	LogRecoverer() automation.LogRecoverer
	UpkeepProvider() automation.ConditionalUpkeepProvider
}

type BatchGetLatestValuesRequest map[BoundContract]ContractBatch

type BatchGetLatestValuesResult map[BoundContract]ContractBatchResults

type BatchRead struct {
	ReadName  string
	Params    any
	ReturnVal any
}

type BatchReadResult struct {
	ReadName string
	// contains filtered or unexported fields
}

type BoundContract struct {
	Address string
	Name    string
}

type CCIPCommitFactoryGenerator interface {
	NewCommitFactory(ctx context.Context, provider CCIPCommitProvider) (ReportingPluginFactory, error)
}

type CCIPCommitProvider interface {
	PluginProvider

	NewCommitStoreReader(ctx context.Context, addr ccip.Address) (ccip.CommitStoreReader, error)
	NewOffRampReader(ctx context.Context, addr ccip.Address) (ccip.OffRampReader, error)
	NewOnRampReader(ctx context.Context, addr ccip.Address, sourceSelector uint64, destSelector uint64) (ccip.OnRampReader, error)
	NewPriceGetter(ctx context.Context) (ccip.PriceGetter, error)
	NewPriceRegistryReader(ctx context.Context, addr ccip.Address) (ccip.PriceRegistryReader, error)
	SourceNativeToken(ctx context.Context, addr ccip.Address) (ccip.Address, error)
}

type CCIPExecProvider interface {
	PluginProvider

	GetTransactionStatus(ctx context.Context, transactionID string) (TransactionStatus, error)
	NewCommitStoreReader(ctx context.Context, addr ccip.Address) (ccip.CommitStoreReader, error)
	NewOffRampReader(ctx context.Context, addr ccip.Address) (ccip.OffRampReader, error)
	NewOnRampReader(ctx context.Context, addr ccip.Address, sourceSelector uint64, destSelector uint64) (ccip.OnRampReader, error)
	NewPriceRegistryReader(ctx context.Context, addr ccip.Address) (ccip.PriceRegistryReader, error)
	NewTokenDataReader(ctx context.Context, tokenAddress ccip.Address) (ccip.TokenDataReader, error)
	NewTokenPoolBatchedReader(ctx context.Context, offRampAddress ccip.Address, sourceSelector uint64) (ccip.TokenPoolBatchedReader, error)
	SourceNativeToken(ctx context.Context, addr ccip.Address) (ccip.Address, error)
}

type CCIPExecutionFactoryGenerator interface {
	NewExecutionFactory(ctx context.Context, provider CCIPExecProvider) (ReportingPluginFactory, error)
}

type CCIPFactoryGenerator interface {
	CCIPCommitFactoryGenerator
	CCIPExecutionFactoryGenerator
}

type CCIPOCR3CommitProvider interface {
	PluginProvider

	ReportCodec(ctx context.Context) (ccipocr3.CommitPluginCodec, error)
	MsgHasher(ctx context.Context) (ccipocr3.MessageHasher, error)
}

type CCIPOCR3ExecuteProvider interface {
	PluginProvider

	ReportCodec(ctx context.Context) (ccipocr3.ExecutePluginCodec, error)
	MsgHasher(ctx context.Context) (ccipocr3.MessageHasher, error)
}

type ChainFeeComponents struct {
	// The cost of executing transaction in the chain's EVM (or the L2 environment).
	ExecutionFee *big.Int

	// The cost associated with an L2 posting a transaction's data to the L1.
	DataAvailabilityFee *big.Int
}

type ChainService interface {
	Service

	// LatestHead returns the latest head for the underlying chain.
	LatestHead(ctx context.Context) (Head, error)
	// GetChainStatus returns the ChainStatus for this Relayer.
	GetChainStatus(ctx context.Context) (ChainStatus, error)
	// ListNodeStatuses returns the status of RPC nodes.
	ListNodeStatuses(ctx context.Context, pageSize int32, pageToken string) (stats []NodeStatus, nextPageToken string, total int, err error)
	// Transact submits a transaction to transfer tokens.
	// If balanceCheck is true, the balance will be checked before submitting.
	Transact(ctx context.Context, from, to string, amount *big.Int, balanceCheck bool) error
}

type ChainStatus struct {
	ID      string
	Enabled bool
	Config  string // TOML
}

type ChainWriter interface {
	services.Service

	// SubmitTransaction packs and broadcasts a transaction to the underlying chain.
	//
	// - `args` should be any object which maps a set of method param into the contract and method specific method params.
	// - `transactionID` will be used by the underlying TXM as an idempotency key, and unique reference to track transaction attempts.
	SubmitTransaction(ctx context.Context, contractName, method string, args any, transactionID string, toAddress string, meta *TxMeta, value *big.Int) error

	// GetTransactionStatus returns the current status of a transaction in the underlying chain's TXM.
	GetTransactionStatus(ctx context.Context, transactionID string) (TransactionStatus, error)

	// GetFeeComponents retrieves the associated gas costs for executing a transaction.
	GetFeeComponents(ctx context.Context) (*ChainFeeComponents, error)
}

type Codec interface {
	Encoder
	Decoder
}

type ConfigProvider interface {
	Service
	OffchainConfigDigester() ocrtypes.OffchainConfigDigester
	ContractConfigTracker() ocrtypes.ContractConfigTracker
}

type ContractBatch []BatchRead

type ContractBatchResults []BatchReadResult

type ContractReader interface {
	services.Service
	// GetLatestValue gets the latest value with a certain confidence level that maps to blockchain finality....
	// The params argument can be any object which maps a set of generic parameters into chain specific parameters defined in RelayConfig.
	// It must encode as an object via [json.Marshal] and [github.com/fxamacker/cbor/v2.Marshal].
	// Typically, would be either a struct with field names mapping to arguments, or anonymous map such as `map[string]any{"baz": 42, "test": true}}`
	//
	// returnVal must [json.Unmarshal] and and [github.com/fxamacker/cbor/v2.Marshal] as an object.
	//
	// Example use:
	//  type ProductParams struct {
	// 		ID int `json:"id"`
	//  }
	//  type ProductReturn struct {
	// 		Foo string `json:"foo"`
	// 		Bar *big.Int `json:"bar"`
	//  }
	//  func do(ctx context.Context, cr ContractReader) (resp ProductReturn, err error) {
	// 		err = cr.GetLatestValue(ctx, "FooContract", "GetProduct", primitives.Finalized, ProductParams{ID:1}, &resp)
	// 		return
	//  }
	//
	// Note that implementations should ignore extra fields in params that are not expected in the call to allow easier
	// use across chains and contract versions.
	// Similarly, when using a struct for returnVal, fields in the return value that are not on-chain will not be set.
	GetLatestValue(ctx context.Context, readIdentifier string, confidenceLevel primitives.ConfidenceLevel, params, returnVal any) error

	// BatchGetLatestValues batches get latest value calls based on request, which is grouped by contract names that each have a slice of BatchRead.
	// BatchGetLatestValuesRequest params and returnVal follow same rules as GetLatestValue params and returnVal arguments, with difference in how response is returned.
	// BatchGetLatestValuesResult response is grouped by contract names, which contain read results that maintain the order from the request.
	// Contract call errors are returned in the Err field of BatchGetLatestValuesResult.
	BatchGetLatestValues(ctx context.Context, request BatchGetLatestValuesRequest) (BatchGetLatestValuesResult, error)

	// Bind will add provided bindings and will return an error if the contract is not known by the ContractReader, or if
	// the Address is invalid. Any provided binding that already exists should result in a noop.
	Bind(ctx context.Context, bindings []BoundContract) error

	// Unbind will remove all provided bindings.
	Unbind(ctx context.Context, bindings []BoundContract) error

	// QueryKey provides fetching chain agnostic events (Sequence) with general querying capability.
	QueryKey(ctx context.Context, contract BoundContract, filter query.KeyFilter, limitAndSort query.LimitAndSort, sequenceDataType any) ([]Sequence, error)
	// contains filtered or unexported methods
}

type ContractTypeProvider interface {
	CreateContractType(readName string, forEncoding bool) (any, error)
}

type Decoder interface {
	Decode(ctx context.Context, raw []byte, into any, itemType string) error
	// GetMaxDecodingSize returns the max size in bytes if n elements are supplied for all top level dynamically sized elements.
	// If no elements are dynamically sized, the returned value will be the same for all n.
	// If there are multiple levels of dynamically sized elements, or itemType cannot be found,
	// ErrInvalidType will be returned.
	GetMaxDecodingSize(ctx context.Context, n int, itemType string) (int, error)
}

type Encoder interface {
	Encode(ctx context.Context, item any, itemType string) ([]byte, error)
	// GetMaxEncodingSize returns the max size in bytes if n elements are supplied for all top level dynamically sized elements.
	// If no elements are dynamically sized, the returned value will be the same for all n.
	// If there are multiple levels of dynamically sized elements, or itemType cannot be found,
	// ErrInvalidType will be returned.
	GetMaxEncodingSize(ctx context.Context, n int, itemType string) (int, error)
}

type FunctionsEvents interface {
	Service
	LatestEvents() ([]OracleRequest, []OracleResponse, error)
}

type FunctionsProvider interface {
	PluginProvider
	FunctionsEvents() FunctionsEvents
}

type Head struct {
	Height string
	Hash   []byte
	// Timestamp is in Unix time
	Timestamp uint64
}

type InternalError string

type InvalidArgumentError string

type LLOProvider interface {
	ConfigProvider
	ContractTransmitter() llo.Transmitter
	ChannelDefinitionCache() llo.ChannelDefinitionCache
}

type MedianProvider interface {
	PluginProvider
	ReportCodec() median.ReportCodec
	MedianContract() median.MedianContract
	OnchainConfigCodec() median.OnchainConfigCodec
}

type MercuryCredentials struct {
	LegacyURL string
	URL       string
	Username  string
	Password  string
}

type MercuryPluginFactory interface {
	Service
	ocr3types.MercuryPluginFactory
}

type MercuryProvider interface {
	PluginProvider

	ReportCodecV1() v1.ReportCodec
	ReportCodecV2() v2.ReportCodec
	ReportCodecV3() v3.ReportCodec
	ReportCodecV4() v4.ReportCodec
	OnchainConfigCodec() mercury.OnchainConfigCodec
	MercuryServerFetcher() mercury.ServerFetcher
	MercuryChainReader() mercury.ChainReader
}

type NodeStatus struct {
	ChainID string
	Name    string
	Config  string // TOML
	State   string
}

type NotFoundError string

type OCR2PluginType string

type OCR3CapabilityProvider interface {
	PluginProvider
	OCR3ContractTransmitter
}

type OCR3ContractTransmitter interface {
	OCR3ContractTransmitter() ocr3types.ContractTransmitter[[]byte]
}

type OracleRequest struct {
	RequestID          [32]byte
	RequestingContract ocrtypes.Account
	RequestInitiator   ocrtypes.Account
	//nolint:revive
	SubscriptionId      uint64
	SubscriptionOwner   ocrtypes.Account
	Data                []byte
	DataVersion         uint16
	Flags               [32]byte
	CallbackGasLimit    uint64
	TxHash              []byte
	CoordinatorContract ocrtypes.Account
	OnchainMetadata     []byte
}

type OracleResponse struct {
	RequestID [32]byte
}

type Plugin = PluginProvider

type PluginArgs struct {
	TransmitterID string
	PluginConfig  []byte
}

type PluginMercury interface {
	NewMercuryV1Factory(ctx context.Context, provider MercuryProvider, dataSource v1.DataSource) (MercuryPluginFactory, error)
	NewMercuryV2Factory(ctx context.Context, provider MercuryProvider, dataSource v2.DataSource) (MercuryPluginFactory, error)
	NewMercuryV3Factory(ctx context.Context, provider MercuryProvider, dataSource v3.DataSource) (MercuryPluginFactory, error)
	NewMercuryV4Factory(ctx context.Context, provider MercuryProvider, dataSource v4.DataSource) (MercuryPluginFactory, error)
}

type PluginProvider interface {
	ConfigProvider
	ContractTransmitter() ocrtypes.ContractTransmitter
	ContractReader() ContractReader
	Codec() Codec
}

type RelayArgs struct {
	ExternalJobID      uuid.UUID
	JobID              int32
	ContractID         string
	New                bool   // Whether this is a first time job add.
	RelayConfig        []byte // The specific configuration of a given relayer instance. Will vary by relayer type.
	ProviderType       string
	MercuryCredentials *MercuryCredentials
}

type RelayID struct {
	Network string
	ChainID string
}

type RemoteCodec interface {
	Codec
	TypeProvider
}

type ReportingPluginFactory interface {
	Service
	libocr.ReportingPluginFactory
}

type Sequence struct {
	// This way we can retrieve past/future sequences (EVM log events) very granularly, but still hide the chain detail.
	Cursor string
	Head
	Data any
}

type TransactionStatus int

type TxMeta struct {
	// Used for Keystone Workflows
	WorkflowExecutionID *string
	// An optional maximum gas limit for the transaction. If not set the ChainWriter implementation will be responsible for
	// setting a gas limit for the transaction.  If it is set and the ChainWriter implementation does not support setting
	// this value per transaction it will return ErrSettingTransactionGasLimitNotSupported
	GasLimit *big.Int
}

type TypeProvider interface {
	CreateType(itemType string, forEncoding bool) (any, error)
}

type UnimplementedContractReader struct{}

type UnimplementedError string