types

type AggchainProof struct {
	LastProvenBlock uint64
	EndBlock        uint64
	CustomChainData []byte
	LocalExitRoot   common.Hash
	AggchainParams  common.Hash
	Context         map[string][]byte
	SP1StarkProof   *SP1StarkProof
	Signature       []byte
}

type AggchainProofClientInterface interface {
	GenerateAggchainProof(ctx context.Context, req *AggchainProofRequest) (*AggchainProof, error)
	GenerateOptimisticAggchainProof(req *AggchainProofRequest, signature []byte) (*AggchainProof, error)
}

type AggchainProofQuerier interface {
	GenerateAggchainProof(
		ctx context.Context,
		lastProvenBlock, toBlock uint64,
		certBuildParams *CertificateBuildParams,
	) (*AggchainProof, *treetypes.Root, error)
}

type AggchainProofRequest struct {
	LastProvenBlock                    uint64
	RequestedEndBlock                  uint64
	L1InfoTreeRootHash                 common.Hash
	L1InfoTreeLeaf                     l1infotreesync.L1InfoTreeLeaf
	L1InfoTreeMerkleProof              agglayer.MerkleProof
	GERLeavesWithBlockNumber           map[common.Hash]*agglayer.ProvenInsertedGERWithBlockNumber
	ImportedBridgeExitsWithBlockNumber []*agglayer.ImportedBridgeExitWithBlockNumber
}

type AggsenderFlow interface {
	// CheckInitialStatus checks the initial status for the flow it's ok
	CheckInitialStatus(ctx context.Context) error
	// GetCertificateBuildParams returns the parameters to build a certificate
	GetCertificateBuildParams(ctx context.Context) (*CertificateBuildParams, error)
	// BuildCertificate builds a certificate based on the buildParams
	BuildCertificate(ctx context.Context,
		buildParams *CertificateBuildParams) (*agglayertypes.Certificate, error)
	// GenerateBuildParams generates the build parameters based on the preParams
	GenerateBuildParams(ctx context.Context,
		preParams *CertificatePreBuildParams) (*CertificateBuildParams, error)
}

type AggsenderFlowBaser interface {
	GetCertificateBuildParamsInternal(
		ctx context.Context, certType CertificateType) (*CertificateBuildParams, error)
	BuildCertificate(ctx context.Context,
		certParams *CertificateBuildParams,
		lastSentCertificate *CertificateHeader,
		allowEmptyCert bool) (*agglayertypes.Certificate, error)
	GetNewLocalExitRoot(ctx context.Context,
		certParams *CertificateBuildParams) (common.Hash, error)
	VerifyBuildParams(ctx context.Context, fullCert *CertificateBuildParams) error
	VerifyBlockRangeGaps(
		ctx context.Context,
		lastSentCertificate *CertificateHeader,
		newFromBlock, newToBlock uint64) error
	ConvertClaimToImportedBridgeExit(claim bridgesync.Claim) (*agglayertypes.ImportedBridgeExit, error)
	StartL2Block() uint64

	GeneratePreBuildParams(ctx context.Context,
		certType CertificateType) (*CertificatePreBuildParams, error)
	GenerateBuildParams(ctx context.Context,
		preParams CertificatePreBuildParams) (*CertificateBuildParams, error)
	LimitCertSize(certParams *CertificateBuildParams) (*CertificateBuildParams, error)
}

type AggsenderInfo struct {
	AggsenderStatus          AggsenderStatus `json:"aggsender_status"`
	Version                  zkevm.FullVersion
	EpochNotifierDescription string `json:"epoch_notifier_description"`
	NetworkID                uint32 `json:"network_id"`
}

type AggsenderMode string

type AggsenderStatus struct {
	Running   bool                `json:"running"`
	StartTime time.Time           `json:"start_time"`
	Status    AggsenderStatusType `json:"status"`
	LastError string              `json:"last_error"`
}

