claimsync

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

type BridgeDeployment byte

type Call struct {
	From  common.Address    `json:"from"`
	To    common.Address    `json:"to"`
	Value *rpctypes.ArgBig  `json:"value"`
	Err   *string           `json:"error"`
	Input rpctypes.ArgBytes `json:"input"`
	Calls []Call            `json:"calls"`
}

type Claim = claimsynctypes.Claim

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

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

type ClaimSyncer interface {
	GetLastProcessedBlock(ctx context.Context) (uint64, bool, error)
	GetFirstProcessedBlock(ctx context.Context) (uint64, bool, error)
	GetClaims(ctx context.Context, fromBlock, toBlock uint64) ([]claimsynctypes.Claim, error)
	GetClaimsByGlobalIndex(ctx context.Context, globalIndex *big.Int) ([]claimsynctypes.Claim, error)
	SetNextRequiredBlock(ctx context.Context, blockNum uint64) error
}

type ClaimType = claimsynctypes.ClaimType

type ConfigEmbedded struct {
	// DBQueryTimeout is the timeout for database operations (queries, transactions)
	// This is separate from HTTP timeouts to allow database operations more time when needed
	DBQueryTimeout types.Duration `mapstructure:"DBQueryTimeout"`
	// BridgeAddr is the address of the bridge smart contract
	BridgeAddr common.Address `mapstructure:"BridgeAddr"`
}

type ConfigStandalone struct {
	ConfigEmbedded `mapstructure:",squash"`
	// DBPath path of the DB
	DBPath string `mapstructure:"DBPath"`
	// BlockFinality indicates the status of the blocks that will be queried in order to sync
	BlockFinality aggkittypes.BlockNumberFinality `` //nolint:lll
	/* 134-byte string literal not displayed */
	// InitialBlockNum is the first block that will be queried when starting the synchronization from scratch.
	// It should be a number equal or below the creation of the bridge contract
	InitialBlockNum uint64 `mapstructure:"InitialBlockNum"`
	// SyncBlockChunkSize is the amount of blocks that will be queried to the client on each request
	SyncBlockChunkSize uint64 `mapstructure:"SyncBlockChunkSize"`
	// RetryAfterErrorPeriod is the time that will be waited when an unexpected error happens before retry
	RetryAfterErrorPeriod types.Duration `mapstructure:"RetryAfterErrorPeriod"`
	// MaxRetryAttemptsAfterError is the maximum number of consecutive attempts that will happen before panicking.
	// Any number smaller than zero will be considered as unlimited retries
	MaxRetryAttemptsAfterError int `mapstructure:"MaxRetryAttemptsAfterError"`

	// WaitForNewBlocksPeriod time that will be waited when the synchronizer has reached the latest block
	WaitForNewBlocksPeriod types.Duration `mapstructure:"WaitForNewBlocksPeriod"`
	// RequireStorageContentCompatibility is true it's mandatory that data stored in the database
	// is compatible with the running environment
	RequireStorageContentCompatibility bool `mapstructure:"RequireStorageContentCompatibility"`
	// AutoStart controls whether the synchronizer should start automatically after initialization.
	// Possible values:
	//   - "true": automatically starts after initialization using InitialBlockNum
	//   - "false": does not start automatically; requires manual start
	//   - "auto": automatically decides based on which component is active
	AutoStart types.TrueFalseAutoMode `jsonschema:"enum=true, enum=false, enum=auto" mapstructure:"AutoStart"`
}

type EmbeddedClaimSync struct {
	Appender  sync.LogAppenderMap
	Processor claimsynctypes.EmbeddedProcessor
	Reader    claimsynctypes.ClaimsReader
}

type Event struct {
	Claim      *Claim
	UnsetClaim *UnsetClaim
	SetClaim   *SetClaim
}

type SetClaim = claimsynctypes.SetClaim

type UnsetClaim = claimsynctypes.UnsetClaim