ccipocr3

type AddressCodec interface {
	AddressBytesToString(UnknownAddress, ChainSelector) (string, error)
	AddressStringToBytes(string, ChainSelector) (UnknownAddress, error)
}

type AllAccessors interface {
	// GetContractAddress returns the contract address that is registered for the provided contract name and chain.
	// WARNING: This function will fail if the oracle does not support the requested chain.
	//
	// TODO(NONEVM-1865): do we want to mark this as deprecated in favor of Metadata()?
	GetContractAddress(contractName string) ([]byte, error)

	// GetAllConfigsLegacy returns a snapshot of all chain configurations for this chain using the legacy
	// config structs.
	//
	// destChainSelector is used to determine whether or not destination chain specific configs should be fetched.
	// sourceChainSelectors is used to determine which source chain configs should be fetched.
	//
	// This includes the following contracts:
	// - Router
	// - OffRamp
	// - OnRamp
	// - FeeQuoter
	// - RMNProxy
	// - RMNRemote
	// - CurseInfo
	//
	// Access Type: Method(many, see code)
	// Contract: Many
	// Confidence: Unconfirmed
	GetAllConfigsLegacy(
		ctx context.Context,
		destChainSelector ChainSelector,
		sourceChainSelectors []ChainSelector,
	) (ChainConfigSnapshot, map[ChainSelector]SourceChainConfig, error)

	// GetChainFeeComponents Returns all fee components for given chains if corresponding
	// chain writer is available.
	//
	// Access Type: ChainWriter
	// Contract: N/A
	// Confidence: N/A
	GetChainFeeComponents(ctx context.Context) (ChainFeeComponents, error)

	// Sync can be used to perform frequent syncing operations inside the reader implementation.
	// Returns an error if the sync operation failed.
	Sync(ctx context.Context, contractName string, contractAddress UnknownAddress) error
}

type BigInt struct {
	*big.Int
}

type Bytes []byte

type Bytes32 [32]byte

type ChainAccessor interface {
	AllAccessors
	SourceAccessor
	DestinationAccessor
	USDCMessageReader
	PriceReader
}

type ChainConfigSnapshot struct {
	Offramp   OfframpConfig
	RMNProxy  RMNProxyConfig
	RMNRemote RMNRemoteConfig
	FeeQuoter FeeQuoterConfig
	OnRamp    OnRampConfig
	Router    RouterConfig
	CurseInfo CurseInfo
}

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 ChainSelector uint64

type ChainSpecificAddressCodec interface {
	// AddressBytesToString converts an address from bytes to string
	AddressBytesToString([]byte) (string, error)
	// AddressStringToBytes converts an address from string to bytes
	AddressStringToBytes(string) ([]byte, error)
	// OracleIDAsAddressBytes returns a valid address for this chain family with the bytes set to the given oracle ID.
	OracleIDAsAddressBytes(oracleID uint8) ([]byte, error)
	// TransmitterBytesToString converts a transmitter account from bytes to string
	TransmitterBytesToString([]byte) (string, error)
}

type Codec struct {
	ChainSpecificAddressCodec
	CommitPluginCodec
	ExecutePluginCodec
	TokenDataEncoder
	SourceChainExtraDataCodec
}

type CommitPluginCodec interface {
	Encode(context.Context, CommitPluginReport) ([]byte, error)
	Decode(context.Context, []byte) (CommitPluginReport, error)
}

type CommitPluginReport struct {
	PriceUpdates         PriceUpdates      `json:"priceUpdates"`
	BlessedMerkleRoots   []MerkleRootChain `json:"blessedMerkleRoots"`
	UnblessedMerkleRoots []MerkleRootChain `json:"unblessedMerkleRoots"`

	// RMNSignatures are the ECDSA signatures from the RMN signing nodes on the RMNReport structure.
	// For more details see the contract here: https://github.com/smartcontractkit/chainlink/blob/7ba0f37134a618375542079ff1805fe2224d7916/contracts/src/v0.8/ccip/interfaces/IRMNV2.sol#L8-L12
	//nolint:lll // it's a url
	RMNSignatures []RMNECDSASignature `json:"rmnSignatures"`
}

