ccip

type Address string

type Addresses []Address

type CommitOffchainConfig struct {
	GasPriceDeviationPPB   uint32
	GasPriceHeartBeat      time.Duration
	TokenPriceDeviationPPB uint32
	TokenPriceHeartBeat    time.Duration
	InflightCacheExpiry    time.Duration
	PriceReportingDisabled bool
}

type CommitStoreInterval struct {
	Min uint64
	Max uint64
}

type CommitStoreReader interface {
	// ChangeConfig notifies the reader that the config has changed onchain
	ChangeConfig(ctx context.Context, onchainConfig []byte, offchainConfig []byte) (Address, error)
	DecodeCommitReport(ctx context.Context, report []byte) (CommitStoreReport, error)
	EncodeCommitReport(ctx context.Context, report CommitStoreReport) ([]byte, error)
	GasPriceEstimator(ctx context.Context) (GasPriceEstimatorCommit, error)
	// GetAcceptedCommitReportsGteTimestamp returns all the commit reports with timestamp greater than or equal to the provided.
	// Returned Commit Reports have to be sorted by Interval.Min/Interval.Max in ascending order.
	GetAcceptedCommitReportsGteTimestamp(ctx context.Context, ts time.Time, confirmations int) ([]CommitStoreReportWithTxMeta, error)
	// GetCommitReportMatchingSeqNum returns accepted commit report that satisfies Interval.Min <= seqNum <= Interval.Max. Returned slice should be empty or have exactly one element
	GetCommitReportMatchingSeqNum(ctx context.Context, seqNum uint64, confirmations int) ([]CommitStoreReportWithTxMeta, error)
	GetCommitStoreStaticConfig(ctx context.Context) (CommitStoreStaticConfig, error)
	GetExpectedNextSequenceNumber(ctx context.Context) (uint64, error)
	GetLatestPriceEpochAndRound(ctx context.Context) (uint64, error)
	IsBlessed(ctx context.Context, root [32]byte) (bool, error)
	// IsDestChainHealthy returns true if the destination chain is healthy.
	IsDestChainHealthy(ctx context.Context) (bool, error)
	IsDown(ctx context.Context) (bool, error)
	OffchainConfig(ctx context.Context) (CommitOffchainConfig, error)
	VerifyExecutionReport(ctx context.Context, report ExecReport) (bool, error)

	io.Closer
}

type CommitStoreReport struct {
	TokenPrices []TokenPrice
	GasPrices   []GasPrice
	Interval    CommitStoreInterval
	MerkleRoot  [32]byte
}

type CommitStoreReportWithTxMeta struct {
	TxMeta
	CommitStoreReport
}

type CommitStoreStaticConfig struct {
	ChainSelector       uint64
	SourceChainSelector uint64
	OnRamp              Address
	ArmProxy            Address
}

type CommonGasPriceEstimator interface {
	// GetGasPrice fetches the current gas price.
	GetGasPrice(ctx context.Context) (*big.Int, error)
	// DenoteInUSD converts the gas price to be in units of USD. Input prices should not be nil.
	DenoteInUSD(ctx context.Context, p *big.Int, wrappedNativePrice *big.Int) (*big.Int, error)
	// TODO CCIP-1882: reconcile gas price estimator to remove unnecessary interface funcs
	// this can be a helper function implementation detail. not needed in the interface
	// Median finds the median gas price in slice. If gas price has multiple components, median of each individual component should be taken. Input prices should not contain nil.
	Median(ctx context.Context, gasPrices []*big.Int) (*big.Int, error)
}

type EVM2EVMMessage struct {
	SequenceNumber      uint64
	GasLimit            *big.Int
	Nonce               uint64
	MessageID           Hash
	SourceChainSelector uint64
	Sender              Address
	Receiver            Address
	Strict              bool
	FeeToken            Address
	FeeTokenAmount      *big.Int
	Data                []byte
	TokenAmounts        []TokenAmount
	SourceTokenData     [][]byte

	// Computed
	Hash Hash
}

type EVM2EVMMessageWithTxMeta struct {
	TxMeta
	EVM2EVMMessage
}

type EVM2EVMOnRampCCIPSendRequestedWithMeta struct {
	EVM2EVMMessage
	BlockTimestamp time.Time
	Executed       bool
	Finalized      bool
	LogIndex       uint
	TxHash         string
}

type ExecOffchainConfig struct {
	// DestOptimisticConfirmations is how many confirmations to wait for the dest chain event before we consider it
	// confirmed (optimistically, need not be finalized).
	DestOptimisticConfirmations uint32
	// BatchGasLimit is the maximum sum of user callback gas we permit in one execution report.
	BatchGasLimit uint32
	// RelativeBoostPerWaitHour indicates how much to increase (artificially) the fee paid on the source chain per hour
	// of wait time, such that eventually the fee paid is greater than the execution cost, and we’ll execute it.
	// For example: if set to 0.5, that means the fee paid is increased by 50% every hour the message has been waiting.
	RelativeBoostPerWaitHour float64
	// InflightCacheExpiry indicates how long we keep a report in the plugin cache before we expire it.
	// The caching prevents us from issuing another report while one is already in flight.
	InflightCacheExpiry config.Duration
	// RootSnoozeTime is the interval at which we check roots for executable messages.
	RootSnoozeTime config.Duration
	// MessageVisibilityInterval is the interval at which we check for new messages.
	MessageVisibilityInterval config.Duration
	// BatchingStrategyID is the strategy to use for batching messages.
	BatchingStrategyID uint32
}

