types

type AggProofPublicValuesQuerier interface {
	GetAggregationProofPublicValuesData(lastProvenBlock, requestedEndBlock uint64,
		l1InfoTreeLeafHash common.Hash) (*AggregationProofPublicValues, error)
}

type AggchainFEPRollupQuerier interface {
	StartL2Block() uint64
	GetLastSettledL2Block() (uint64, error)
	IsFEP() bool
}

type AggchainParams struct {
	AggregationProofPublicValues
	OptimisticMode bool
}

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, 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
	RemovedGERs                        []*agglayer.RemovedGER
	Unclaims                           []*agglayer.Unclaim
}

type AgglayerBridgeL2Reader interface {
	GetUnsetClaimsForBlockRange(ctx context.Context,
		fromBlock, toBlock uint64) ([]bridgesynctypes.Unclaim, error)
}

type AggregationProofPublicValues struct {
	L1Head              common.Hash
	L2PreRoot           common.Hash
	ClaimRoot           common.Hash
	L2BlockNumber       uint64
	RollupConfigHash    common.Hash
	MultiBlockVKey      common.Hash
	TrustedSigner       common.Address
	AggregationVKeyHash common.Hash
}

type AggsenderBuilderFlow 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)
	// UpdateAggchainData updates the aggchain data field for the given certificate
	UpdateAggchainData(cert *agglayertypes.Certificate, multisig *agglayertypes.Multisig) error
	// Signer is the signer used to sign the certificate
	Signer() signertypes.Signer
}

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         aggkit.FullVersion
	TriggerStatus   string        `json:"trigger_status"`
	NetworkID       uint32        `json:"network_id"`
	Mode            AggsenderMode `json:"mode"`
}

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 AggsenderVerifierFlow interface {
	// 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)
	// VerifyCertificate verifies the certificate field for the given certificate
	VerifyCertificate(
		ctx context.Context,
		cert *agglayertypes.Certificate,
		lastBlockInCert uint64,
		lastSettledBlock uint64) error
}

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
	GetUnsetClaimsForBlockRange(ctx context.Context,
		fromBlock, toBlock uint64) ([]bridgesynctypes.Unclaim, 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
	Unclaims                       []bridgesynctypes.Unclaim
	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
	L1InfoTreeLeaf        *l1infotreesync.L1InfoTreeLeaf
}

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

type CertificateQuerier interface {
	GetLastSettledCertificateToBlock(
		ctx context.Context,
		cert *agglayertypes.CertificateHeader) (uint64, error)
	GetNewCertificateToBlock(
		ctx context.Context,
		cert *agglayertypes.Certificate) (uint64, error)
	CalculateCertificateType(cert *agglayertypes.Certificate, certToBlock uint64) CertificateType
	CalculateCertificateTypeFromToBlock(certToBlock uint64) CertificateType
}

type CertificateSendTrigger interface {
	Setup(ctx context.Context)
	Status() string
	TriggerCh(ctx context.Context) <-chan CertificateTriggerEvent
	ForceTriggerEvent()
}

type CertificateSource string

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

type CertificateTriggerEvent interface {
	fmt.Stringer
}

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,
		lastL2BlockInCert uint64,
	) ([]byte, error)
	URL() string
	String() string
	Address() common.Address
	Index() uint32
}

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)
	GetRemovedGERsForRange(ctx context.Context,
		fromBlock, toBlock uint64) ([]*agglayertypes.RemovedGER, 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
	ForcePublishEpochEvent()
}

type EpochStatus struct {
	Epoch        uint64
	PercentEpoch float64
}

type FEPContractQuerier interface {
	StartingBlockNumber(opts *bind.CallOpts) (*big.Int, error)
	LatestBlockNumber(opts *bind.CallOpts) (*big.Int, error)
	GetAggchainSigners(opts *bind.CallOpts) ([]common.Address, error)
	OptimisticMode(opts *bind.CallOpts) (bool, error)
	SelectedOpSuccinctConfigName(opts *bind.CallOpts) ([common.HashLength]byte, error)
	OpSuccinctConfigs(opts *bind.CallOpts, arg0 [common.HashLength]byte) (struct {
		AggregationVkey     [common.HashLength]byte
		RangeVkeyCommitment [common.HashLength]byte
		RollupConfigHash    [common.HashLength]byte
	}, error)
}

type FEPInputsQuerier interface {
	GetAggchainParams(
		lastProvenBlock, requestedEndBlock uint64,
		l1InfoTreeLeafHash common.Hash) (*AggchainParams, error)
}

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

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
	GetFinalizedL1InfoTreeData(
		ctx context.Context,
		finalizedL1InfoTreeRootHash common.Hash,
		finalizedL1InfoTreeLeafCount uint32,
	) (treetypes.Proof, *l1infotreesync.L1InfoTreeLeaf, 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)

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

	// GetInfoByIndex returns the L1 Info tree leaf for the given index
	GetInfoByIndex(ctx context.Context, index uint32) (*l1infotreesync.L1InfoTreeLeaf, error)

	// IsGERFinalized checks if the given global exit root is finalized
	IsGERFinalized(ger common.Hash, finalizedL1InfoLeafCount uint32) (bool, error)

	// DoesGERExistsOnL1 checks if the given global exit root exists on L1
	DoesGERExistsOnL1(ger common.Hash) (bool, 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)
	IsUpToDate(ctx context.Context, l1Client aggkittypes.BaseEthereumClienter) (bool, 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
	GetLastProcessedBlock(ctx context.Context) (uint64, error)
	GetExitRootByHash(ctx context.Context, root common.Hash) (*treetypes.Root, error)
	GetClaimsByGlobalIndex(ctx context.Context, globalIndex *big.Int) ([]bridgesync.Claim, error)
	SubscribeToSync(subscriberID string) <-chan sync.Block
}

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 MultisigCommittee struct {
	// contains filtered or unexported fields
}

type MultisigContract interface {
	Threshold(opts *bind.CallOpts) (*big.Int, error)
	GetAggchainSignerInfos(opts *bind.CallOpts) ([]aggchainbase.IAggchainSignersSignerInfo, error)
	AGGCHAINTYPE(opts *bind.CallOpts) ([2]byte, error)
	CONSENSUSTYPE(opts *bind.CallOpts) (uint32, error)
}

type MultisigQuerier interface {
	GetMultisigCommittee(ctx context.Context, blockNum *big.Int) (*MultisigCommittee, error)
	ContractMode() (AggsenderMode, error)
	ResolveAutoMode(cfgMode AggsenderMode) (AggsenderMode, error)
}

type OpNodeClienter interface {
	OutputAtBlockRoot(blockNum uint64) (common.Hash, 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) (agglayermanager.AgglayerManagerRollupDataReturn, error)
	GetRollupChainID() (uint64, error)
}

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

type SignerInfo struct {
	URL     string
	Address common.Address
}

type ValidationRequest struct {
	Certificate       *agglayertypes.Certificate
	LastL2BlockInCert uint64
}

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

type ValidatorPoller interface {
	PollValidators(ctx context.Context, req *ValidationRequest) (*agglayertypes.Multisig, error)
}

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