type CommitPluginReportWithMeta struct {
	Report    CommitPluginReport `json:"report"`
	Timestamp time.Time          `json:"timestamp"`
	BlockNum  uint64             `json:"blockNum"`
}

type CommitReportInfo struct {
	// RemoteF Max number of faulty RMN nodes; f+1 signers are required to verify a report.
	RemoteF     uint64            `json:"remoteF"`
	MerkleRoots []MerkleRootChain `json:"merkleRoots"`
	PriceUpdates
}

type CommitReportsByConfidenceLevel struct {
	Finalized   []CommitPluginReportWithMeta `json:"finalized"`
	Unfinalized []CommitPluginReportWithMeta `json:"unfinalized"`
}

type Config struct {
	RMNHomeContractConfigDigest Bytes32  `json:"rmnHomeContractConfigDigest"`
	Signers                     []Signer `json:"signers"`
	FSign                       uint64   `json:"fSign"` // previously: MinSigners
}

type ConfigInfo struct {
	ConfigDigest                   Bytes32
	F                              uint8
	N                              uint8
	IsSignatureVerificationEnabled bool
}

type ContractAddresses map[string]map[ChainSelector]UnknownAddress

type CurseInfo struct {
	// CursedSourceChains contains the cursed source chains.
	CursedSourceChains map[ChainSelector]bool
	// CursedDestination indicates that the destination chain is cursed.
	CursedDestination bool
	// GlobalCurse indicates that all chains are cursed.
	GlobalCurse bool
}

type DataAvailabilityGasConfig struct {
	DestDataAvailabilityOverheadGas   uint32 // Extra data availability gas charged, e.g., for OCR
	DestGasPerDataAvailabilityByte    uint16 // Gas charged per byte of message data needing availability
	DestDataAvailabilityMultiplierBps uint16 // Multiplier for data availability gas in bps
}

type DestinationAccessor interface {

	// CommitReportsGTETimestamp reads CommitReportAccepted events starting from a given timestamp.
	// The number of results are limited according to limit.
	//
	// Access Type: Event(CommitReportAccepted)
	// Contract: OffRamp
	// Confidence: Unconfirmed, Finalized
	CommitReportsGTETimestamp(
		ctx context.Context,
		ts time.Time,
		confidence primitives.ConfidenceLevel,
		limit int,
	) ([]CommitPluginReportWithMeta, error)

	// ExecutedMessages looks for ExecutionStateChanged events for each sequence
	// in a given range. The presence of these events indicates that an attempt to
	// execute the message has been made, which the system considers "executed".
	// A slice of all executed sequence numbers is returned.
	//
	// Access Type: Event(ExecutionStateChanged)
	// Contract: OffRamp
	// Confidence: Unconfirmed, Finalized
	ExecutedMessages(
		ctx context.Context,
		ranges map[ChainSelector][]SeqNumRange,
		confidence primitives.ConfidenceLevel,
	) (map[ChainSelector][]SeqNum, error)

	// NextSeqNum reads the source chain config to get the next expected
	// sequence number for the given source chains.
	//
	// Access Type: Method(NextSeqNum)
	// Contract: OffRamp
	// Confidence: Unconfirmed
	NextSeqNum(ctx context.Context, sources []ChainSelector) (map[ChainSelector]SeqNum, error)

	// Nonces for all provided selector/address pairs. Addresses must be encoded
	// according to the source chain requirements by using the AddressCodec.
	//
	// Access Type: Method(GetInboundNonce)
	// Contract: NonceManager
	// Confidence: Unconfirmed
	Nonces(ctx context.Context, addresses map[ChainSelector][]UnknownEncodedAddress) (map[ChainSelector]map[string]uint64, error)

	// GetChainFeePriceUpdate Gets latest chain fee price update for the provided chains.
	//
	// Access Type: Method(GetChainFeePriceUpdate)
	// Contract: FeeQuoter
	// Confidence: Unconfirmed
	GetChainFeePriceUpdate(ctx context.Context, selectors []ChainSelector) (map[ChainSelector]TimestampedUnixBig, error)

	// GetLatestPriceSeqNr returns the latest price sequence number for the destination chain.
	// Not to confuse with the sequence number of the messages. This is the OCR sequence number.
	//
	// Access Type: Method(GetLatestPriceSequenceNumber)
	// Contract: OffRamp
	// Confidence: Unconfirmed
	GetLatestPriceSeqNr(ctx context.Context) (SeqNum, error)
}