type ExecOnchainConfig struct {
	PermissionLessExecutionThresholdSeconds time.Duration
	Router                                  Address
	MaxDataBytes                            uint32
	MaxNumberOfTokensPerMsg                 uint16
	PriceRegistry                           Address
	MaxPoolReleaseOrMintGas                 uint32
	MaxTokenTransferGas                     uint32
}

type ExecReport struct {
	Messages          []EVM2EVMMessage
	OffchainTokenData [][][]byte
	Proofs            [][32]byte
	ProofFlagBits     *big.Int
}

type ExecutionStateChanged struct {
	SequenceNumber uint64
}

type ExecutionStateChangedWithTxMeta struct {
	TxMeta
	ExecutionStateChanged
}

type FinalizedStatus int

type GasPrice struct {
	DestChainSelector uint64
	Value             *big.Int
}

type GasPriceEstimator interface {
	GasPriceEstimatorCommit
	GasPriceEstimatorExec
}

type GasPriceEstimatorCommit interface {
	CommonGasPriceEstimator

	// TODO CCIP-1882: reconcile gas price estimator to remove unnecessary interface funcs
	// this can be a helper function implementation detail. not needed in the interface
	// Deviates checks if p1 gas price diffs from p2 by deviation options. Input prices should not be nil.
	Deviates(ctx context.Context, p1 *big.Int, p2 *big.Int) (bool, error)
}

type GasPriceEstimatorExec interface {
	CommonGasPriceEstimator

	// EstimateMsgCostUSD estimates the costs for msg execution, and converts to USD value scaled by 1e18 (e.g. 5$ = 5e18).
	EstimateMsgCostUSD(ctx context.Context, p *big.Int, wrappedNativePrice *big.Int, msg EVM2EVMOnRampCCIPSendRequestedWithMeta) (*big.Int, error)
}

type GasPriceUpdate struct {
	GasPrice
	TimestampUnixSec *big.Int
}

type GasPriceUpdateWithTxMeta struct {
	TxMeta
	GasPriceUpdate
}

type Hash [32]byte

type MessageExecutionState uint8

type OffRampReader interface {
	Address(ctx context.Context) (Address, error)
	// ChangeConfig notifies the reader that the config has changed onchain
	ChangeConfig(ctx context.Context, onchainConfig []byte, offchainConfig []byte) (Address, Address, error)
	CurrentRateLimiterState(ctx context.Context) (TokenBucketRateLimit, error)
	// DecodeExecutionReport will error if messages are not a compatible version.
	DecodeExecutionReport(ctx context.Context, report []byte) (ExecReport, error)
	// EncodeExecutionReport will error if messages are not a compatible version.
	EncodeExecutionReport(ctx context.Context, report ExecReport) ([]byte, error)
	// GasPriceEstimator returns the gas price estimator for the offramp.
	GasPriceEstimator(ctx context.Context) (GasPriceEstimatorExec, error)
	GetExecutionState(ctx context.Context, sequenceNumber uint64) (uint8, error)
	// GetExecutionStateChangesBetweenSeqNums returns all the execution state change events for the provided message sequence numbers (inclusive).
	GetExecutionStateChangesBetweenSeqNums(ctx context.Context, seqNumMin, seqNumMax uint64, confirmations int) ([]ExecutionStateChangedWithTxMeta, error)
	GetRouter(ctx context.Context) (Address, error)
	ListSenderNonces(ctx context.Context, senders []Address) (map[Address]uint64, error)
	GetSourceToDestTokensMapping(ctx context.Context) (map[Address]Address, error)
	GetStaticConfig(ctx context.Context) (OffRampStaticConfig, error)
	GetTokens(ctx context.Context) (OffRampTokens, error)
	OffchainConfig(ctx context.Context) (ExecOffchainConfig, error)
	OnchainConfig(ctx context.Context) (ExecOnchainConfig, error)

	io.Closer
}

type OffRampStaticConfig struct {
	CommitStore         Address
	ChainSelector       uint64
	SourceChainSelector uint64
	OnRamp              Address
	PrevOffRamp         Address
	ArmProxy            Address
}

type OffRampTokens struct {
	DestinationTokens []Address
	SourceTokens      []Address
}