type AggsenderStatusType string

type BlockNotifier interface {
	// NotifyEpochStarted notifies the epoch has started.
	Subscribe(id string) <-chan EventNewBlock
	GetCurrentBlockNumber() uint64
	String() string
}

type BlockRange struct {
	FromBlock uint64
	ToBlock   uint64
}

type BridgeQuerier interface {
	GetBridgesAndClaims(
		ctx context.Context,
		fromBlock, toBlock uint64,
	) ([]bridgesync.Bridge, []bridgesync.Claim, error)
	GetExitRootByIndex(ctx context.Context, index uint32) (common.Hash, error)
	GetLastProcessedBlock(ctx context.Context) (uint64, error)
	OriginNetwork() uint32
	WaitForSyncerToCatchUp(ctx context.Context, block uint64) error
}

type CertStatus struct {
	ExistPendingCerts   bool
	ExistNewInErrorCert bool
}

type Certificate struct {
	Header            *CertificateHeader
	SignedCertificate *string        `meddler:"signed_certificate"`
	AggchainProof     *AggchainProof `meddler:"aggchain_proof,aggchainproof"`
	// ExtraData is a no structured data used to debug or extra info for this certificate
	ExtraData string `meddler:"extra_data"`
}

type CertificateBuildParams struct {
	FromBlock                      uint64
	ToBlock                        uint64
	Bridges                        []bridgesync.Bridge
	Claims                         []bridgesync.Claim
	CreatedAt                      uint32
	RetryCount                     int
	LastSentCertificate            *CertificateHeader
	L1InfoTreeRootFromWhichToProve common.Hash
	L1InfoTreeLeafCount            uint32
	AggchainProof                  *AggchainProof
	CertificateType                CertificateType
	ExtraData                      string
}

type CertificateHeader struct {
	Height                  uint64                          `meddler:"height"`
	RetryCount              int                             `meddler:"retry_count"`
	CertificateID           common.Hash                     `meddler:"certificate_id,hash"`
	PreviousLocalExitRoot   *common.Hash                    `meddler:"previous_local_exit_root,hash"`
	NewLocalExitRoot        common.Hash                     `meddler:"new_local_exit_root,hash"`
	FromBlock               uint64                          `meddler:"from_block"`
	ToBlock                 uint64                          `meddler:"to_block"`
	Status                  agglayertypes.CertificateStatus `meddler:"status"`
	CreatedAt               uint32                          `meddler:"created_at"`
	UpdatedAt               uint32                          `meddler:"updated_at"`
	FinalizedL1InfoTreeRoot *common.Hash                    `meddler:"finalized_l1_info_tree_root,hash"`
	L1InfoTreeLeafCount     uint32                          `meddler:"l1_info_tree_leaf_count"`
	// CertType must be private but there are a lot of code that create CertificateInfo directly
	// so I add a GetCertType() that is not idiomatic but helps to determine the kind of certificate
	CertType CertificateType `meddler:"cert_type"`
	// This is the origin of this data, it can be from the AggLayer or from the local sender
	CertSource CertificateSource `meddler:"cert_source"`
}

type CertificateL1InfoTreeData struct {
	L1InfoTreeRootToProve common.Hash
	L1InfoTreeLeafCount   uint32
}

type CertificateMetadata struct {
	// ToBlock contains the pre v1 value stored in the metadata certificate field
	// is not stored in the hash post v1
	ToBlock uint64

	// FromBlock is the block number from which the certificate contains data
	FromBlock uint64

	// Offset is the number of blocks from the FromBlock that the certificate contains
	Offset uint32

	// CreatedAt is the timestamp when the certificate was created
	CreatedAt uint32

	// Version is the version of the metadata
	Version uint8

	// CertType is the type of certificate
	CertType uint8 // version >= V2
}