type EstimateProvider interface {
	CalculateMerkleTreeGas(numRequests int) uint64
	CalculateMessageMaxGas(msg Message) uint64
}

type ExecutePluginCodec interface {
	Encode(context.Context, ExecutePluginReport) ([]byte, error)
	Decode(context.Context, []byte) (ExecutePluginReport, error)
}

type ExecutePluginReport struct {
	ChainReports []ExecutePluginReportSingleChain `json:"chainReports"`
}

type ExecutePluginReportSingleChain struct {
	SourceChainSelector ChainSelector `json:"sourceChainSelector"`
	Messages            []Message     `json:"messages"`
	OffchainTokenData   [][][]byte    `json:"offchainTokenData"`
	Proofs              []Bytes32     `json:"proofs"`
	ProofFlagBits       BigInt        `json:"proofFlagBits"`
}

type ExecuteReportInfo struct {
	AbstractReports []ExecutePluginReportSingleChain
	MerkleRoots     []MerkleRootChain
}

type ExtraDataCodec map[string]SourceChainExtraDataCodec

type FeeQuoterConfig struct {
	StaticConfig FeeQuoterStaticConfig
}

type FeeQuoterDestChainConfig struct {
	IsEnabled                         bool    // Whether this destination chain is enabled
	MaxNumberOfTokensPerMsg           uint16  // Maximum number of distinct ERC20 token transferred per message
	MaxDataBytes                      uint32  // Maximum payload data size in bytes
	MaxPerMsgGasLimit                 uint32  // Maximum gas limit for messages targeting EVMs
	DestGasOverhead                   uint32  // Gas charged on top of the gasLimit to cover destination chain costs
	DestGasPerPayloadByteBase         uint32  // Destination gas charged per byte of payload to receiver by default
	DestGasPerPayloadByteHigh         uint32  // Destination gas charged per byte of payload over the threshold
	DestGasPerPayloadByteThreshold    uint32  // Threshold of payload byte size over which the high rate applies
	DestDataAvailabilityOverheadGas   uint32  // Extra data availability gas charged, e.g., for OCR
	DestGasPerDataAvailabilityByte    uint16  // Gas charged per byte of message data needing availability
	DestDataAvailabilityMultiplierBps uint16  // Multiplier for data availability gas in bps
	DefaultTokenFeeUSDCents           uint16  // Default token fee charged per token transfer
	DefaultTokenDestGasOverhead       uint32  // Default gas charged to execute token transfer on destination
	DefaultTxGasLimit                 uint32  // Default gas limit for a transaction
	GasMultiplierWeiPerEth            uint64  // Multiplier for gas costs, 1e18 based (11e17 = 10% extra cost)
	NetworkFeeUSDCents                uint32  // Flat network fee for messages, in multiples of 0.01 USD
	GasPriceStalenessThreshold        uint32  // Maximum time for gas price to be valid (0 means disabled)
	EnforceOutOfOrder                 bool    // Enforce the allowOutOfOrderExecution extraArg to be true
	ChainFamilySelector               [4]byte // Selector identifying the destination chain's family
}

type FeeQuoterStaticConfig struct {
	MaxFeeJuelsPerMsg  BigInt `json:"maxFeeJuelsPerMsg"`
	LinkToken          []byte `json:"linkToken"`
	StalenessThreshold uint32 `json:"stalenessThreshold"`
}