type OnRampDynamicConfig struct {
	Router                            Address
	MaxNumberOfTokensPerMsg           uint16
	DestGasOverhead                   uint32
	DestGasPerPayloadByte             uint16
	DestDataAvailabilityOverheadGas   uint32
	DestGasPerDataAvailabilityByte    uint16
	DestDataAvailabilityMultiplierBps uint16
	PriceRegistry                     Address
	MaxDataBytes                      uint32
	MaxPerMsgGasLimit                 uint32
}

type OnRampReader interface {
	Address(ctx context.Context) (Address, error)
	GetDynamicConfig(ctx context.Context) (OnRampDynamicConfig, error)
	// GetSendRequestsBetweenSeqNums returns all the finalized message send requests in the provided sequence numbers range (inclusive).
	GetSendRequestsBetweenSeqNums(ctx context.Context, seqNumMin, seqNumMax uint64, finalized bool) ([]EVM2EVMMessageWithTxMeta, error)
	// IsSourceChainHealthy returns true if the source chain is healthy.
	IsSourceChainHealthy(ctx context.Context) (bool, error)
	// IsSourceCursed returns true if the source chain is cursed. OnRamp communicates with the underlying RMN
	// to verify if source chain was cursed or not.
	IsSourceCursed(ctx context.Context) (bool, error)
	// RouterAddress returns the router address that is configured on the onRamp
	RouterAddress(context.Context) (Address, error)
	// SourcePriceRegistryAddress returns the address of the current price registry configured on the onRamp.
	SourcePriceRegistryAddress(ctx context.Context) (Address, error)
	io.Closer
}

type PriceGetter interface {
	// FilterConfiguredTokens filters a list of token addresses
	// for only those that are configured to be able to get a price and those that aren't
	FilterConfiguredTokens(ctx context.Context, tokens []Address) (configured []Address, unconfigured []Address, err error)
	// TokenPricesUSD returns token prices in USD.
	// Note: The result might contain tokens that are not passed with the 'tokens' param.
	//       The opposite cannot happen, an error will be returned if a token price was not found.
	TokenPricesUSD(ctx context.Context, tokens []Address) (map[Address]*big.Int, error)
	io.Closer
}

type PriceRegistryFactory interface {
	NewPriceRegistryReader(ctx context.Context, addr Address) (PriceRegistryReader, error)
}

type PriceRegistryReader interface {
	// GetTokenPriceUpdatesCreatedAfter returns all the token price updates that happened after the provided timestamp.
	// The returned updates are sorted by timestamp in ascending order.
	GetTokenPriceUpdatesCreatedAfter(ctx context.Context, ts time.Time, confirmations int) ([]TokenPriceUpdateWithTxMeta, error)

	// GetGasPriceUpdatesCreatedAfter returns all the gas price updates that happened after the provided timestamp.
	// The returned updates are sorted by timestamp in ascending order.
	GetGasPriceUpdatesCreatedAfter(ctx context.Context, chainSelector uint64, ts time.Time, confirmations int) ([]GasPriceUpdateWithTxMeta, error)

	// GetAllGasPriceUpdatesCreatedAfter returns all the gas price updates that happened after the provided timestamp for all chain selectors.
	// The returned updates are sorted by timestamp in ascending order.
	GetAllGasPriceUpdatesCreatedAfter(ctx context.Context, ts time.Time, confirmations int) ([]GasPriceUpdateWithTxMeta, error)

	// Address returns the address of the price registry.
	Address(ctx context.Context) (Address, error)

	GetFeeTokens(ctx context.Context) ([]Address, error)

	// GetTokenPrices returns the latest price and time of quote of the given tokens.
	GetTokenPrices(ctx context.Context, wantedTokens []Address) ([]TokenPriceUpdate, error)

	GetTokensDecimals(ctx context.Context, tokenAddresses []Address) ([]uint8, error)

	Close() error
}

type TokenAmount struct {
	Token  Address
	Amount *big.Int
}

type TokenBucketRateLimit struct {
	Tokens      *big.Int
	LastUpdated uint32
	IsEnabled   bool
	Capacity    *big.Int
	Rate        *big.Int
}

type TokenDataReader interface {
	// ReadTokenData returns the attestation bytes if ready, and throws an error if not ready.
	// It supports messages with a single token transfer, the returned []byte has the token data for the first token of the msg.
	ReadTokenData(ctx context.Context, msg EVM2EVMOnRampCCIPSendRequestedWithMeta, tokenIndex int) (tokenData []byte, err error)
	io.Closer
}

type TokenPoolBatchedReader interface {
	GetInboundTokenPoolRateLimits(ctx context.Context, tokenPoolReaders []Address) ([]TokenBucketRateLimit, error)
	io.Closer
}

type TokenPrice struct {
	Token Address
	Value *big.Int
}

type TokenPriceUpdate struct {
	TokenPrice
	TimestampUnixSec *big.Int
}

type TokenPriceUpdateWithTxMeta struct {
	TxMeta
	TokenPriceUpdate
}

type TxMeta struct {
	BlockTimestampUnixMilli int64
	BlockNumber             uint64
	TxHash                  string
	LogIndex                uint64
	Finalized               FinalizedStatus
}