type CertificatePreBuildParams struct {
	BlockRange          BlockRange
	RetryCount          int
	CertificateType     CertificateType
	LastSentCertificate *CertificateHeader
	L1InfoTreeToProve   *CertificateL1InfoTreeData
	CreatedAt           uint32
}

type CertificateSource string

type CertificateStatusChecker interface {
	CheckPendingCertificatesStatus(ctx context.Context) CertStatus
	CheckInitialStatus(
		ctx context.Context,
		delayBetweenRetries time.Duration,
		aggsenderStatus *AggsenderStatus)
}

type CertificateType uint8

type CertificateValidateAndSigner interface {
	// HealthCheck checks the health of the validator service
	HealthCheck(ctx context.Context) (*HealthCheckResponse, error)
	// ValidateAndSignCertificate validates the certificate and signs it if valid.
	ValidateAndSignCertificate(
		ctx context.Context,
		certificate *agglayertypes.Certificate,
	) ([]byte, error)
	String() string
}

type CertificateValidator interface {
	ValidateCertificate(ctx context.Context, params VerifyIncomingRequest) error
}

type ChainGERReader interface {
	GetInjectedGERsForRange(ctx context.Context,
		fromBlock, toBlock uint64) (map[common.Hash]l2gersync.GlobalExitRootInfo, error)
}

type EpochEvent struct {
	Epoch uint64
	// ExtraInfo if a detailed information about the epoch that depends on implementation
	ExtraInfo fmt.Stringer
}

type EpochNotifier interface {
	// NotifyEpochStarted notifies the epoch is close to end.
	Subscribe(id string) <-chan EpochEvent
	// Start starts the notifier synchronously
	Start(ctx context.Context)
	// GetEpochStatus returns the current status of the epoch
	GetEpochStatus() EpochStatus
	String() string
}

type EpochStatus struct {
	Epoch        uint64
	PercentEpoch float64
}

type EventNewBlock struct {
	BlockNumber       uint64
	BlockFinalityType aggkittypes.BlockNumberFinality
	BlockRate         time.Duration
}

type GERQuerier interface {
	GetInjectedGERsProofs(
		ctx context.Context,
		finalizedL1InfoTreeRoot *treetypes.Root,
		fromBlock, toBlock uint64) (map[common.Hash]*agglayertypes.ProvenInsertedGERWithBlockNumber, error)
}

type GenericSubscriber[T any] interface {
	Subscribe(subscriberName string) <-chan T
	Publish(data T)
}

type HealthCheckResponse struct {
	Status       HealthCheckStatus
	StatusReason string
	Version      string
}

type HealthCheckStatus = string

type L1InfoTreeDataQuerier interface {
	// GetLatestFinalizedL1InfoRoot returns the latest processed l1 info tree root
	// based on the latest finalized l1 block
	GetLatestFinalizedL1InfoRoot(ctx context.Context) (*treetypes.Root, *l1infotreesync.L1InfoTreeLeaf, error)

	// GetFinalizedL1InfoTreeData returns the L1 Info tree data for the last finalized processed block
	// l1InfoTreeData is:
	// - merkle proof of given l1 info tree leaf
	// - the leaf data of the highest index leaf on that block and root
	// - the root of the l1 info tree on that block
	GetFinalizedL1InfoTreeData(ctx context.Context,
	) (treetypes.Proof, *l1infotreesync.L1InfoTreeLeaf, *treetypes.Root, error)

	// GetProofForGER returns the L1 Info tree leaf and the merkle proof for the given GER
	GetProofForGER(ctx context.Context, ger, rootFromWhichToProve common.Hash) (
		*l1infotreesync.L1InfoTreeLeaf, treetypes.Proof, error)

	// CheckIfClaimsArePartOfFinalizedL1InfoTree checks if the claims are part of the finalized L1 Info tree
	CheckIfClaimsArePartOfFinalizedL1InfoTree(
		finalizedL1InfoTreeRoot *treetypes.Root, claims []bridgesync.Claim) error

	// GetL1InfoRootByLeafIndex returns the L1 Info tree root for the given leaf index
	GetL1InfoRootByLeafIndex(ctx context.Context, leafCount uint32) (*treetypes.Root, error)
}