type GasPriceChain struct {
	ChainSel ChainSelector `json:"chainSel"`
	GasPrice BigInt        `json:"gasPrice"`
}

type GetOnRampDynamicConfigResponse struct {
	DynamicConfig OnRampDynamicConfig `json:"dynamicConfig"`
}

type MerkleRootChain struct {
	ChainSel      ChainSelector  `json:"chain"`
	OnRampAddress UnknownAddress `json:"onRampAddress"`
	SeqNumsRange  SeqNumRange    `json:"seqNumsRange"`
	MerkleRoot    Bytes32        `json:"merkleRoot"`
}

type Message struct {
	// Header is the family-agnostic header for OnRamp and OffRamp messages.
	// This is always set on all CCIP messages.
	Header RampMessageHeader `json:"header"`
	// Sender address on the source chain.
	// i.e if the source chain is EVM, this is an abi-encoded EVM address.
	Sender UnknownAddress `json:"sender"`
	// Data is the arbitrary data payload supplied by the message sender.
	Data Bytes `json:"data"`
	// Receiver is the receiver address on the destination chain.
	// This is encoded in the destination chain family specific encoding.
	// i.e if the destination is EVM, this is abi.encode(receiver).
	Receiver UnknownAddress `json:"receiver"`
	// ExtraArgs is destination-chain specific extra args,
	// such as the gasLimit for EVM chains.
	// This field is encoded in the source chain encoding scheme.
	ExtraArgs Bytes `json:"extraArgs"`
	// FeeToken is the fee token address.
	// i.e if the source chain is EVM, len(FeeToken) == 20 (i.e, is not abi-encoded).
	FeeToken UnknownAddress `json:"feeToken"`
	// FeeTokenAmount is the amount of fee tokens paid.
	FeeTokenAmount BigInt `json:"feeTokenAmount"`
	// FeeValueJuels is the fee amount in Juels
	FeeValueJuels BigInt `json:"feeValueJuels"`
	// TokenAmounts is the array of tokens and amounts to transfer.
	TokenAmounts []RampTokenAmount `json:"tokenAmounts"`
}

type MessageHasher interface {
	Hash(context.Context, Message) (Bytes32, error)
}

type MessageTokenID struct {
	SeqNr SeqNum
	Index int
}

type OCRConfig struct {
	ConfigInfo   ConfigInfo
	Signers      [][]byte
	Transmitters [][]byte
}

type OCRConfigResponse struct {
	OCRConfig OCRConfig
}

type OffRampDynamicChainConfig struct {
	FeeQuoter                               []byte `json:"feeQuoter"`
	PermissionLessExecutionThresholdSeconds uint32 `json:"permissionLessExecutionThresholdSeconds"`
	IsRMNVerificationDisabled               bool   `json:"isRMNVerificationDisabled"`
	MessageInterceptor                      []byte `json:"messageInterceptor"`
}

type OffRampStaticChainConfig struct {
	ChainSelector        ChainSelector `json:"chainSelector"`
	GasForCallExactCheck uint16        `json:"gasForCallExactCheck"`
	RmnRemote            []byte        `json:"rmnRemote"`
	TokenAdminRegistry   []byte        `json:"tokenAdminRegistry"`
	NonceManager         []byte        `json:"nonceManager"`
}

type OfframpConfig struct {
	CommitLatestOCRConfig OCRConfigResponse
	ExecLatestOCRConfig   OCRConfigResponse
	StaticConfig          OffRampStaticChainConfig
	DynamicConfig         OffRampDynamicChainConfig
}

type OnRampConfig struct {
	DynamicConfig   GetOnRampDynamicConfigResponse
	DestChainConfig OnRampDestChainConfig
}

type OnRampDestChainConfig struct {
	SequenceNumber   uint64 `json:"sequenceNumber"`
	AllowListEnabled bool   `json:"allowListEnabled"`
	Router           []byte `json:"router"`
}

