types

type BlockWithLogs struct {
	Header  aggkittypes.BlockHeader
	IsFinal bool
	Logs    []Log
}

type CompareBlockHeaders struct {
	BlockNumber   uint64
	StorageHeader *aggkittypes.BlockHeader
	IsFinalized   FinalizedType
	RpcHeader     *aggkittypes.BlockHeader
}

type ContractConfig struct {
	Address             common.Address
	FromBlock           uint64
	ToBlock             aggkittypes.BlockNumberFinality
	RequiredBlockHeader bool
	Syncers             []SyncerID
}

type DetectedReorgError struct {
	OffendingBlockNumber uint64 // Important: is not the first reorged block, but one of them
	OldHash              common.Hash
	NewHash              common.Hash
	ReorgDetectionReason ReorgDetectionReason
	Message              string
}

type FinalizedType = bool

type Log struct {
	// Consensus fields:
	// address of the contract that generated the event
	Address common.Address `json:"address" gencodec:"required"`
	// list of topics provided by the contract.
	Topics []common.Hash `json:"topics" gencodec:"required"`
	// supplied by the contract, usually ABI-encoded
	Data []byte `json:"data" gencodec:"required"`

	// Derived fields. These fields are filled in by the node
	// but not secured by consensus.
	// block in which the transaction was included
	BlockNumber uint64 `json:"blockNumber" rlp:"-"`
	// hash of the transaction
	TxHash common.Hash `json:"transactionHash" gencodec:"required" rlp:"-"`
	// index of the transaction in the block
	TxIndex uint `json:"transactionIndex" rlp:"-"`
	// timestamp of the block in which the transaction was included
	BlockTimestamp uint64 `json:"blockTimestamp" rlp:"-"`
	// index of the log in the block
	Index uint `json:"logIndex" rlp:"-"`

	// The Removed field is true if this log was reverted due to a chain reorganisation.
	// You must pay attention to this field if you receive logs through a filter query.
	Removed bool `json:"removed" rlp:"-"`
}

type LogQuery struct {
	Addrs      []common.Address
	BlockRange aggkitcommon.BlockRange
	// If BlockHash is set BlockRange contains the corresponding blockNumber
	BlockHash *common.Hash
}

type LogQueryResponse struct {
	Blocks []BlockWithLogs
	// ResponseRange indicates the block range covered by the response, even if blocks are empty
	ResponseRange aggkitcommon.BlockRange
	// UnsafeRange indicates the block range that are in unsafe zone (not finalized)
	UnsafeRange aggkitcommon.BlockRange
}

type ReorgData struct {
	// ReorgID is the unique identifier for the reorg stored in DB (incremental ID)
	ReorgID uint64
	// BlockRangeAffected is the range of blocks affected by the reorg (from,to inclusive)
	BlockRangeAffected aggkitcommon.BlockRange
	// DetectedAtBlock is the block number where the reorg was detected
	DetectedAtBlock           uint64
	DetectedTimestamp         uint64
	NetworkLatestBlock        uint64
	NetworkFinalizedBlock     uint64
	NetworkFinalizedBlockName aggkittypes.BlockNumberFinality
	Description               string
}

type ReorgDetectionReason int

type ReorgPorter interface {
	NewTx(ctx context.Context) (dbtypes.Txer, error)
	GetBlockStorageAndRPC(ctx context.Context, tx dbtypes.Querier, blockNumber uint64) (*CompareBlockHeaders, error)
	GetLastBlockNumberInStorage(tx dbtypes.Querier) (uint64, error)
	// Return ChainID of the inserted reorg
	MoveReorgedBlocks(tx dbtypes.Querier, reorgData ReorgData) (uint64, error)
	GetBlockNumberInRPC(ctx context.Context, blockFinality aggkittypes.BlockNumberFinality) (uint64, error)
	TimeNowUnix() uint64
}

type ReorgProcessor interface {
	// ProcessReorg processes a detected reorg starting from the offending block number.
	// It identifies the range of blocks affected by the reorg and takes necessary actions
	// to handle the reorganization.
	// input parameters:
	// - ctx: the context for managing cancellation and timeouts
	// - detectedReorgError: the error returned by the reorg detection logic, containing
	//   the offending block number and the reason for the reorg detection
	// - finalizedBlockTag: the block tag to consider as finalized (typically finalizedBlock)
	ProcessReorg(ctx context.Context, detectedReorgError DetectedReorgError,
		finalizedBlockTag aggkittypes.BlockNumberFinality) error
}

type ReorgedError struct {
	Message           string
	BlockRangeReorged aggkitcommon.BlockRange
	ReorgID           uint64
}

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

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

type Storager interface {
	StoragerForReorg
	dbtypes.KeyValueStorager
	// GetSyncedBlockRangePerContract It returns the synced block range stored in DB
	GetSyncedBlockRangePerContract(tx dbtypes.Querier) (SetSyncSegment, error)
	SaveEthLogsWithHeaders(tx dbtypes.Querier, blockHeaders aggkittypes.ListBlockHeaders,
		logs []types.Log, isFinal bool) error
	// TODO: Deprecate GetEthLogs and use LogQuery instead
	GetEthLogs(tx dbtypes.Querier, query LogQuery) ([]types.Log, error)
	LogQuery(tx dbtypes.Querier, query LogQuery) (LogQueryResponse, error)
	UpdateSyncedStatus(tx dbtypes.Querier, segments []SyncSegment) error
	UpsertSyncerConfigs(tx dbtypes.Querier, configs []ContractConfig) error
	GetBlockHeaderByNumber(tx dbtypes.Querier, blockNumber uint64) (*aggkittypes.BlockHeader, FinalizedType, error)
	NewTx(ctx context.Context) (dbtypes.Txer, error)
	// GetBlockHeadersNotFinalized retrieves all block headers that are not finalized <= maxBlock
	// if maxBlock is nil, retrieves all not finalized blocks
	GetBlockHeadersNotFinalized(tx dbtypes.Querier, maxBlock *uint64) (aggkittypes.ListBlockHeaders, error)
	UpdateBlockToFinalized(tx dbtypes.Querier, blockNumbers []uint64) error
	GetRangeBlockHeader(tx dbtypes.Querier, isFinal FinalizedType) (lowest *aggkittypes.BlockHeader,
		highest *aggkittypes.BlockHeader, err error)
	// GetHighestBlockNumber returns the highest block number stored in db
	GetHighestBlockNumber(tx dbtypes.Querier) (uint64, error)
	// GetBlockReorgedReorgID returns the reorgID of the reorged block if exists
	// second return value indicates if the block is reorged
	GetBlockReorgedReorgID(tx dbtypes.Querier,
		blockNumber uint64, blockHash common.Hash) (uint64, bool, error)
	GetReorgedDataByReorgID(tx dbtypes.Querier,
		reorgID uint64) (*ReorgData, error)
}

type StoragerForReorg interface {
	GetBlockHeaderByNumber(tx dbtypes.Querier, blockNumber uint64) (*aggkittypes.BlockHeader, FinalizedType, error)
	InsertReorgAndMoveReorgedBlocksAndLogs(tx dbtypes.Querier, reorgData ReorgData) (uint64, error)
}

type SyncSegment struct {
	ContractAddr common.Address
	// BlockRange can be empty  BlockRange.IsEmpty()
	BlockRange    aggkitcommon.BlockRange
	TargetToBlock aggkittypes.BlockNumberFinality
}

type SyncerID = string