type L1InfoTreeSyncer interface {
	GetInfoByGlobalExitRoot(globalExitRoot common.Hash) (*l1infotreesync.L1InfoTreeLeaf, error)
	GetL1InfoTreeMerkleProofFromIndexToRoot(
		ctx context.Context, index uint32, root common.Hash,
	) (treetypes.Proof, error)
	GetL1InfoTreeRootByIndex(ctx context.Context, index uint32) (treetypes.Root, error)
	GetLastL1InfoTreeRoot(ctx context.Context) (treetypes.Root, error)
	GetProcessedBlockUntil(ctx context.Context, blockNumber uint64) (uint64, common.Hash, error)
	GetInfoByIndex(ctx context.Context, index uint32) (*l1infotreesync.L1InfoTreeLeaf, error)
	GetLatestL1InfoLeafUntilBlock(ctx context.Context, blockNum uint64) (*l1infotreesync.L1InfoTreeLeaf, error)
}

type L2BridgeSyncer interface {
	GetBlockByLER(ctx context.Context, ler common.Hash) (uint64, error)
	GetExitRootByIndex(ctx context.Context, index uint32) (treetypes.Root, error)
	GetBridges(ctx context.Context, fromBlock, toBlock uint64) ([]bridgesync.Bridge, error)
	GetClaims(ctx context.Context, fromBlock, toBlock uint64) ([]bridgesync.Claim, error)
	OriginNetwork() uint32
	BlockFinality() aggkittypes.BlockNumberFinality
	GetLastProcessedBlock(ctx context.Context) (uint64, error)
}

type LERQuerier interface {
	GetLastLocalExitRoot() (common.Hash, error)
}

type LocalExitRootQuery interface {
	GetNewLocalExitRoot(ctx context.Context,
		certParams *CertificateBuildParams) (common.Hash, error)
}

type Logger interface {
	Panicf(format string, args ...interface{})
	Fatalf(format string, args ...interface{})
	Info(args ...interface{})
	Infof(format string, args ...interface{})
	Error(args ...interface{})
	Errorf(format string, args ...interface{})
	Warn(args ...interface{})
	Warnf(format string, args ...interface{})
	Debug(args ...interface{})
	Debugf(format string, args ...interface{})
}

type MaxL2BlockNumberLimiterInterface interface {
	// AdaptCertificate is a custom handler that adjusts the certificate build parameters
	//  and return it through a new buildParams
	AdaptCertificate(
		buildParams *CertificateBuildParams) (*CertificateBuildParams, error)
}

type OptimisticModeQuerier interface {
	// IsOptimisticModeOn returns true if the optimistic mode is on
	IsOptimisticModeOn() (bool, error)
}

type OptimisticSigner interface {
	Sign(ctx context.Context,
		aggchainReq AggchainProofRequest,
		newLocalExitRoot common.Hash,
		claims []bridgesync.Claim,
	) ([]byte, string, error)
}

type RollupDataQuerier interface {
	GetRollupData(blockNumber *big.Int) (polygonrollupmanager.PolygonRollupManagerRollupDataReturn, error)
}

type SP1StarkProof struct {
	// SP1 Version
	Version string
	// SP1 stark proof.
	Proof []byte
	// SP1 stark proof verification key.
	Vkey []byte
}

type ValidatorClient interface {
	HealthCheck(ctx context.Context) (*HealthCheckResponse, error)
	ValidateCertificate(
		ctx context.Context,
		previousCertificateID *common.Hash,
		certificate *agglayertypes.Certificate,
	) ([]byte, error)
}

type VerifyIncomingRequest struct {
	Certificate         *agglayertypes.Certificate
	PreviousCertificate *agglayertypes.CertificateHeader
}