type OnRampDynamicConfig struct {
	FeeQuoter              []byte `json:"feeQuoter"`
	ReentrancyGuardEntered bool   `json:"reentrancyGuardEntered"`
	MessageInterceptor     []byte `json:"messageInterceptor"`
	FeeAggregator          []byte `json:"feeAggregator"`
	AllowListAdmin         []byte `json:"allowListAdmin"`
}

type PriceReader interface {
	// GetFeedPricesUSD returns the prices of the provided tokens in USD normalized to e18.
	//	1 USDC = 1.00 USD per full token, each full token is 1e6 units -> 1 * 1e18 * 1e18 / 1e6 = 1e30
	//	1 ETH = 2,000 USD per full token, each full token is 1e18 units -> 2000 * 1e18 * 1e18 / 1e18 = 2_000e18
	//	1 LINK = 5.00 USD per full token, each full token is 1e18 units -> 5 * 1e18 * 1e18 / 1e18 = 5e18
	// The order of the returned prices corresponds to the order of the provided tokens.
	GetFeedPricesUSD(
		ctx context.Context,
		tokens []UnknownEncodedAddress,
		tokenInfo map[UnknownEncodedAddress]TokenInfo,
	) (TokenPriceMap, error)

	// GetFeeQuoterTokenUpdates returns the latest token prices from the FeeQuoter on the specified chain
	GetFeeQuoterTokenUpdates(
		ctx context.Context,
		tokens []UnknownEncodedAddress,
		chain ChainSelector,
	) (map[UnknownEncodedAddress]TimestampedUnixBig, error)
}

type PriceUpdates struct {
	TokenPriceUpdates []TokenPrice    `json:"tokenPriceUpdates"`
	GasPriceUpdates   []GasPriceChain `json:"gasPriceUpdates"`
}

type RMNCrypto interface {
	// VerifyReportSignatures verifies each provided signature against the provided report and the signer addresses.
	// If any signature is invalid (no matching signer address is found), an error is returned immediately.
	VerifyReportSignatures(
		ctx context.Context,
		sigs []RMNECDSASignature,
		report RMNReport,
		signerAddresses []UnknownAddress,
	) error
}

type RMNCurseResponse struct {
	CursedSubjects [][16]byte
}

type RMNDigestHeader struct {
	DigestHeader Bytes32
}

type RMNECDSASignature struct {
	R Bytes32 `json:"r"`
	S Bytes32 `json:"s"`
}

type RMNLaneUpdate struct {
	SourceChainSelector ChainSelector
	OnRampAddress       UnknownAddress // (for EVM should be abi-encoded)
	MinSeqNr            SeqNum
	MaxSeqNr            SeqNum
	MerkleRoot          Bytes32
}

type RMNProxyConfig struct {
	RemoteAddress []byte
}

type RMNRemoteConfig struct {
	DigestHeader    RMNDigestHeader
	VersionedConfig VersionedConfig
}

type RMNReport struct {
	ReportVersionDigest         Bytes32 // e.g. keccak256("RMN_V1_6_ANY2EVM_REPORT")
	DestChainID                 BigInt  // If applies, a chain specific id, e.g. evm chain id otherwise empty.
	DestChainSelector           ChainSelector
	RmnRemoteContractAddress    UnknownAddress
	OfframpAddress              UnknownAddress
	RmnHomeContractConfigDigest Bytes32
	LaneUpdates                 []RMNLaneUpdate
}

type RampMessageHeader struct {
	// MessageID is a unique identifier for the message, it should be unique across all chains.
	// It is generated on the chain that the CCIP send is requested (i.e. the source chain of a message).
	MessageID Bytes32 `json:"messageId"`
	// SourceChainSelector is the chain selector of the chain that the message originated from.
	SourceChainSelector ChainSelector `json:"sourceChainSelector,string"`
	// DestChainSelector is the chain selector of the chain that the message is destined for.
	DestChainSelector ChainSelector `json:"destChainSelector,string"`
	// SequenceNumber is an auto-incrementing sequence number for the message.
	// Not unique across lanes.
	SequenceNumber SeqNum `json:"seqNum,string"`
	// Nonce is the nonce for this lane for this sender, not unique across senders/lanes
	Nonce uint64 `json:"nonce"`

	// MsgHash is the hash of all the message fields.
	// NOTE: The field is expected to be empty, and will be populated by the plugin using the MsgHasher interface.
	MsgHash Bytes32 `json:"msgHash"` // populated

	// OnRamp is the address of the onramp that sent the message.
	// NOTE: This is populated by the ccip reader. Not emitted explicitly onchain.
	OnRamp UnknownAddress `json:"onRamp"`

	// TxHash is the hash of the transaction that emitted this message.
	TxHash string `json:"txHash"`
}

type RampTokenAmount struct {
	// SourcePoolAddress is the source pool address, encoded according to source family native encoding scheme.
	// This value is trusted as it was obtained through the onRamp. It can be relied upon by the destination
	// pool to validate the source pool.
	SourcePoolAddress UnknownAddress `json:"sourcePoolAddress"`

	// DestTokenAddress is the address of the destination token, abi encoded in the case of EVM chains.
	// This value is UNTRUSTED as any pool owner can return whatever value they want.
	DestTokenAddress UnknownAddress `json:"destTokenAddress"`

	// ExtraData is optional pool data to be transferred to the destination chain. Be default this is capped at
	// CCIP_LOCK_OR_BURN_V1_RET_BYTES bytes. If more data is required, the TokenTransferFeeConfig.destBytesOverhead
	// has to be set for the specific token.
	ExtraData Bytes `json:"extraData"`

	// Amount is the amount of tokens to be transferred.
	Amount BigInt `json:"amount"`

	// DestExecData is destination chain specific execution data encoded in bytes.
	// For an EVM destination, it consists of the amount of gas available for the releaseOrMint
	// and transfer calls made by the offRamp.
	// NOTE: this must be decoded before providing it as an execution input to the destination chain
	// or hashing it. See Internal._hash(Any2EVMRampMessage) for more details as an example.
	DestExecData Bytes `json:"destExecData"`
}

type RemoteConfig struct {
	ContractAddress UnknownAddress     `json:"contractAddress"`
	ConfigDigest    Bytes32            `json:"configDigest"`
	Signers         []RemoteSignerInfo `json:"signers"`
	// F defines the max number of faulty RMN nodes; F+1 signers are required to verify a report.
	FSign            uint64  `json:"fSign"` // previously: MinSigners
	ConfigVersion    uint32  `json:"configVersion"`
	RmnReportVersion Bytes32 `json:"rmnReportVersion"` // e.g., keccak256("RMN_V1_6_ANY2EVM_REPORT")
}

type RemoteSignerInfo struct {
	// The signer's onchain address, used to verify report signature
	OnchainPublicKey UnknownAddress `json:"onchainPublicKey"`
	// The index of the node in the RMN config
	NodeIndex uint64 `json:"nodeIndex"`
}

type RouterConfig struct {
	WrappedNativeAddress Bytes
}

type SeqNum uint64

type SeqNumRange [2]SeqNum

type Signer struct {
	OnchainPublicKey []byte `json:"onchainPublicKey"`
	NodeIndex        uint64 `json:"nodeIndex"`
}

type SourceAccessor interface {
	// MsgsBetweenSeqNums returns all messages being sent to the provided dest
	// chain, between the provided sequence numbers. Messages are sorted ascending
	// based on their timestamp.
	//
	// Access Type: Event(CCIPMessageSent)
	// Contract: OnRamp
	// Confidence: Finalized
	MsgsBetweenSeqNums(ctx context.Context, dest ChainSelector, seqNumRange SeqNumRange) ([]Message, error)

	// LatestMessageTo returns the sequence number associated with the most
	// recent message being sent to a given destination.
	//
	// Access Type: Event(CCIPMessageSent)
	// Contract: OnRamp
	// Confidence: Finalized
	LatestMessageTo(ctx context.Context, dest ChainSelector) (SeqNum, error)

	// GetExpectedNextSequenceNumber returns the expected next sequence number
	// messages being sent to the provided destination.
	//
	// Access Type: Method(GetExpectedNextSequenceNumber)
	// Contract: OnRamp
	// Confidence: Unconfirmed
	GetExpectedNextSequenceNumber(ctx context.Context, dest ChainSelector) (SeqNum, error)

	// GetTokenPriceUSD looks up a token price in USD. The address value should
	// be retrieved from a configuration cache (i.e. ConfigPoller).
	//
	// Access Type: Method(GetTokenPrice)
	// Contract: FeeQuoter
	// Confidence: Unconfirmed
	//
	// Notes: This function is new and serves as a general price interface for
	//        both LinkPriceUSD and GetWrappedNativeTokenPriceUSD.
	//        See Design Doc (Combined Token Price Helper) for notes.
	GetTokenPriceUSD(ctx context.Context, address UnknownAddress) (TimestampedUnixBig, error)

	// GetFeeQuoterDestChainConfig returns the fee quoter destination chain config.
	//
	// Access Type: Method(GetDestChainConfig)
	// Contract: FeeQuoter
	// Confidence: Unconfirmed
	//
	// Notes: This is a new general purpose function needed to implement
	//        GetMedianDataAvailabilityGasConfig.
	GetFeeQuoterDestChainConfig(ctx context.Context, dest ChainSelector) (FeeQuoterDestChainConfig, error)
}

type SourceChainConfig struct {
	Router                    []byte // local router
	IsEnabled                 bool
	IsRMNVerificationDisabled bool
	MinSeqNr                  uint64
	OnRamp                    UnknownAddress
}

type SourceChainExtraDataCodec interface {
	// DecodeExtraArgsToMap reformat bytes into a chain agnostic map[string]any representation for extra args
	DecodeExtraArgsToMap(extraArgs Bytes) (map[string]any, error)
	// DecodeDestExecDataToMap reformat bytes into a chain agnostic map[string]interface{} representation for dest exec data
	DecodeDestExecDataToMap(destExecData Bytes) (map[string]any, error)
}

type TimestampedBig struct {
	Timestamp time.Time `json:"timestamp"`
	Value     BigInt    `json:"value"`
}

type TimestampedUnixBig struct {
	// Value in uint224, can contain several packed fields
	Value *big.Int `json:"value"`
	// Timestamp in seconds since epoch of most recent update
	Timestamp uint32 `json:"timestamp"`
}

type TokenDataEncoder interface {
	EncodeUSDC(ctx context.Context, message Bytes, attestation Bytes) (Bytes, error)
}

type TokenInfo struct {
	// AggregatorAddress is the address of the price feed TOKEN/USD aggregator on the feed chain.
	AggregatorAddress UnknownEncodedAddress `json:"aggregatorAddress"`

	// DeviationPPB is the deviation in parts per billion that the price feed is allowed to deviate
	// from the last written price on-chain before we write a new price.
	DeviationPPB BigInt `json:"deviationPPB"`

	// Decimals is the number of decimals for the token (NOT the feed).
	Decimals uint8 `json:"decimals"`
}

type TokenPrice struct {
	TokenID UnknownEncodedAddress `json:"tokenID"`
	Price   BigInt                `json:"price"`
}

type TokenPriceMap map[UnknownEncodedAddress]BigInt

type USDCMessageReader interface {
	MessagesByTokenID(ctx context.Context,
		source, dest ChainSelector,
		tokens map[MessageTokenID]RampTokenAmount,
	) (map[MessageTokenID]Bytes, error)
}

type UnknownAddress []byte

type UnknownEncodedAddress = libocr.Account

type VersionedConfig struct {
	Version uint32 `json:"version"`
	Config  Config `json:"config"`
}